NET实现RSA AES DES 字符串 加密解密以及SHA1 MD5加密
本文列举了 数据加密算法（Data Encryption Algorithm，DEA） 密码学中的高级加密标准（Advanced EncryptionStandard，AES）RSA公钥加密算法 的加密解密 .NET实现以及 安全哈希算法（Secure Hash Algorithm）和MD5的实现。
实现如下
using System;
usingSystem.Security.Cryptography;
usingSystem.IO;
usingSystem.Text;
usingSystem.Globalization;
usingSystem.Xml.Linq;
usingSystem.Collections.Generic;
namespaceEncriptSample
{
/// <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 };
#region MD5
/// <summary>
/// MD5加密为32字符长度的16进制字符串
/// </summary>
/// <paramname="input"></param>
/// <returns></returns>
public static stringEncryptByMD5(string input)
{
MD5 md5Hasher = MD5.Create();
byte[] data =md5Hasher.ComputeHash(Encoding.UTF8.GetBytes(input));
StringBuilder sBuilder = newStringBuilder();
//将每个字节转为16进制
for (int i = ; i < data.Length;i++)
{
sBuilder.Append(data[i].ToString("x2"));
}
return sBuilder.ToString();
}
#endregion
#region SHA1
/// <summary>
/// SHA1加密
/// </summary>
/// <paramname="input"></param>
/// <returns></returns>
public static stringEncryptBySHA1(string input)
{
SHA1 sha = new SHA1CryptoServiceProvider();
byte[] bytes =Encoding.Unicode.GetBytes(input);
byte[] result =sha.ComputeHash(bytes);
returnBitConverter.ToString(result);
}
#endregion
#region DES
/// <summary>
/// 加密方法
/// </summary>
/// <paramname="input"></param>
/// <paramname="key"></param>
/// <returns></returns>
public static stringEncryptByDES(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 = newDESCryptoServiceProvider())
{
using (MemoryStream ms = newMemoryStream())
{
using (CryptoStream cs =new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write))
{
using (StreamWriterwriter = new StreamWriter(cs))
{
writer.Write(inputBytes);
}
}
}
}
string result =Convert.ToBase64String(encryptBytes);
return result;
}
/// <summary>
/// DES加密
/// </summary>
/// <paramname="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 = newDESCryptoServiceProvider();
//建立加密对象的密钥和偏移量
des.Key = key;
des.IV = IV;
string result = string.Empty;
//1、如果通过CryptoStreamMode.Write方式进行加密，然后CryptoStreamMode.Read方式进行解密，解密成功。
using (MemoryStream ms = newMemoryStream())
{
using (CryptoStream cs = newCryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(inputBytes, ,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 = newMemoryStream(inputBytes))
//{
// using (CryptoStream cs = newCryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Read))
// {
// using (StreamReader reader = newStreamReader(cs))
// {
// result = reader.ReadToEnd();
// returnEncoding.UTF8.GetBytes(result);
// }
// }
//}
}
/// <summary>
/// 解密
/// </summary>
/// <paramname="input"></param>
/// <paramname="key"></param>
/// <returns></returns>
public static stringDecryptByDES(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>
/// <paramname="key"></param>
/// <paramname="iv"></param>
/// <returns></returns>
public static byte[]DecryptByDES(byte[] inputBytes, byte[] key, byte[] iv)
{
DESCryptoServiceProvider des = newDESCryptoServiceProvider();
//建立加密对象的密钥和偏移量，此值重要，不能修改
des.Key = key;
des.IV = iv;
//通过write方式解密
//using (MemoryStream ms = newMemoryStream())
//{
// using (CryptoStream cs = newCryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write))
// {
// cs.Write(inputBytes, 0,inputBytes.Length);
// }
// return ms.ToArray();
//}
//通过read方式解密
using (MemoryStream ms = newMemoryStream(inputBytes))
{
using (CryptoStream cs = newCryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Read))
{
using (StreamReader reader = newStreamReader(cs))
{
string result =reader.ReadToEnd();
returnEncoding.UTF8.GetBytes(result);
}
}
}
//错误写法,注意哪个是输出流的位置，如果范围ms，与原文不一致。
//using (MemoryStream ms = newMemoryStream(inputBytes))
//{
// using (CryptoStream cs = newCryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Read))
// {
// cs.Read(inputBytes, 0,inputBytes.Length);
// }
// return ms.ToArray();
//}
}
/// <summary>
/// 加密字符串
/// </summary>
/// <param name="input"></param>
/// <paramname="sKey"></param>
/// <returns></returns>
public static stringEncryptString(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, , data.Length);
returnBitConverter.ToString(result);
}
}
/// <summary>
/// 解密字符串
/// </summary>
/// <paramname="input"></param>
/// <paramname="sKey"></param>
/// <returns></returns>
public static stringDecryptString(string input, string sKey)
{
string[] sInput =input.Split("-".ToCharArray());
byte[] data = new byte[sInput.Length];
for (int i = ; 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, , data.Length);
returnEncoding.UTF8.GetString(result);
}
}
#endregion
#region AES
/// <summary>
/// AES加密算法
/// </summary>
/// <paramname="input">明文字符串</param>
/// <param name="key">密钥</param>
/// <returns>字符串</returns>
public static stringEncryptByAES(string input, string key)
{
byte[] keyBytes =Encoding.UTF8.GetBytes(key.Substring(, ));
using (AesCryptoServiceProvideraesAlg = new AesCryptoServiceProvider())
{
aesAlg.Key = keyBytes;
aesAlg.IV = AES_IV;
ICryptoTransform encryptor =aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
using (MemoryStream msEncrypt =new MemoryStream())
{
using (CryptoStreamcsEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (StreamWriterswEncrypt = new StreamWriter(csEncrypt))
{
swEncrypt.Write(input);
}
byte[] bytes =msEncrypt.ToArray();
//returnConvert.ToBase64String(bytes);//此方法不可用
returnBitConverter.ToString(bytes);
}
}
}
}
/// <summary>
/// AES解密
/// </summary>
/// <paramname="input">密文字节数组</param>
/// <param name="key">密钥</param>
/// <returns>返回解密后的字符串</returns>
public static stringDecryptByAES(string input, string key)
{
//byte[] inputBytes =Convert.FromBase64String(input); //Encoding.UTF8.GetBytes(input);
string[] sInput =input.Split("-".ToCharArray());
byte[] inputBytes = newbyte[sInput.Length];
for (int i = ; i <sInput.Length; i++)
{
inputBytes[i] =byte.Parse(sInput[i], NumberStyles.HexNumber);
}
byte[] keyBytes =Encoding.UTF8.GetBytes(key.Substring(, ));
using (AesCryptoServiceProvideraesAlg = new AesCryptoServiceProvider())
{
aesAlg.Key = keyBytes;
aesAlg.IV = AES_IV;
ICryptoTransform decryptor =aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
using (MemoryStream msEncrypt =new MemoryStream(inputBytes))
{
using (CryptoStreamcsEncrypt = new CryptoStream(msEncrypt, decryptor, CryptoStreamMode.Read))
{
using (StreamReadersrEncrypt = new StreamReader(csEncrypt))
{
returnsrEncrypt.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 = newAesCryptoServiceProvider();
////设置密钥及密钥向量
//aes.Key = key;
//aes.IV = iv;
//using (MemoryStream ms = newMemoryStream())
//{
// using (CryptoStream cs = newCryptoStream(ms, aes.CreateEncryptor(), CryptoStreamMode.Write))
// {
// using (StreamWriter writer = newStreamWriter(cs))
// {
// writer.Write(inputdata);
// }
// return ms.ToArray();
// }
//}
using (AesCryptoServiceProvideraesAlg = new AesCryptoServiceProvider())
{
aesAlg.Key = key;
aesAlg.IV = iv;
ICryptoTransform encryptor =aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
using (MemoryStream msEncrypt =new MemoryStream())
{
using (CryptoStreamcsEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (StreamWriterswEncrypt = 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 = newAesCryptoServiceProvider();
aes.Key = key;
aes.IV = iv;
byte[] decryptBytes;
using (MemoryStream ms = newMemoryStream(inputBytes))
{
using (CryptoStream cs = newCryptoStream(ms, aes.CreateDecryptor(), CryptoStreamMode.Read))
{
using (StreamReader reader= new StreamReader(cs))
{
string result =reader.ReadToEnd();
decryptBytes =Encoding.UTF8.GetBytes(result);
}
}
}
return decryptBytes;
}
#endregion
#region DSA
#endregion
#region RSA
/// <summary>
/// RSA加密
/// </summary>
/// <paramname="plaintext">明文</param>
/// <paramname="publicKey">公钥</param>
/// <returns>密文字符串</returns>
public static stringEncryptByRSA(string plaintext, string publicKey)
{
UnicodeEncoding ByteConverter = newUnicodeEncoding();
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>
/// <paramname="ciphertext">密文</param>
/// <paramname="privateKey">私钥</param>
/// <returns>明文字符串</returns>
public static stringDecryptByRSA(string ciphertext, string privateKey)
{
UnicodeEncoding byteConverter = newUnicodeEncoding();
using (RSACryptoServiceProvider RSA= new RSACryptoServiceProvider())
{
RSA.FromXmlString(privateKey);
byte[] encryptedData =Convert.FromBase64String(ciphertext);
byte[] decryptedData =RSA.Decrypt(encryptedData, false);
returnbyteConverter.GetString(decryptedData);
}
}
//public static string signByRSA(stringplaintext, string privateKey)
//{
// UnicodeEncoding ByteConverter = new UnicodeEncoding();
// byte[] dataToEncrypt = ByteConverter.GetBytes(plaintext);
// using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
// {
// RSA.FromXmlString(privateKey);
// byte[] encryptedData =RSA.SignData(dataToEncrypt,);
// return Convert.ToBase64String(encryptedData);
// }
//}
/// <summary>
/// 数字签名
/// </summary>
/// <paramname="plaintext">原文</param>
/// <paramname="privateKey">私钥</param>
/// <returns>签名</returns>
public static stringHashAndSignString(string plaintext, string privateKey)
{
UnicodeEncoding ByteConverter = newUnicodeEncoding();
byte[] dataToEncrypt =ByteConverter.GetBytes(plaintext);
using (RSACryptoServiceProviderRSAalg = new RSACryptoServiceProvider())
{
RSAalg.FromXmlString(privateKey);
//使用SHA1进行摘要算法，生成签名
byte[] encryptedData =RSAalg.SignData(dataToEncrypt, new SHA1CryptoServiceProvider());
returnConvert.ToBase64String(encryptedData);
}
}
/// <summary>
/// 验证签名
/// </summary>
/// <paramname="plaintext">原文</param>
/// <paramname="SignedData">签名</param>
/// <paramname="publicKey">公钥</param>
/// <returns></returns>
public static bool VerifySigned(stringplaintext, string SignedData, string publicKey)
{
using (RSACryptoServiceProviderRSAalg = new RSACryptoServiceProvider())
{
RSAalg.FromXmlString(publicKey);
UnicodeEncoding ByteConverter =new UnicodeEncoding();
byte[] dataToVerifyBytes =ByteConverter.GetBytes(plaintext);
byte[] signedDataBytes =Convert.FromBase64String(SignedData);
returnRSAalg.VerifyData(dataToVerifyBytes, new SHA1CryptoServiceProvider(),signedDataBytes);
}
}
/// <summary>
/// 获取Key
/// 键为公钥，值为私钥
/// </summary>
/// <returns></returns>
public static KeyValuePair<string,string> CreateRSAKey()
{
RSACryptoServiceProvider RSA = newRSACryptoServiceProvider();
string privateKey =RSA.ToXmlString(true);
string publicKey =RSA.ToXmlString(false);
return new KeyValuePair<string,string>(publicKey, privateKey);
}
#endregion
#region other
/// <summary>
///
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public static byte[] GetBytes(stringinput)
{
string[] sInput =input.Split("-".ToCharArray());
byte[] inputBytes = newbyte[sInput.Length];
for (int i = ; i <sInput.Length; i++)
{
inputBytes[i] =byte.Parse(sInput[i], NumberStyles.HexNumber);
}
return inputBytes;
}
#endregion
}
}
NET实现RSA AES DES 字符串 加密解密以及SHA1 MD5加密的更多相关文章
- Asp.Net Core 2.0 项目实战（7）MD5加密、AES&DES对称加解密
本文目录 1. 摘要 2. MD5加密封装 3. AES的加密.解密 4. DES加密/解密 5. 总结 1. 摘要 C#中常用的一些加密和解密方案,如:md5加密.RSA加密与解密和DES加密等, ...
- 各种加密解密函数（URL加密解密、sha1加密解密、des加密解密）
原文:各种加密解密函数(URL加密解密.sha1加密解密.des加密解密) 普通hash函数如md5.sha1.base64等都是不可逆函数.虽然我们利用php可以利用这些函数写出可逆函数来.但是跨语 ...
- AES加密解密 助手类 CBC加密模式
"; string result1 = AESHelper.AesEncrypt(str); string result2 = AESHelper.AesDecrypt(result1); ...
- 16位的MD5加密和32位MD5加密的区别
16位的MD5加密和32位MD5加密的区别 MD5加密后所得到的通常是32位的编码,而在不少地方会用到16位的编码它们有什么区别呢?16位加密就是从32位MD5散列中把中间16位提取出来!其实破解16 ...
- 加密 解密 RSA & AES & DES
git: https://github.com/XHTeng/XHCryptorTools rsa RSA加解密中必须考虑到的密钥长度.明文长度和密文长度问题.明文长度需要小于密钥长度,而密文长度则等 ...
- Android DES加密的CBC模式加密解密和ECB模式加密解密
DES加密共有四种模式:电子密码本模式(ECB).加密分组链接模式(CBC).加密反馈模式(CFB)和输出反馈模式(OFB). CBC模式加密: import java.security.Key; i ...
- PHP中使用OpenSSL生成RSA公钥私钥及进行加密解密示例（非对称加密）
php服务端与客户端交互.提供开放api时,通常需要对敏感的部分api数据传输进行数据加密,这时候rsa非对称加密就能派上用处了,下面通过一个例子来说明如何用php来实现数据的加密解密 先了解一下关于 ...
- Java常用的加密解密类（对称加密类）
Java常用的加密解密类 原文转载至:http://blog.csdn.net/wyc_cs/article/details/8793198 原创 2013年04月12日 14:33:35 1704 ...
- 加密解密知识 php非对称加密
function test1(){ $config = array( "digest_alg" => "sha1", "private_key_ ...
随机推荐
- MQ选型对比RabbitMQ RocketMQ ActiveMQ
原文:MQ选型对比RabbitMQ RocketMQ ActiveMQ 几种MQ产品说明: ZeroMQ : 扩展性好,开发比较灵活,采用C语言实现,实际上他只是一个socket库的重新封装 ...
- [React] Use React ref to Get a Reference to Specific Components
When you are using React components you need to be able to access specific references to individual ...
- 20+ 个很有用的 jQuery 的 Google 地图插件 （英语）
20+ 个很有用的 jQuery 的 Google 地图插件 (英语) 一.总结 一句话总结:英语提上来我才能快速去google上面找资源啊.google上面的资源要比百度丰富很多,然后有了英语就可以 ...
- 浅谈 Redis 与 MySQL 的耦合性以及利用管道完成 MySQL 到 Redis 的高效迁移
http://blog.csdn.net/dba_waterbin/article/details/8996872 ㈠ Redis 与 MySQL 的耦合性 在业务架构早期.我们 ...
- 【a501】算24点
Time Limit: 1 second Memory Limit: 32 MB [问题描述] 几十年前全世界就浒一种数字游戏,至今仍有人乐此不疲.在中国我们把这种游戏称为"算24点&quo ...
- 【codeforces 765D】Artsem and Saunders
[题目链接]:http://codeforces.com/contest/765/problem/D [题意] 给你一个函数f(x); 要让你求2个函数g[x]和h[x],使得g[h[x]] = x对 ...
- iOS QLPreviewController(Quick Look)快速浏览jpg,PDF,world等
#import <QuickLook/QuickLook.h> @interface ViewController ()<QLPreviewControllerDataSource, ...
- spark rdd持久化的简单对比
未使用rdd持久化 使用后 通过对比可以发现,未使用RDD持久化时,第一次计算比使用RDD持久化要快,但之后的计算显然要慢的多,差不多10倍的样子 代码 public class PersistRDD ...
- nginx 和 tomcat 生产环境配置 建议和方法
参考 以下内容: http://blog.csdn.net/lifetragedy/article/details/7708724 一. nginx参数调优 worker_processes 3; ...
- Linux 网络编程——TCP
环境:Linux C 一.协议介绍 TCP是面向连接的协议,提供可靠的数据传输:TCP协议的可靠传输基于三次握手.四次挥手以及确认重传机制实现.下面来具体展示下TCP的三次握手.四次挥 ...