最近需要用到加密算法，因此研究了一下，记录在此。
加密算法分为两大类，可逆与不可逆，即是否可以进行解密。常见的Hash算法，比如MD5，SHA1等算法，均为不可逆算法。此种算法加密之后没法解密获得原始信息。可逆加密算法又可以分为对称加密和非对称加密。对称加密表示加密和解密用的是同一个密钥；而非对称加密则存在一对公钥和私钥，用公钥加密的信息只能用对应的私钥进行解密。常用的对称加密算法有DES，AES等，非对称加密算法有RSA，ECC等。
从加密强度上来看，SHA512>SHA256>SHA-1>MD5，AES>DES，ECC>RSA。性能上则通常是反过来。
由于非对称加密算法的运行速度比对称加密算法的速度慢很多，当我们需要加密大量的数据时，建议采用对称加密算法，提高加解密速度。
对称加密算法不能实现签名，因此签名只能用非对称加密。
由于对称加密算法的密钥管理是一个复杂的过程，密钥的管理直接决定着他的安全性，因此当数据量很小时，可以考虑采用非对称加密算法。
在实际的操作过程中，通常采用的方式是：采用非对称加密算法管理对称算法的密钥，然后用对称加密算法加密数据，这样就集成了两类加密算法的优点，既实现了加密速度快的优点，又实现了安全方便管理密钥的优点。
那采用多少位的密钥合适呢？ RSA建议采用1024位的数字，ECC建议采用160位，AES采用128位即可。
下面以C#为实现语言，给出各个加密算法的样例代码
Encrypter.cs
using System;
using System.Security.Cryptography;
using System.IO;
using System.Text;
using System.Globalization;
using System.Xml.Linq;
using System.Collections.Generic;
namespace EncriptSample
{
/// <summary>
/// 加密、解密
/// </summary>
class Encrypter
{
//DES默认密钥向量
private static byte[] DES_IV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
//AES默认密钥向量
public static readonly byte[] AES_IV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF, 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
//ECC公钥
public static byte[] senderPublicKey;
public static byte[] receiverPublicKey;
//ECC私钥
private static byte[] senderPrivateKey;
private static byte[] receiverPrivateKey;
//ECC 初始化向量
private static byte[] iVector;
#region MD5
/// <summary>
/// MD5加密为32字符长度的16进制字符串
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public static string EncryptByMD5(string input)
{
MD5 md5Hasher = MD5.Create();
byte[] data = md5Hasher.ComputeHash(Encoding.UTF8.GetBytes(input));
StringBuilder sBuilder = new StringBuilder();
//将每个字节转为16进制
for (int i = 0; i < data.Length; i++)
{
sBuilder.Append(data[i].ToString("x2"));
}
return sBuilder.ToString();
}
#endregion
#region SHA1
/// <summary>
/// SHA1加密
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public static string EncryptBySHA1(string input)
{
SHA1 sha = new SHA1CryptoServiceProvider();
byte[] bytes = Encoding.Unicode.GetBytes(input);
byte[] result = sha.ComputeHash(bytes);
return BitConverter.ToString(result);
}
#endregion
#region SHA256
/// <summary>
/// SHA256加密
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public static string EncryptBySHA256(string input)
{
SHA256 sha256 = new SHA256Managed();
byte[] bytes = Encoding.Unicode.GetBytes(input);
byte[] result = sha256.ComputeHash(bytes);
return BitConverter.ToString(result);
}
#endregion
#region SHA512
/// <summary>
/// SHA512加密
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public static string EncryptBySHA512(string input)
{
SHA512 sha512 = new SHA512Managed();
byte[] bytes = Encoding.Unicode.GetBytes(input);
byte[] result = sha512.ComputeHash(bytes);
return BitConverter.ToString(result);
}
#endregion
#region DES
/// <summary>
/// 加密方法
/// </summary>
/// <param name="input"></param>
/// <param name="key"></param>
/// <returns></returns>
public static string EncryptByDES(string input, string key)
{
byte[] inputBytes = Encoding.UTF8.GetBytes(input); //Encoding.UTF8.GetBytes(input);
byte[] keyBytes = ASCIIEncoding.UTF8.GetBytes(key);
byte[] encryptBytes = EncryptByDES(inputBytes, keyBytes, keyBytes);
//string result = Encoding.UTF8.GetString(encryptBytes); //无法解码,其加密结果中文出现乱码：d\"�e�� ��(��uπ �W��-�� ,_�\nJn7
//原因：如果明文为中文，UTF8编码两个字节标识一个中文字符，但是加密后，两个字节密文，不一定还是中文字符。
using (DES des = new DESCryptoServiceProvider())
{
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write))
{
using (StreamWriter writer = new StreamWriter(cs))
{
writer.Write(inputBytes);
}
}
}
}
string result = Convert.ToBase64String(encryptBytes);
return result;
}
/// <summary>
/// DES加密
/// </summary>
/// <param name="inputBytes">输入byte数组</param>
/// <param name="key">密钥，只能是英文字母或数字</param>
/// <param name="IV">偏移向量</param>
/// <returns></returns>
public static byte[] EncryptByDES(byte[] inputBytes, byte[] key, byte[] IV)
{
DES des = new DESCryptoServiceProvider();
//建立加密对象的密钥和偏移量
des.Key = key;
des.IV = IV;
string result = string.Empty;
//1、如果通过CryptoStreamMode.Write方式进行加密，然后CryptoStreamMode.Read方式进行解密，解密成功。
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(inputBytes, 0, inputBytes.Length);
}
return ms.ToArray();
}
//2、如果通过CryptoStreamMode.Write方式进行加密，然后再用CryptoStreamMode.Write方式进行解密，可以得到正确结果
//3、如果通过CryptoStreamMode.Read方式进行加密，然后再用CryptoStreamMode.Read方式进行解密，无法解密，Error：要解密的数据的长度无效。
//4、如果通过CryptoStreamMode.Read方式进行加密，然后再用CryptoStreamMode.Write方式进行解密,无法解密，Error：要解密的数据的长度无效。
//using (MemoryStream ms = new MemoryStream(inputBytes))
//{
// using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Read))
// {
// using (StreamReader reader = new StreamReader(cs))
// {
// result = reader.ReadToEnd();
// return Encoding.UTF8.GetBytes(result);
// }
// }
//}
}
/// <summary>
/// 解密
/// </summary>
/// <param name="input"></param>
/// <param name="key"></param>
/// <returns></returns>
public static string DecryptByDES(string input, string key)
{
//UTF8无法解密，Error: 要解密的数据的长度无效。
//byte[] inputBytes = Encoding.UTF8.GetBytes(input);//UTF8乱码，见加密算法
byte[] inputBytes = Convert.FromBase64String(input);
byte[] keyBytes = ASCIIEncoding.UTF8.GetBytes(key);
byte[] resultBytes = DecryptByDES(inputBytes, keyBytes, keyBytes);
string result = Encoding.UTF8.GetString(resultBytes);
return result;
}
/// <summary>
/// 解密方法
/// </summary>
/// <param name="inputBytes"></param>
/// <param name="key"></param>
/// <param name="iv"></param>
/// <returns></returns>
public static byte[] DecryptByDES(byte[] inputBytes, byte[] key, byte[] iv)
{
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
//建立加密对象的密钥和偏移量，此值重要，不能修改
des.Key = key;
des.IV = iv;
//通过write方式解密
//using (MemoryStream ms = new MemoryStream())
//{
// using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write))
// {
// cs.Write(inputBytes, 0, inputBytes.Length);
// }
// return ms.ToArray();
//}
//通过read方式解密
using (MemoryStream ms = new MemoryStream(inputBytes))
{
using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Read))
{
using (StreamReader reader = new StreamReader(cs))
{
string result = reader.ReadToEnd();
return Encoding.UTF8.GetBytes(result);
}
}
}
//错误写法,注意哪个是输出流的位置，如果范围ms，与原文不一致。
//using (MemoryStream ms = new MemoryStream(inputBytes))
//{
// using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Read))
// {
// cs.Read(inputBytes, 0, inputBytes.Length);
// }
// return ms.ToArray();
//}
}
/// <summary>
/// 加密字符串
/// </summary>
/// <param name="input"></param>
/// <param name="sKey"></param>
/// <returns></returns>
public static string EncryptString(string input, string sKey)
{
byte[] data = Encoding.UTF8.GetBytes(input);
using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
{
des.Key = ASCIIEncoding.ASCII.GetBytes(sKey);
des.IV = ASCIIEncoding.ASCII.GetBytes(sKey);
ICryptoTransform desencrypt = des.CreateEncryptor();
byte[] result = desencrypt.TransformFinalBlock(data, 0, data.Length);
return BitConverter.ToString(result);
}
}
/// <summary>
/// 解密字符串
/// </summary>
/// <param name="input"></param>
/// <param name="sKey"></param>
/// <returns></returns>
public static string DecryptString(string input, string sKey)
{
string[] sInput = input.Split("-".ToCharArray());
byte[] data = new byte[sInput.Length];
for (int i = 0; i < sInput.Length; i++)
{
data[i] = byte.Parse(sInput[i], NumberStyles.HexNumber);
}
using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
{
des.Key = ASCIIEncoding.ASCII.GetBytes(sKey);
des.IV = ASCIIEncoding.ASCII.GetBytes(sKey);
ICryptoTransform desencrypt = des.CreateDecryptor();
byte[] result = desencrypt.TransformFinalBlock(data, 0, data.Length);
return Encoding.UTF8.GetString(result);
}
}
#endregion
#region AES
/// <summary>
/// AES加密算法
/// </summary>
/// <param name="input">明文字符串</param>
/// <param name="key">密钥</param>
/// <returns>字符串</returns>
public static string EncryptByAES(string input, string key)
{
byte[] keyBytes = Encoding.UTF8.GetBytes(key.Substring(0, 32));
using (AesCryptoServiceProvider aesAlg = new AesCryptoServiceProvider())
{
aesAlg.Key = keyBytes;
aesAlg.IV = AES_IV;
ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
using (MemoryStream msEncrypt = new MemoryStream())
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
{
swEncrypt.Write(input);
}
byte[] bytes = msEncrypt.ToArray();
//return Convert.ToBase64String(bytes);//此方法不可用
return BitConverter.ToString(bytes);
}
}
}
}
/// <summary>
/// AES解密
/// </summary>
/// <param name="input">密文字节数组</param>
/// <param name="key">密钥</param>
/// <returns>返回解密后的字符串</returns>
public static string DecryptByAES(string input, string key)
{
//byte[] inputBytes = Convert.FromBase64String(input); //Encoding.UTF8.GetBytes(input);
string[] sInput = input.Split("-".ToCharArray());
byte[] inputBytes = new byte[sInput.Length];
for (int i = 0; i < sInput.Length; i++)
{
inputBytes[i] = byte.Parse(sInput[i], NumberStyles.HexNumber);
}
byte[] keyBytes = Encoding.UTF8.GetBytes(key.Substring(0, 32));
using (AesCryptoServiceProvider aesAlg = new AesCryptoServiceProvider())
{
aesAlg.Key = keyBytes;
aesAlg.IV = AES_IV;
ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
using (MemoryStream msEncrypt = new MemoryStream(inputBytes))
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, decryptor, CryptoStreamMode.Read))
{
using (StreamReader srEncrypt = new StreamReader(csEncrypt))
{
return srEncrypt.ReadToEnd();
}
}
}
}
}
/// <summary>
/// AES加密
/// </summary>
/// <param name="inputdata">输入的数据</param>
/// <param name="iv">向量128位</param>
/// <param name="strKey">加密密钥</param>
/// <returns></returns>
public static byte[] EncryptByAES(byte[] inputdata, byte[] key, byte[] iv)
{
分组加密算法
//Aes aes = new AesCryptoServiceProvider();
设置密钥及密钥向量
//aes.Key = key;
//aes.IV = iv;
//using (MemoryStream ms = new MemoryStream())
//{
// using (CryptoStream cs = new CryptoStream(ms, aes.CreateEncryptor(), CryptoStreamMode.Write))
// {
// using (StreamWriter writer = new StreamWriter(cs))
// {
// writer.Write(inputdata);
// }
// return ms.ToArray();
// }
//}
using (AesCryptoServiceProvider aesAlg = new AesCryptoServiceProvider())
{
aesAlg.Key = key;
aesAlg.IV = iv;
ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
using (MemoryStream msEncrypt = new MemoryStream())
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
{
swEncrypt.Write(inputdata);
}
byte[] encrypted = msEncrypt.ToArray();
return encrypted;
}
}
}
}
/// <summary>
/// AES解密
/// </summary>
/// <param name="inputdata">输入的数据</param>
/// <param name="key">key</param>
/// <param name="iv">向量128</param>
/// <returns></returns>
public static byte[] DecryptByAES(byte[] inputBytes, byte[] key, byte[] iv)
{
Aes aes = new AesCryptoServiceProvider();
aes.Key = key;
aes.IV = iv;
byte[] decryptBytes;
using (MemoryStream ms = new MemoryStream(inputBytes))
{
using (CryptoStream cs = new CryptoStream(ms, aes.CreateDecryptor(), CryptoStreamMode.Read))
{
using (StreamReader reader = new StreamReader(cs))
{
string result = reader.ReadToEnd();
decryptBytes = Encoding.UTF8.GetBytes(result);
}
}
}
return decryptBytes;
}
#endregion
#region RSA
/// <summary>
/// RSA加密
/// </summary>
/// <param name="plaintext">明文</param>
/// <param name="publicKey">公钥</param>
/// <returns>密文字符串</returns>
public static string EncryptByRSA(string plaintext, string publicKey)
{
UnicodeEncoding ByteConverter = new UnicodeEncoding();
byte[] dataToEncrypt = ByteConverter.GetBytes(plaintext);
using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
{
RSA.FromXmlString(publicKey);
byte[] encryptedData = RSA.Encrypt(dataToEncrypt, false);
return Convert.ToBase64String(encryptedData);
}
}
/// <summary>
/// RSA解密
/// </summary>
/// <param name="ciphertext">密文</param>
/// <param name="privateKey">私钥</param>
/// <returns>明文字符串</returns>
public static string DecryptByRSA(string ciphertext, string privateKey)
{
UnicodeEncoding byteConverter = new UnicodeEncoding();
using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
{
RSA.FromXmlString(privateKey);
byte[] encryptedData = Convert.FromBase64String(ciphertext);
byte[] decryptedData = RSA.Decrypt(encryptedData, false);
return byteConverter.GetString(decryptedData);
}
}
/// <summary>
/// 数字签名
/// </summary>
/// <param name="plaintext">原文</param>
/// <param name="privateKey">私钥</param>
/// <returns>签名</returns>
public static string HashAndSignString(string plaintext, string privateKey)
{
UnicodeEncoding ByteConverter = new UnicodeEncoding();
byte[] dataToEncrypt = ByteConverter.GetBytes(plaintext);
using (RSACryptoServiceProvider RSAalg = new RSACryptoServiceProvider())
{
RSAalg.FromXmlString(privateKey);
//使用SHA1进行摘要算法，生成签名
byte[] encryptedData = RSAalg.SignData(dataToEncrypt, new SHA1CryptoServiceProvider());
return Convert.ToBase64String(encryptedData);
}
}
/// <summary>
/// 验证签名
/// </summary>
/// <param name="plaintext">原文</param>
/// <param name="SignedData">签名</param>
/// <param name="publicKey">公钥</param>
/// <returns></returns>
public static bool VerifySigned(string plaintext, string SignedData, string publicKey)
{
using (RSACryptoServiceProvider RSAalg = new RSACryptoServiceProvider())
{
RSAalg.FromXmlString(publicKey);
UnicodeEncoding ByteConverter = new UnicodeEncoding();
byte[] dataToVerifyBytes = ByteConverter.GetBytes(plaintext);
byte[] signedDataBytes = Convert.FromBase64String(SignedData);
return RSAalg.VerifyData(dataToVerifyBytes, new SHA1CryptoServiceProvider(), signedDataBytes);
}
}
/// <summary>
/// 获取Key
/// 键为公钥，值为私钥
/// </summary>
/// <returns></returns>
public static KeyValuePair<string, string> CreateRSAKey()
{
RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
string privateKey = RSA.ToXmlString(true);
string publicKey = RSA.ToXmlString(false);
return new KeyValuePair<string, string>(publicKey, privateKey);
}
#endregion
#region ECC
public static void Init()
{
using (ECDiffieHellmanCng sender = new ECDiffieHellmanCng())
{
sender.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash;
sender.HashAlgorithm = CngAlgorithm.Sha256;
senderPublicKey = sender.PublicKey.ToByteArray();
//Bob bob = new Bob();
using (ECDiffieHellmanCng receiver = new ECDiffieHellmanCng())
{
receiver.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash;
receiver.HashAlgorithm = CngAlgorithm.Sha256;
receiverPublicKey = receiver.PublicKey.ToByteArray();
receiverPrivateKey = receiver.DeriveKeyMaterial(CngKey.Import(senderPublicKey, CngKeyBlobFormat.EccPublicBlob));
}
senderPrivateKey = sender.DeriveKeyMaterial(CngKey.Import(receiverPublicKey, CngKeyBlobFormat.EccPublicBlob));
}
}
public static string EncriptByECC(string plaintext)
{
byte[] encryptedMessage = null;
iVector = null;
Send(senderPrivateKey, plaintext, out encryptedMessage, out iVector);
return Convert.ToBase64String(encryptedMessage);
}
public static string DecryptByECC(string ciphertext)
{
byte[] encryptedMessage = Convert.FromBase64String(ciphertext);
return Receive(encryptedMessage, iVector);
}
private static void Send(byte[] key, string secretMessage, out byte[] encryptedMessage, out byte[] iv)
{
using (Aes aes = new AesCryptoServiceProvider())
{
aes.Key = key;
iv = aes.IV;
//aes.Padding = PaddingMode.ISO10126;
// Encrypt the message
using (MemoryStream ciphertext = new MemoryStream())
using (CryptoStream cs = new CryptoStream(ciphertext, aes.CreateEncryptor(), CryptoStreamMode.Write))
{
byte[] plaintextMessage = Encoding.UTF8.GetBytes(secretMessage);
cs.Write(plaintextMessage, 0, plaintextMessage.Length);
cs.Close();
encryptedMessage = ciphertext.ToArray();
}
}
}
private static string Receive(byte[] encryptedMessage, byte[] iv)
{
using (Aes aes = new AesCryptoServiceProvider())
{
aes.Key = receiverPrivateKey;
aes.IV = iv;
//aes.Padding = PaddingMode.ISO10126;
// Decrypt the message
using (MemoryStream plaintext = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(plaintext, aes.CreateDecryptor(), CryptoStreamMode.Write))
{
cs.Write(encryptedMessage, 0, encryptedMessage.Length);
cs.Close();
string message = Encoding.UTF8.GetString(plaintext.ToArray());
return message;
}
}
}
}
#endregion
#region other
/// <summary>
///
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public static byte[] GetBytes(string input)
{
string[] sInput = input.Split("-".ToCharArray());
byte[] inputBytes = new byte[sInput.Length];
for (int i = 0; i < sInput.Length; i++)
{
inputBytes[i] = byte.Parse(sInput[i], NumberStyles.HexNumber);
}
return inputBytes;
}
#endregion
}
}
Program.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
namespace EncriptSample
{
class Program
{
static void Main(string[] args)
{
string input = "abc";
input = "银行密码统统都给我";
string key = "justdoit";
string result = string.Empty;
result = Encrypter.EncryptByMD5(input);
Console.WriteLine("MD5加密结果：{0}",result);
result = Encrypter.EncryptBySHA1(input);
Console.WriteLine("SHA1加密结果：{0}", result);
result = Encrypter.EncryptBySHA256(input);
Console.WriteLine("SHA256加密结果：{0}", result);
result = Encrypter.EncryptBySHA512(input);
Console.WriteLine("SHA256加密结果：{0}", result);
result = Encrypter.EncryptString(input, key);
Console.WriteLine("DES加密结果：{0}", result);
result = Encrypter.DecryptString(result, key);
Console.WriteLine("DES解密结果：{0}", result);
result = Encrypter.EncryptByDES(input,key);
Console.WriteLine("DES加密结果：{0}", result);
result = Encrypter.DecryptByDES(result, key);
Console.WriteLine("DES解密结果：{0}", result); //结果："银行密码统统都给我�\nJn7"，与明文不一致，为什么呢？在加密后，通过base64编码转为字符串，可能是这个问题。
key = "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111";
result = Encrypter.EncryptByAES(input, key);
Console.WriteLine("AES加密结果：{0}", result);
result = Encrypter.DecryptByAES(result, key);
Console.WriteLine("AES解密结果：{0}", result);
KeyValuePair<string,string> keyPair = Encrypter.CreateRSAKey();
string privateKey = keyPair.Value;
string publicKey = keyPair.Key;
result = Encrypter.EncryptByRSA(input, publicKey);
Console.WriteLine("RSA公钥加密后的结果：{0}",result);
result = Encrypter.DecryptByRSA(result, privateKey);
Console.WriteLine("RSA私钥解密后的结果：{0}", result);
TestSign();
Encrypter.Init();
result = Encrypter.EncriptByECC(input);
Console.WriteLine("ECC加密后的结果：{0}", result);
result = Encrypter.DecryptByECC(result);
Console.WriteLine("ECC解密后的结果：{0}", result);
Console.WriteLine("输入任意键退出！");
Console.ReadKey();
}
/// <summary>
/// 测试数字签名
/// </summary>
public static void TestSign()
{
string originalData = "文章不错，这是我的签名：奥巴马！";
Console.WriteLine("签名数为：{0}",originalData);
KeyValuePair<string,string> keyPair = Encrypter.CreateRSAKey();
string privateKey = keyPair.Value;
string publicKey = keyPair.Key;
//1、生成签名，通过摘要算法
string signedData = Encrypter.HashAndSignString(originalData, privateKey);
Console.WriteLine("数字签名:{0}",signedData);
//2、验证签名
bool verify = Encrypter.VerifySigned(originalData, signedData,publicKey);
Console.WriteLine("签名验证结果：{0}",verify);
}
}
}
注意以上代码虽然可以编译运行，但仅作为几种加密算法的样例，在实际应用中需要根据使用环境，条件等信息仔细考虑和修改，以保证加密有效，不会造成信息泄露。
827
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
