E2eSymmetricCipher.cs

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Runtime.IO;
using Waher.Runtime.Temporary;
using Waher.Security;
 
namespace Waher.Networking.XMPP.P2P.SymmetricCiphers
{
    public abstract class E2eSymmetricCipher : IE2eSymmetricCipher
    {
        protected readonly static RandomNumberGenerator rnd = RandomNumberGenerator.Create();
 
        public abstract string LocalName { get; }
 
        public virtual string Namespace => EndpointSecurity.IoTHarmonizationE2ECurrent;
 
        public virtual bool AuthenticatedEncryption => false;
 
        public virtual void Dispose()
        {
        }
 
        public static IE2eSymmetricCipher Create(SymmetricCipherAlgorithms Algorithm)
        {
            return Algorithm switch
            {
                SymmetricCipherAlgorithms.Aes256 => new Aes256(),
                SymmetricCipherAlgorithms.ChaCha20 => new ChaCha20(),
                SymmetricCipherAlgorithms.AeadChaCha20Poly1305 => new AeadChaCha20Poly1305(),
                _ => throw new ArgumentException("Unrecognized algorithm: " + Algorithm.ToString(), nameof(Algorithm)),
            };
        }
 
        public abstract bool Supported(XmlElement E2e);
 
        public abstract IE2eSymmetricCipher CreteNew();
 
        public abstract byte[] GetIV(string Id, string Type, string From, string To, uint Counter);
 
        protected virtual long GetEncryptedLength(long ContentLength)
        {
            return ContentLength;
        }
 
        public virtual byte[] Encrypt(byte[] Data, byte[] Key, byte[] IV, byte[] AssociatedData,
            E2eBufferFillAlgorithm FillAlgorithm)
        {
            int c = Data.Length;
            int d = 0;
            int i = c;
 
            do
            {
                i >>= 7;
                d++;
            }
            while (i != 0);
 
            int ContentLen = c + d;
            int BlockLen = (int)this.GetEncryptedLength(ContentLen);
            byte[] Encrypted = new byte[BlockLen];
            int j = 0;
 
            i = c;
 
            do
            {
                Encrypted[j] = (byte)(i & 127);
                i >>= 7;
                if (i != 0)
                    Encrypted[j] |= 0x80;
 
                j++;
            }
            while (i != 0);
 
            Buffer.BlockCopy(Data, 0, Encrypted, j, c);
 
            if (ContentLen < BlockLen)
            {
                switch (FillAlgorithm)
                {
                    case E2eBufferFillAlgorithm.Random:
                    default:
                        c = BlockLen - ContentLen;
                        byte[] Bin = new byte[c];
 
                        lock (rnd)
                        {
                            rnd.GetBytes(Bin);
                        }
 
                        Buffer.BlockCopy(Bin, 0, Encrypted, ContentLen, c);
                        break;
 
                    case E2eBufferFillAlgorithm.Zeroes:
                        break;
                }
            }
 
            return Encrypted;
        }
 
        public virtual byte[] Decrypt(byte[] Data, byte[] Key, byte[] IV, byte[] AssociatedData)
        {
            int c = 0;
            int i = 0;
            int Offset = 0;
            byte b;
 
            do
            {
                b = Data[i++];
 
                c |= (b & 127) << Offset;
                Offset += 7;
            }
            while (b >= 0x80);
 
            if (c < 0 || c + i > Data.Length)
                return null;
 
            byte[] Decrypted = new byte[c];
 
            Buffer.BlockCopy(Data, i, Decrypted, 0, c);
 
            return Decrypted;
        }
 
        public virtual async Task Encrypt(Stream Data, Stream Encrypted, byte[] Key, byte[] IV, byte[] AssociatedData)
        {
            long c = Data.Length;
            int d = 0;
            long i = c;
 
            do
            {
                i >>= 7;
                d++;
            }
            while (i != 0);
 
            long ContentLen = c + d;
            long BlockLen = this.GetEncryptedLength(ContentLen);
            byte b;
 
            i = c;
 
            do
            {
                b = (byte)(i & 127);
                i >>= 7;
                if (i != 0)
                    b |= 0x80;
 
                Encrypted.WriteByte(b);
            }
            while (i != 0);
 
            await Data.CopyToAsync(Encrypted);
 
            if (ContentLen < BlockLen)
            {
                c = BlockLen - ContentLen;
                byte[] Bin = new byte[c];
 
                lock (rnd)
                {
                    rnd.GetBytes(Bin);
                }
 
                await Encrypted.WriteAsync(Bin, 0, (int)c);
            }
        }
 
