Aes256.cs

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content.Xml;
using Waher.Runtime.Temporary;
using Waher.Security;
 
namespace Waher.Networking.XMPP.P2P.SymmetricCiphers
{
    public class Aes256 : E2eSymmetricCipher
    {
        protected Aes aes;
 
        public Aes256()
        {
            this.aes = Aes.Create();
            this.aes.BlockSize = 128;
            this.aes.KeySize = 256;
            this.aes.Mode = CipherMode.CBC;
            this.aes.Padding = PaddingMode.None;
        }
 
        public override string LocalName => "aes";
 
        public override bool Supported(XmlElement E2e)
        {
            return XML.Attribute(E2e, "aes", false);
        }
 
        public override IE2eSymmetricCipher CreteNew()
        {
            return new Aes256();
        }
 
        public override void Dispose()
        {
            base.Dispose();
 
            this.aes?.Dispose();
            this.aes = null;
        }
 
        public override byte[] GetIV(string Id, string Type, string From, string To, uint Counter)
        {
            byte[] IV = Hashes.ComputeSHA256Hash(Encoding.UTF8.GetBytes(Id + Type + From + To));
            Array.Resize(ref IV, 16);
 
            IV[12] = (byte)Counter;
            Counter >>= 8;
            IV[13] = (byte)Counter;
            Counter >>= 8;
            IV[14] = (byte)Counter;
            Counter >>= 8;
            IV[15] = (byte)Counter;
 
            return IV;
        }
 
        protected override long GetEncryptedLength(long ContentLength)
        {
            return (ContentLength + 15L) & ~0xfL;
        }
 
        public override byte[] Encrypt(byte[] Data, byte[] Key, byte[] IV, byte[] AssociatedData,
            E2eBufferFillAlgorithm FillAlgorithm)
        {
            byte[] Encrypted = base.Encrypt(Data, Key, IV, AssociatedData, FillAlgorithm);
 
            lock (this.aes)
            {
                using ICryptoTransform Aes = this.aes.CreateEncryptor(Key, IV);
                
                Encrypted = Aes.TransformFinalBlock(Encrypted, 0, Encrypted.Length);
            }
 
            return Encrypted;
        }
 
        public override byte[] Decrypt(byte[] Data, byte[] Key, byte[] IV, byte[] AssociatedData)
        {
            lock (this.aes)
            {
                using ICryptoTransform Aes = this.aes.CreateDecryptor(Key, IV);
                
                Data = Aes.TransformFinalBlock(Data, 0, Data.Length);
            }
 
            return base.Decrypt(Data, Key, IV, AssociatedData);
        }
 
        public override async Task Encrypt(Stream Data, Stream Encrypted, byte[] Key, byte[] IV, byte[] AssociatedData)
        {
            TemporaryStream PreEncrypt = new TemporaryStream();
            ICryptoTransform Aes = null;
 
            try
            {
                await base.Encrypt(Data, PreEncrypt, Key, IV, AssociatedData);
                PreEncrypt.Position = 0;
 
                lock (this.aes)
                {
                    Aes = this.aes.CreateEncryptor(Key, IV);
                }
 
                await Crypto.CryptoTransform(Aes, PreEncrypt, Encrypted);
            }
            finally
            {
                PreEncrypt.Dispose();
                Aes?.Dispose();
            }
        }
 
        public override async Task<Stream> Decrypt(Stream Data, byte[] Key, byte[] IV, byte[] AssociatedData)
        {
            ICryptoTransform Aes = null;
            TemporaryStream Decrypted = new TemporaryStream();
 
            try
            {
                lock (this.aes)
                {
                    Aes = this.aes.CreateDecryptor(Key, IV);
                }
 
                await Crypto.CryptoTransform(Aes, Data, Decrypted);
 
                Decrypted.Position = 0;
                return await base.Decrypt(Decrypted, Key, IV, AssociatedData);
            }
            finally
            {
                Decrypted.Dispose();
                Aes?.Dispose();
            }
        }
 
        public override byte[] GenerateKey()
        {
            lock (this.aes)
            {
                this.aes.GenerateKey();
                return this.aes.Key;
            }
        }
 
    }
}