RsaEndpoint.cs

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using Waher.Networking.XMPP.P2P.SymmetricCiphers;
 
namespace Waher.Networking.XMPP.P2P.E2E
{
    public class RsaEndpoint : E2eEndpoint
    {
        private RSA rsa;
        private readonly byte[] modulus;
        private readonly byte[] exponent;
        private readonly int keySize;
        private byte[] publicKey;
        private string publicKeyBase64;
        private string modulusBase64;
        private string exponentBase64;
 
        public RsaEndpoint()
            : this(4096)
        {
        }
 
        public RsaEndpoint(int KeySize)
            : this(CreateRSA(KeySize))
        {
        }
 
        public RsaEndpoint(int KeySize, IE2eSymmetricCipher SymmetricCipher)
            : this(CreateRSA(KeySize), SymmetricCipher)
        {
        }
 
        private static RSA CreateRSA(int KeySize)
        {
            RSA Result = RSA.Create();
 
            if (Result.KeySize != KeySize)
                Result.KeySize = KeySize;
 
            return Result;
        }
 
        public RsaEndpoint(RSA Rsa)
            : this(Rsa, new Aes256())
        {
        }
 
        public RsaEndpoint(RSA Rsa, IE2eSymmetricCipher SymmetricCipher)
            : base(SymmetricCipher)
        {
            this.rsa = Rsa;
 
            RSAParameters P = this.rsa.ExportParameters(false);
 
            this.keySize = this.rsa.KeySize;
            this.modulus = P.Modulus;
            this.exponent = P.Exponent;
 
            this.Init();
        }
 
        public RsaEndpoint(int KeySize, byte[] Modulus, byte[] Exponent)
            : this(KeySize, Modulus, Exponent, new Aes256())
        {
        }
 
        public RsaEndpoint(int KeySize, byte[] Modulus, byte[] Exponent,
            IE2eSymmetricCipher SymmetricCipher)
            : base(SymmetricCipher)
        {
            this.rsa = CreateRSA(KeySize);
 
            this.keySize = KeySize;
            this.modulus = Modulus;
            this.exponent = Exponent;
 
            RSAParameters Param = new RSAParameters()
            {
                Modulus = Modulus,
                Exponent = Exponent
            };
 
            this.rsa.ImportParameters(Param);
 
            this.Init();
        }
 
        private void Init()
        {
            this.modulusBase64 = Convert.ToBase64String(this.modulus);
            this.exponentBase64 = Convert.ToBase64String(this.exponent);
 
            int c = this.modulus.Length;
            int d = this.exponent.Length;
 
            this.publicKey = new byte[2 + c + d];
 
            this.publicKey[0] = (byte)(this.keySize);
            this.publicKey[1] = (byte)(this.keySize >> 8);
            Buffer.BlockCopy(this.modulus, 0, this.publicKey, 2, c);
            Buffer.BlockCopy(this.exponent, 0, this.publicKey, c + 2, d);
 
            this.publicKeyBase64 = Convert.ToBase64String(this.publicKey);
        }
 
        public override string LocalName => "rsa";
 
        public int KeySize => this.keySize;
 
        public override byte[] PublicKey => this.publicKey;
 
        public override string PublicKeyBase64 => this.publicKeyBase64;
 
        public byte[] Modulus => this.modulus;
 
        public byte[] Exponent => this.exponent;
 
        public override int SecurityStrength
        {
            get
            {
                if (this.keySize < 768)
                    return 0;
                else if (this.keySize < 1024)
                    return 80;
                else if (this.keySize < 2048)
                    return 96;
                else if (this.keySize < 3072)
                    return 112;
                else if (this.keySize < 4096)
                    return 128;
                else if (this.keySize < 7680)
                    return 140;
                else if (this.keySize < 15360)
                    return 192;
                else
                    return 256;
            }
        }
 
        public override IE2eEndpoint Create(int SecurityStrength)
        {
            int KeySize;
 
            if (SecurityStrength <= 80)
                KeySize = 768;
            else if (SecurityStrength <= 96)
                KeySize = 1024;
            else if (SecurityStrength <= 112)
                KeySize = 2048;
            else if (SecurityStrength <= 128)
                KeySize = 3072;
            else if (SecurityStrength <= 140)
                KeySize = 4096;
            else if (SecurityStrength <= 192)
                KeySize = 7680;
            else if (SecurityStrength <= 256)
                KeySize = 15360;
            else
                throw new ArgumentException("Key strength too high.", nameof(SecurityStrength));
 
            RSA Rsa = CreateRSA(KeySize);
 
            return new RsaEndpoint(Rsa, this.DefaultSymmetricCipher.CreteNew());
        }
 