        public virtual async Task<Stream> Decrypt(Stream Data, byte[] Key, byte[] IV, byte[] AssociatedData)
        {
            int c = 0;
            int i;
            int Offset = 0;
 
            do
            {
                i = Data.ReadByte();
                if (i < 0)
                    return null;
 
                c |= (i & 127) << Offset;
                Offset += 7;
            }
            while (i >= 0x80);
 
            if (c < 0 || c + Data.Position > Data.Length)
                return null;
 
            TemporaryStream Decrypted = new TemporaryStream();
            try
            {
                await Crypto.CopyAsync(Data, Decrypted, c);
                return Decrypted;
            }
            catch (Exception)
            {
                Decrypted.Dispose();
                return null;
            }
        }
 
        public abstract byte[] GenerateKey();
 
        public virtual byte[] Encrypt(string Id, string Type, string From, string To, uint Counter, byte[] Data, IE2eEndpoint Sender, IE2eEndpoint Receiver)
        {
            byte[] Encrypted;
            byte[] Key;
            byte[] IV = this.GetIV(Id, Type, From, To, Counter);
            byte[] AssociatedData = this.AuthenticatedEncryption ? Encoding.UTF8.GetBytes(From) : null;
            byte[] Signature;
            byte[] Block;
            int i, j, k, l;
            int c = 8;
 
            Key = Sender.GetSharedSecretForEncryption(Receiver, this, out byte[] KeyCipherText);
            if (KeyCipherText is null)
            {
                l = 0;
 
                if (Sender.SharedSecretUseCipherText)
                    c += 2;
            }
            else
            {
                if (!Sender.SharedSecretUseCipherText)
                    throw new InvalidOperationException("Shared secret ciphertexts not supported.");
 
                l = KeyCipherText.Length;
                c += l + 2;
            }
 
            Encrypted = this.Encrypt(Data, Key, IV, AssociatedData, E2eBufferFillAlgorithm.Random);
            i = Encrypted.Length;
            j = 0;
            c += i;
 
            if (Sender.SupportsSignatures)
            {
                Signature = Sender.Sign(Data);
                k = Signature.Length;
                c += k + 1;
                if (k >= 128)
                    c++;
            }
            else
            {
                k = 0;
                Signature = null;
            }
 
            Block = new byte[c];
 
            if (k > 0)
            {
                if (k < 128)
                    Block[j++] = (byte)k;
                else
                {
                    Block[j++] = (byte)(k | 128);
                    Block[j++] = (byte)(k >> 7);
                }
            }
 
            if (Sender.SharedSecretUseCipherText)
            {
                Block[j++] = (byte)l;
                Block[j++] = (byte)(l >> 8);
            }
 
            Block[j++] = (byte)i;
            Block[j++] = (byte)(i >> 8);
            Block[j++] = (byte)(i >> 16);
            Block[j++] = (byte)(i >> 24);
 
            Block[j++] = (byte)Counter;
            Block[j++] = (byte)(Counter >> 8);
            Block[j++] = (byte)(Counter >> 16);
            Block[j++] = (byte)(Counter >> 24);
 
            if (k > 0)
            {
                Buffer.BlockCopy(Signature, 0, Block, j, k);
                j += k;
            }
 
            if (l > 0)
            {
                Buffer.BlockCopy(KeyCipherText, 0, Block, j, l);
                j += l;
            }
 
            Buffer.BlockCopy(Encrypted, 0, Block, j, i);
 
            return Block;
        }
 
