RSA.cs

using System.IO;
using System.Runtime.InteropServices;
using System.Security.Util;
using System.Text;

namespace System.Security.Cryptography
{
    [ComVisible(true)]
    public abstract class RSA : AsymmetricAlgorithm
    {
        public override string KeyExchangeAlgorithm => "RSA";

        public override string SignatureAlgorithm => "RSA";

        public new static RSA Create()
        {
            return Create("System.Security.Cryptography.RSA");
        }

        public new static RSA Create(string algName)
        {
            return (RSA)CryptoConfig.CreateFromName(algName);
        }

        public virtual byte[] Encrypt(byte[] data, RSAEncryptionPadding padding)
        {
            throw DerivedClassMustOverride();
        }

        public virtual byte[] Decrypt(byte[] data, RSAEncryptionPadding padding)
        {
            throw DerivedClassMustOverride();
        }

        public virtual byte[] SignHash(byte[] hash, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
        {
            throw DerivedClassMustOverride();
        }

        public virtual bool VerifyHash(byte[] hash, byte[] signature, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
        {
            throw DerivedClassMustOverride();
        }

        protected virtual byte[] HashData(byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm)
        {
            throw DerivedClassMustOverride();
        }

        protected virtual byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm)
        {
            throw DerivedClassMustOverride();
        }

        public byte[] SignData(byte[] data, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            return SignData(data, 0, data.Length, hashAlgorithm, padding);
        }

        public virtual byte[] SignData(byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            if (offset < 0 || offset > data.Length)
            {
                throw new ArgumentOutOfRangeException("offset");
            }
            if (count < 0 || count > data.Length - offset)
            {
                throw new ArgumentOutOfRangeException("count");
            }
            if (string.IsNullOrEmpty(hashAlgorithm.Name))
            {
                throw HashAlgorithmNameNullOrEmpty();
            }
            if (padding == null)
            {
                throw new ArgumentNullException("padding");
            }
            byte[] hash = HashData(data, offset, count, hashAlgorithm);
            return SignHash(hash, hashAlgorithm, padding);
        }

        public virtual byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            if (string.IsNullOrEmpty(hashAlgorithm.Name))
            {
                throw HashAlgorithmNameNullOrEmpty();
            }
            if (padding == null)
            {
                throw new ArgumentNullException("padding");
            }
            byte[] hash = HashData(data, hashAlgorithm);
            return SignHash(hash, hashAlgorithm, padding);
        }

        public bool VerifyData(byte[] data, byte[] signature, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            return VerifyData(data, 0, data.Length, signature, hashAlgorithm, padding);
        }

        public virtual bool VerifyData(byte[] data, int offset, int count, byte[] signature, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            if (offset < 0 || offset > data.Length)
            {
                throw new ArgumentOutOfRangeException("offset");
            }
            if (count < 0 || count > data.Length - offset)
            {
                throw new ArgumentOutOfRangeException("count");
            }
            if (signature == null)
            {
                throw new ArgumentNullException("signature");
            }
            if (string.IsNullOrEmpty(hashAlgorithm.Name))
            {
                throw HashAlgorithmNameNullOrEmpty();
            }
            if (padding == null)
            {
                throw new ArgumentNullException("padding");
            }
            byte[] hash = HashData(data, offset, count, hashAlgorithm);
            return VerifyHash(hash, signature, hashAlgorithm, padding);
        }

        public bool VerifyData(Stream data, byte[] signature, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            if (signature == null)
            {
                throw new ArgumentNullException("signature");
            }
            if (string.IsNullOrEmpty(hashAlgorithm.Name))
            {
                throw HashAlgorithmNameNullOrEmpty();
            }
            if (padding == null)
            {
                throw new ArgumentNullException("padding");
            }
            byte[] hash = HashData(data, hashAlgorithm);
            return VerifyHash(hash, signature, hashAlgorithm, padding);
        }

        private static Exception DerivedClassMustOverride()
        {
            return new NotImplementedException(Environment.GetResourceString("NotSupported_SubclassOverride"));
        }

        internal static Exception HashAlgorithmNameNullOrEmpty()
        {
            return new ArgumentException(Environment.GetResourceString("Cryptography_HashAlgorithmNameNullOrEmpty"), "hashAlgorithm");
        }

