WingMan – Rev 32

?pathlinks?

Rev 14 – Rev 34 – Go to most recent revision – Blame – Compare with Previous – Last modification – View Log – Download

using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

namespace WingMan.Utilities
{
    public static class AES
    {
        private const int AesKeyIterations = 4096;
        private const int AesBlockSize = 128;
        private const CipherMode AesCipherMode = CipherMode.CBC;
        private const PaddingMode AesPaddingMode = PaddingMode.PKCS7;
        private const int AesKeySaltBytes = 16;
        private static readonly RNGCryptoServiceProvider Rng = new RNGCryptoServiceProvider();

        ///////////////////////////////////////////////////////////////////////////
        //  Copyright (C) Wizardry and Steamworks 2016 - License: GNU GPLv3      //
        ///////////////////////////////////////////////////////////////////////////
        /// <summary>
        ///     Encrypts a string given a key and initialization vector.
        /// </summary>
        /// <param name="data">the string to encrypt</param>
        /// <param name="key">the encryption key</param>
        /// <param name="separator">the separator to use between the cyphertext and the IV</param>
        /// <returns>Base64 encoded encrypted data</returns>
        public static async Task<byte[]> Encrypt(byte[] data, string key, string separator = ":")
        {
            using (var rijdanelManaged = new RijndaelManaged())
            {
                //  FIPS-197 / CBC
                rijdanelManaged.BlockSize = AesBlockSize;
                rijdanelManaged.Mode = AesCipherMode;
                rijdanelManaged.Padding = AesPaddingMode;

                // Compute the salt and the IV from the key.
                var salt = new byte[AesKeySaltBytes];
                Rng.GetBytes(salt);
                var derivedKey = new Rfc2898DeriveBytes(key, salt, AesKeyIterations);
                rijdanelManaged.Key = derivedKey.GetBytes(rijdanelManaged.KeySize / 8);
                rijdanelManaged.IV = derivedKey.GetBytes(rijdanelManaged.BlockSize / 8);

                using (var encryptor = rijdanelManaged.CreateEncryptor(rijdanelManaged.Key, rijdanelManaged.IV))
                {
                    using (var memoryStream = new MemoryStream())
                    {
                        using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
                        {
                            using (var inputStream = new MemoryStream(data))
                            {
                                await inputStream.CopyToAsync(cryptoStream);
                                cryptoStream.FlushFinalBlock();

                                inputStream.Position = 0L;

                                return salt.Concat(memoryStream.ToArray()).ToArray();
                            }
                        }
                    }
                }
            }
        }

        ///////////////////////////////////////////////////////////////////////////
        //  Copyright (C) Wizardry and Steamworks 2016 - License: GNU GPLv3      //
        ///////////////////////////////////////////////////////////////////////////
        /// <summary>
        ///     Decrypts a Base64 encoded string using AES with a given key and initialization vector.
        /// </summary>
        /// <param name="data">
        ///     a string consisting of the cyphertext to decrypt in Base64 and the IV in Base64 separated by the
        ///     separator
        /// </param>
        /// <param name="key">the encryption key</param>
        /// <param name="separator">the separator to use between the cyphertext and the IV</param>
        /// <returns>the decrypted data</returns>
        public static async Task<byte[]> Decrypt(byte[] data, string key, string separator = ":")
        {
            var salt = data.Take(AesKeySaltBytes).ToArray();
            var text = data.Skip(AesKeySaltBytes).ToArray();

            using (var rijdanelManaged = new RijndaelManaged())
            {
                //  FIPS-197 / CBC
                rijdanelManaged.BlockSize = AesBlockSize;
                rijdanelManaged.Mode = AesCipherMode;
                rijdanelManaged.Padding = AesPaddingMode;

                // Retrieve the key and the IV from the salt.
                var derivedKey = new Rfc2898DeriveBytes(key, salt, AesKeyIterations);
                rijdanelManaged.Key = derivedKey.GetBytes(rijdanelManaged.KeySize / 8);
                rijdanelManaged.IV = derivedKey.GetBytes(rijdanelManaged.BlockSize / 8);

                using (var decryptor = rijdanelManaged.CreateDecryptor(rijdanelManaged.Key, rijdanelManaged.IV))
                {
                    using (var memoryStream = new MemoryStream(text))
                    {
                        using (var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
                        {
                            using (var outputStream = new MemoryStream())
                            {
                                await cryptoStream.CopyToAsync(outputStream);

                                outputStream.Position = 0L;

                                return outputStream.ToArray();
                            }
                        }
                    }
                }
            }
        }

        public static string ExpandKey(string password, int size = 32)
        {
            var sb = new StringBuilder(password);
            do
            {
                sb.Append(password);
            } while (sb.Length < size);

            return sb.ToString(0, size);
        }
    }
}

---

Generated by GNU Enscript 1.6.5.90.