        public virtual byte[] Decrypt(string Id, string Type, string From, string To, byte[] Data, IE2eEndpoint Sender, IE2eEndpoint Receiver)
        {
            if (Data.Length < 8)
                return null;
 
            int SignatureLen;
            int KeyLen;
            int DataLen;
            uint Counter;
            int i = 0;
 
            if (Receiver.SupportsSignatures)
            {
                SignatureLen = Data[i++];
                if ((SignatureLen & 128) != 0)
                {
                    SignatureLen &= 127;
                    SignatureLen |= Data[i++] << 7;
                }
            }
            else
                SignatureLen = 0;
 
            if (Receiver.SharedSecretUseCipherText)
            {
                KeyLen = Data[i++];
                KeyLen |= Data[i++] << 8;
            }
            else
                KeyLen = 0;
 
            if (i + 4 > Data.Length)
                return null;
 
            DataLen = Data[i++];
            DataLen |= Data[i++] << 8;
            DataLen |= Data[i++] << 16;
            DataLen |= Data[i++] << 24;
 
            Counter = Data[i++];
            Counter |= (uint)(Data[i++] << 8);
            Counter |= (uint)(Data[i++] << 16);
            Counter |= (uint)(Data[i++] << 24);
 
            if (Data.Length != i + SignatureLen + KeyLen + DataLen)
                return null;
 
            byte[] Signature = new byte[SignatureLen];
            byte[] KeyCipherText = KeyLen > 0 ? new byte[KeyLen] : null;
            byte[] Encrypted = new byte[DataLen];
            byte[] Key;
 
            Buffer.BlockCopy(Data, i, Signature, 0, SignatureLen);
            i += SignatureLen;
 
            if (KeyLen > 0)
            {
                Buffer.BlockCopy(Data, i, KeyCipherText, 0, KeyLen);
                i += KeyLen;
            }
 
            Buffer.BlockCopy(Data, i, Encrypted, 0, DataLen);
 
            Key = Receiver.GetSharedSecretForDecryption(Sender, KeyCipherText);
 
            byte[] Decrypted;
            byte[] IV = this.GetIV(Id, Type, From, To, Counter);
            byte[] AssociatedData = this.AuthenticatedEncryption ? Encoding.UTF8.GetBytes(From) : null;
 
            try
            {
                Decrypted = this.Decrypt(Encrypted, Key, IV, AssociatedData);
 
                if (!(Decrypted is null) &&
                    ((Sender.SupportsSignatures && Sender.Verify(Decrypted, Signature)) ||
                    (!Sender.SupportsSignatures && SignatureLen == 0)))
                {
                    return Decrypted;
                }
            }
            catch (Exception)
            {
                // Invalid key
            }
 
            if (!(Receiver.Previous is null))
            {
                try
                {
                    Key = Receiver.Previous.GetSharedSecretForDecryption(Sender, KeyCipherText);
 
                    if (!(Key is null))
                    {
                        Decrypted = this.Decrypt(Encrypted, Key, IV, AssociatedData);
 
                        if (!(Decrypted is null) &&
                            ((Sender.SupportsSignatures && Sender.Verify(Decrypted, Signature)) ||
                            (!Sender.SupportsSignatures && SignatureLen == 0)))
                        {
                            return Decrypted;
                        }
                    }
                }
                catch (Exception)
                {
                    // Invalid key
                }
            }
 
            return null;
        }
 
        public virtual async Task Encrypt(string Id, string Type, string From, string To, uint Counter, Stream Data, Stream Encrypted, IE2eEndpoint Sender, IE2eEndpoint Receiver)
        {
            using TemporaryStream TempEncrypted = new TemporaryStream();
 
            byte[] Key;
            byte[] IV = this.GetIV(Id, Type, From, To, Counter);
            byte[] AssociatedData = this.AuthenticatedEncryption ? Encoding.UTF8.GetBytes(From) : null;
            byte[] Signature;
            long i;
            int k, l;
 
            Key = Sender.GetSharedSecretForEncryption(Receiver, this, out byte[] KeyCipherText);
            if (KeyCipherText is null)
                l = 0;
            else
            {
                if (!Sender.SharedSecretUseCipherText)
                    throw new InvalidOperationException("Shared secret ciphertexts not supported.");
 
                l = KeyCipherText.Length;
            }
 
            await this.Encrypt(Data, TempEncrypted, Key, IV, AssociatedData);
            i = TempEncrypted.Length;
 
            if (i > uint.MaxValue)
                throw new NotSupportedException("Too large.");
 
            if (Sender.SupportsSignatures)
            {
                Data.Position = 0;
                Signature = Sender.Sign(Data);
                k = Signature.Length;
            }
            else
            {
                k = 0;
                Signature = null;
            }
 
            if (k > 0)
            {
                if (k < 128)
                    Encrypted.WriteByte((byte)k);
                else
                {
                    Encrypted.WriteByte((byte)(k | 128));
                    Encrypted.WriteByte((byte)(k >> 7));
                }
            }
 
            if (Receiver.SharedSecretUseCipherText)
            {
                Encrypted.WriteByte((byte)l);
                Encrypted.WriteByte((byte)(l >> 8));
            }
 
            Encrypted.WriteByte((byte)i);
            Encrypted.WriteByte((byte)(i >> 8));
            Encrypted.WriteByte((byte)(i >> 16));
            Encrypted.WriteByte((byte)(i >> 24));
 
            Encrypted.WriteByte((byte)Counter);
            Encrypted.WriteByte((byte)(Counter >> 8));
            Encrypted.WriteByte((byte)(Counter >> 16));
            Encrypted.WriteByte((byte)(Counter >> 24));
 
            if (k > 0)
                await Encrypted.WriteAsync(Signature, 0, k);
 
            if (l > 0)
                await Encrypted.WriteAsync(KeyCipherText, 0, l);
 
            TempEncrypted.Position = 0;
            await TempEncrypted.CopyToAsync(Encrypted);
        }
 
