自己做了个RSA和AES加密的，JAVA，C#,C++可以做交互。算法用的是BouncyCastle的。感兴趣的可以去http://www.bouncycastle.org/
下面是源码，就是那个用证书验证的我没用，就没做，需要的可以自己看下，网上很多例子。
里面的注释应该比较明白了，有问题的可以在后面评论
using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Text;
using Org.BouncyCastle.Math;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.Utilities.Encoders;
using Org.BouncyCastle.Asn1;
using Org.BouncyCastle.Asn1.Pkcs;
using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Parameters;
using System.IO;
namespace Encryption_and_Decryption
{
public class AESRSAED
{
private AsymmetricKeyParameter publickey;
private AsymmetricKeyParameter privatekey;
/// <summary>
/// 创建公钥私钥对
/// </summary>
public void GetRsaKey()
{
IAsymmetricCipherKeyPairGenerator keyPairGen = GeneratorUtilities.GetKeyPairGenerator("RSA");
keyPairGen.Init(new RsaKeyGenerationParameters(
BigInteger.ValueOf(0x10001),
new SecureRandom(),
1024,
25));
AsymmetricCipherKeyPair kp = keyPairGen.GenerateKeyPair();
publickey = kp.Public;
privatekey = kp.Private;
}
/// <summary>
/// 公钥
/// </summary>
public AsymmetricKeyParameter s_publickey
{
get
{
return this.publickey;
}
}
/// <summary>
/// 私钥
/// </summary>
public AsymmetricKeyParameter s_private
{
get
{
return this.privatekey;
}
}
#region 公钥加密方法
/// <summary>
/// RSA公钥加密
/// </summary>
/// <param name="pubKey">RSA公钥</param>
/// <param name="data">需要加密的数据</param>
/// <returns>加密后的数据</returns>
byte[] RSAEncrypt(AsymmetricKeyParameter pubKey, string data)
{
byte[] inBytes = Encoding.GetEncoding("GB2312").GetBytes(data);
IBufferedCipher c = CipherUtilities.GetCipher("RSA");
c.Init(true, pubKey);
byte[] outBytes = c.DoFinal(inBytes, 0, inBytes.Length);
return outBytes;
}
/// <summary>
/// 使用本地公钥加密信息
/// </summary>
/// <param name="filename">公钥文件路径</param>
/// <param name="data">需要加密的数据</param>
/// <returns>加密后的数据</returns>
public static byte[] LocalRSAEncrypt(string PublicKeyfilename, string data)
{
AESRSAED ASD = new AESRSAED();
string pubMould = ASD.readPubM(PublicKeyfilename);
string pubEX = ASD.readPubEX(PublicKeyfilename);
RsaKeyParameters rsapubk = ASD.Certpubkey(pubMould, pubEX);
byte[] data1 = ASD.RSAEncrypt(rsapubk, data);
return data1;
}
/// <summary>
/// 使用本地公钥加密信息
/// </summary>
/// <param name="filename">公钥文件路径</param>
/// <param name="data">需要加密的数据</param>
/// <param name="dataLength">加密后数据的长度</param>
/// <returns>加密后的数据</returns>
public static byte[] LocalRSAEncrypt(string PublicKeyfilename, string data, out int dataLength)
{
AESRSAED ASD = new AESRSAED();
string pubMould = ASD.readPubM(PublicKeyfilename);
string pubEX = ASD.readPubEX(PublicKeyfilename);
RsaKeyParameters rsapubk = ASD.Certpubkey(pubMould, pubEX);
byte[] data1 = ASD.RSAEncrypt(rsapubk, data);
dataLength = data1.Length;
return data1;
}
/// <summary>
/// 使用本地公钥加密信息取得加密后信息的长度
/// </summary>
/// <param name="filename">公钥文件路径</param>
/// <param name="data">需要加密的数据</param>
/// <returns>加密后数据的长度</returns>
public static int LocalRSAEncryptLength(string PublicKeyfilename, string data)
{
AESRSAED ASD = new AESRSAED();
string pubMould = ASD.readPubM(PublicKeyfilename);
string pubEX = ASD.readPubEX(PublicKeyfilename);
RsaKeyParameters rsapubk = ASD.Certpubkey(pubMould, pubEX);
byte[] data1 = ASD.RSAEncrypt(rsapubk, data);
return data1.Length;
}
#endregion
#region 私钥解密函数
/// <summary>
/// RSA私钥解密
/// </summary>
/// <param name="priKey">RSA私钥</param>
/// <param name="data">需要解密的数据</param>
/// <returns>解密后的数据</returns>
byte[] RSADecrypt(AsymmetricKeyParameter priKey, byte[] data)
{
IBufferedCipher c = CipherUtilities.GetCipher("RSA");
c.Init(false, priKey);
byte[] outBytre = c.DoFinal(data);
return outBytre;
}
/// <summary>
/// 使用本地私钥解密数据
/// </summary>
/// <param name="PrivateKeyfilename">私钥路径</param>
/// <param name="data">需要解密的数据</param>
/// <returns>解密后的数据</returns>
public static byte[] LocalRSADecrypt(string PrivateKeyfilename, byte[] data)
{
AESRSAED ASD = new AESRSAED();
string PriM=ASD.readPriM(PrivateKeyfilename);
string PriEX=ASD.readPriEX(PrivateKeyfilename);
string PriPUEX = ASD.readPriPUEX(PrivateKeyfilename);
string PriP = ASD.readPriP(PrivateKeyfilename);
string PriDP = ASD.readPriDP(PrivateKeyfilename);
string PriQ = ASD.readPriQ(PrivateKeyfilename);
string PriDQ = ASD.readPriDQ(PrivateKeyfilename);
string PriQIV = ASD.readPriQIV(PrivateKeyfilename);
RsaPrivateCrtKeyParameters rsapkey= ASD.Certprikey(PriM, PriPUEX, PriEX, PriP, PriDP, PriQ, PriDQ, PriQIV);
byte[] ENdata=ASD.RSADecrypt(rsapkey, data);
return ENdata;
}
/// <summary>
/// 使用本地私钥解密数据
/// </summary>
/// <param name="PrivateKeyfilename">私钥路径</param>
/// <param name="data">需要解密的数据</param>
/// <param name="dataLength">解密后的数据长度</param>
/// <returns>解密后的数据</returns>
public static byte[] LocalRSADecrypt(string PrivateKeyfilename, byte[] data,out int dataLength)
{
AESRSAED ASD = new AESRSAED();
string PriM = ASD.readPriM(PrivateKeyfilename);
string PriEX = ASD.readPriEX(PrivateKeyfilename);
string PriPUEX = ASD.readPriPUEX(PrivateKeyfilename);
string PriP = ASD.readPriP(PrivateKeyfilename);
string PriDP = ASD.readPriDP(PrivateKeyfilename);
string PriQ = ASD.readPriQ(PrivateKeyfilename);
string PriDQ = ASD.readPriDQ(PrivateKeyfilename);
string PriQIV = ASD.readPriQIV(PrivateKeyfilename);
RsaPrivateCrtKeyParameters rsapkey = ASD.Certprikey(PriM, PriPUEX, PriEX, PriP, PriDP, PriQ, PriDQ, PriQIV);
byte[] ENdata = ASD.RSADecrypt(rsapkey, data);
dataLength = ENdata.Length;
return ENdata;
}
/// <summary>
/// 使用本地私钥解密数据得到数据长度
/// </summary>
/// <param name="PrivateKeyfilename">私钥路径</param>
/// <param name="data">需要解密的数据</param>
/// <returns>解密后的数据长度</returns>
public static int LocalRSADecryptLength(string PrivateKeyfilename, byte[] data)
{
AESRSAED ASD = new AESRSAED();
string PriM = ASD.readPriM(PrivateKeyfilename);
string PriEX = ASD.readPriEX(PrivateKeyfilename);
string PriPUEX = ASD.readPriPUEX(PrivateKeyfilename);
string PriP = ASD.readPriP(PrivateKeyfilename);
string PriDP = ASD.readPriDP(PrivateKeyfilename);
string PriQ = ASD.readPriQ(PrivateKeyfilename);
string PriDQ = ASD.readPriDQ(PrivateKeyfilename);
string PriQIV = ASD.readPriQIV(PrivateKeyfilename);
RsaPrivateCrtKeyParameters rsapkey = ASD.Certprikey(PriM, PriPUEX, PriEX, PriP, PriDP, PriQ, PriDQ, PriQIV);
byte[] ENdata = ASD.RSADecrypt(rsapkey, data);
return ENdata.Length;
}
#endregion
/// <summary>
/// 保存公钥信息
/// </summary>
/// <param name="filename">公钥文件路径</param>
/// <param name="modulus">公钥的M参数</param>
/// <param name="exponet">公钥的EX参数</param>
public static void SavePublicKey(string filename, byte[] modulus, byte[] exponet)
{
AESRSAED ASD = new AESRSAED();
RsaKeyParameters pubkey= ASD.JavaPublickey(modulus, exponet);
ASD.SavePub(pubkey, filename);
}
/// <summary>
/// 保存私钥信息
/// </summary>
/// <param name="filename">私钥文件路径</param>
/// <param name="privatekey">私钥参数</param>
public static void SavePrivateKey(string filename, AsymmetricKeyParameter privatekey)
{
AESRSAED ASD = new AESRSAED();
ASD.SavePri(privatekey, filename);
}
#region 公钥操作函数
/// <summary>
/// 接收JAVA公钥参数
/// </summary>
/// <param name="modulus">接收的公钥模数</param>
/// <param name="exponet">接收的EX</param>
/// <returns>公钥</returns>
public RsaKeyParameters JavaPublickey(byte[] modulus, byte[] exponet)
{
string Modulus = Encoding.GetEncoding("GB2312").GetString(modulus);
string Exponet = Encoding.GetEncoding("GB2312").GetString(exponet);
RsaKeyParameters rsaPublicKeyStructure1 = new RsaKeyParameters(false,
new BigInteger(Modulus),
new BigInteger(Exponet)
);
return rsaPublicKeyStructure1;
}
/// <summary>
/// 提取本地公钥的M
/// </summary>
/// <param name="parameters">公钥</param>
/// <returns>公钥M</returns>
string publickeyM(RsaKeyParameters parameters)
{
return parameters.Modulus.ToString();
}
/// <summary>
/// 提取本地公钥的EX
/// </summary>
/// <param name="parameters">公钥</param>
/// <returns>公钥EX</returns>
string publickeyEX(RsaKeyParameters parameters)
{
return parameters.Exponent.ToString();
}
/// <summary>
/// 将公钥信息保存到本地文件中
/// </summary>
/// <param name="publicKey">公钥信息</param>
/// <param name="filename">公钥文件的物理路径</param>
void SavePub(AsymmetricKeyParameter publicKey, string filename)
{
RsaKeyParameters publicKeyStructure = (RsaKeyParameters)publicKey;
string Modulus = publicKeyStructure.Modulus.ToString();
string exponet = publicKeyStructure.Exponent.ToString();
string pubkey = Modulus + "|" + exponet;
byte[] pub = Encoding.GetEncoding("GB2312").GetBytes(pubkey);
FileStream fs = new FileStream(filename, FileMode.Create);
fs.Write(pub, 0, pub.Length);
fs.Close();
}
/// <summary>
/// 读取公钥文件M信息
/// </summary>
/// <param name="filename">文件路径</param>
/// <returns>公钥M</returns>
string readPubM(string filename)
{
int bufferlen = 0x8000;
FileStream fs = new FileStream(filename, FileMode.Open);
byte[] buff = new byte[bufferlen];
int read = 0;
int block;
while ((block = fs.Read(buff, read, buff.Length - read)) > 0)
{
read = block + read;
if (read == buff.Length)
{
int nextbyte = fs.ReadByte();
if (nextbyte == -1)
{
string a = Encoding.GetEncoding("GB2312").GetString(buff);
string[] strInfo = a.Split('|');
fs.Close();
return strInfo[0];
}
byte[] newbuf = new byte[buff.Length * 2];
Array.Copy(buff, newbuf, buff.Length);
newbuf[read] = (byte)nextbyte;
buff = newbuf;
read++;
}
}
byte[] ret = new byte[read];
Array.Copy(buff, ret, read);
string b = Encoding.GetEncoding("GB2312").GetString(ret);
string[] strInfo1 = b.Split('|');
fs.Close();
return strInfo1[0];
}
/// <summary>
/// 读取公钥文件EX信息
/// </summary>
/// <param name="filename">文件路径</param>
/// <returns>公钥EX</returns>
string readPubEX(string filename)
{
int bufferlen = 0x8000;
FileStream fs = new FileStream(filename, FileMode.Open);
byte[] buff = new byte[bufferlen];
int read = 0;
int block;
while ((block = fs.Read(buff, read, buff.Length - read)) > 0)
{
read = block + read;
if (read == buff.Length)
{
int nextbyte = fs.ReadByte();
if (nextbyte == -1)
{
string a = Encoding.GetEncoding("GB2312").GetString(buff);
string[] strInfo = a.Split('|');
fs.Close();
return strInfo[1];
}
byte[] newbuf = new byte[buff.Length * 2];
Array.Copy(buff, newbuf, buff.Length);
newbuf[read] = (byte)nextbyte;
buff = newbuf;
read++;
}
}
byte[] ret = new byte[read];
Array.Copy(buff, ret, read);
string b = Encoding.GetEncoding("GB2312").GetString(ret);
string[] strInfo1 = b.Split('|');
fs.Close();
return strInfo1[1];
}
/// <summary>
/// 根据公钥参数创建公钥
/// </summary>
/// <param name="Modulus">公钥模数</param>
/// <param name="Ex">公钥EX</param>
/// <returns>公钥</returns>
RsaKeyParameters Certpubkey(string Modulus, string Ex)
{
RsaKeyParameters rsaKeyParameters = new RsaKeyParameters(false,
new BigInteger(Modulus),
new BigInteger(Ex)
);
return rsaKeyParameters;
}
#endregion
#region 私钥操作函数
/// <summary>
/// 使用参数创建私钥
/// </summary>
/// <param name="Modulus">私钥的模数</param>
/// <param name="pubExponent">私钥中的公钥EX</param>
/// <param name="PriExponent">私钥中的私钥EX</param>
/// <param name="P">私钥的P</param>
/// <param name="DP">私钥的DP</param>
/// <param name="Q">私钥的Q</param>
/// <param name="DQ">私钥的DQ</param>
/// <param name="QInv">私钥的QINV</param>
/// <returns>私钥</returns>
RsaPrivateCrtKeyParameters Certprikey(string Modulus, string pubExponent, string PriExponent, string P, string DP, string Q, string DQ, string QInv)
{
RsaPrivateCrtKeyParameters rsaPrivateKeyStructure = new RsaPrivateCrtKeyParameters(
new BigInteger(Modulus),
new BigInteger(pubExponent),
new BigInteger(PriExponent),
new BigInteger(P),
new BigInteger(Q),
new BigInteger(DP),
new BigInteger(DQ),
new BigInteger(QInv)
);
return rsaPrivateKeyStructure;
}
/// <summary>
/// 将私钥信息保存到文件中
/// </summary>
/// <param name="parameter">私钥</param>
/// <param name="filename">文件路径</param>
void SavePri(AsymmetricKeyParameter parameter,string filename)
{
RsaPrivateCrtKeyParameters pri = (RsaPrivateCrtKeyParameters)parameter;
string modulus = pri.Modulus.ToString();
string PubExponent =pri.PublicExponent.ToString();
string priExponent = pri.Exponent.ToString();
string p = pri.P.ToString();
string dp = pri.DP.ToString();
string q = pri.Q.ToString();
string dq =pri.DQ.ToString();
string qiv = pri.QInv.ToString();
string prikey = modulus + "|" + PubExponent + "|" + priExponent + "|" + p + "|" + dp + "|" + q + "|" + dq +
"|" + qiv;
byte[] prik = Encoding.GetEncoding("GB2312").GetBytes(prikey);
FileStream fs = new FileStream(filename, FileMode.Create);
fs.Write(prik, 0, prik.Length);
fs.Close();
}
/// <summary>
/// 读取私钥信息M
/// </summary>
/// <param name="filename">私钥文件路径</param>
/// <returns>私钥M</returns>
string readPriM(string filename)
{
int bufferlen = 0x8000;
FileStream fs = new FileStream(filename, FileMode.Open);
byte[] buff = new byte[bufferlen];
int read = 0;
int block;
while ((block = fs.Read(buff, read, buff.Length - read)) > 0)
{
read = block + read;
if (read == buff.Length)
{
int nextbyte = fs.ReadByte();
if (nextbyte == -1)
{
string prikey = Encoding.GetEncoding("GB2312").GetString(buff);
string []priinfo =prikey.Split('|');
fs.Close();
return priinfo[0];
}
byte[] newbuf = new byte[buff.Length * 2];
Array.Copy(buff, newbuf, buff.Length);
newbuf[read] = (byte)nextbyte;
buff = newbuf;
read++;
}
}
byte[] ret = new byte[read];
Array.Copy(buff, ret, read);
string prikey1 = Encoding.GetEncoding("GB2312").GetString(ret);
string[] priinfo1 = prikey1.Split('|');
fs.Close();
return priinfo1[0];
}
/// <summary>
/// 读取私钥信息公钥EX
/// </summary>
/// <param name="filename">私钥文件路径</param>
/// <returns>私钥的公钥EX</returns>
string readPriPUEX(string filename)
{
int bufferlen = 0x8000;
FileStream fs = new FileStream(filename, FileMode.Open);
byte[] buff = new byte[bufferlen];
int read = 0;
int block;
while ((block = fs.Read(buff, read, buff.Length - read)) > 0)
{
read = block + read;
if (read == buff.Length)
{
int nextbyte = fs.ReadByte();
if (nextbyte == -1)
{
string prikey = Encoding.GetEncoding("GB2312").GetString(buff);
string[] priinfo = prikey.Split('|');
fs.Close();
return priinfo[1];
}
byte[] newbuf = new byte[buff.Length * 2];
Array.Copy(buff, newbuf, buff.Length);
newbuf[read] = (byte)nextbyte;
buff = newbuf;
read++;
}
}
byte[] ret = new byte[read];
Array.Copy(buff, ret, read);
string prikey1 = Encoding.GetEncoding("GB2312").GetString(ret);
string[] priinfo1 = prikey1.Split('|');
fs.Close();
return priinfo1[1];
}
/// <summary>
/// 读取私钥的私钥EX
/// </summary>
/// <param name="filename">私钥文件路径</param>
/// <returns>私钥的私钥EX</returns>
string readPriEX(string filename)
{
int bufferlen = 0x8000;
FileStream fs = new FileStream(filename, FileMode.Open);
byte[] buff = new byte[bufferlen];
int read = 0;
int block;
while ((block = fs.Read(buff, read, buff.Length - read)) > 0)
{
read = block + read;
if (read == buff.Length)
{
int nextbyte = fs.ReadByte();
if (nextbyte == -1)
{
string prikey = Encoding.GetEncoding("GB2312").GetString(buff);
string[] priinfo = prikey.Split('|');
fs.Close();
return priinfo[2];
}
byte[] newbuf = new byte[buff.Length * 2];
Array.Copy(buff, newbuf, buff.Length);
newbuf[read] = (byte)nextbyte;
buff = newbuf;
read++;
}
}
byte[] ret = new byte[read];
Array.Copy(buff, ret, read);
string prikey1 = Encoding.GetEncoding("GB2312").GetString(ret);
string[] priinfo1 = prikey1.Split('|');
fs.Close();
return priinfo1[2];
}
/// <summary>
/// 读取私钥信息P
/// </summary>
/// <param name="filename">私钥文件路径</param>
/// <returns>私钥P</returns>
string readPriP(string filename)
{
int bufferlen = 0x8000;
FileStream fs = new FileStream(filename, FileMode.Open);
byte[] buff = new byte[bufferlen];
int read = 0;
int block;
while ((block = fs.Read(buff, read, buff.Length - read)) > 0)
{
read = block + read;
if (read == buff.Length)
{
int nextbyte = fs.ReadByte();
if (nextbyte == -1)
{
string prikey = Encoding.GetEncoding("GB2312").GetString(buff);
string[] priinfo = prikey.Split('|');
fs.Close();
return priinfo[3];
}
byte[] newbuf = new byte[buff.Length * 2];
Array.Copy(buff, newbuf, buff.Length);
newbuf[read] = (byte)nextbyte;
buff = newbuf;
read++;
}
}
byte[] ret = new byte[read];
Array.Copy(buff, ret, read);
string prikey1 = Encoding.GetEncoding("GB2312").GetString(ret);
string[] priinfo1 = prikey1.Split('|');
fs.Close();
return priinfo1[3];
}
/// <summary>
/// 读取私钥信息DP
/// </summary>
/// <param name="filename">私钥文件路径</param>
/// <returns>私钥DP</returns>
string readPriDP(string filename)
{
int bufferlen = 0x8000;
FileStream fs = new FileStream(filename, FileMode.Open);
byte[] buff = new byte[bufferlen];
int read = 0;
int block;
while ((block = fs.Read(buff, read, buff.Length - read)) > 0)
{
read = block + read;
if (read == buff.Length)
{
int nextbyte = fs.ReadByte();
if (nextbyte == -1)
{
string prikey = Encoding.GetEncoding("GB2312").GetString(buff);
string[] priinfo = prikey.Split('|');
fs.Close();
return priinfo[4];
}
byte[] newbuf = new byte[buff.Length * 2];
Array.Copy(buff, newbuf, buff.Length);
newbuf[read] = (byte)nextbyte;
buff = newbuf;
read++;
}
}
byte[] ret = new byte[read];
Array.Copy(buff, ret, read);
string prikey1 = Encoding.GetEncoding("GB2312").GetString(ret);
string[] priinfo1 = prikey1.Split('|');
fs.Close();
return priinfo1[4];
}
/// <summary>
/// 读取私钥信息Q
/// </summary>
/// <param name="filename">私钥文件路径</param>
/// <returns>私钥Q</returns>
string readPriQ(string filename)
{
int bufferlen = 0x8000;
FileStream fs = new FileStream(filename, FileMode.Open);
byte[] buff = new byte[bufferlen];
int read = 0;
int block;
while ((block = fs.Read(buff, read, buff.Length - read)) > 0)
{
read = block + read;
if (read == buff.Length)
{
int nextbyte = fs.ReadByte();
if (nextbyte == -1)
{
string prikey = Encoding.GetEncoding("GB2312").GetString(buff);
string[] priinfo = prikey.Split('|');
fs.Close();
return priinfo[5];
}
byte[] newbuf = new byte[buff.Length * 2];
Array.Copy(buff, newbuf, buff.Length);
newbuf[read] = (byte)nextbyte;
buff = newbuf;
read++;
}
}
byte[] ret = new byte[read];
Array.Copy(buff, ret, read);
string prikey1 = Encoding.GetEncoding("GB2312").GetString(ret);
string[] priinfo1 = prikey1.Split('|');
fs.Close();
return priinfo1[5];
}
/// <summary>
/// 读取私钥信息DQ
/// </summary>
/// <param name="filename">私钥文件路径</param>
/// <returns>私钥DQ</returns>
string readPriDQ(string filename)
{
int bufferlen = 0x8000;
FileStream fs = new FileStream(filename, FileMode.Open);
byte[] buff = new byte[bufferlen];
int read = 0;
int block;
while ((block = fs.Read(buff, read, buff.Length - read)) > 0)
{
read = block + read;
if (read == buff.Length)
{
int nextbyte = fs.ReadByte();
if (nextbyte == -1)
{
string prikey = Encoding.GetEncoding("GB2312").GetString(buff);
string[] priinfo = prikey.Split('|');
fs.Close();
return priinfo[6];
}
byte[] newbuf = new byte[buff.Length * 2];
Array.Copy(buff, newbuf, buff.Length);
newbuf[read] = (byte)nextbyte;
buff = newbuf;
read++;
}
}
byte[] ret = new byte[read];
Array.Copy(buff, ret, read);
string prikey1 = Encoding.GetEncoding("GB2312").GetString(ret);
string[] priinfo1 = prikey1.Split('|');
fs.Close();
return priinfo1[6];
}
/// <summary>
/// 读取私钥信息QIVN
/// </summary>
/// <param name="filename">私钥文件路径</param>
/// <returns>私钥QIVN</returns>
string readPriQIV(string filename)
{
int bufferlen = 0x8000;
FileStream fs = new FileStream(filename, FileMode.Open);
byte[] buff = new byte[bufferlen];
int read = 0;
int block;
while ((block = fs.Read(buff, read, buff.Length - read)) > 0)
{
read = block + read;
if (read == buff.Length)
{
int nextbyte = fs.ReadByte();
if (nextbyte == -1)
{
string prikey = Encoding.GetEncoding("GB2312").GetString(buff);
string[] priinfo = prikey.Split('|');
fs.Close();
return priinfo[7];
}
byte[] newbuf = new byte[buff.Length * 2];
Array.Copy(buff, newbuf, buff.Length);
newbuf[read] = (byte)nextbyte;
buff = newbuf;
read++;
}
}
byte[] ret = new byte[read];
Array.Copy(buff, ret, read);
string prikey1 = Encoding.GetEncoding("GB2312").GetString(ret);
string[] priinfo1 = prikey1.Split('|');
fs.Close();
return priinfo1[7];
}
#endregion
/// <summary>
/// 创建对称密钥
/// </summary>
/// <returns>对称密钥</returns>
public string CreatKey()
{
string str = "1234567890abcdefghijklmnopqrstuvwxyz";
Random R = new Random();
int maxIndex = str.Length - 1;
string recal = "";
for (int i = 0; i < 16; i++)
{
int currentIndex = R.Next(maxIndex);
string charStr = str[currentIndex].ToString();
recal = recal + charStr;
}
return recal;
}
#region AES加密函数
/// <summary>
/// AES加密
/// </summary>
/// <param name="Data">需要加密的数据</param>
/// <param name="Key">AES密钥</param>
/// <returns>秘文</returns>
public byte[] AESEncrypt(byte[] Data, String Key)
{
byte[] bKey = Encoding.GetEncoding("GB2312").GetBytes(Key);
Rijndael Aes = Rijndael.Create();
Aes.Key = bKey;
Aes.Mode = CipherMode.ECB;
Aes.Padding = PaddingMode.PKCS7;
byte[] Cryptograph = null; // 加密后的密文
ICryptoTransform i = Aes.CreateEncryptor();
Cryptograph = i.TransformFinalBlock(Data, 0, Data.Length);
return Cryptograph;
}
/// <summary>
/// AES加密
/// </summary>
/// <param name="Data">需要加密的数据</param>
/// <param name="Key">AES密钥</param>
/// <param name="DataLength">加密后的秘文长度</param>
/// <returns>秘文</returns>
public byte[] AESEncrypt(byte[] Data, String Key, out int DataLength)
{
byte[] bKey = Encoding.GetEncoding("GB2312").GetBytes(Key);
Rijndael Aes = Rijndael.Create();
Aes.Key = bKey;
Aes.Mode = CipherMode.ECB;
Aes.Padding = PaddingMode.PKCS7;
byte[] Cryptograph = null; // 加密后的密文
ICryptoTransform i = Aes.CreateEncryptor();
Cryptograph = i.TransformFinalBlock(Data, 0, Data.Length);
DataLength = Cryptograph.Length;
return Cryptograph;
}
/// <summary>
/// 返回数据加密后的长度信息
/// </summary>
/// <param name="Data">需要加密的数据</param>
/// <param name="Key">AES密钥</param>
/// <returns>加密后数据的长度</returns>
public int AESEncryptLength(byte[] Data, String Key)
{
byte[] bKey = Encoding.GetEncoding("GB2312").GetBytes(Key);
Rijndael Aes = Rijndael.Create();
Aes.Key = bKey;
Aes.Mode = CipherMode.ECB;
Aes.Padding = PaddingMode.PKCS7;
byte[] Cryptograph = null; // 加密后的密文
ICryptoTransform i = Aes.CreateEncryptor();
Cryptograph = i.TransformFinalBlock(Data, 0, Data.Length);
return Cryptograph.Length;
}
#endregion
#region AES解密
/// <summary>
/// AES解密
/// </summary>
/// <param name="Data">需要解密的数据</param>
/// <param name="Key">AES密钥</param>
/// <returns>解密后的明文</returns>
public byte[] AESDecrypt(byte[] Data, String Key)
{
byte[] bKey = Encoding.GetEncoding("GB2312").GetBytes(Key);
Rijndael Aes = Rijndael.Create();
Aes.Key = bKey;
Aes.Mode = CipherMode.ECB;
Aes.Padding = PaddingMode.PKCS7;
byte[] original = null; // 解密后的明文
ICryptoTransform i = Aes.CreateDecryptor();
original = i.TransformFinalBlock(Data, 0, Data.Length);
return original;
}
/// <summary>
/// AES解密
/// </summary>
/// <param name="Data">需要解密的数据</param>
/// <param name="Key">AES密钥</param>
/// <param name="DataLength">解密后的秘文长度</param>
/// <returns>解密后的明文</returns>
public byte[] AESDecrypt(byte[] Data, String Key, out int DataLength)
{
byte[] bKey = Encoding.GetEncoding("GB2312").GetBytes(Key);
Rijndael Aes = Rijndael.Create();
Aes.Key = bKey;
Aes.Mode = CipherMode.ECB;
Aes.Padding = PaddingMode.PKCS7;
byte[] original = null; // 解密后的明文
ICryptoTransform i = Aes.CreateDecryptor();
original = i.TransformFinalBlock(Data, 0, Data.Length);
DataLength = original.Length;
return original;
}
/// <summary>
/// 返回数据解密后的长度信息
/// </summary>
/// <param name="Data">需要解密的数据</param>
/// <param name="Key">AES密钥</param>
/// <returns>解密后数据的长度</returns>
public int AESDecryptLength(byte[] Data, String Key)
{
byte[] bKey = Encoding.GetEncoding("GB2312").GetBytes(Key);
Rijndael Aes = Rijndael.Create();
Aes.Key = bKey;
Aes.Mode = CipherMode.ECB;
Aes.Padding = PaddingMode.PKCS7;
byte[] original = null; // 解密后的明文
ICryptoTransform i = Aes.CreateDecryptor();
original = i.TransformFinalBlock(Data, 0, Data.Length);
return original.Length;
}
#endregion
}
}
扫一扫
598
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