        public virtual byte[] DecryptValue(byte[] rgb)
        {
            throw new NotSupportedException(Environment.GetResourceString("NotSupported_Method"));
        }

        public virtual byte[] EncryptValue(byte[] rgb)
        {
            throw new NotSupportedException(Environment.GetResourceString("NotSupported_Method"));
        }

        public override void FromXmlString(string xmlString)
        {
            if (xmlString == null)
            {
                throw new ArgumentNullException("xmlString");
            }
            RSAParameters parameters = default(RSAParameters);
            Parser parser = new Parser(xmlString);
            SecurityElement topElement = parser.GetTopElement();
            string text = topElement.SearchForTextOfLocalName("Modulus");
            if (text == null)
            {
                throw new CryptographicException(Environment.GetResourceString("Cryptography_InvalidFromXmlString", "RSA", "Modulus"));
            }
            parameters.Modulus = Convert.FromBase64String(Utils.DiscardWhiteSpaces(text));
            string text2 = topElement.SearchForTextOfLocalName("Exponent");
            if (text2 == null)
            {
                throw new CryptographicException(Environment.GetResourceString("Cryptography_InvalidFromXmlString", "RSA", "Exponent"));
            }
            parameters.Exponent = Convert.FromBase64String(Utils.DiscardWhiteSpaces(text2));
            string text3 = topElement.SearchForTextOfLocalName("P");
            if (text3 != null)
            {
                parameters.P = Convert.FromBase64String(Utils.DiscardWhiteSpaces(text3));
            }
            string text4 = topElement.SearchForTextOfLocalName("Q");
            if (text4 != null)
            {
                parameters.Q = Convert.FromBase64String(Utils.DiscardWhiteSpaces(text4));
            }
            string text5 = topElement.SearchForTextOfLocalName("DP");
            if (text5 != null)
            {
                parameters.DP = Convert.FromBase64String(Utils.DiscardWhiteSpaces(text5));
            }
            string text6 = topElement.SearchForTextOfLocalName("DQ");
            if (text6 != null)
            {
                parameters.DQ = Convert.FromBase64String(Utils.DiscardWhiteSpaces(text6));
            }
            string text7 = topElement.SearchForTextOfLocalName("InverseQ");
            if (text7 != null)
            {
                parameters.InverseQ = Convert.FromBase64String(Utils.DiscardWhiteSpaces(text7));
            }
            string text8 = topElement.SearchForTextOfLocalName("D");
            if (text8 != null)
            {
                parameters.D = Convert.FromBase64String(Utils.DiscardWhiteSpaces(text8));
            }
            ImportParameters(parameters);
        }

        public override string ToXmlString(bool includePrivateParameters)
        {
            RSAParameters rSAParameters = ExportParameters(includePrivateParameters);
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.Append("<RSAKeyValue>");
            stringBuilder.Append("<Modulus>" + Convert.ToBase64String(rSAParameters.Modulus) + "</Modulus>");
            stringBuilder.Append("<Exponent>" + Convert.ToBase64String(rSAParameters.Exponent) + "</Exponent>");
            if (includePrivateParameters)
            {
                stringBuilder.Append("<P>" + Convert.ToBase64String(rSAParameters.P) + "</P>");
                stringBuilder.Append("<Q>" + Convert.ToBase64String(rSAParameters.Q) + "</Q>");
                stringBuilder.Append("<DP>" + Convert.ToBase64String(rSAParameters.DP) + "</DP>");
                stringBuilder.Append("<DQ>" + Convert.ToBase64String(rSAParameters.DQ) + "</DQ>");
                stringBuilder.Append("<InverseQ>" + Convert.ToBase64String(rSAParameters.InverseQ) + "</InverseQ>");
                stringBuilder.Append("<D>" + Convert.ToBase64String(rSAParameters.D) + "</D>");
            }
            stringBuilder.Append("</RSAKeyValue>");
            return stringBuilder.ToString();
        }

        public abstract RSAParameters ExportParameters(bool includePrivateParameters);

        public abstract void ImportParameters(RSAParameters parameters);
    }
}