        public virtual async Task<Stream> Decrypt(string Id, string Type, string From, string To, Stream Data, IE2eEndpoint Sender, IE2eEndpoint Receiver)
        {
            if (Data.Length < 8)
                return null;
 
            int SignatureLen;
            int KeyLen;
            int DataLen;
            uint Counter;
 
            if (Receiver.SupportsSignatures)
            {
                SignatureLen = Data.ReadByte();
                if ((SignatureLen & 128) != 0)
                {
                    SignatureLen &= 127;
                    SignatureLen |= Data.ReadByte() << 7;
                }
            }
            else
                SignatureLen = 0;
 
            if (Receiver.SharedSecretUseCipherText)
            {
                KeyLen = Data.ReadByte();
                KeyLen |= Data.ReadByte() << 8;
            }
            else
                KeyLen = 0;
 
            if (Data.Position + 4 > Data.Length)
                return null;
 
            DataLen = Data.ReadByte();
            DataLen |= Data.ReadByte() << 8;
            DataLen |= Data.ReadByte() << 16;
            DataLen |= Data.ReadByte() << 24;
 
            Counter = (byte)Data.ReadByte();
            Counter |= (uint)(Data.ReadByte() << 8);
            Counter |= (uint)(Data.ReadByte() << 16);
            Counter |= (uint)(Data.ReadByte() << 24);
 
            if (Data.Length != Data.Position + SignatureLen + KeyLen + DataLen)
                return null;
 
            byte[] Signature = new byte[SignatureLen];
            byte[] KeyCipherText = KeyLen > 0 ? new byte[KeyLen] : null;
            byte[] Key;
 
            if (await Data.TryReadAllAsync(Signature, 0, SignatureLen) != SignatureLen)
                return null;
 
            if (KeyLen > 0)
            {
                if (await Data.TryReadAllAsync(KeyCipherText, 0, KeyLen) != KeyLen)
                    return null;
            }
 
            using TemporaryStream Encrypted = new TemporaryStream();
 
            await Crypto.CopyAsync(Data, Encrypted, DataLen);
 
            Key = Receiver.GetSharedSecretForDecryption(Sender, KeyCipherText);
 
            byte[] IV = this.GetIV(Id, Type, From, To, Counter);
            byte[] AssociatedData = this.AuthenticatedEncryption ? Encoding.UTF8.GetBytes(From) : null;
            Stream Decrypted = null;
 
            try
            {
                Encrypted.Position = 0;
                Decrypted = await this.Decrypt(Encrypted, Key, IV, AssociatedData);
 
                if (!(Decrypted is null))
                {
                    Decrypted.Position = 0;
 
                    if ((Sender.SupportsSignatures && Sender.Verify(Decrypted, Signature)) ||
                        (!Sender.SupportsSignatures && SignatureLen == 0))
                    {
                        return Decrypted;
                    }
 
                    Decrypted.Dispose();
                    Decrypted = null;
                }
            }
            catch (Exception)
            {
                // Invalid key
 
                Decrypted?.Dispose();
                Decrypted = null;
            }
 
            if (!(Receiver.Previous is null))
            {
                try
                {
                    Key = Receiver.Previous.GetSharedSecretForDecryption(Sender, KeyCipherText);
 
                    if (!(Key is null))
                    {
                        Encrypted.Position = 0;
                        Decrypted = await this.Decrypt(Encrypted, Key, IV, AssociatedData);
 
                        if (!(Decrypted is null))
                        {
                            Decrypted.Position = 0;
 
                            if ((Sender.SupportsSignatures && Sender.Verify(Decrypted, Signature)) ||
                                (!Sender.SupportsSignatures && SignatureLen == 0))
                            {
                                return Decrypted;
                            }
 
                            Decrypted.Dispose();
                            Decrypted = null;
                        }
                    }
                }
                catch (Exception)
                {
                    // Invalid key
 
                    Decrypted?.Dispose();
                    Decrypted = null;
                }
            }
 
            return null;
        }
 
 
        public virtual bool Encrypt(string Id, string Type, string From, string To, uint Counter, byte[] Data,
            StringBuilder Xml, IE2eEndpoint Sender, IE2eEndpoint Receiver)
        {
            byte[] Encrypted;
            byte[] Key;
            byte[] IV = this.GetIV(Id, Type, From, To, Counter);
            byte[] AssociatedData = this.AuthenticatedEncryption ? Encoding.UTF8.GetBytes(From) : null;
 
            Xml.Append('<');
            Xml.Append(this.LocalName);
            Xml.Append(" xmlns=\"");
            Xml.Append(this.Namespace);
            Xml.Append("\" r=\"");
            if (Sender.Namespace != EndpointSecurity.IoTHarmonizationE2ECurrent)
            {
                Xml.Append(Sender.Namespace);
                Xml.Append('#');
            }
            Xml.Append(Sender.LocalName);
            Xml.Append("\" c=\"");
            Xml.Append(Counter.ToString());
 
            Key = Sender.GetSharedSecretForEncryption(Receiver, this, out byte[] KeyCipherText);
 
            if (!(KeyCipherText is null))
            {
                if (!Sender.SharedSecretUseCipherText)
                    throw new InvalidOperationException("Shared secret ciphertexts not supported.");
 
                Xml.Append("\" k=\"");
                Xml.Append(Convert.ToBase64String(KeyCipherText));
            }
 
            Encrypted = this.Encrypt(Data, Key, IV, AssociatedData, E2eBufferFillAlgorithm.Random);
 
            if (Sender.SupportsSignatures)
            {
                byte[] Signature = Sender.Sign(Data);
 
                Xml.Append("\" s=\"");
                Xml.Append(Convert.ToBase64String(Signature));
            }
 
            Xml.Append("\">");
            Xml.Append(Convert.ToBase64String(Encrypted));
            Xml.Append("</");
            Xml.Append(this.LocalName);
            Xml.Append('>');
 
            return true;
        }
 