        public override IE2eEndpoint CreatePrivate(byte[] Secret)
        {
            RSAParameters P = new RSAParameters();
            string s = Encoding.ASCII.GetString(Secret);
            string[] Parts = s.Split(',');
            string Name;
            byte[] Value;
            int i;
 
            foreach (string Part in Parts)
            {
                i = Part.IndexOf('=');
                if (i < 0)
                    continue;
 
                Name = Part[..i];
                Value = Convert.FromBase64String(Part[(i + 1)..]);
 
                switch (Name)
                {
                    case "D": P.D = Value; break;
                    case "DP": P.DP = Value; break;
                    case "DQ": P.DQ = Value; break;
                    case "Exponent": P.Exponent = Value; break;
                    case "InverseQ": P.InverseQ = Value; break;
                    case "Modulus": P.Modulus = Value; break;
                    case "P": P.P = Value; break;
                    case "Q": P.Q = Value; break;
                }
            }
 
            RSA Rsa = RSA.Create();
            Rsa.ImportParameters(P);
 
            return new RsaEndpoint(Rsa, this.DefaultSymmetricCipher.CreteNew());
        }
 
        public byte[] Export(bool Private)
        {
            RSAParameters P = this.rsa.ExportParameters(Private);
            StringBuilder sb = new StringBuilder();
 
            sb.Append("Exponent=");
            sb.Append(Convert.ToBase64String(P.Exponent));
            sb.Append(",Modulus=");
            sb.Append(Convert.ToBase64String(P.Modulus));
            if (Private)
            {
                sb.Append(",D=");
                sb.Append(Convert.ToBase64String(P.D));
                sb.Append(",DP=");
                sb.Append(Convert.ToBase64String(P.DP));
                sb.Append(",DQ=");
                sb.Append(Convert.ToBase64String(P.DQ));
                sb.Append(",InverseQ=");
                sb.Append(Convert.ToBase64String(P.InverseQ));
                sb.Append(",P=");
                sb.Append(Convert.ToBase64String(P.P));
                sb.Append(",Q=");
                sb.Append(Convert.ToBase64String(P.P));
            }
 
            return Encoding.ASCII.GetBytes(sb.ToString());
        }
 
        public override IE2eEndpoint CreatePublic(byte[] PublicKey)
        {
            if (PublicKey.Length < 2)
                throw new ArgumentException("Invalid public key.", nameof(PublicKey));
 
            int KeySize = PublicKey[1];
            KeySize <<= 8;
            KeySize |= PublicKey[0];
 
            int ModSize = KeySize >> 3;
            if (PublicKey.Length < 2 + ModSize)
                throw new ArgumentException("Invalid public key.", nameof(PublicKey));
 
            int ExpSize = PublicKey.Length - 2 - ModSize;
            if (ExpSize <= 0)
                throw new ArgumentException("Invalid public key.", nameof(PublicKey));
 
            byte[] Modulus = new byte[ModSize];
            byte[] Exponent = new byte[ExpSize];
 
            Buffer.BlockCopy(PublicKey, 2, Modulus, 0, ModSize);
            Buffer.BlockCopy(PublicKey, 2 + ModSize, Exponent, 0, ExpSize);
 
            return new RsaEndpoint(KeySize, Modulus, Exponent, this.DefaultSymmetricCipher.CreteNew());
        }
 
        public override void Dispose()
        {
            base.Dispose();
 
            this.rsa?.Dispose();
            this.rsa = null;
        }
 
        public override byte[] GetSharedSecretForEncryption(IE2eEndpoint RemoteEndpoint,
            IE2eSymmetricCipher Cipher, out byte[] CipherText)
        {
            if (!(RemoteEndpoint is RsaEndpoint RemoteRsaEndpoint))
                throw new InvalidOperationException("Remote endpoint is not an RSA endpoint.");
 
            byte[] Secret = Cipher.GenerateKey();
 
            lock (RemoteRsaEndpoint.rsa)
            {
                CipherText = RemoteRsaEndpoint.rsa.Encrypt(Secret, RSAEncryptionPadding.OaepSHA256);
            }
 
            return Secret;
        }
 
