C# RSACryptoServiceProvider.ExportCspBlob方法代码示例

        //RSA加密,随机生成公私钥对并作为出参返回
        public static string RSA_Encrypt(string str_Plain_Text, out string str_Public_Key, out string str_Private_Key)
        {
            str_Public_Key = "";
            str_Private_Key = "";
            UnicodeEncoding ByteConverter = new UnicodeEncoding();
            byte[] DataToEncrypt = ByteConverter.GetBytes(str_Plain_Text);
            try
            {
                RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
                str_Public_Key = Convert.ToBase64String(RSA.ExportCspBlob(false));
                str_Private_Key = Convert.ToBase64String(RSA.ExportCspBlob(true));

                //OAEP padding is only available on Microsoft Windows XP or later.
                byte[] bytes_Cypher_Text = RSA.Encrypt(DataToEncrypt, false);
                str_Public_Key = Convert.ToBase64String(RSA.ExportCspBlob(false));
                str_Private_Key = Convert.ToBase64String(RSA.ExportCspBlob(true));
                string str_Cypher_Text = Convert.ToBase64String(bytes_Cypher_Text);
                return str_Cypher_Text;
            }
            catch (CryptographicException e)
            {
                Console.WriteLine(e.Message);
                return null;
            }
        }

        /// <summary>
        /// Generate keys into specified files.
        /// </summary>
        /// <param name="publicKeyFileName">Name of the file that will contain public key</param>
        /// <param name="privateKeyFileName">Name of the file that will contain private key</param>
        public void GenerateKeys(out byte[] publicKey, out byte[] privateKey)
        {
            // Variables
            CspParameters cspParams = null;
            RSACryptoServiceProvider rsaProvider = null;

            try
            {
                // Create a new key pair on target CSP
                cspParams = new CspParameters()
                {
                    ProviderType = 1,                          // PROV_RSA_FULL
                    Flags = CspProviderFlags.UseArchivableKey, // can be exported
                    KeyNumber = (int)KeyNumber.Exchange        // can be safely stored and exchanged
                };

                rsaProvider = new RSACryptoServiceProvider(cspParams);
                rsaProvider.PersistKeyInCsp = false;

                // Export public key only
                publicKey = rsaProvider.ExportCspBlob(false);
                privateKey = rsaProvider.ExportCspBlob(true);
            }
            catch (Exception ex)
            {
                Debug.Fail(string.Format("Exception occured while generating keys: {0}", ex.Message));
                publicKey = null;
                privateKey = null;
            }
            finally
            {
                if (rsaProvider != null) rsaProvider.PersistKeyInCsp = false;
            }
        }

        public UpdateSigningKey() {

            RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
            PrivateKey = provider.ExportCspBlob(true);
            PublicKey = provider.ExportCspBlob(false);

            Name = "New Key";
        }

 public static void GenerateKeyPairFiles(FileInfo privateKeyFile, FileInfo publicKeyFile)
 {
     using (var rsa = new RSACryptoServiceProvider())
     {
         rsa.ExportCspBlob(true).CompressToFile(privateKeyFile);
         rsa.ExportCspBlob(false).CompressToFile(publicKeyFile);
     }
 }

        public void GenerateKeys()
        {
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();

            string privateKey = Convert.ToBase64String(rsa.ExportCspBlob(true));
            Console.WriteLine("\nPrivateKey:\n{0}", privateKey);

            string publicKey = Convert.ToBase64String(rsa.ExportCspBlob(false));
            Console.WriteLine("\nPublicKey:\n{0}", publicKey);
        }

        //Generates keys to be used for testing purposes
        public static Settings GenerateKeyPair()
        {
            var cspParams = new CspParameters { ProviderType = 1 };
            var rsaProvider = new RSACryptoServiceProvider(1024, cspParams);

            var publicKey = Convert.ToBase64String(rsaProvider.ExportCspBlob(false));
            var privateKey = Convert.ToBase64String(rsaProvider.ExportCspBlob(true));

            return new Settings { PublicKey = publicKey, PrivateKey = privateKey };
        }

 public override void ImportFromXml(IKeyStore keyStore, string xml, int keySize = 1024)
 {
     using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(keySize))
     {
         rsa.PersistKeyInCsp = false;
         rsa.FromXmlString(xml);
         keyStore.PublicKey.Key = rsa.ExportCspBlob(false);
         if(!rsa.PublicOnly)
             keyStore.PrivateKey.Key = rsa.ExportCspBlob(true);
     }
 }

        public string CreateKeyPair()
        {
            CspParameters cspParams = new CspParameters { ProviderType = 1 };

            RSACryptoServiceProvider rsaProvider = new RSACryptoServiceProvider(1024, cspParams);

            string publicKey = Convert.ToBase64String(rsaProvider.ExportCspBlob(false));
            string privateKey = Convert.ToBase64String(rsaProvider.ExportCspBlob(true));

            return privateKey + ":" + publicKey;
        }

        public Tuple<string, string> CreateKeys()
        {
            CspParameters cspParams = new CspParameters {ProviderType = 1};

            RSACryptoServiceProvider rsaProvider = new RSACryptoServiceProvider(1024, cspParams);

            string publicKey = Convert.ToBase64String(rsaProvider.ExportCspBlob(false));
            string privateKey = Convert.ToBase64String(rsaProvider.ExportCspBlob(true));

            return new Tuple<string, string>(privateKey, publicKey);
        }

        public override void CreateNewKeyPair(IKeyStore keyStore, int keySize = 1024)
        {

            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(keySize))
            {
                rsa.PersistKeyInCsp = false;

                keyStore.PublicKey.Key = rsa.ExportCspBlob(false);
                keyStore.PrivateKey.Key = rsa.ExportCspBlob(true);
                keyStore.KeySize = keySize;
            }
        }

 public byte[] ExportPrivateKey()
 {
     using (var rsa = new RSACryptoServiceProvider(RSA_KEY_SIZE))
     {
         return rsa.ExportCspBlob(true);
     }
 }

        /// <summary>
        /// Create a new certificate.
        /// </summary>
        /// <param name="language">Language preferred by the certificate holder.</param>
        /// <param name="passphrase">Passphrase to encrypt the key with or null for no encryption.</param>
        public Certificate(Language language, string passphrase)
        {
            CreationDate = DateTime.Now;
              Id = Guid.NewGuid();

              RSACryptoServiceProvider rsaProvider = new RSACryptoServiceProvider();
              rsaProvider.KeySize = 4096;
              PublicKey = rsaProvider.ExportCspBlob(false);

              PrivateKeyStatus = PrivateKeyStatus.Unencrypted;

              if (passphrase == null)
              {
            this.privateKeyData = rsaProvider.ExportCspBlob(true);
              }
              else
              {
            EncryptPrivateKey(passphrase, rsaProvider);
            Unlock(passphrase);
              }

              this.signatures = new List<Signature>();
              this.attributes = new List<CertificateAttribute>();

              AddAttribute(new Int32CertificateAttribute(CertificateAttributeName.Language, (int)language));
        }

 public static ICspProxyFactory Create(int keySize)
 {
     using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(keySize))
     {
         return new DefaultFactory(rsa.ExportCspBlob(true), rsa.KeySize);
     }
 }

        public string SignN3Rsa(string data)
        {
            var cspParams = new CspParameters {KeyContainerName = "XML_DSIG_RSA_KEY"};
            var key = new RSACryptoServiceProvider(cspParams);
            var cspBlob = key.ExportCspBlob(false);
            var base64Blob = Convert.ToBase64String(cspBlob);

            var rsaFormatter = new RSAPKCS1SignatureFormatter(key);
            rsaFormatter.SetHashAlgorithm("MD5");

            var hash = Md5Helper.GetMd5Hash(data);
            var base64Hash = Convert.ToBase64String(hash);
            var sign = rsaFormatter.CreateSignature(hash);
            var base64Sign = Convert.ToBase64String(sign);

            var signData = new SignData
                           {
                               data = data,
                               public_key = base64Blob,
                               hash = base64Hash,
                               sign = base64Sign
                           };

            return new SerializationHelper<SignData>().Serialize(signData);
        }

 /// <summary>
 /// Generates a 1024 bit the strong-name key pair that can be written to an SNK file.
 /// </summary>
 /// <returns>A strong-name key pair array.</returns>
 public static byte[] GenerateStrongNameKeyPair()
 {
     using (var provider = new RSACryptoServiceProvider(1024, new CspParameters() { KeyNumber = 2 }))
       {
     return provider.ExportCspBlob(!provider.PublicOnly);
       }
 }