C# RSA加密、解密、加簽、驗籤、支援JAVA格式公鑰私鑰、PEM格式公鑰私鑰、.NET格式公鑰私鑰、一般模式【支援公鑰加密，私鑰解密】（一）
阿新 • • 發佈：2019-01-20
2017-12-04日更新：增加支援微信支付。程式碼註釋中//☆☆☆☆.NET 4.6以後特有☆☆☆☆的別用，那個不對。
RSA非對稱加密。簡明扼要吧，直說乾貨。（在此特別感謝下貳進位制，提供JAVA版的公鑰私鑰）
C#RSA加簽解籤加密比較常見，一般遇到的問題是非.NET程式碼的加簽驗籤、加密解密。以下就是解決此類問題的。
一般情況下是【公鑰加密，私鑰解密。】
* 重要的事情說三遍，不懂的自己惡補去。
* RSA加密解密：私鑰解密，公鑰加密。
* RSA數字簽名-俗稱加簽驗籤：私鑰加簽，公鑰驗籤。
* RSA加密解密：私鑰解密，公鑰加密。
* RSA數字簽名-俗稱加簽驗籤：私鑰加簽，公鑰驗籤。
* RSA加密解密：私鑰解密，公鑰加密。
* RSA數字簽名-俗稱加簽驗籤：私鑰加簽，公鑰驗籤。
關於hashAlgorithm引數值有：MD5、SHA1、SHA256、SHA384、SHA512。其它的自己試吧，可能這個不全。
在這裡提醒下各位對接其他它非.NET對接時注意事項吧。下面是自己總結的一些方法。
【注意簡單的地方，越是簡單的地方越容易陰溝裡翻船】。
1、首先測試的時候，先給對方提供一整套公私鑰，或者問對方要一套，以便方便自己和對方測試使用。因為跟你對接的兄弟多半跟你不在一個頻道上，你說的他不明白。他也不明白你說的。
2、對方是否使用safeurl，請問清楚。如沒有請忽略以下程式碼。
public static string ConvertEncodeBase64URLSafe(string data) { return data.Replace("=", String.Empty).Replace('+', '-').Replace('/', '_'); } public static string ConvertDecodeBase64URLSafe(string data) { data = data.Replace('-', '+').Replace('_', '/'); int len = data.Length % 4; if (len > 0) { data += "====".Substring(0, 4 - len); } return data; }
3、對方是否使用MD5withRas。請看加簽、驗籤。
4、一些單元測試及使用方法，都在
5、rsa.KeySize / 8-11是可加密的長度，RSA是本意是加密部分及其重要的資料，如果超過，多半是你自己的設計有問題。請改進，網上有分段加密解密超長資料的方法。不建議採用，改進自己的設計去。
6、【注意雙方的編碼格式。】
【注意雙方的編碼格式。】
【注意雙方的編碼格式。】
7、【注意本文的加密、加簽結果都是Base64的。】
【注意本文的加密、加簽結果都是Base64的。】
【注意本文的加密、加簽結果都是Base64的。】
byte[] dataBytes = Convert.FromBase64String(data);
string base64Str = Convert.ToBase64String(signer.GenerateSignature()); 10、JAVA 使用PEM的為PKCS8，轉換命令如下
PKCS8轉換為普通的PKCS1，本示列使用普通PEM私鑰
openssl pkcs8 -in private_key_pkcs8.pem -nocrypt -out private_key.pem
11、微信RSA支付。必須使用.NET4.6以上版本 。
使用如下程式碼。
https://pay.weixin.qq.com/wiki/doc/api/tools/mch_pay.php?chapter=24_7&index=4
public static string DecryptPEMByWeiXin(string privateKeyPEM, string data, string encoding = "UTF-8")
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
byte[] cipherbytes;
rsa.LoadPrivateKeyPEM(privateKeyPEM);
var padding = System.Security.Cryptography.RSAEncryptionPadding.Pkcs1;
cipherbytes = rsa.Decrypt(Convert.FromBase64String(data), padding);
return Encoding.GetEncoding(encoding).GetString(cipherbytes);
}以下是RSA的幫助類：
加簽：
#region 加簽
/// <summary>
/// RSA簽名
/// </summary>
/// <param name="privateKeyJava">私鑰</param>
/// <param name="data">待簽名的內容</param>
/// <returns></returns>
public static string RSASignJava(string data, string privateKeyJava, string hashAlgorithm = "MD5", string encoding = "UTF-8")
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
rsa.FromPrivateKeyJavaString(privateKeyJava);//載入私鑰
//RSAPKCS1SignatureFormatter RSAFormatter = new RSAPKCS1SignatureFormatter(rsa);
////設定簽名的演算法為MD5 MD5withRSA 簽名
//RSAFormatter.SetHashAlgorithm(hashAlgorithm);
var dataBytes = Encoding.GetEncoding(encoding).GetBytes(data);
var HashbyteSignature = rsa.SignData(dataBytes, hashAlgorithm);
return Convert.ToBase64String(HashbyteSignature);
//byte[] HashbyteSignature = ConvertToRgbHash(data, encoding);
//byte[] dataBytes =Encoding.GetEncoding(encoding).GetBytes(data);
//HashbyteSignature = rsa.SignData(dataBytes, hashAlgorithm);
//return Convert.ToBase64String(HashbyteSignature);
//執行簽名
//EncryptedSignatureData = RSAFormatter.CreateSignature(HashbyteSignature);
//return Convert.ToBase64String(RSAFormatter.CreateSignature(HashbyteSignature));
//return result.Replace("=", String.Empty).Replace('+', '-').Replace('/', '_');
}
/// <summary>
/// RSA簽名
/// </summary>
/// <param name="privateKeyPEM">私鑰</param>
/// <param name="data">待簽名的內容</param>
/// <returns></returns>
public static string RSASignPEM(string data, string privateKeyPEM, string hashAlgorithm = "MD5", string encoding = "UTF-8")
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
rsa.LoadPrivateKeyPEM(privateKeyPEM);//載入私鑰
var dataBytes = Encoding.GetEncoding(encoding).GetBytes(data);
var HashbyteSignature = rsa.SignData(dataBytes, hashAlgorithm);
return Convert.ToBase64String(HashbyteSignature);
}
/// <summary>
/// RSA簽名CSharp
/// </summary>
/// <param name="privateKeyCSharp">私鑰</param>
/// <param name="data">待簽名的內容</param>
/// <returns></returns>
public static string RSASignCSharp(string data, string privateKeyCSharp, string hashAlgorithm = "MD5", string encoding = "UTF-8")
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
rsa.FromXmlString(privateKeyCSharp);//載入私鑰
var dataBytes = Encoding.GetEncoding(encoding).GetBytes(data);
var HashbyteSignature = rsa.SignData(dataBytes, hashAlgorithm);
return Convert.ToBase64String(HashbyteSignature);
}
#endregion
驗籤：
#region 驗籤
/// <summary>
/// 驗證簽名-方法一
/// </summary>
/// <param name="data"></param>
/// <param name="signature"></param>
/// <param name="encoding"></param>
/// <returns></returns>
public static bool VerifyJava(string data, string publicKeyJava, string signature, string hashAlgorithm = "MD5", string encoding = "UTF-8")
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
//匯入公鑰，準備驗證簽名
rsa.FromPublicKeyJavaString(publicKeyJava);
//返回資料驗證結果
byte[] Data = Encoding.GetEncoding(encoding).GetBytes(data);
byte[] rgbSignature = Convert.FromBase64String(signature);
return rsa.VerifyData(Data, hashAlgorithm, rgbSignature);
//return SignatureDeformatter(publicKeyJava, data, signature);
//return CheckSign(publicKeyJava, data, signature);
//return rsa.VerifyData(Encoding.GetEncoding(encoding).GetBytes(data), "MD5", Encoding.GetEncoding(encoding).GetBytes(signature));
}
/// <summary>
/// 驗證簽名PEM
/// </summary>
/// <param name="data"></param>
/// <param name="signature"></param>
/// <param name="encoding"></param>
/// <returns></returns>
public static bool VerifyPEM(string data, string publicKeyPEM, string signature, string hashAlgorithm = "MD5", string encoding = "UTF-8")
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
//匯入公鑰，準備驗證簽名
rsa.LoadPublicKeyPEM(publicKeyPEM);
//返回資料驗證結果
byte[] Data = Encoding.GetEncoding(encoding).GetBytes(data);
byte[] rgbSignature = Convert.FromBase64String(signature);
return rsa.VerifyData(Data, hashAlgorithm, rgbSignature);
}
/// <summary>
/// 驗證簽名CSharp
/// </summary>
/// <param name="data"></param>
/// <param name="signature"></param>
/// <param name="encoding"></param>
/// <returns></returns>
public static bool VerifyCSharp(string data, string publicKeyCSharp, string signature, string hashAlgorithm = "MD5", string encoding = "UTF-8")
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
//匯入公鑰，準備驗證簽名
rsa.LoadPublicKeyPEM(publicKeyCSharp);
//返回資料驗證結果
byte[] Data = Encoding.GetEncoding(encoding).GetBytes(data);
byte[] rgbSignature = Convert.FromBase64String(signature);
return rsa.VerifyData(Data, hashAlgorithm, rgbSignature);
}
#region 簽名驗證-方法二
/// <summary>
/// 簽名驗證
/// </summary>
/// <param name="publicKey">公鑰</param>
/// <param name="p_strHashbyteDeformatter">待驗證的使用者名稱</param>
/// <param name="signature">註冊碼</param>
/// <returns>簽名是否符合</returns>
public static bool SignatureDeformatter(string publicKey, string data, string signature, string hashAlgorithm = "MD5")
{
try
{
byte[] rgbHash = ConvertToRgbHash(data);
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
//匯入公鑰，準備驗證簽名
rsa.FromPublicKeyJavaString(publicKey);
RSAPKCS1SignatureDeformatter deformatter = new RSAPKCS1SignatureDeformatter(rsa);
deformatter.SetHashAlgorithm("MD5");
byte[] rgbSignature = Convert.FromBase64String(signature);
if (deformatter.VerifySignature(rgbHash, rgbSignature))
{
return true;
}
return false;
}
catch
{
return false;
}
}
/// <summary>
/// 簽名資料轉化為RgbHash
/// </summary>
/// <param name="data"></param>
/// <param name="encoding"></param>
/// <returns></returns>
public static byte[] ConvertToRgbHash(string data, string encoding = "UTF-8")
{
using (MD5 md5 = new MD5CryptoServiceProvider())
{
byte[] bytes_md5_in = Encoding.GetEncoding(encoding).GetBytes(data);
return md5.ComputeHash(bytes_md5_in);
}
}
#endregion
#region 簽名驗證-方法三
/// <summary>
/// 驗證簽名
/// </summary>
/// <param name="data">原始資料</param>
/// <param name="sign">簽名</param>
/// <returns></returns>
public static bool CheckSign(string publicKey, string data, string sign, string encoding = "UTF-8")
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
rsa.FromPublicKeyJavaString(publicKey);
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
byte[] Data = Encoding.GetEncoding(encoding).GetBytes(data);
byte[] rgbSignature = Convert.FromBase64String(sign);
if (rsa.VerifyData(Data, md5, rgbSignature))
{
return true;
}
return false;
}
#endregion
#endregion加密：
#region 加密
/// <summary>
/// RSA加密
/// </summary>
/// <param name="publicKeyJava"></param>
/// <param name="data"></param>
/// <returns></returns>
public static string EncryptJava(string publicKeyJava, string data, string encoding = "UTF-8")
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
byte[] cipherbytes;
rsa.FromPublicKeyJavaString(publicKeyJava);
//☆☆☆☆.NET 4.6以後特有☆☆☆☆
//HashAlgorithmName hashName = new System.Security.Cryptography.HashAlgorithmName(hashAlgorithm);
//RSAEncryptionPadding padding = RSAEncryptionPadding.OaepSHA512;//RSAEncryptionPadding.CreateOaep(hashName);//.NET 4.6以後特有
//cipherbytes = rsa.Encrypt(Encoding.GetEncoding(encoding).GetBytes(data), padding);
//☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
//☆☆☆☆.NET 4.6以前請用此段程式碼☆☆☆☆
cipherbytes = rsa.Encrypt(Encoding.GetEncoding(encoding).GetBytes(data), false);
return Convert.ToBase64String(cipherbytes);
}
/// <summary>
/// RSA加密
/// </summary>
/// <param name="publicKeyCSharp"></param>
/// <param name="data"></param>
/// <returns></returns>
public static string EncryptCSharp(string publicKeyCSharp, string data, string encoding = "UTF-8")
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
byte[] cipherbytes;
rsa.FromXmlString(publicKeyCSharp);
//☆☆☆☆.NET 4.6以後特有☆☆☆☆
//HashAlgorithmName hashName = new System.Security.Cryptography.HashAlgorithmName(hashAlgorithm);
//RSAEncryptionPadding padding = RSAEncryptionPadding.OaepSHA512;//RSAEncryptionPadding.CreateOaep(hashName);//.NET 4.6以後特有
//cipherbytes = rsa.Encrypt(Encoding.GetEncoding(encoding).GetBytes(data), padding);
//☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
//☆☆☆☆.NET 4.6以前請用此段程式碼☆☆☆☆
cipherbytes = rsa.Encrypt(Encoding.GetEncoding(encoding).GetBytes(data), false);
return Convert.ToBase64String(cipherbytes);
}
/// <summary>
/// RSA加密PEM祕鑰
/// </summary>
/// <param name="publicKeyPEM"></param>
/// <param name="data"></param>
/// <returns></returns>
public static string EncryptPEM(string publicKeyPEM, string data, string encoding = "UTF-8")
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
byte[] cipherbytes;
rsa.LoadPublicKeyPEM(publicKeyPEM);
//☆☆☆☆.NET 4.6以後特有☆☆☆☆
//HashAlgorithmName hashName = new System.Security.Cryptography.HashAlgorithmName(hashAlgorithm);
//RSAEncryptionPadding padding = RSAEncryptionPadding.OaepSHA512;//RSAEncryptionPadding.CreateOaep(hashName);//.NET 4.6以後特有
//cipherbytes = rsa.Encrypt(Encoding.GetEncoding(encoding).GetBytes(data), padding);
//☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
//☆☆☆☆.NET 4.6以前請用此段程式碼☆☆☆☆
cipherbytes = rsa.Encrypt(Encoding.GetEncoding(encoding).GetBytes(data), false);
return Convert.ToBase64String(cipherbytes);
}
#endregion解密：
#region 解密
/// <summary>
/// RSA解密
/// </summary>
/// <param name="privateKeyJava"></param>
/// <param name="content"></param>
/// <returns></returns>
public static string DecryptJava(string privateKeyJava, string data, string encoding = "UTF-8")
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
byte[] cipherbytes;
rsa.FromPrivateKeyJavaString(privateKeyJava);
//☆☆☆☆.NET 4.6以後特有☆☆☆☆
//RSAEncryptionPadding padding = RSAEncryptionPadding.CreateOaep(new System.Security.Cryptography.HashAlgorithmName(hashAlgorithm));//.NET 4.6以後特有
//cipherbytes = rsa.Decrypt(Encoding.GetEncoding(encoding).GetBytes(data), padding);
//☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
//☆☆☆☆.NET 4.6以前請用此段程式碼☆☆☆☆
cipherbytes = rsa.Decrypt(Convert.FromBase64String(data), false);
return Encoding.GetEncoding(encoding).GetString(cipherbytes);
}
/// <summary>
/// RSA解密
/// </summary>
/// <param name="privateKeyCSharp"></param>
/// <param name="content"></param>
/// <returns></returns>
public static string DecryptCSharp(string privateKeyCSharp, string data, string encoding = "UTF-8")
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
byte[] cipherbytes;
rsa.FromXmlString(privateKeyCSharp);
//☆☆☆☆.NET 4.6以後特有☆☆☆☆
//RSAEncryptionPadding padding = RSAEncryptionPadding.CreateOaep(new System.Security.Cryptography.HashAlgorithmName(hashAlgorithm));//.NET 4.6以後特有
//cipherbytes = rsa.Decrypt(Encoding.GetEncoding(encoding).GetBytes(data), padding);
//☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
//☆☆☆☆.NET 4.6以前請用此段程式碼☆☆☆☆
cipherbytes = rsa.Decrypt(Convert.FromBase64String(data), false);
return Encoding.GetEncoding(encoding).GetString(cipherbytes);
}
/// <summary>
/// RSA解密
/// </summary>
/// <param name="privateKeyPEM"></param>
/// <param name="content"></param>
/// <returns></returns>
public static string DecryptPEM(string privateKeyPEM, string data, string encoding = "UTF-8")
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
byte[] cipherbytes;
rsa.LoadPrivateKeyPEM(privateKeyPEM);
//☆☆☆☆.NET 4.6以後特有☆☆☆☆
//RSAEncryptionPadding padding = RSAEncryptionPadding.CreateOaep(new System.Security.Cryptography.HashAlgorithmName(hashAlgorithm));//.NET 4.6以後特有
//cipherbytes = rsa.Decrypt(Encoding.GetEncoding(encoding).GetBytes(data), padding);
//☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
//☆☆☆☆.NET 4.6以前請用此段程式碼☆☆☆☆
cipherbytes = rsa.Decrypt(Convert.FromBase64String(data), false);
return Encoding.GetEncoding(encoding).GetString(cipherbytes);
}
#endregion
RSA擴充套件方法：
public static class RSAExtensions
{
/// <summary>
/// 把java的私鑰轉換成.net的xml格式
/// </summary>
/// <param name="rsa"></param>
/// <param name="privateJavaKey"></param>
/// <returns></returns>
public static string ConvertToXmlPrivateKey(this RSA rsa, string privateJavaKey)
{
RsaPrivateCrtKeyParameters privateKeyParam = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(privateJavaKey));
string xmlPrivateKey = string.Format("<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent><P>{2}</P><Q>{3}</Q><DP>{4}</DP><DQ>{5}</DQ><InverseQ>{6}</InverseQ><D>{7}</D></RSAKeyValue>",
Convert.ToBase64String(privateKeyParam.Modulus.ToByteArrayUnsigned()),
Convert.ToBase64String(privateKeyParam.PublicExponent.ToByteArrayUnsigned()),
Convert.ToBase64String(privateKeyParam.P.ToByteArrayUnsigned()),
Convert.ToBase64String(privateKeyParam.Q.ToByteArrayUnsigned()),
Convert.ToBase64String(privateKeyParam.DP.ToByteArrayUnsigned()),
Convert.ToBase64String(privateKeyParam.DQ.ToByteArrayUnsigned()),
Convert.ToBase64String(privateKeyParam.QInv.ToByteArrayUnsigned()),
Convert.ToBase64String(privateKeyParam.Exponent.ToByteArrayUnsigned()));
return xmlPrivateKey;
}
/// <summary>
/// RSA載入JAVA PrivateKey
/// </summary>
/// <param name="privateJavaKey">java提供的第三方私鑰</param>
/// <returns></returns>
public static void FromPrivateKeyJavaString(this RSA rsa, string privateJavaKey)
{
string xmlPrivateKey = rsa.ConvertToXmlPrivateKey(privateJavaKey);
rsa.FromXmlString(xmlPrivateKey);
}
/// <summary>
/// 把java的公鑰轉換成.net的xml格式
/// </summary>
/// <param name="privateKey">java提供的第三方公鑰</param>
/// <returns></returns>
public static string ConvertToXmlPublicJavaKey(this RSA rsa, string publicJavaKey)
{
RsaKeyParameters publicKeyParam = (RsaKeyParameters)PublicKeyFactory.CreateKey(Convert.FromBase64String(publicJavaKey));
string xmlpublicKey = string.Format("<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent></RSAKeyValue>",
Convert.ToBase64String(publicKeyParam.Modulus.ToByteArrayUnsigned()),
Convert.ToBase64String(publicKeyParam.Exponent.ToByteArrayUnsigned()));
return xmlpublicKey;
}
/// <summary>
/// 把java的私鑰轉換成.net的xml格式
/// </summary>
/// <param name="privateKey">java提供的第三方公鑰</param>
/// <returns></returns>
public static void FromPublicKeyJavaString(this RSA rsa, string publicJavaKey)
{
string xmlpublicKey = rsa.ConvertToXmlPublicJavaKey(publicJavaKey);
rsa.FromXmlString(xmlpublicKey);
}
///// <summary>
///// RSA公鑰格式轉換，java->.net
///// </summary>
///// <param name="publicKey">java生成的公鑰</param>
///// <returns></returns>
//private static string ConvertJavaPublicKeyToDotNet(this RSA rsa,string publicKey)
//{
// RsaKeyParameters publicKeyParam = (RsaKeyParameters)PublicKeyFactory.CreateKey(Convert.FromBase64String(publicKey));
// return string.Format("<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent></RSAKeyValue>",
// Convert.ToBase64String(publicKeyParam.Modulus.ToByteArrayUnsigned()),
// Convert.ToBase64String(publicKeyParam.Exponent.ToByteArrayUnsigned()));
//}
/// <summary>Extension method for initializing a RSACryptoServiceProvider from PEM data string.</summary>
#region Methods
/// <summary>Extension method which initializes an RSACryptoServiceProvider from a DER public key blob.</summary>
public static void LoadPublicKeyDER(this RSACryptoServiceProvider provider, byte[] DERData)
{
byte[] RSAData = GetRSAFromDER(DERData);
byte[] publicKeyBlob = GetPublicKeyBlobFromRSA(RSAData);
provider.ImportCspBlob(publicKeyBlob);
}
/// <summary>Extension method which initializes an RSACryptoServiceProvider from a DER private key blob.</summary>
public static void LoadPrivateKeyDER(this RSACryptoServiceProvider provider, byte[] DERData)
{
byte[] privateKeyBlob = GetPrivateKeyDER(DERData);
provider.ImportCspBlob(privateKeyBlob);
}
/// <summary>Extension method which initializes an RSACryptoServiceProvider from a PEM public key string.</summary>
public static void LoadPublicKeyPEM(this RSACryptoServiceProvider provider, string sPEM)
{
byte[] DERData = GetDERFromPEM(sPEM);
LoadPublicKeyDER(provider, DERData);
}
/// <summary>Extension method which initializes an RSACryptoServiceProvider from a PEM private key string.</summary>
public static void LoadPrivateKeyPEM(this RSACryptoServiceProvider provider, string sPEM)
{
byte[] DERData = GetDERFromPEM(sPEM);
LoadPrivateKeyDER(provider, DERData);
}
/// <summary>Returns a public key blob from an RSA public key.</summary>
internal static byte[] GetPublicKeyBlobFromRSA(byte[] RSAData)
{
byte[] data = null;
UInt32 dwCertPublicKeyBlobSize = 0;
if (CryptDecodeObject(CRYPT_ENCODING_FLAGS.X509_ASN_ENCODING | CRYPT_ENCODING_FLAGS.PKCS_7_ASN_ENCODING,
new IntPtr((int)CRYPT_OUTPUT_TYPES.RSA_CSP_PUBLICKEYBLOB), RSAData, (UInt32)RSAData.Length, CRYPT_DECODE_FLAGS.NONE,
data, ref dwCertPublicKeyBlobSize))
{
data = new byte[dwCertPublicKeyBlobSize];
if (!CryptDecodeObject(CRYPT_ENCODING_FLAGS.X509_ASN_ENCODING | CRYPT_ENCODING_FLAGS.PKCS_7_ASN_ENCODING,
new IntPtr((int)CRYPT_OUTPUT_TYPES.RSA_CSP_PUBLICKEYBLOB), RSAData, (UInt32)RSAData.Length, CRYPT_DECODE_FLAGS.NONE,
data, ref dwCertPublicKeyBlobSize))
throw new Win32Exception(Marshal.GetLastWin32Error());
}
else
throw new Win32Exception(Marshal.GetLastWin32Error());
return data;
}
/// <summary>Converts DER binary format to a CAPI CRYPT_PRIVATE_KEY_INFO structure.</summary>
internal static byte[] GetPrivateKeyDER(byte[] DERData)
{
byte[] data = null;
UInt32 dwRSAPrivateKeyBlobSize = 0;
IntPtr pRSAPrivateKeyBlob = IntPtr.Zero;
if (CryptDecodeObject(CRYPT_ENCODING_FLAGS.X509_ASN_ENCODING | CRYPT_ENCODING_FLAGS.PKCS_7_ASN_ENCODING, new IntPtr((int)CRYPT_OUTPUT_TYPES.PKCS_RSA_PRIVATE_KEY),
DERData, (UInt32)DERData.Length, CRYPT_DECODE_FLAGS.NONE, data, ref dwRSAPrivateKeyBlobSize))
{
data = new byte[dwRSAPrivateKeyBlobSize];
if (!CryptDecodeObject(CRYPT_ENCODING_FLAGS.X509_ASN_ENCODING | CRYPT_ENCODING_FLAGS.PKCS_7_ASN_ENCODING, new IntPtr((int)CRYPT_OUTPUT_TYPES.PKCS_RSA_PRIVATE_KEY),
DERData, (UInt32)DERData.Length, CRYPT_DECODE_FLAGS.NONE, data, ref dwRSAPrivateKeyBlobSize))
throw new Win32Exception(Marshal.GetLastWin32Error());
}
else
throw new Win32Exception(Marshal.GetLastWin32Error());
return data;
}
/// <summary>Converts DER binary format to a CAPI CERT_PUBLIC_KEY_INFO structure containing an RSA key.</summary>
internal static byte[] GetRSAFromDER(byte[] DERData)
{
byte[] data = null;
byte[] publicKey = null;
CERT_PUBLIC_KEY_INFO info;
UInt32 dwCertPublicKeyInfoSize = 0;
IntPtr pCertPublicKeyInfo = IntPtr.Zero;
if (CryptDecodeObject(CRYPT_ENCODING_FLAGS.X509_ASN_ENCODING | CRYPT_ENCODING_FLAGS.PKCS_7_ASN_ENCODING, new IntPtr((int)CRYPT_OUTPUT_TYPES.X509_PUBLIC_KEY_INFO),
DERData, (UInt32)DERData.Length, CRYPT_DECODE_FLAGS.NONE, data, ref dwCertPublicKeyInfoSize))
{
data = new byte[dwCertPublicKeyInfoSize];
if (CryptDecodeObject(CRYPT_ENCODING_FLAGS.X509_ASN_ENCODING | CRYPT_ENCODING_FLAGS.PKCS_7_ASN_ENCODING, new IntPtr((int)CRYPT_OUTPUT_TYPES.X509_PUBLIC_KEY_INFO),
DERData, (UInt32)DERData.Length, CRYPT_DECODE_FLAGS.NONE, data, ref dwCertPublicKeyInfoSize))
{
GCHandle handle = GCHandle.Alloc(data, GCHandleType.Pinned);
try
{
info = (CERT_PUBLIC_KEY_INFO)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(CERT_PUBLIC_KEY_INFO));
publicKey = new byte[info.PublicKey.cbData];
Marshal.Copy(info.PublicKey.pbData, publicKey, 0, publicKey.Length);
}
finally
{
handle.Free();
}
}
else
throw new Win32Exception(Marshal.GetLastWin32Error());
}
else
throw new Win32Exception(Marshal.GetLastWin32Error());
return publicKey;
}
/// <summary>Extracts the binary data from a PEM file.</summary>
internal static byte[] GetDERFromPEM(string sPEM)
{
UInt32 dwSkip, dwFlags;
UInt32 dwBinarySize = 0;
if (!CryptStringToBinary(sPEM, (UInt32)sPEM.Length, CRYPT_STRING_FLAGS.CRYPT_STRING_BASE64HEADER, null, ref dwBinarySize, out dwSkip, out dwFlags))
throw new Win32Exception(Marshal.GetLastWin32Error());
byte[] decodedData = new byte[dwBinarySize];
if (!CryptStringToBinary(sPEM, (UInt32)sPEM.Length, CRYPT_STRING_FLAGS.CRYPT_STRING_BASE64HEADER, decodedData, ref dwBinarySize, out dwSkip, out dwFlags))
throw new Win32Exception(Marshal.GetLastWin32Error());
return decodedData;
}
#endregion Methods
#region P/Invoke Constants
/// <summary>Enumeration derived from Crypto API.</summary>
internal enum CRYPT_ACQUIRE_CONTEXT_FLAGS : uint
{
CRYPT_NEWKEYSET = 0x8,
CRYPT_DELETEKEYSET = 0x10,
CRYPT_MACHINE_KEYSET = 0x20,
CRYPT_SILENT = 0x40,
CRYPT_DEFAULT_CONTAINER_OPTIONAL = 0x80,
CRYPT_VERIFYCONTEXT = 0xF0000000
}
/// <summary>Enumeration derived from Crypto API.</summary>
internal enum CRYPT_PROVIDER_TYPE : uint
{
PROV_RSA_FULL = 1
}
/// <summary>Enumeration derived from Crypto API.</summary>
internal enum CRYPT_DECODE_FLAGS : uint
{
NONE = 0,
CRYPT_DECODE_ALLOC_FLAG = 0x8000
}
/// <summary>Enumeration derived from Crypto API.</summary>
internal enum CRYPT_ENCODING_FLAGS : uint
{
PKCS_7_ASN_ENCODING = 0x00010000,
X509_ASN_ENCODING = 0x00000001,
}
/// <summary>Enumeration derived from Crypto API.</summary>
internal enum CRYPT_OUTPUT_TYPES : int
{
X509_PUBLIC_KEY_INFO = 8,
RSA_CSP_PUBLICKEYBLOB = 19,
PKCS_RSA_PRIVATE_KEY = 43,
PKCS_PRIVATE_KEY_INFO = 44
}
/// <summary>Enumeration derived from Crypto API.</summary>
internal enum CRYPT_STRING_FLAGS : uint
{
CRYPT_STRING_BASE64HEADER = 0,
CRYPT_STRING_BASE64 = 1,
CRYPT_STRING_BINARY = 2,
CRYPT_STRING_BASE64REQUESTHEADER = 3,
CRYPT_STRING_HEX = 4,
CRYPT_STRING_HEXASCII = 5,
CRYPT_STRING_BASE64_ANY = 6,
CRYPT_STRING_ANY = 7,
CRYPT_STRING_HEX_ANY = 8,
CRYPT_STRING_BASE64X509CRLHEADER = 9,
CRYPT_STRING_HEXADDR = 10,
CRYPT_STRING_HEXASCIIADDR = 11,
CRYPT_STRING_HEXRAW = 12,
CRYPT_STRING_NOCRLF = 0x40000000,
CRYPT_STRING_NOCR = 0x80000000
}
#endregion P/Invoke Constants
#region P/Invoke Structures
/// <summary>Structure from Crypto API.</summary>
[StructLayout(LayoutKind.Sequential)]
internal struct CRYPT_OBJID_BLOB
{
internal UInt32 cbData;
internal IntPtr pbData;
}
/// <summary>Structure from Crypto API.</summary>
[StructLayout(LayoutKind.Sequential)]
internal struct CRYPT_ALGORITHM_IDENTIFIER
{
internal IntPtr pszObjId;
internal CRYPT_OBJID_BLOB Parameters;
}
/// <summary>Structure from Crypto API.</summary>
[StructLayout(LayoutKind.Sequential)]
struct CRYPT_BIT_BLOB
{
internal UInt32 cbData;
internal IntPtr pbData;
internal UInt32 cUnusedBits;
}
/// <summary>Structure from Crypto API.</summary>
[StructLayout(LayoutKind.Sequential)]
struct CERT_PUBLIC_KEY_INFO
{
internal CRYPT_ALGORITHM_IDENTIFIER Algorithm;
internal CRYPT_BIT_BLOB PublicKey;
}
#endregion P/Invoke Structures
#region P/Invoke Functions
/// <summary>Function for Crypto API.</summary>
[DllImport("advapi32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
internal static extern bool CryptDestroyKey(IntPtr hKey);
/// <summary>Function for Crypto API.</summary>
[DllImport("advapi32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
internal static extern bool CryptImportKey(IntPtr hProv, byte[] pbKeyData, UInt32 dwDataLen, IntPtr hPubKey, UInt32 dwFlags, ref IntPtr hKey);
/// <summary>Function for Crypto API.</summary>
[DllImport("advapi32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
internal static extern bool CryptReleaseContext(IntPtr hProv, Int32 dwFlags);
/// <summary>Function for Crypto API.</summary>
[DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
internal static extern bool CryptAcquireContext(ref IntPtr hProv, string pszContainer, string pszProvider, CRYPT_PROVIDER_TYPE dwProvType, CRYPT_ACQUIRE_CONTEXT_FLAGS dwFlags);
/// <summary>Function from Crypto API.</summary>
[DllImport("crypt32.dll", SetLastError = true, CharSet = CharSet.Auto)]
[return: MarshalAs(UnmanagedType.Bool)]
internal static extern bool CryptStringToBinary(string sPEM, UInt32 sPEMLength, CRYPT_STRING_FLAGS dwFlags, [Out] byte[] pbBinary, ref UInt32 pcbBinary, out UInt32 pdwSkip, out UInt32 pdwFlags);
/// <summary>Function from Crypto API.</summary>
[DllImport("crypt32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
internal static extern bool CryptDecodeObjectEx(CRYPT_ENCODING_FLAGS dwCertEncodingType, IntPtr lpszStructType, byte[] pbEncoded, UInt32 cbEncoded, CRYPT_DECODE_FLAGS dwFlags, IntPtr pDecodePara, ref byte[] pvStructInfo, ref UInt32 pcbStructInfo);
/// <summary>Function from Crypto API.</summary>
[DllImport("crypt32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
internal static extern bool CryptDecodeObject(CRYPT_ENCODING_FLAGS dwCertEncodingType, IntPtr lpszStructType, byte[] pbEncoded, UInt32 cbEncoded, CRYPT_DECODE_FLAGS flags, [In, Out] byte[] pvStructInfo, ref UInt32 cbStructInfo);
#endregion P/Invoke Functions
}單元測試：
[TestClass]
public class RSAHelperTest
{
string publicKeyJava = @"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCkixtIe0MzCFDW3eCDSq/6SFFN+eK+zg1q62SX
TbJprt7zOD6D9A8zU1fTEzY9+0gVUYmOMPOF8jI8EMZOnl2jDUtn3KdD2Uuee3/cmEfMpAN++KMG
6Tfm3p3Iz4kw/dLmM1EAkADIp4zFmkvxd/BN+dmT/1Tp87mMUQBS8mvdRwIDAQAB";
string privateKeyJava = @"MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAKSLG0h7QzMIUNbd4INKr/pIUU35
4r7ODWrrZJdNsmmu3vM4PoP0DzNTV9MTNj37SBVRiY4w84XyMjwQxk6eXaMNS2fcp0PZS557f9yY
R8ykA374owbpN+bencjPiTD90uYzUQCQAMinjMWaS/F38E352ZP/VOnzuYxRAFLya91HAgMBAAEC
gYBXJCSq2jzYhgrqAE+quJ9CGZKVjUV8b3vDqC55wvg96BLDFIJnN5XlRLo6Wu5bHP0r7SbAW0Rd
J8ta7DdZ450Kow+k2Z69gYO818cptQXYrs4ky6M48NXeSSoYeGESxW7LGJs++o2nGmVRkhj4DMYY
8lur1oYsyDAy/d3B0ucnwQJBAP0Kc2KCOl8xnbXUuoFhJHaVoKPWqdhody5sNHK+11Bgc3/ZhqNM
T1uIiiZnB3CTyfKeJAgX0fwde7fmtZHaUO8CQQCmd7a3qXvUbnQao03ITrthGRvGAJSAfTAG/VEx
2g1knxUmiq+bek+FGi7UYXYRZ/rVqX934ztTAOnBqVtnK4kpAkEAs6KAqVUkFUJG4LfFM2YAGcM9
SDJzXvNCcI1WaoM6nY/rTr7hCvp4d9WlpX+M04nHWtqTX79xTdasZrB9A68FtwJAHXWmIk6eGXQK
nAQ2abJ1OrPE1H+ZyDtfWn1N9zKNmDcG+TEl7q/wjq+ZhgBRcrciDtnWMxNFlmTc+WbNRC7SMQJB
AIBSE1kfhy3V63db91Gnr789G2QKy3TI46QEY3dirLiXWF3/tt+9K8itjeB22S5S7cWbzJ+2FIFW
mFB/DP3ER8Q=";
string publicKeyPEM = @"-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDe8W+2jrrWY55W8nZcWCBXQSJJ
uJxkannRsZbwiwJBftXCzN0wSaujwmT0S0Aqttnqg/sO+jDHVnpph8omZdSvnySt
/PiGEqmsk+6AsgZ7eczeokVkrFvVbjq13s6NVF8tgMds/w5VG8+uEECmiHCKM8/V
3oXhq7aLPLINFYggcQIDAQAB
-----END PUBLIC KEY-----
";
string privateKeyPEM = @"-----BEGIN RSA PRIVATE KEY-----
MIICWwIBAAKBgQDe8W+2jrrWY55W8nZcWCBXQSJJuJxkannRsZbwiwJBftXCzN0w
SaujwmT0S0Aqttnqg/sO+jDHVnpph8omZdSvnySt/PiGEqmsk+6AsgZ7eczeokVk
rFvVbjq13s6NVF8tgMds/w5VG8+uEECmiHCKM8/V3oXhq7aLPLINFYggcQIDAQAB
AoGAN9OnkMRe/u6FKOqgPvGGb7MMvf8vkmmjRaI91NBKaVI0fwpD3SKli2VTWGU7
lTaijPottQtriY8bKi/prAHV5wiSetsiPB9DQq8bN3rLtJPG6NCmwiOUhamBg9kD
VbqOb/1dg0vGL1zEKxtscaK5yDCBnyX+4LfAR5Upg0Q4t70CQQD8n5XxSdQpHNAf
sl26cTxf6YHCzHoqUfDo4SE74jWy8ooNF3qk0jaYy6+N1EOLwpMfm2MeWdxCYFmC
9NdbowIDAkEA4exKy9FGTPVkkVhAwva0fm7/mJSHsl7btPTJvmgEfO9eHbozYacQ
2PmbZd46uPzaI0LaDh8ICbaLvf8IPiVjewJAXIMUpggjaerjTLhFGsHdGkKpAm1f
T6AyWRYY1ZVBlQa9B45Rm4pf9BSjdY0GL2hR+IEvCy5dOvGN1idTtns7gQJAfiqO
TqptPxcfdYe6iuZpP95PAO+ZpEQTIEg/zgSa1QZ8Ic/VV+iLoRAr90SWuK4ESALS
cWZk/7+g5JbjDImmtwJAfBpGw+TVeMw+2Oo9GJnIM9Ga/hiYQDCkZ9A/4fYrNxxr
znkMqFQ28dhYQbKK9/WcPTjHGakpY/2hY/9dki6CJw==
-----END RSA PRIVATE KEY-----
";
[TestMethod]
public void RSA_Java_MD5Verify()
{
string data = "hello word!";
string hashAlgorithm = "MD5";
string signResult = RSAHelper.RSASignJava(data,privateKeyJava, hashAlgorithm);
string sign1 = "bI/x8LHsuvCVgO7YEBA0hvQWdpLzqdThfYKYEeo4YFTclhFV+R4QCN2FgYshZqjDTBzHAvRHxoRk4kbYWeOuVNG+W3exdtqfUuUp29EgxEPFfqECUqucgN/bFxrtKtNGOCAqOBSx6SBkRpByKEAH7FHsRmPS4Bd4MUT4xr9gGg8=";
if (sign1 == signResult)
{
}
bool result = RSAHelper.VerifyJava(data, publicKeyJava, signResult, hashAlgorithm);
if (!result)
{
int a = 0;
int b = 0 / a;
}
Console.WriteLine(hashAlgorithm + ":" + result);
}
[TestMethod]
public void RSA_Java_SHA1Verify()
{
//通過測試
string data = "hello word!";
string hashAlgorithm = "SHA1";
string signResult = RSAHelper.RSASignJava(data,privateKeyJava, hashAlgorithm);
bool result = RSAHelper.VerifyJava(data,publicKeyJava, signResult, hashAlgorithm);
if (!result)
{
int a = 0;
int b = 0 / a;
}
Console.WriteLine(hashAlgorithm + ":" + result);
}
[TestMethod]
public void RSA_Java_SHA256Verify()
{
//未通過
string data = "hello word!";
string hashAlgorithm = "SHA256";
string signResult = RSAHelper.RSASignJava(data,privateKeyJava, hashAlgorithm);
bool result = RSAHelper.VerifyJava(data,publicKeyJava, signResult, hashAlgorithm);
if (!result)
{
int a = 0;
int b = 0 / a;
}
Console.WriteLine(hashAlgorithm + ":" + result);
}
[TestMethod]
public void RSASign_JAVA_WithVerify()
{
string data = "hello word!";
//"RIPEMD160",
List<string> hashAlgorithmList = new List<string>() { "MD5", "SHA1", "SHA256", "SHA384", "SHA512" };//{MD5、RIPEMD160、SHA1、SHA256、SHA384、SHA512}
foreach (var hashAlgorithm in hashAlgorithmList)
{
string signResult = RSAHelper.RSASignJava(data,privateKeyJava, hashAlgorithm);
bool result = RSAHelper.VerifyJava(data,publicKeyJava, signResult, hashAlgorithm);
if (!result)
{
int a = 0;
int b = 0 / a;
}
Console.WriteLine(hashAlgorithm + ":" + result);
}
}
[TestMethod]
public void RSASign_PEM_WithVerify()
{
string data = "hello word!";
//"RIPEMD160",
List<string> hashAlgorithmList = new List<string>() { "MD5", "SHA1", "SHA256", "SHA384", "SHA512" };//{MD5、RIPEMD160、SHA1、SHA256、SHA384、SHA512}
foreach (var hashAlgorithm in hashAlgorithmList)
{
string signResult = RSAHelper.RSASignPEM(data, privateKeyPEM, hashAlgorithm);
bool result = RSAHelper.VerifyPEM(data, publicKeyPEM, signResult, hashAlgorithm);
if (!result)
{
int a = 0;
int b = 0 / a;
}
Console.WriteLine(hashAlgorithm + ":" + result);
}
}
[TestMethod]
public void RSA_Java_EncryptWithDecrypt()
{
string data = "hello word!";//"MD5",
string encryptResult = RSAHelper.EncryptJava(publicKeyJava,data);
string decryptResult = RSAHelper.DecryptJava(privateKeyJava,encryptResult);
if (data != decryptResult)
{
int a = 0;
int b = 0 / a;
}
}
[TestMethod]
public void RSA_PEM_EncryptWithDecrypt()
{
string data = "hello word!";//"MD5",
string encryptResult = RSAHelper.EncryptPEM(publicKeyPEM,data);
string decryptResult = RSAHelper.DecryptPEM(privateKeyPEM,encryptResult);
if (data != decryptResult)
{
int a = 0;
int b = 0 / a;
}
}
}測試結果：
下載地址：
CSDN下載不靠譜，不要積分的現在下的人多了積分要那麼多，誰沒事老去整積分啊。要原始碼的可以直接留言，留下郵箱。
相關推薦
C# RSA加密、解密、加簽、驗籤、支援JAVA格式公鑰私鑰、PEM格式公鑰私鑰、.NET格式公鑰私鑰、一般模式【支援公鑰加密，私鑰解密】（一）
2017-12-04日更新：增加支援微信支付。程式碼註釋中//☆☆☆☆.NET 4.6以後特有☆☆☆☆的別用，那個不對。 RSA非對稱加密。簡明扼要吧，直說乾貨。（在此特別感謝下貳進位制，提供JAVA版的公鑰私鑰） C#RSA加簽解籤加密比較常見，一般遇到的問題是非.NET
【java並發編程藝術學習】（一）初衷、感想與筆記目錄
家庭 需求 ring 薪資 問題 發現 開發 nbsp 編程 不忘初心，方得始終。 學習java編程這麽長時間，自認為在項目功能需求開發中沒啥問題，但是之前的幾次面試和跟一些勤奮的或者小牛、大牛級別的人的接觸中，才發現自己的無知與淺薄。 學習總得有個方向吧，現階段就想把並發
【知識積累】（一）、瞭解Regex（正則表示式）
一、正則表示式簡介 一種可以用於模式匹配和替換的規範，由普通字元 + 特殊字元構成一個模板，用於對目標字串進行匹配、查詢、替換、判斷。 原始碼：JDK1.4中的java.util.regex下的Pattern和Matcher類。 二、常用語法 1、字元取值範圍 [abc]：表示可能是a
【計算機網路】（一）OSI, TCP/IP模型 & 網路HTTP、TCP、UDP、Socket 基本知識總結
OSI 七層模型 我們一般使用的網路資料傳輸由下而上共有七層,分別為物理層、資料鏈路層、網路層、傳輸層、會話層、表示層、應用層,也被依次稱為 OSI 第一層、第二層、⋯⋯、 第七層。 如下圖: 各層功能簡介 1.物理層(Physical Layer)
【資料結構之二叉樹】（一）B樹、B-樹、B+樹、B*樹介紹，和B+樹更適合做檔案索引的原因
今天看資料庫，書中提到：由於索引是採用 B 樹結構儲存的，所以對應的索引項並不會被刪除，經過一段時間的增刪改操作後，資料庫中就會出現大量的儲存碎片，這和磁碟碎片、記憶體碎片產生原理是類似的，這些儲存碎片不僅佔用了儲存空間，而且降低了資料庫執行的速度。如果發現索引
必須知道的八大種排序演算法【java實現】（一） 氣泡排序、快速排序
氣泡排序 氣泡排序是一種簡單的排序演算法。它重複地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個演算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端。 氣泡排序的示例： 氣
【Node.js Koa框架入門】（一）Koa 框架介紹以及環境搭建、簡單使用
一、框架介紹 Koa -- 基於 Node.js 平臺的下一代 web 開發框架 koa是由 Express 原班人馬打造的，致力於成為一個更小、更富有表現力、更健壯的 Web 框架。 使用 koa 編寫 web 應用，可以免除重複繁瑣的回撥函式巢狀， 並極大地提升錯誤
RSA加解密，加簽以及驗籤。
由於RSA演算法是不對稱加密演算法，所以每次加密得到的資料都不相同，同理加簽得到的資料每次也不一樣。 簡單的說下不對稱演算法，就是兩把不同，但是完全匹配的祕鑰，去進行加解密，公鑰對外提供進行資料加密，私鑰自己儲存，對加密的資料進行解密。所以私鑰不要洩露。 RSA演算法原理：
【Ibatis】（一）、sqlMapConfig.xml配置檔案詳解
1.sqlMapConfig.xml配置檔案詳解： Xml程式碼 <? xml version="1.0" encoding="UTF-8" ?> <! DOCTYPE sqlMapConfig PUBLIC "-//iBATIS.com//DTD SQL Map Co
【C++併發實戰】（一）併發基本概念
什麼是併發 併發，最簡單的理解就是，兩個或者以上的活動同時進行。舉個比較實際的例子，你可以手腳並用，兩隻手做不同的動作等等。 在計算機中的“併發”，是指一個系統可以同時執行多個獨立的活動。在以前大多數計算機都只有一個處理單元（或者核心），這種計算機在同一時刻只能執行一個任務，任務
【設計模式】（一）-簡單工廠模式和策略模式
前言 最近開始和春哥，張鐸 ，銀平討論設計模式，成立了一個小菜變大鳥的小組，每天討論一個模式，並且把這個模式搞懂，每學一個新的模式，再回顧一下之前學的模式。這兩天學了簡單工廠模式和策略模式，發現兩個模式有很多相同之處，下面用商場促銷的例子來對兩個模式總結一下。 簡單工廠模式 1.
【 C# 資料結構】（一） -------------------------- 泛型帶頭節點的單鏈表，雙向連結串列實現
在程式設計領域，資料結構與演算法向來都是提升程式設計能力的重點。而一般常見的資料結構是連結串列，棧，佇列，樹等。事實上C#也已經封裝好了這些資料結構，在標頭檔案 System.Collections.Generic 中，直接建立並呼叫其成員方法就行。不過我們學習當然要知其然，亦知其所以然。 本文實現的是連結
【程式設計模式】（一） ------ 命令模式 和 “重做” 及 “撤銷”
前言 本文及以後該系列的篇章都是本人對 《遊戲程式設計模式》這本書的閱讀理解，從中對一些原理，用更直白的語言描述出來，並對部分思路或功能進行初步實現。而本文所描述的 命令模式， 相信讀者應該都有了解過或聽說過，如果尚有疑惑的讀者，我希望本文能對你有所幫助。 命令模式是設計模式中的一種，但該系列所指的程式設計模
C入門【總結】（一）
題記：重新認真學習C入門這段時間，發現自己之前的不足與許多能力裡不達標的地方。通過不斷地練習，今天總結一下前段時間學習內容。 ——————————————————————————————————————————————— 分子與迴圈語句 這部分的內容在C整個部分扮演者重要的角色使用頻
C入門【五】（一）
內容核心 鞏固練習C語言入門語法練習 1.編寫一個程式，可以一直接收鍵盤字元 詳細/* 如果是小寫字元就輸出對應的大寫字元， 如果接收的是大寫字元，就輸出對應的小寫字元， 如果是數字不輸出。 */ 個人看法：這道題我在練習時有兩種思路 1.將輸入的字元先轉化為int型 然後根據 AS
【資訊學奧賽】【C++】（一）賦值語句
一、基本知識 在C/C++中，“=” 在語言中的作用並非是數學意義上的“等於號”，也不表示判斷。 “=”在這裡的意思是賦值：表示把它右邊的值賦給左邊。 一般形式為：變數=表示式 有的時候編譯器會提示不
【C#冷知識系列】（一）那些你知道或者不知道的奇淫巧技
愛的 讓我 同事 orm lec 工程師 能夠 代碼 優勢 引子 正如我在個人介紹中所寫，我是一個仍然堅持.NET的頭鐵高級軟件工程師，研究C#，.NET已經六年多，一直堅持認為自己的能力不足以教授別人，所以一直沒有想法寫博客。工作幾年，內容涵蓋了.NET框架下的各種軟件的
【WCF系列】（一）為什麽我們需要WCF
企業網 密碼 統一 兼容 erp service mage 數據完整性 圖片 為什麽我們需要WCF 傳統分布式軟件的架構分析 一個開發需求：社保平臺 訪問量較大客戶端類型/平臺多和其他系統交互多快速開發/部署結構復雜（B/S、C/S、桌面、服務…） 傳
【微信小遊戲】（一）小遊戲開發調試--關於找不到app.json入口文件
com png info alt 微信開發者 遊戲 進入 http 找不到 經了解發現 小程序必須要有app.json 小遊戲必須的文件只有2個 game.js 小遊戲入口文件 game.json 小遊戲配置文件 所以不是工程文件缺失，解決方案如下： 進入微信開發者工具
【完全分散式Hadoop】（一）從虛擬機器Centos6.5的安裝開始
一、虛擬機器安裝 不做過多介紹，自行去某度搜索 二、Centos6.5配置 1. 關閉防火牆 service iptables stop 關閉防火牆開機啟動 chkconfig iptables off 2. windows中檢視VM8的IPv4 ipconfig -