        public virtual string Decrypt(string Id, string Type, string From, string To, XmlElement Xml,
            IE2eEndpoint Sender, IE2eEndpoint Receiver)
        {
            byte[] KeyCipherText = null;
            byte[] Signature = null;
            uint? Counter = null;
 
            foreach (XmlAttribute Attr in Xml.Attributes)
            {
                switch (Attr.Name)
                {
                    case "c":
                        if (!uint.TryParse(Attr.Value, out uint i))
                            return null;
 
                        Counter = i;
                        break;
 
                    case "s":
                        Signature = Convert.FromBase64String(Attr.Value);
                        break;
 
                    case "k":
                        KeyCipherText = Convert.FromBase64String(Attr.Value);
                        break;
                }
            }
 
            if (!Counter.HasValue)
                return null;
 
            byte[] Encrypted = Convert.FromBase64String(Xml.InnerText);
            byte[] Decrypted;
            byte[] Key;
 
            Key = Receiver.GetSharedSecretForDecryption(Sender, KeyCipherText);
 
            byte[] IV = this.GetIV(Id, Type, From, To, Counter.Value);
            byte[] AssociatedData = this.AuthenticatedEncryption ? Encoding.UTF8.GetBytes(From) : null;
 
            try
            {
                Decrypted = this.Decrypt(Encrypted, Key, IV, AssociatedData);
 
                if (!(Decrypted is null) &&
                    ((Sender.SupportsSignatures && Sender.Verify(Decrypted, Signature)) ||
                    (!Sender.SupportsSignatures && Signature is null)))
                {
                    return Encoding.UTF8.GetString(Decrypted);
                }
            }
            catch (Exception)
            {
                // Invalid key
            }
 
            if (!(Receiver.Previous is null))
            {
                try
                {
                    Key = Receiver.Previous.GetSharedSecretForDecryption(Sender, KeyCipherText);
 
                    if (!(Key is null))
                    {
                        Decrypted = this.Decrypt(Encrypted, Key, IV, AssociatedData);
 
                        if (!(Decrypted is null) &&
                            ((Sender.SupportsSignatures && Sender.Verify(Decrypted, Signature)) ||
                            (!Sender.SupportsSignatures && Signature is null)))
                        {
                            return Encoding.UTF8.GetString(Decrypted);
                        }
                    }
                }
                catch (Exception)
                {
                    // Invalid key
                }
            }
 
            return null;
        }
    }
}