        public override byte[] GetSharedSecretForDecryption(IE2eEndpoint RemoteEndpoint,
            byte[] CipherText)
        {
            lock (this.rsa)
            {
                return this.rsa.Decrypt(CipherText, RSAEncryptionPadding.OaepSHA256);
            }
        }
 
        public override bool SharedSecretUseCipherText => true;
 
        public override byte[] Sign(byte[] Data)
        {
            return this.rsa.SignData(Data, HashAlgorithmName.SHA256, RSASignaturePadding.Pss);
        }
 
        public override byte[] Sign(Stream Data)
        {
            return this.rsa.SignData(Data, HashAlgorithmName.SHA256, RSASignaturePadding.Pss);
        }
 
        public override bool Verify(byte[] Data, byte[] Signature)
        {
            return RsaEndpoint.Verify(Data, Signature, this.keySize, this.modulus, this.exponent);
        }
 
        public override bool Verify(Stream Data, byte[] Signature)
        {
            return RsaEndpoint.Verify(Data, Signature, this.keySize, this.modulus, this.exponent);
        }
 
        public static bool Verify(byte[] Data, byte[] Signature, int KeySize, byte[] PublicKey)
        {
            int c = KeySize >> 3;
            int d = PublicKey.Length - c;
            if (d <= 0)
                throw new ArgumentException("Invalid public key.", nameof(PublicKey));
 
            byte[] Modulus = new byte[c];
            byte[] Exponent = new byte[d];
 
            Buffer.BlockCopy(PublicKey, 0, Modulus, 0, c);
            Buffer.BlockCopy(PublicKey, c, Exponent, 0, d);
 
            return Verify(Data, Signature, KeySize, Modulus, Exponent);
        }
 
        public static bool Verify(Stream Data, byte[] Signature, int KeySize, byte[] PublicKey)
        {
            int c = KeySize >> 3;
            int d = PublicKey.Length - c;
            if (d <= 0)
                throw new ArgumentException("Invalid public key.", nameof(PublicKey));
 
            byte[] Modulus = new byte[c];
            byte[] Exponent = new byte[d];
 
            Buffer.BlockCopy(PublicKey, 0, Modulus, 0, c);
            Buffer.BlockCopy(PublicKey, c, Exponent, 0, d);
 
            return Verify(Data, Signature, KeySize, Modulus, Exponent);
        }
 
        public static bool Verify(byte[] Data, byte[] Signature, int KeySize, byte[] Modulus, byte[] Exponent)
        {
            using RSA Rsa = CreateRSA(KeySize);
            RSAParameters P = new RSAParameters()
            {
                Modulus = Modulus,
                Exponent = Exponent
            };
 
            Rsa.ImportParameters(P);
 
            return Rsa.VerifyData(Data, Signature, HashAlgorithmName.SHA256, RSASignaturePadding.Pss);
        }
 
        public static bool Verify(Stream Data, byte[] Signature, int KeySize, byte[] Modulus, byte[] Exponent)
        {
            using RSA Rsa = CreateRSA(KeySize);
            RSAParameters P = new RSAParameters()
            {
                Modulus = Modulus,
                Exponent = Exponent
            };
 
            Rsa.ImportParameters(P);
 
            return Rsa.VerifyData(Data, Signature, HashAlgorithmName.SHA256, RSASignaturePadding.Pss);
        }
 
        public override bool Slow => true;
 
        public override bool Equals(object obj)
        {
            return obj is RsaEndpoint RsaEndpoint &&
                this.keySize.Equals(RsaEndpoint.keySize) &&
                this.modulusBase64.Equals(RsaEndpoint.modulusBase64) &&
                this.exponentBase64.Equals(RsaEndpoint.exponentBase64);
        }
 
        public override int GetHashCode()
        {
            int Result = this.keySize.GetHashCode();
            Result ^= Result << 5 ^ this.modulusBase64.GetHashCode();
            Result ^= Result << 5 ^ this.exponentBase64.GetHashCode();
 
            return Result;
        }
    }
}