} //compute hash from arguments and return hash value as string
private static string GetRC2Hash(string text)
{
//create variables for computing hash and making it a string
UnicodeEncoding UniCode = new UnicodeEncoding();
byte[] HashResult;
byte[] msg = UniCode.GetBytes(text);
RC2 hashString = new RC2CryptoServiceProvider();
//generate a weak KEY and Initialization Vector for the hash algorithm
hashString.GenerateKey();
hashString.GenerateIV();
ICryptoTransform encryptor = hashString.CreateEncryptor(hashString.Key, hashString.IV);
string Str = "";
//compute hash with RC2 module and format output as string
//convert bytes in HashResult to string values
HashResult = encryptor.TransformFinalBlock(msg, 0, msg.Length);
foreach (byte x in HashResult)
{
Str += String.Format("{0:x2}", x);
}
//clear excess resource usage
hashString.Clear();
return(Str);
} //compute hash from arguments and return hash value as string
/// <summary>
/// Generate new encryption key
/// </summary>
/// <param name="algId"></param>
/// <returns></returns>
public string GenerateKey(EncryptionAlgorithm algId)
{
byte[] NewKey = null;
// Pick the provider.
switch (algId)
{
case EncryptionAlgorithm.Des:
{
DES des = new DESCryptoServiceProvider();
des.Mode = CipherMode.CBC;
des.GenerateKey();
NewKey = des.Key;
des = null;
break;
}
case EncryptionAlgorithm.TripleDes:
{
TripleDES des3 = new TripleDESCryptoServiceProvider();
des3.Mode = CipherMode.CBC;
des3.GenerateKey();
NewKey = des3.Key;
des3 = null;
break;
}
case EncryptionAlgorithm.Rc2:
{
RC2 rc2 = new RC2CryptoServiceProvider();
rc2.Mode = CipherMode.CBC;
rc2.GenerateKey();
NewKey = rc2.Key;
rc2 = null;
break;
}
case EncryptionAlgorithm.Rijndael:
{
Rijndael rijndael = new RijndaelManaged();
rijndael.Mode = CipherMode.CBC;
rijndael.Padding = PaddingMode.PKCS7;
rijndael.KeySize = 256;
rijndael.BlockSize = 256;
rijndael.GenerateKey();
NewKey = rijndael.Key;
rijndael = null;
break;
}
default:
{
throw new CryptographicException("Algorithm ID '" + algId +
"' not supported.");
}
}
return(Encoding.ASCII.GetString(NewKey));
}
/// <summary>
/// RC2算法构造函数（KEY和IV随机生成）
/// </summary>
public RC2()
{
rc2 = new RC2CryptoServiceProvider();
rc2.GenerateKey();
rc2.GenerateIV();
Key = Convert.ToBase64String(rc2.Key);
IV = Convert.ToBase64String(rc2.IV);
}
public void GenerateKey(EncoderType type)
{
switch (type)
{
case EncoderType.AES:
using (AesCryptoServiceProvider csp = new AesCryptoServiceProvider())
{
csp.GenerateIV();
IV = Convert.ToBase64String(csp.IV);
csp.GenerateKey();
Key = Convert.ToBase64String(csp.Key);
}
break;
case EncoderType.DES:
using (DESCryptoServiceProvider csp = new DESCryptoServiceProvider())
{
csp.GenerateIV();
IV = Convert.ToBase64String(csp.IV);
csp.GenerateKey();
Key = Convert.ToBase64String(csp.Key);
}
break;
case EncoderType.RC2:
using (RC2CryptoServiceProvider csp = new RC2CryptoServiceProvider())
{
csp.GenerateIV();
IV = Convert.ToBase64String(csp.IV);
csp.GenerateKey();
Key = Convert.ToBase64String(csp.Key);
}
break;
case EncoderType.TripleDES:
using (TripleDESCryptoServiceProvider csp = new TripleDESCryptoServiceProvider())
{
csp.GenerateIV();
IV = Convert.ToBase64String(csp.IV);
csp.GenerateKey();
Key = Convert.ToBase64String(csp.Key);
}
break;
case EncoderType.RSA:
using (RSACryptoServiceProvider csp = new RSACryptoServiceProvider())
{
IV = "";
Key = csp.ToXmlString(true);
}
break;
default:
break;
}
}
public RC2(string rc2Text)
{
orgText = Encoding.Default.GetBytes(rc2Text);
RC2CryptoServiceProvider myRC2 = new RC2CryptoServiceProvider();
myRC2.GenerateIV();
myRC2.GenerateKey();
Key = myRC2.Key;
IV = myRC2.IV;
}
public CipherMessage EncryptMessage(string text)
{
// Convert string to a byte array
CipherMessage message = new CipherMessage();
byte[] plainBytes = Encoding.Unicode.GetBytes(text.ToCharArray());
// A new key and iv are generated for every message
rc2.GenerateKey();
rc2.GenerateIV();
// The rc2 initialization doesnt need to be encrypted, but will
// be used in conjunction with the key to decrypt the message.
message.rc2IV = rc2.IV;
try
{
// Encrypt the RC2 key using RSA encryption
message.rc2Key = rsa.Encrypt(rc2.Key, false);
}
catch (CryptographicException e)
{
// The High Encryption Pack is required to run this sample
// because we are using a 128-bit key. See the readme for
// additional information.
Console.WriteLine("Encryption Failed. Ensure that the" +
" High Encryption Pack is installed.");
Console.WriteLine("Error Message: " + e.Message);
Environment.Exit(0);
}
// Encrypt the Text Message using RC2 (Symmetric algorithm)
ICryptoTransform sse = rc2.CreateEncryptor();
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, sse, CryptoStreamMode.Write);
try
{
cs.Write(plainBytes, 0, plainBytes.Length);
cs.FlushFinalBlock();
message.cipherBytes = ms.ToArray();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
finally
{
ms.Close();
cs.Close();
}
return(message);
} // method EncryptMessage
/// <summary>
/// RC2 数据加密
/// </summary>
/// <param name="Values">加密后的字符串</param>
/// <returns>加密后的字符串</returns>
public string RC2Encrypt(string Values)
{
try
{
RC2CryptoServiceProvider rc2CSP = new RC2CryptoServiceProvider();
rc2CSP.Mode = CipherMode.CBC;
byte[] byt;
//Key 和 IV 为 16或24字节
if (null == this._Key)
{
rc2CSP.GenerateKey();
_Key = Encoding.ASCII.GetString(rc2CSP.Key);
}
else
{
if (_Key.Length != 16)
{
throw new Exception("加密数据出错,详细原因：Key的长度不为 16 byte.");
}
}
if (null == this._IV)
{
rc2CSP.GenerateIV();
_IV = Encoding.ASCII.GetString(rc2CSP.IV);
}
else
{
if (_IV.Length != 8)
{
throw new Exception("加密数据出错,详细原因：IV的长度不为 8 byte.");
}
}
//return _Key + "：" + Encoding.ASCII.GetBytes(_Key).Length.ToString() + "<br>"+ _IV + "：" + Encoding.ASCII.GetBytes(this._IV).Length.ToString();
byt = Encoding.UTF8.GetBytes(Values);
ICryptoTransform ct = rc2CSP.CreateEncryptor(Encoding.ASCII.GetBytes(this._Key), Encoding.ASCII.GetBytes(this._IV));
rc2CSP.Clear();
System.IO.MemoryStream ms = new System.IO.MemoryStream();
CryptoStream cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);
cs.Write(byt, 0, byt.Length);
cs.FlushFinalBlock();
cs.Close();
return(Convert.ToBase64String(ms.ToArray()));
}
catch (Exception e)
{
throw new Exception("加密数据出错,详细原因：" + e.Message);
}
}
public void _40(Int32 numberIterations)
{
RC2CryptoServiceProvider rm = new RC2CryptoServiceProvider();
rm.KeySize = 128;
rm.GenerateIV();
rm.GenerateKey();
ICryptoTransform enc = rm.CreateEncryptor();
ICryptoTransform dec = rm.CreateDecryptor();
for (int i = 0; i < numberIterations; ++i)
{
byte[] enrytped = enc.TransformFinalBlock(_testData, 0, 10);
dec.TransformFinalBlock(enrytped, 0, enrytped.Length);
}
}
/// <summary>
/// 获得密钥
/// </summary>
/// <returns>密钥</returns>
private byte[] GetLegalKey()
{
string sTemp = Key;
rc2.GenerateKey();
byte[] bytTemp = rc2.Key;
int KeyLength = bytTemp.Length;
if (sTemp.Length > KeyLength)
{
sTemp = sTemp.Substring(0, KeyLength);
}
else if (sTemp.Length < KeyLength)
{
sTemp = sTemp.PadRight(KeyLength, ' ');
}
return(ASCIIEncoding.ASCII.GetBytes(sTemp));
}
public static void Main()
{
byte[] originalBytes = ASCIIEncoding.ASCII.GetBytes("Here is some data.");
//Create a new RC2CryptoServiceProvider.
RC2CryptoServiceProvider rc2CSP = new RC2CryptoServiceProvider();
rc2CSP.UseSalt = true;
rc2CSP.GenerateKey();
rc2CSP.GenerateIV();
//Encrypt the data.
MemoryStream msEncrypt = new MemoryStream();
CryptoStream csEncrypt = new CryptoStream(msEncrypt, rc2CSP.CreateEncryptor(rc2CSP.Key, rc2CSP.IV), CryptoStreamMode.Write);
//Write all data to the crypto stream and flush it.
csEncrypt.Write(originalBytes, 0, originalBytes.Length);
csEncrypt.FlushFinalBlock();
//Get encrypted array of bytes.
byte[] encryptedBytes = msEncrypt.ToArray();
//Decrypt the previously encrypted message.
MemoryStream msDecrypt = new MemoryStream(encryptedBytes);
CryptoStream csDecrypt = new CryptoStream(msDecrypt, rc2CSP.CreateDecryptor(rc2CSP.Key, rc2CSP.IV), CryptoStreamMode.Read);
byte[] unencryptedBytes = new byte[originalBytes.Length];
//Read the data out of the crypto stream.
csDecrypt.Read(unencryptedBytes, 0, unencryptedBytes.Length);
//Convert the byte array back into a string.
string plaintext = ASCIIEncoding.ASCII.GetString(unencryptedBytes);
//Display the results.
Console.WriteLine("Unencrypted text: {0}", plaintext);
Console.ReadLine();
}
internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey)
{
// Pick the provider.
switch (algorithmID)
{
case EncryptionAlgorithm.Des:
{
DES des = new DESCryptoServiceProvider();
des.Mode = CipherMode.CBC;
// See if a key was provided
if (null == bytesKey)
{
des.GenerateKey();
encKey = des.Key;
}
else
{
des.Key = bytesKey;
encKey = des.Key;
}
// See if the client provided an initialization vector
if (null == initVec)
{ // Have the algorithm create one
des.GenerateIV();
initVec = des.IV;
}
else
{ //No, give it to the algorithm
des.IV = initVec;
}
return(des.CreateEncryptor());
}
case EncryptionAlgorithm.TripleDes:
{
TripleDES des3 = new TripleDESCryptoServiceProvider();
des3.Mode = CipherMode.CBC;
// See if a key was provided
if (null == bytesKey)
{
des3.GenerateKey();
encKey = des3.Key;
}
else
{
des3.Key = bytesKey;
encKey = des3.Key;
}
// See if the client provided an IV
if (null == initVec)
{ //Yes, have the alg create one
des3.GenerateIV();
initVec = des3.IV;
}
else
{ //No, give it to the alg.
des3.IV = initVec;
}
return(des3.CreateEncryptor());
}
case EncryptionAlgorithm.Rc2:
{
RC2 rc2 = new RC2CryptoServiceProvider();
rc2.Mode = CipherMode.CBC;
// Test to see if a key was provided
if (null == bytesKey)
{
rc2.GenerateKey();
encKey = rc2.Key;
}
else
{
rc2.Key = bytesKey;
encKey = rc2.Key;
}
// See if the client provided an IV
if (null == initVec)
{ //Yes, have the alg create one
rc2.GenerateIV();
initVec = rc2.IV;
}
else
{ //No, give it to the alg.
rc2.IV = initVec;
}
return(rc2.CreateEncryptor());
}
case EncryptionAlgorithm.Rijndael:
{
Rijndael rijndael = new RijndaelManaged();
rijndael.Mode = CipherMode.CBC;
rijndael.Padding = PaddingMode.PKCS7;
// Set the key and block size.
// Although the key size defaults to 256, it's better to be explicit.
rijndael.KeySize = 256;
// BlockSize defaults to 128 bits, so let's set this
// to 256 for better security
rijndael.BlockSize = 256;
// Test to see if a key was provided
if (null == bytesKey)
{
// GenerateKey method utilizes the RNGCryptoServiceProvider
// class to generate random bytes of necessary length.
rijndael.GenerateKey();
encKey = rijndael.Key;
}
else
{
rijndael.Key = bytesKey;
encKey = rijndael.Key;
}
// See if the client provided an IV
if (null == initVec)
{ //Yes, have the alg create one
rijndael.GenerateIV();
initVec = rijndael.IV;
}
else
{ //No, give it to the alg.
rijndael.IV = initVec;
}
return(rijndael.CreateEncryptor());
}
default:
{
throw new CryptographicException("Algorithm ID '" + algorithmID +
"' not supported.");
}
}
}
public void EncryptFile(string fileInput,
string fileOutput,
EncryptingFileInfo fileInfo,
string publicKey
)
{
SymmetricAlgorithm symmetricAlgorithm = null;
switch (fileInfo.Algorithm)
{
case Algorithm.AES:
symmetricAlgorithm = new AesCryptoServiceProvider();
symmetricAlgorithm.KeySize = 256;
symmetricAlgorithm.BlockSize = 128;
break;
case Algorithm.DES:
symmetricAlgorithm = new DESCryptoServiceProvider();
symmetricAlgorithm.KeySize = 64;
break;
case Algorithm.TripleDES:
symmetricAlgorithm = new TripleDESCryptoServiceProvider();
symmetricAlgorithm.KeySize = 192;
break;
case Algorithm.Rijndael:
symmetricAlgorithm = new RijndaelManaged();
symmetricAlgorithm.KeySize = 256;
symmetricAlgorithm.BlockSize = 256;
break;
case Algorithm.RC2:
symmetricAlgorithm = new RC2CryptoServiceProvider();
symmetricAlgorithm.KeySize = 128;
break;
}
var rsa = new RSACryptoServiceProvider();
rsa.FromXmlString(publicKey);
symmetricAlgorithm.Padding = (PaddingMode)fileInfo.PaddingMode;
symmetricAlgorithm.Mode = (CipherMode)fileInfo.CipherMode;
symmetricAlgorithm.GenerateKey();
symmetricAlgorithm.GenerateIV();
var encryptedKey = rsa.Encrypt(symmetricAlgorithm.Key, false);
fileInfo.Key = encryptedKey;
fileInfo.IV = symmetricAlgorithm.IV;
//var ivLength = new byte[4];
var fileInfoLen = new byte[4];
byte[] fileInfoBytes;
using (var memoryStream = new MemoryStream())
{
new BinaryFormatter().Serialize(memoryStream, fileInfo);
fileInfoBytes = memoryStream.ToArray();
}
fileInfoLen = BitConverter.GetBytes(fileInfoBytes.Length);
try
{
using (var outFs = new FileStream(fileOutput, FileMode.Create))
{
var encryptor = symmetricAlgorithm.CreateEncryptor(symmetricAlgorithm.Key, symmetricAlgorithm.IV);
outFs.Write(fileInfoLen, 0, 4);
outFs.Write(fileInfoBytes, 0, fileInfoBytes.Length);
using (var outCs = new CryptoStream(outFs, encryptor, CryptoStreamMode.Write))
{
int count = 0;
int offset = 0;
int blockSizeBytes = symmetricAlgorithm.BlockSize / 8;
byte[] data = new byte[blockSizeBytes];
int bytesRead = 0;
using (var inFs = new FileStream(fileInput, FileMode.Open))
{
do
{
count = inFs.Read(data, 0, blockSizeBytes);
offset += count;
outCs.Write(data, 0, count);
bytesRead += blockSizeBytes;
}while (count > 0);
inFs.Close();
}
outCs.FlushFinalBlock();
outCs.Close();
}
outFs.Close();
}
//if (fileInfo.IsCompressed)
//{
// var zipDirPath = Path.ChangeExtension(fileOutput, null);
// var zipFilePath = Path.ChangeExtension(zipDirPath, "zip");
// var encryptedFilePath = Path.Combine(zipDirPath, Path.GetFileName(fileOutput));
// Directory.CreateDirectory(zipDirPath);
// File.Move(fileOutput, encryptedFilePath);
// ZipFile.CreateFromDirectory(zipDirPath, zipFilePath);
// Directory.Delete(zipDirPath, true);
//}
}
catch (Exception ex)
{
throw ex;
}
}
