private static string SignXml(XmlDocument unsignedXml,
                                        AsymmetricAlgorithm key)
        {
            if (unsignedXml.DocumentElement == null)
            {
                throw new ArgumentNullException("unsignedXml");
            }

            // Create a reference to be signed. Blank == Everything
                var emptyReference = new Reference { Uri = "" };

            // Add an enveloped transformation to the reference.
            var envelope = new XmlDsigEnvelopedSignatureTransform();
            emptyReference.AddTransform(envelope);

            var signedXml = new SignedXml(unsignedXml) { SigningKey = key };
            signedXml.AddReference(emptyReference);
            signedXml.ComputeSignature();

            var digitalSignature = signedXml.GetXml();
       
                unsignedXml.DocumentElement.AppendChild(
                    unsignedXml.ImportNode(digitalSignature, true));

            var signedXmlOut = new StringBuilder();
            using (var swOut = new StringWriter(signedXmlOut))
            {
                unsignedXml.Save(swOut);
            }

            return signedXmlOut.ToString();
        }

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

            var provider = (RSACryptoServiceProvider)key;

            // The provider is probably using the default ProviderType. That's
            // a problem, because it doesn't support SHA256. Let's do some
            // black magic and create a new provider of a type that supports
            // SHA256 without the user ever knowing we fix this. This is what
            // is done in X509AsymmetricKey.GetSignatureFormatter if
            // http://www.w3.org/2001/04/xmldsig-more#rsa-sha256 isn't
            // a known algorithm, so users kind of expect this to be handled
            // for them magically.

            var cspParams = new CspParameters();
            cspParams.ProviderType = 24; //PROV_RSA_AES
            cspParams.KeyContainerName = provider.CspKeyContainerInfo.KeyContainerName;
            cspParams.KeyNumber = (int)provider.CspKeyContainerInfo.KeyNumber;
            SetMachineKeyFlag(provider, cspParams);

            cspParams.Flags |= CspProviderFlags.UseExistingKey;

            provider = new RSACryptoServiceProvider(cspParams);

            var f = new RSAPKCS1SignatureFormatter(provider);
            f.SetHashAlgorithm(typeof(SHA256Managed).FullName);
            return f;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RsaCryptographicKey" /> class.
        /// </summary>
        /// <param name="key">The RSA crypto service provider.</param>
        /// <param name="algorithm">The algorithm.</param>
        internal RsaCryptographicKey(RSA key, AsymmetricAlgorithm algorithm)
        {
            Requires.NotNull(key, "key");

            this.key = key;
            this.algorithm = algorithm;
        }

 public override AsymmetricSignatureDeformatter CreateDeformatter(AsymmetricAlgorithm key)
 {
     AsymmetricSignatureDeformatter deformatter = (AsymmetricSignatureDeformatter) CryptoConfig.CreateFromName(base.DeformatterAlgorithm);
     deformatter.SetKey(key);
     deformatter.SetHashAlgorithm("SHA1");
     return deformatter;
 }

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

            _rsaKey = (RSA)key;
        }

 public override void SetKey(AsymmetricAlgorithm key) {
     if (key == null) 
         throw new ArgumentNullException("key");
     Contract.EndContractBlock();
     _rsaKey = (RSA) key;
     _rsaOverridesDecrypt = default(bool?);
 }

 internal static IEnumerable<XmlElement> Decrypt(this IEnumerable<XmlElement> elements, AsymmetricAlgorithm key)
 {
     foreach (var element in elements)
     {
         yield return element.Decrypt(key);
     }
 }

        public virtual AsymmetricSignatureFormatter CreateFormatter(AsymmetricAlgorithm key) {
            AsymmetricSignatureFormatter     item;

            item = (AsymmetricSignatureFormatter) CryptoConfig.CreateFromName(_strFormatter);
            item.SetKey(key);
            return item;
        }

 public override AsymmetricSignatureDeformatter CreateDeformatter(AsymmetricAlgorithm key)
 {
     var asymmetricSignatureDeformatter = (AsymmetricSignatureDeformatter)CryptoConfig.CreateFromName(DeformatterAlgorithm);
     asymmetricSignatureDeformatter.SetKey(key);
     asymmetricSignatureDeformatter.SetHashAlgorithm("SHA256");
     return asymmetricSignatureDeformatter;
 }

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

            _rsaKey = (RSA)key;
        }

        /// <summary>
        /// Verifies the signature of the XmlDocument instance using the key given as a parameter.
        /// </summary>
        /// <param name="doc">The doc.</param>
        /// <param name="alg">The algorithm.</param>
        /// <returns><code>true</code> if the document's signature can be verified. <code>false</code> if the signature could
        /// not be verified.</returns>
        /// <exception cref="InvalidOperationException">if the XmlDocument instance does not contain a signed XML document.</exception>
        public static bool CheckSignature(XmlDocument doc, AsymmetricAlgorithm alg)
        {
            CheckDocument(doc);
            var signedXml = RetrieveSignature(doc);

            return signedXml.CheckSignature(alg);
        }

        public HttpConnection(Socket sock, EndPointListener epl, bool secure, X509Certificate2 cert, AsymmetricAlgorithm key)
        {
            this.sock   = sock;

            this.epl    = epl;

            this.secure = secure;

            this.key    = key;

            var networkstream = new NetworkStream(sock, false);

            if (secure)
            {
                var sslstream = new System.Net.Security.SslStream(networkstream);

                sslstream.AuthenticateAsServer(cert);

                stream  = sslstream;
            }
            else
            {
                stream = networkstream;
            }

            timer = new Timer(OnTimeout, null, System.Threading.Timeout.Infinite, System.Threading.Timeout.Infinite);

            if (buffer == null)
            {
                buffer = new byte[BufferSize];
            }

            Init();
        }

        public DSASignatureFormatter(AsymmetricAlgorithm key) : this()
        {
            if (key == null)
                throw new ArgumentNullException(nameof(key));

            _dsaKey = (DSA)key;
        }

 public override void SetKey(AsymmetricAlgorithm key)
 {
     if (key == null)
     {
         throw new ArgumentNullException("key");
     }
     this._rsaKey = (RSA) key;
 }

 public RSAPKCS1SignatureDeformatter(AsymmetricAlgorithm key)
 {
     if (key == null)
     {
         throw new ArgumentNullException("key");
     }
     this._rsaKey = (RSA) key;
 }

        /// <summary>
        /// This constructor allows the caller to provide a preloaded private key for use 
        /// when OAuth calls are made.
        /// </summary>
        /// <param name="consumerKey"></param>
        /// <param name="privateKey"></param>
        public Connector(string consumerKey, AsymmetricAlgorithm privateKey)
        {
            this.ConsumerKey = consumerKey;
            this.privateKey = privateKey;

            // Turns the handling of a 100 HTTP server response ON
            System.Net.ServicePointManager.Expect100Continue = true;
        }

 public override AsymmetricSignatureFormatter CreateFormatter(AsymmetricAlgorithm key)
 {
     if (key == null)
         throw new ArgumentNullException(nameof(key));
     var f = new RSAPKCS1SignatureFormatter(key);
     f.SetHashAlgorithm(SHA_512);
     return f;
 }

        public static bool XmlFileIsValid(string signedXmlPath,
                                            AsymmetricAlgorithm key)
        {
            var signedXml = new XmlDocument { PreserveWhitespace = false };
            signedXml.Load(signedXmlPath);

            return XmlIsValid(signedXml, key);
        }

 public RSAOAEPKeyExchangeDeformatter(AsymmetricAlgorithm key)
 {
     if (key == null)
     {
         throw new ArgumentNullException("key");
     }
     this._rsaKey = (RSA) key;
 }

        public RequestTokenService(Environments.Environment environment, string consumerKey, AsymmetricAlgorithm privateKey)
            : base(consumerKey, privateKey)
        {
            this.environment = environment;

            // ignore possible security certificate errors
            ServicePointManager.ServerCertificateValidationCallback += (sender, cert, chain, sslPolicyErrors) => true;
        }