.NET / Node AES round-trip

aes.js

/*********************************************************************************
Dependencies
**********************************************************************************/
var crypto = require("crypto");

/*********************************************************************************
Utilities
*********************************************************************************/
var AES = {};
AES.encrypt = function(plaintext, key, iv) {
    var encipher = crypto.createCipheriv(algo, key, iv);
    return Buffer.concat([
        encipher.update(plaintext),
        encipher.final()
    ]);
}
AES.decrypt = function(encrypted, key, iv) {
    var decipher = crypto.createDecipheriv(algo, key, iv);
    return Buffer.concat([
        decipher.update(encrypted),
        decipher.final()
    ]);
}

/**********************************************************************************
Configuration
**********************************************************************************/
var algo = 'aes-256-cbc';
var textToEncrypt = 'rumpelstiltskin';
var iv = new Buffer('0000000000000000'); // This, in effect, removes security


/**********************************************************************************
Round-Trip Test (self-generated key)
**********************************************************************************/
var key = crypto.randomBytes(32);
var keyBuffer = new Buffer(key);
var enc = AES.encrypt(textToEncrypt, key, iv);
var dec = AES.decrypt(enc, key, iv);
console.log('Round-Trip Test (self-generated key):');
console.log('================');
console.log('key (base64):', key.toString('base64'));
console.log('value:', textToEncrypt);
console.log('encrypted: ', enc.toString('base64'));
console.log('decrypted: ' + dec.toString('utf8'));

console.log();

/**********************************************************************************
External Test: (key generated in .NET)
**********************************************************************************/
var key = new Buffer('L2cF8j9xCV+HYpypK4vLLHIh8XV3VJrndvpStTKPVi0=', 'base64');
var enc = AES.encrypt(textToEncrypt, key, iv);
var dec = AES.decrypt(enc, key, iv);
console.log('External Test: (key generated in .NET)');
console.log('================');
console.log('key (base64):', key.toString('base64'));
console.log('value:', textToEncrypt);
console.log('encrypted: ', enc.toString('base64'));
console.log('decrypted: ' + dec.toString('utf8'));

Program.cs

using System;
using System.Security.Cryptography;
using System.Text;

namespace Aes
{
    static class Program
    {
        static void Main()
        {
            RoundTripTest();
            
            Console.WriteLine();
            
            ExternalTest();

            Console.ReadKey();
        }

        private static void ExternalTest()
        {
            Console.WriteLine("External Test: (key generated in NodeJS)");
            Console.WriteLine("================");

            const string textToEncrypt = "rumpelstiltskin";
            var key = Convert.FromBase64String("QjKCs050O+Zh8Ff3m6+yVM61HgnW4QVQ5Tdr1REO/xk=");
            var iv = Encoding.UTF8.GetBytes("0000000000000000"); // This, in effect, removes security
            var keyBase64 = Convert.ToBase64String(key);
            var enc = Encrypt(textToEncrypt, key, iv);
            var dec = Decrypt(enc, key, iv);

            Console.WriteLine("key (base64): " + keyBase64);
            Console.WriteLine("value: " + textToEncrypt);
            Console.WriteLine("encrypted: " + Convert.ToBase64String(enc));
            Console.WriteLine("decrypted: " + Encoding.UTF8.GetString(dec));
        }

        private static void RoundTripTest()
        {
            Console.WriteLine("Round-Trip Test (self-generated key):");
            Console.WriteLine("================");

            const string textToEncrypt = "rumpelstiltskin";
            var key = GenerateSymmetricKey();
            var iv = Encoding.UTF8.GetBytes("0000000000000000"); // This, in effect, removes security
            var keyBase64 = Convert.ToBase64String(key);
            var enc = Encrypt(textToEncrypt, key, iv);
            var dec = Decrypt(enc, key, iv);

            Console.WriteLine("key (base64): " + keyBase64);
            Console.WriteLine("value: " + textToEncrypt);
            Console.WriteLine("encrypted: " + Convert.ToBase64String(enc));
            Console.WriteLine("decrypted: " + Encoding.UTF8.GetString(dec));
        }

        private static byte[] GenerateSymmetricKey(int size = 32)
        {
            try
            {
                byte[] keyBytes;
                using (var crypto = new RNGCryptoServiceProvider())
                {
                    keyBytes = new byte[size];
                    crypto.GetBytes(keyBytes);
                }
                return keyBytes;
            }
            finally
            {
                GC.Collect(0);
            }
        }

        public static byte[] Encrypt(string plaintext, byte[] key, byte[] iv)
        {
            byte[] encrypted;
            try
            {
                var aes = ConfigureAes(key, iv);
                var encryptor = aes.CreateEncryptor();
                var inputBuffer = Encoding.UTF8.GetBytes(plaintext);
                encrypted = encryptor.TransformFinalBlock(inputBuffer, 0, inputBuffer.Length);
            }
            catch (Exception)
            {
                encrypted = null;
            }
            return encrypted;
        }

        private static AesManaged ConfigureAes(byte[] secretBytes, byte[] iv)
        {
            var aes = new AesManaged
            {
                Mode = CipherMode.CBC,
                BlockSize = 128,
                KeySize = 256,
                Key = secretBytes,
                IV = iv
            };
            return aes;
        }

        public static byte[] Decrypt(byte[] encrypted, byte[] key, byte[] iv)
        {
            byte[] decrypted;
            try
            {
                var aes = ConfigureAes(key, iv);
                var decryptor = aes.CreateDecryptor();
                decrypted = decryptor.TransformFinalBlock(encrypted, 0, encrypted.Length);
            }
            catch (Exception)
            {
                decrypted = null;
            }
            return decrypted;
        }
    }
}