/// <summary>
 /// Gets the hash algorithm for a given asymmetric algorithm.
 /// </summary>
 /// <param name="algorithm">The algorithm.</param>
 /// <returns>A hash algorithm.</returns>
 internal static HashAlgorithm GetHashAlgorithmEnum(AsymmetricAlgorithm algorithm)
 {
     switch (algorithm)
     {
         case AsymmetricAlgorithm.DsaSha1:
         case AsymmetricAlgorithm.RsaOaepSha1:
         case AsymmetricAlgorithm.RsaSignPkcs1Sha1:
         case AsymmetricAlgorithm.RsaSignPssSha1:
             return HashAlgorithm.Sha1;
         case AsymmetricAlgorithm.DsaSha256:
         case AsymmetricAlgorithm.RsaOaepSha256:
         case AsymmetricAlgorithm.EcdsaP256Sha256:
         case AsymmetricAlgorithm.RsaSignPkcs1Sha256:
         case AsymmetricAlgorithm.RsaSignPssSha256:
             return HashAlgorithm.Sha256;
         case AsymmetricAlgorithm.EcdsaP384Sha384:
         case AsymmetricAlgorithm.RsaOaepSha384:
         case AsymmetricAlgorithm.RsaSignPkcs1Sha384:
         case AsymmetricAlgorithm.RsaSignPssSha384:
             return HashAlgorithm.Sha384;
         case AsymmetricAlgorithm.EcdsaP521Sha512:
         case AsymmetricAlgorithm.RsaOaepSha512:
         case AsymmetricAlgorithm.RsaSignPkcs1Sha512:
         case AsymmetricAlgorithm.RsaSignPssSha512:
             return HashAlgorithm.Sha512;
         default:
             throw new NotSupportedException();
     }
 }

        public override void SetKey(AsymmetricAlgorithm key)
        {
            if (key == null)
                throw new ArgumentNullException(nameof(key));

            _rsaKey = (RSA)key;
        }

        public RSAOAEPKeyExchangeFormatter(AsymmetricAlgorithm key)
        {
            if (key == null)
                throw new ArgumentNullException(nameof(key));

            _rsaKey = (RSA)key;
        }

        /// <inheritdoc />
        public IAsymmetricKeyAlgorithmProvider OpenAlgorithm(AsymmetricAlgorithm algorithm)
        {
            switch (algorithm)
            {
#if DESKTOP
                case AsymmetricAlgorithm.DsaSha1:
                case AsymmetricAlgorithm.DsaSha256:
                case AsymmetricAlgorithm.EcdsaP256Sha256:
                case AsymmetricAlgorithm.EcdsaP384Sha384:
                case AsymmetricAlgorithm.EcdsaP521Sha512:
                    return new CngAsymmetricKeyAlgorithmProvider(algorithm);
#endif
#if !SILVERLIGHT || WINDOWS_PHONE
                case AsymmetricAlgorithm.RsaOaepSha1:
                case AsymmetricAlgorithm.RsaOaepSha256:
                case AsymmetricAlgorithm.RsaOaepSha384:
                case AsymmetricAlgorithm.RsaOaepSha512:
                case AsymmetricAlgorithm.RsaPkcs1:
                case AsymmetricAlgorithm.RsaSignPkcs1Sha1:
                case AsymmetricAlgorithm.RsaSignPkcs1Sha256:
                case AsymmetricAlgorithm.RsaSignPkcs1Sha384:
                case AsymmetricAlgorithm.RsaSignPkcs1Sha512:
                case AsymmetricAlgorithm.RsaSignPssSha1:
                case AsymmetricAlgorithm.RsaSignPssSha256:
                case AsymmetricAlgorithm.RsaSignPssSha384:
                case AsymmetricAlgorithm.RsaSignPssSha512:
                    return new RsaAsymmetricKeyAlgorithmProvider(algorithm);
#endif
                default:
                    throw new NotSupportedException();
            }
        }

    public void LegalKeySizes(AsymmetricAlgorithm name, int minSize, int maxSize, int stepSize)
    {
        IAsymmetricKeyAlgorithmProvider provider = WinRTCrypto.AsymmetricKeyAlgorithmProvider.OpenAlgorithm(name);
        var result = provider.LegalKeySizes;
        Assert.NotNull(result);
        Assert.NotEmpty(result);

        Action<int> attemptKeySize = size =>
        {
            provider.CreateKeyPair(size).Dispose();
        };

        var range = result.Single();
        Assert.Equal(minSize, range.MinSize);
        Assert.Equal(maxSize, range.MaxSize);
        Assert.Equal(stepSize, range.StepSize);
    }

		public HttpConnection (Socket sock, EndPointListener epl, bool secure, X509Certificate2 cert, AsymmetricAlgorithm key)
		{
			this.sock = sock;
			this.epl = epl;
			this.secure = secure;
			this.key = key;
			if (secure == false) {
				stream = new NetworkStream (sock, false);
			} else {
				SslServerStream ssl_stream = new SslServerStream (new NetworkStream (sock, false), cert, false, true, false);
				ssl_stream.PrivateKeyCertSelectionDelegate += OnPVKSelection;
				ssl_stream.ClientCertValidationDelegate += OnClientCertificateValidation;
				stream = ssl_stream;
			}
			timer = new Timer (OnTimeout, null, Timeout.Infinite, Timeout.Infinite);
			Init ();
		}

    public void AsymmetricEncryption(AsymmetricAlgorithm algorithmName)
    {
        var algorithm = WinRTCrypto.AsymmetricKeyAlgorithmProvider.OpenAlgorithm(algorithmName);

        foreach (var keySize in algorithm.LegalKeySizes.SelectMany(k => k))
        {
            try
            {
                this.logger.WriteLine($"Testing {algorithmName} with {keySize} bit key.");
                using (var key = algorithm.CreateKeyPair(keySize))
                {
                }

                break;
            }
            catch (ArgumentException)
            {
                // WinRT does not provide legal key sizes, and doesn't allow small RSA keys.
                // It throws ArgumentException in this case. We can remove the skip on ArgumentException
                // after we switch WinRT over to using BCrypt directly.
                this.logger.WriteLine("Key size rejected. Please fix LegalKeySizes to report key sizes that actually work.");
            }
        }
    }

 public abstract void SetKey(AsymmetricAlgorithm key);

 public RSAPKCS1KeyExchangeFormatter(AsymmetricAlgorithm key)
 {
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="AsymmetricKeyAlgorithmProvider"/> class.
 /// </summary>
 /// <param name="algorithm">The algorithm.</param>
 public AsymmetricKeyAlgorithmProvider(AsymmetricAlgorithm algorithm)
 {
     this.algorithm = algorithm;
     this.platform = Platform.AsymmetricKeyAlgorithmProvider.OpenAlgorithm(GetAlgorithmName(algorithm));
 }

 // Methods
 public virtual void SetKey(AsymmetricAlgorithm key)
 {
 }

        /// <summary>
        ///     Log the verification parameters when verifying the SignedInfo section of a signature using an
        ///     asymmetric key
        /// </summary>
        /// <param name="signedXml">SignedXml object doing the verification</param>
        /// <param name="key">key being used to verify the signed info</param>
        /// <param name="signatureDescription">type of signature description class used</param>
        /// <param name="hashAlgorithm">type of hash algorithm used</param>
        /// <param name="asymmetricSignatureDeformatter">type of signature deformatter used</param>
        /// <param name="actualHashValue">hash value of the signed info</param>
        /// <param name="signatureValue">raw signature value</param>
        internal static void LogVerifySignedInfo(SignedXml signedXml,
                                                 AsymmetricAlgorithm key,
                                                 SignatureDescription signatureDescription,
                                                 HashAlgorithm hashAlgorithm,
                                                 AsymmetricSignatureDeformatter asymmetricSignatureDeformatter,
                                                 byte[] actualHashValue,
                                                 byte[] signatureValue) {
            Debug.Assert(signedXml != null, "signedXml != null");
            Debug.Assert(signatureDescription != null, "signatureDescription != null");
            Debug.Assert(hashAlgorithm != null, "hashAlgorithm != null");
            Debug.Assert(asymmetricSignatureDeformatter != null, "asymmetricSignatureDeformatter != null");

            if (InformationLoggingEnabled) {
                string logMessage = String.Format(CultureInfo.InvariantCulture,
                                                  SecurityResources.GetResourceString("Log_VerifySignedInfoAsymmetric"),
                                                  GetKeyName(key),
                                                  signatureDescription.GetType().Name,
                                                  hashAlgorithm.GetType().Name,
                                                  asymmetricSignatureDeformatter.GetType().Name);
                WriteLine(signedXml,
                          TraceEventType.Information,
                          SignedXmlDebugEvent.VerifySignedInfo,
                          logMessage);
            }

            if (VerboseLoggingEnabled) {
                string hashLog = String.Format(CultureInfo.InvariantCulture,
                                               SecurityResources.GetResourceString("Log_ActualHashValue"),
                                               FormatBytes(actualHashValue));
                WriteLine(signedXml, TraceEventType.Verbose, SignedXmlDebugEvent.VerifySignedInfo, hashLog);

                string signatureLog = String.Format(CultureInfo.InvariantCulture,
                                                    SecurityResources.GetResourceString("Log_RawSignatureValue"),
                                                    FormatBytes(signatureValue));
                WriteLine(signedXml, TraceEventType.Verbose, SignedXmlDebugEvent.VerifySignedInfo, signatureLog);
            }
        }

        public override AsymmetricSignatureFormatter CreateFormatter(AsymmetricAlgorithm key)
        {
            if (key == null)
            {
                throw new ArgumentNullException("key");
            }

            RSAPKCS1SignatureFormatter formatter = new RSAPKCS1SignatureFormatter(key);
            formatter.SetHashAlgorithm("SHA256");
            return formatter;
        }

	public DSASignatureDeformatter(AsymmetricAlgorithm key) {}

        /// <summary>
        /// Verifies the asymmetric signature of some data blob.
        /// </summary>
        /// <param name="signingPublicKey">The public key used to verify the signature.</param>
        /// <param name="data">The data that was signed.</param>
        /// <param name="signature">The signature.</param>
        /// <param name="signingAlgorithm">The signing algorithm.</param>
        /// <returns>
        /// A value indicating whether the signature is valid.
        /// </returns>
        internal static bool VerifySignatureWithTolerantHashAlgorithm(byte[] signingPublicKey, byte[] data, byte[] signature, AsymmetricAlgorithm? signingAlgorithm = null)
        {
            if (signingAlgorithm.HasValue)
            {
                var key = WinRTCrypto.AsymmetricKeyAlgorithmProvider.OpenAlgorithm(signingAlgorithm.Value)
                    .ImportPublicKey(signingPublicKey, CryptoSettings.PublicKeyFormat);
                return WinRTCrypto.CryptographicEngine.VerifySignature(key, data, signature);
            }

            var key1 = WinRTCrypto.AsymmetricKeyAlgorithmProvider.OpenAlgorithm(AsymmetricAlgorithm.RsaSignPkcs1Sha1)
                .ImportPublicKey(signingPublicKey, CryptoSettings.PublicKeyFormat);
            var key2 = WinRTCrypto.AsymmetricKeyAlgorithmProvider.OpenAlgorithm(AsymmetricAlgorithm.RsaSignPkcs1Sha256)
                .ImportPublicKey(signingPublicKey, CryptoSettings.PublicKeyFormat);
            return WinRTCrypto.CryptographicEngine.VerifySignature(key1, data, signature)
                || WinRTCrypto.CryptographicEngine.VerifySignature(key2, data, signature);
        }

	// Methods
	public abstract virtual void SetKey(AsymmetricAlgorithm key) {}

        private static byte[] CalculateSignerPublicKeyToken(AsymmetricAlgorithm key) {
            Debug.Assert(key != null, "key != null");

            ICspAsymmetricAlgorithm cspAlgorithm = key as ICspAsymmetricAlgorithm;
            if (cspAlgorithm == null) {
                return null;
            }

            byte[] publicKey = cspAlgorithm.ExportCspBlob(false);
            SafeAxlBufferHandle tokenBuffer;

            unsafe {
                fixed (byte* pPublicKey = publicKey) {
                    // Safe, since we're ensuring the CAPI buffer going in is sized correctly
                    CapiNative.CRYPTOAPI_BLOB keyBlob = new CapiNative.CRYPTOAPI_BLOB();
                    keyBlob.cbData = publicKey.Length;
                    keyBlob.pbData = new IntPtr(pPublicKey);

                    int hrToken = CapiNative.UnsafeNativeMethods._AxlPublicKeyBlobToPublicKeyToken(ref keyBlob,
                                                                                                   out tokenBuffer);
                    if (((uint)hrToken & 0x80000000) != 0) {
                        return null;
                    }
                }
            }

            bool acquired = false;

            RuntimeHelpers.PrepareConstrainedRegions();
            try {
                tokenBuffer.DangerousAddRef(ref acquired);
                return HexStringToBytes(Marshal.PtrToStringUni(tokenBuffer.DangerousGetHandle()));
            }
            finally {
                if (acquired) {
                    tokenBuffer.DangerousRelease();
                }
            }
        }

 public RSAPKCS1SignatureDeformatter(AsymmetricAlgorithm key)
 {
 }

 public RSAOAEPKeyExchangeDeformatter(AsymmetricAlgorithm key)
 {
 }

 /// <summary>
 /// Returns the string to pass to the platform APIs for a given algorithm.
 /// </summary>
 /// <param name="algorithm">The algorithm desired.</param>
 /// <returns>The platform-specific string to pass to OpenAlgorithm.</returns>
 private static string GetAlgorithmName(AsymmetricAlgorithm algorithm)
 {
     switch (algorithm)
     {
         case AsymmetricAlgorithm.DsaSha1:
             return Platform.AsymmetricAlgorithmNames.DsaSha1;
         case AsymmetricAlgorithm.DsaSha256:
             return Platform.AsymmetricAlgorithmNames.DsaSha256;
         case AsymmetricAlgorithm.EcdsaP256Sha256:
             return Platform.AsymmetricAlgorithmNames.EcdsaP256Sha256;
         case AsymmetricAlgorithm.EcdsaP384Sha384:
             return Platform.AsymmetricAlgorithmNames.EcdsaP384Sha384;
         case AsymmetricAlgorithm.EcdsaP521Sha512:
             return Platform.AsymmetricAlgorithmNames.EcdsaP521Sha512;
         case AsymmetricAlgorithm.RsaOaepSha1:
             return Platform.AsymmetricAlgorithmNames.RsaOaepSha1;
         case AsymmetricAlgorithm.RsaOaepSha256:
             return Platform.AsymmetricAlgorithmNames.RsaOaepSha256;
         case AsymmetricAlgorithm.RsaOaepSha384:
             return Platform.AsymmetricAlgorithmNames.RsaOaepSha384;
         case AsymmetricAlgorithm.RsaOaepSha512:
             return Platform.AsymmetricAlgorithmNames.RsaOaepSha512;
         case AsymmetricAlgorithm.RsaPkcs1:
             return Platform.AsymmetricAlgorithmNames.RsaPkcs1;
         case AsymmetricAlgorithm.RsaSignPkcs1Sha1:
             return Platform.AsymmetricAlgorithmNames.RsaSignPkcs1Sha1;
         case AsymmetricAlgorithm.RsaSignPkcs1Sha256:
             return Platform.AsymmetricAlgorithmNames.RsaSignPkcs1Sha256;
         case AsymmetricAlgorithm.RsaSignPkcs1Sha384:
             return Platform.AsymmetricAlgorithmNames.RsaSignPkcs1Sha384;
         case AsymmetricAlgorithm.RsaSignPkcs1Sha512:
             return Platform.AsymmetricAlgorithmNames.RsaSignPkcs1Sha512;
         case AsymmetricAlgorithm.RsaSignPssSha1:
             return Platform.AsymmetricAlgorithmNames.RsaSignPssSha1;
         case AsymmetricAlgorithm.RsaSignPssSha256:
             return Platform.AsymmetricAlgorithmNames.RsaSignPssSha256;
         case AsymmetricAlgorithm.RsaSignPssSha384:
             return Platform.AsymmetricAlgorithmNames.RsaSignPssSha384;
         case AsymmetricAlgorithm.RsaSignPssSha512:
             return Platform.AsymmetricAlgorithmNames.RsaSignPssSha512;
         default:
             throw new NotSupportedException();
     }
 }