public static bool Test()
{
Random rnd = new Random();
// create a random array of random bytes
int len = rnd.Next(1000000);
byte[] plain = new byte[len];
rnd.NextBytes(plain);
Console.Write("Working with " + len + " bytes of plaintext...");
// encrypt with salt
RC2CryptoServiceProvider rc2s = new RC2CryptoServiceProvider();
rc2s.UseSalt = true;
rc2s.Key = new byte[]{1,2,3,4,5};
byte[] encrypted = (rc2s.CreateEncryptor()).TransformFinalBlock(plain, 0, plain.Length);
// decrypt with salt
RC2CryptoServiceProvider rc2sd = new RC2CryptoServiceProvider();
rc2sd.UseSalt = true;
rc2sd.Key = rc2s.Key;
rc2sd.IV = rc2s.IV;
byte[] decrypted = (rc2sd.CreateDecryptor()).TransformFinalBlock(encrypted, 0, encrypted.Length);
if (CompareSlow(plain, decrypted))
{
Console.WriteLine("OK.");
return true;
} else {
Console.WriteLine("FAIL.");
return false;
}
}
public static void Main() {
string PlainText = "Titan";
byte[] PlainBytes = new byte[5];
PlainBytes = Encoding.ASCII.GetBytes(PlainText.ToCharArray());
PrintByteArray(PlainBytes);
byte[] CipherBytes = new byte[8];
PasswordDeriveBytes pdb = new PasswordDeriveBytes("Titan", null);
byte[] IV = new byte[8];
byte[] Key = pdb.CryptDeriveKey("RC2", "SHA1", 40, IV);
PrintByteArray(Key);
PrintByteArray(IV);
// Now use the data to encrypt something
RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider();
Console.WriteLine(rc2.Padding);
Console.WriteLine(rc2.Mode);
ICryptoTransform sse = rc2.CreateEncryptor(Key, IV);
MemoryStream ms = new MemoryStream();
CryptoStream cs1 = new CryptoStream(ms, sse, CryptoStreamMode.Write);
cs1.Write(PlainBytes, 0, PlainBytes.Length);
cs1.FlushFinalBlock();
CipherBytes = ms.ToArray();
cs1.Close();
Console.WriteLine(Encoding.ASCII.GetString(CipherBytes));
PrintByteArray(CipherBytes);
ICryptoTransform ssd = rc2.CreateDecryptor(Key, IV);
CryptoStream cs2 = new CryptoStream(new MemoryStream(CipherBytes), ssd, CryptoStreamMode.Read);
byte[] InitialText = new byte[5];
cs2.Read(InitialText, 0, 5);
Console.WriteLine(Encoding.ASCII.GetString(InitialText));
PrintByteArray(InitialText);
}
public static bool Test()
{
Random rnd = new Random();
// create a random array of random bytes
int len = rnd.Next(1000000);
byte[] plain = new byte[len];
rnd.NextBytes(plain);
Console.Write("Working with " + len + " bytes of plaintext...");
// encrypt by default
RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider();
rc2.Key = new byte[]{5,4,3,2,1,0,0,0,0,0,0,0,0,0,0,0}; // salt only takes effect when we use a 40-bit key
byte[] encrypted1 = (rc2.CreateEncryptor()).TransformFinalBlock(plain, 0, plain.Length);
// encrypt with salt
RC2CryptoServiceProvider rc2s = new RC2CryptoServiceProvider();
rc2s.UseSalt = true;
rc2s.Key = new byte[]{1,2,3,4,5};
rc2s.IV = rc2.IV;
byte[] encrypted2 = (rc2s.CreateEncryptor()).TransformFinalBlock(plain, 0, plain.Length);
if (CompareSlow(encrypted1, encrypted2))
{
Console.WriteLine("OK.");
return true;
} else {
Console.WriteLine("FAIL.");
return false;
}
}
public static void RC2KeySize()
{
using (RC2 rc2 = new RC2CryptoServiceProvider())
{
rc2.KeySize = 40;
Assert.Equal(40 / 8, rc2.Key.Length);
Assert.Equal(40, rc2.KeySize);
rc2.KeySize = 128;
Assert.Equal(128 / 8, rc2.Key.Length);
Assert.Equal(128, rc2.KeySize);
Assert.Throws<CryptographicException>(() => rc2.KeySize = 40 - 8);
Assert.Throws<CryptographicException>(() => rc2.KeySize = 128 + 8);
}
}
static void Main(string[] args)
{
AesManaged aes = new AesManaged();
Console.WriteLine("AesManaged ");
KeySizes[] ks = aes.LegalKeySizes;
foreach (KeySizes k in ks)
{
Console.WriteLine("\tLegal min key size = " + k.MinSize);
Console.WriteLine("\tLegal max key size = " + k.MaxSize);
}
ks = aes.LegalBlockSizes;
foreach (KeySizes k in ks)
{
Console.WriteLine("\tLegal min block size = " + k.MinSize);
Console.WriteLine("\tLegal max block size = " + k.MaxSize);
}
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
Console.WriteLine("DESCryptoServiceProvider ");
ks = des.LegalKeySizes;
foreach (KeySizes k in ks)
{
Console.WriteLine("\tLegal min key size = " + k.MinSize);
Console.WriteLine("\tLegal max key size = " + k.MaxSize);
}
ks = des.LegalBlockSizes;
foreach (KeySizes k in ks)
{
Console.WriteLine("\tLegal min block size = " + k.MinSize);
Console.WriteLine("\tLegal max block size = " + k.MaxSize);
}
RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider();
Console.WriteLine("RC2CryptoServiceProvider ");
ks = rc2.LegalKeySizes;
foreach (KeySizes k in ks)
{
Console.WriteLine("\tLegal min key size = " + k.MinSize);
Console.WriteLine("\tLegal max key size = " + k.MaxSize);
}
ks = rc2.LegalBlockSizes;
foreach (KeySizes k in ks)
{
Console.WriteLine("\tLegal min block size = " + k.MinSize);
Console.WriteLine("\tLegal max block size = " + k.MaxSize);
}
RijndaelManaged rij = new RijndaelManaged();
Console.WriteLine("RijndaelManaged ");
ks = rij.LegalKeySizes;
foreach (KeySizes k in ks)
{
Console.WriteLine("\tLegal min key size = " + k.MinSize);
Console.WriteLine("\tLegal max key size = " + k.MaxSize);
}
ks = rij.LegalBlockSizes;
foreach (KeySizes k in ks)
{
Console.WriteLine("\tLegal min block size = " + k.MinSize);
Console.WriteLine("\tLegal max block size = " + k.MaxSize);
}
TripleDESCryptoServiceProvider tsp = new TripleDESCryptoServiceProvider();
Console.WriteLine("TripleDESCryptoServiceProvider ");
ks = tsp.LegalKeySizes;
foreach (KeySizes k in ks)
{
Console.WriteLine("\tLegal min key size = " + k.MinSize);
Console.WriteLine("\tLegal max key size = " + k.MaxSize);
}
ks = tsp.LegalBlockSizes;
foreach (KeySizes k in ks)
{
Console.WriteLine("\tLegal min block size = " + k.MinSize);
Console.WriteLine("\tLegal max block size = " + k.MaxSize);
}
}
//---------------------------------------------------------------------
public static SymmetricAlgorithm Create_SymmetricAlgorithm(SymmetricAlgorithms SymmetricAlgorithm_in, byte[] PasswordBytes_in)
{
HashAlgorithm HA = Create_HashAlgorithm(HashAlgorithms.SHA_512);
SymmetricAlgorithm SA = null;
switch (SymmetricAlgorithm_in)
{
case SymmetricAlgorithms.None:
return(null);
case SymmetricAlgorithms.Unused_1:
return(null);
case SymmetricAlgorithms.RC2_64_40:
SA = new RC2CryptoServiceProvider();
SA.BlockSize = 64;
SA.KeySize = 40;
break;
case SymmetricAlgorithms.RC2_64_48:
SA = new RC2CryptoServiceProvider();
SA.BlockSize = 64;
SA.KeySize = 48;
break;
case SymmetricAlgorithms.RC2_64_56:
SA = new RC2CryptoServiceProvider();
SA.BlockSize = 64;
SA.KeySize = 56;
break;
case SymmetricAlgorithms.RC2_64_64:
SA = new RC2CryptoServiceProvider();
SA.BlockSize = 64;
SA.KeySize = 64;
break;
case SymmetricAlgorithms.RC2_64_72:
SA = new RC2CryptoServiceProvider();
SA.BlockSize = 64;
SA.KeySize = 72;
break;
case SymmetricAlgorithms.RC2_64_80:
SA = new RC2CryptoServiceProvider();
SA.BlockSize = 64;
SA.KeySize = 80;
break;
case SymmetricAlgorithms.RC2_64_88:
SA = new RC2CryptoServiceProvider();
SA.BlockSize = 64;
SA.KeySize = 88;
break;
case SymmetricAlgorithms.RC2_64_96:
SA = new RC2CryptoServiceProvider();
SA.BlockSize = 64;
SA.KeySize = 96;
break;
case SymmetricAlgorithms.RC2_64_104:
SA = new RC2CryptoServiceProvider();
SA.BlockSize = 64;
SA.KeySize = 104;
break;
case SymmetricAlgorithms.RC2_64_112:
SA = new RC2CryptoServiceProvider();
SA.BlockSize = 64;
SA.KeySize = 112;
break;
case SymmetricAlgorithms.RC2_64_120:
SA = new RC2CryptoServiceProvider();
SA.BlockSize = 64;
SA.KeySize = 120;
break;
case SymmetricAlgorithms.RC2_64_128:
SA = new RC2CryptoServiceProvider();
SA.BlockSize = 64;
SA.KeySize = 128;
break;
case SymmetricAlgorithms.DES_64_64:
SA = new DESCryptoServiceProvider();
SA.BlockSize = 64;
SA.KeySize = 64;
break;
case SymmetricAlgorithms.DES3_64_128:
SA = new TripleDESCryptoServiceProvider();
SA.BlockSize = 64;
SA.KeySize = 128;
break;
case SymmetricAlgorithms.DES3_64_192:
SA = new TripleDESCryptoServiceProvider();
SA.BlockSize = 64;
SA.KeySize = 192;
break;
case SymmetricAlgorithms.AES_128_128:
SA = new RijndaelManaged();
SA.BlockSize = 128;
SA.KeySize = 128;
break;
case SymmetricAlgorithms.AES_128_192:
SA = new RijndaelManaged();
SA.BlockSize = 128;
SA.KeySize = 192;
break;
case SymmetricAlgorithms.AES_128_256:
SA = new RijndaelManaged();
SA.BlockSize = 128;
SA.KeySize = 256;
break;
case SymmetricAlgorithms.AES_192_128:
SA = new RijndaelManaged();
SA.BlockSize = 192;
SA.KeySize = 128;
break;
case SymmetricAlgorithms.AES_192_192:
SA = new RijndaelManaged();
SA.BlockSize = 192;
SA.KeySize = 192;
break;
case SymmetricAlgorithms.AES_192_256:
SA = new RijndaelManaged();
SA.BlockSize = 192;
SA.KeySize = 256;
break;
case SymmetricAlgorithms.AES_256_128:
SA = new RijndaelManaged();
SA.BlockSize = 256;
SA.KeySize = 128;
break;
case SymmetricAlgorithms.AES_256_192:
SA = new RijndaelManaged();
SA.BlockSize = 256;
SA.KeySize = 192;
break;
case SymmetricAlgorithms.AES_256_256:
SA = new RijndaelManaged();
SA.BlockSize = 256;
SA.KeySize = 256;
break;
default:
return(null);
}
SA.Key = Create_CryptographicKey(HashAlgorithms.SHA_256, SA.KeySize, PasswordBytes_in);
SA.IV = Create_CryptographicIV(HashAlgorithms.SHA_256, SA.BlockSize, PasswordBytes_in);
return(SA);
}
public System.Security.Cryptography.ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey, out System.Security.Cryptography.SymmetricAlgorithm algorithm)
{
System.Security.Cryptography.DES des;
switch (this._algorithm)
{
case EncryptionAlgorithm.Des:
des = new DESCryptoServiceProvider();
des.Mode = CipherMode.CBC;
if (bytesKey != null)
{
des.Key = bytesKey;
_encKey = des.Key;
break;
}
_encKey = des.Key;
break;
case EncryptionAlgorithm.Rc2:
RC2 rc = new RC2CryptoServiceProvider();
rc.Mode = CipherMode.CBC;
if (bytesKey != null)
{
rc.Key = bytesKey;
_encKey = rc.Key;
}
else
{
_encKey = rc.Key;
}
if (_initVec == null)
{
_initVec = rc.IV;
}
else
{
rc.IV = _initVec;
}
algorithm = rc;
return(rc.CreateEncryptor());
case EncryptionAlgorithm.Rijndael:
{
Rijndael rijndael = new RijndaelManaged();
rijndael.Mode = System.Security.Cryptography.CipherMode.CBC;
if (bytesKey != null)
{
rijndael.Key = bytesKey;
_encKey = rijndael.Key;
}
else
{
_encKey = rijndael.Key;
}
if (_initVec == null)
{
_initVec = rijndael.IV;
}
else
{
rijndael.IV = _initVec;
}
algorithm = rijndael;
return(rijndael.CreateEncryptor());
}
case EncryptionAlgorithm.TripleDes:
{
TripleDES edes = new TripleDESCryptoServiceProvider();
edes.Mode = CipherMode.CBC;
if (bytesKey != null)
{
edes.Key = bytesKey;
_encKey = edes.Key;
}
else
{
_encKey = edes.Key;
}
if (_initVec == null)
{
_initVec = edes.IV;
}
else
{
edes.IV = _initVec;
}
algorithm = edes;
return(edes.CreateEncryptor());
}
default:
throw new CryptographicException("Algorithm '" + _algorithm + "' not supported.");
}
if (_initVec == null)
{
_initVec = des.IV;
}
else
{
des.IV = _initVec;
}
algorithm = des;
return(des.CreateEncryptor());
}
/// <summary> Function to encrypt an one content bytes
/// </summary>
/// <param name="content">Function to encrypt an one content bytes</param>
/// <returns>Array of bytes</returns>
public byte[] Encrypt(byte[] content)
{
if (!IsHashAlgorithm && _key == null)
{
throw new CryptographicException(Resources.Cypher_NoKey);
}
if (content == null || content.Equals(String.Empty))
{
throw new CryptographicException(Resources.Cypher_NoContent);
}
byte[] cipherBytes = null;
int NumBytes = 0;
#if !CompactFramework
if (_algorithm == Algorithm.RSA)
{
//This is an asymmetric call, which has to be treated differently
cipherBytes = RSAEncrypt(content);
}
else
#endif
if (IsHashAlgorithm)
{
string hash = GenerateHash(System.Text.Encoding.UTF8.GetString(content, 0, content.Length));
cipherBytes = System.Text.Encoding.UTF8.GetBytes(hash);
}
else
{
SymmetricAlgorithm provider;
switch (_algorithm)
{
case Algorithm.DES:
provider = new DESCryptoServiceProvider();
NumBytes = Convert.ToInt32(AlgorithmKeySize.DES);
break;
case Algorithm.TripleDES:
provider = new TripleDESCryptoServiceProvider();
NumBytes = Convert.ToInt32(AlgorithmKeySize.TripleDES);
break;
case Algorithm.Rijndael:
provider = new RijndaelManaged();
NumBytes = Convert.ToInt32(AlgorithmKeySize.Rijndael);
break;
case Algorithm.RC2:
provider = new RC2CryptoServiceProvider();
NumBytes = Convert.ToInt32(AlgorithmKeySize.RC2);
break;
default:
throw new CryptographicException(Resources.Cypher_InvalidProvider);
}
try
{
//Encrypt the string
cipherBytes = SymmetricEncrypt(provider, content, _key, NumBytes);
}
finally
{
//Free any resources held by the SymmetricAlgorithm provider
provider.Clear();
}
}
return(cipherBytes);
}
private static byte[] _Decrypt(byte[] Content)
{
if (!IsHashAlgorithm && _key == null)
{
throw new CryptographicException(ERR_NO_KEY);
}
if (_algorithm.Equals(-1))
{
throw new CryptographicException(ERR_NO_ALGORITHM);
}
if (Content == null || Content.Length.Equals(0))
{
throw new CryptographicException(ERR_NO_CONTENT);
}
string encText = Encoding.UTF8.GetString(Content);
if (_encodingType == EncodingType.BASE_64)
{
//We need to convert the content to Hex before decryption
encText = BytesToHex(System.Convert.FromBase64String(encText));
}
byte[] clearBytes = null;
int NumBytes = 0;
if (_algorithm == Algorithm.RSA)
{
try {
clearBytes = RSADecrypt(encText);
}
catch (CryptographicException ex) {
throw ex;
}
}
else
{
SymmetricAlgorithm provider = null;
switch (_algorithm)
{
case Algorithm.DES:
provider = new DESCryptoServiceProvider();
NumBytes = KeySize.DES;
break;
case Algorithm.TripleDES:
provider = new TripleDESCryptoServiceProvider();
NumBytes = KeySize.TripleDES;
break;
case Algorithm.Rijndael:
provider = new RijndaelManaged();
NumBytes = KeySize.AES;
break;
case Algorithm.RC2:
provider = new RC2CryptoServiceProvider();
NumBytes = KeySize.RC2;
break;
default:
throw new CryptographicException(ERR_INVALID_PROVIDER);
}
try {
clearBytes = SymmetricDecrypt(provider, encText, _key, NumBytes);
}
catch (CryptographicException ex) {
throw ex;
}
finally {
//Free any resources held by the SymmetricAlgorithm provider
provider.Clear();
}
}
//Now return the plain text content
return(clearBytes);
}
/// <summary>
/// Writes the value of 'LicenseString' as an encrypted stream to the file:stream specified
/// by 'currentFile'.
/// </summary>
/// <param name="currentFile">Fully qualified path to the alternate stream</param>
/// <param name="LicenseString">The string value to encrypt and write to the alternate stream</param>
public static void WriteAlternateStreamEncrypted(string currentFile, string LicenseString)
{
RC2CryptoServiceProvider rc2 = null;
CryptoStream cs = null;
MemoryStream ms = null;
uint count = 0;
IntPtr buffer = IntPtr.Zero;
IntPtr hFile = IntPtr.Zero;
try
{
Encoding enc = Encoding.Unicode;
byte[] ba = enc.GetBytes(LicenseString);
ms = new MemoryStream();
rc2 = new RC2CryptoServiceProvider();
rc2.Key = GetBytesFromHexString("7a6823a42a3a3ae27057c647db812d0");
rc2.IV = GetBytesFromHexString("827d961224d99b2d");
cs = new CryptoStream(ms, rc2.CreateEncryptor(), CryptoStreamMode.Write);
cs.Write(ba, 0, ba.Length);
cs.FlushFinalBlock();
buffer = Marshal.AllocHGlobal(1000 * sizeof(char));
ZeroMemory(buffer, 1000 * sizeof(char));
uint nBytes = (uint)ms.Length;
Marshal.Copy(ms.GetBuffer(), 0, buffer, (int)nBytes);
DeleteFile(currentFile);
hFile = CreateFile(currentFile, GENERIC_WRITE, 0, IntPtr.Zero,
CREATE_ALWAYS, 0, IntPtr.Zero);
if (-1 != hFile.ToInt32())
{
bool bRtn = WriteFile(hFile, buffer, nBytes, out count, 0);
}
else
{
Exception excptn = new Win32Exception(Marshal.GetLastWin32Error());
if (!excptn.Message.Contains("cannot find the file"))
{
throw excptn;
}
}
}
catch (Exception exception)
{
Console.WriteLine("WriteAlternateStreamEncrypted()");
Console.WriteLine(exception.Message);
}
finally
{
CloseHandle(hFile);
hFile = IntPtr.Zero;
if (cs != null)
{
cs.Close();
cs.Dispose();
}
rc2 = null;
if (ms != null)
{
ms.Close();
ms.Dispose();
}
if (buffer != IntPtr.Zero)
{
Marshal.FreeHGlobal(buffer);
}
}
}
public static void Main()
{
// Create a new instance of the RC2CryptoServiceProvider class
// and automatically generate a Key and IV.
RC2CryptoServiceProvider rc2CSP = new RC2CryptoServiceProvider();
Console.WriteLine("Effective key size is {0} bits.", rc2CSP.EffectiveKeySize);
// Get the key and IV.
byte[] key = rc2CSP.Key;
byte[] IV = rc2CSP.IV;
// Get an encryptor.
ICryptoTransform encryptor = rc2CSP.CreateEncryptor(key, IV);
// Encrypt the data as an array of encrypted bytes in memory.
MemoryStream msEncrypt = new MemoryStream();
CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write);
// Convert the data to a byte array.
string original = "Here is some data to encrypt.";
byte[] toEncrypt = Encoding.ASCII.GetBytes(original);
// Write all data to the crypto stream and flush it.
csEncrypt.Write(toEncrypt, 0, toEncrypt.Length);
csEncrypt.FlushFinalBlock();
// Get the encrypted array of bytes.
byte[] encrypted = msEncrypt.ToArray();
///////////////////////////////////////////////////////
// This is where the data could be transmitted or saved.
///////////////////////////////////////////////////////
//Get a decryptor that uses the same key and IV as the encryptor.
ICryptoTransform decryptor = rc2CSP.CreateDecryptor(key, IV);
// Now decrypt the previously encrypted message using the decryptor
// obtained in the above step.
MemoryStream msDecrypt = new MemoryStream(encrypted);
CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read);
// Read the decrypted bytes from the decrypting stream
// and place them in a StringBuilder class.
StringBuilder roundtrip = new StringBuilder();
int b = 0;
do
{
b = csDecrypt.ReadByte();
if (b != -1)
{
roundtrip.Append((char)b);
}
} while (b != -1);
// Display the original data and the decrypted data.
Console.WriteLine("Original: {0}", original);
Console.WriteLine("Round Trip: {0}", roundtrip);
Console.ReadLine();
}
public RC2EncryptionService()
{
rc2Instance = new RC2CryptoServiceProvider();
}
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)
{
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
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)
{
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
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)
{
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
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;
// Test to see if a key was provided
if (null == bytesKey)
{
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
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 Rc2StorageEncryptionProvider(string key)
{
encryptionProvider = new RC2CryptoServiceProvider();
encryptionProvider.KeySize = 256;
encryptionProvider.Key = Encoding.UTF8.GetBytes(key);
}
public static byte[] ObtenerIV()
{
RC2CryptoServiceProvider rC2 = new RC2CryptoServiceProvider();
return(rC2.IV);
}
private void process(int action)
{
//Encrypt/Decrypt Stream
try
{
if (inputStream == null || inputStream.Length == 0)
{
GuiLogMessage("No input data, aborting now", NotificationLevel.Error);
return;
}
ICryptoTransform p_encryptor;
SymmetricAlgorithm p_alg = new RC2CryptoServiceProvider();
ConfigureAlg(p_alg);
outputStreamWriter = new CStreamWriter();
ICryptoolStream inputdata = InputStream;
if (action == 0)
{
inputdata = BlockCipherHelper.AppendPadding(InputStream, settings.padmap[settings.Padding], p_alg.BlockSize / 8);
}
CStreamReader reader = inputdata.CreateReader();
GuiLogMessage("Starting " + ((settings.Action == 0)?"encryption":"decryption") + " [Keysize=" + p_alg.KeySize.ToString() + " Bits, Blocksize=" + p_alg.BlockSize.ToString() + " Bits]", NotificationLevel.Info);
DateTime startTime = DateTime.Now;
// special handling of OFB mode, as it's not available for RC2 in .Net
if (settings.Mode == 3) // OFB - bei OFB ist encrypt = decrypt, daher keine Fallunterscheidung
{
p_encryptor = p_alg.CreateEncryptor(p_alg.Key, p_alg.IV);
byte[] IV = new byte[p_alg.IV.Length];
Array.Copy(p_alg.IV, IV, p_alg.IV.Length);
byte[] tmpInput = BlockCipherHelper.StreamToByteArray(inputdata);
byte[] outputData = new byte[tmpInput.Length];
for (int pos = 0; pos <= tmpInput.Length - p_encryptor.InputBlockSize;)
{
int l = p_encryptor.TransformBlock(IV, 0, p_encryptor.InputBlockSize, outputData, pos);
for (int i = 0; i < l; i++)
{
IV[i] = outputData[pos + i];
outputData[pos + i] ^= tmpInput[pos + i];
}
pos += l;
}
outputStreamWriter.Write(outputData);
}
else
{
p_encryptor = (action == 0) ? p_alg.CreateEncryptor() : p_alg.CreateDecryptor();
p_crypto_stream = new CryptoStream((Stream)reader, p_encryptor, CryptoStreamMode.Read);
byte[] buffer = new byte[p_alg.BlockSize / 8];
int bytesRead;
while ((bytesRead = p_crypto_stream.Read(buffer, 0, buffer.Length)) > 0 && !stop)
{
outputStreamWriter.Write(buffer, 0, bytesRead);
}
p_crypto_stream.Flush();
}
outputStreamWriter.Close();
DateTime stopTime = DateTime.Now;
TimeSpan duration = stopTime - startTime;
if (action == 1)
{
outputStreamWriter = BlockCipherHelper.StripPadding(outputStreamWriter, settings.padmap[settings.Padding], p_alg.BlockSize / 8) as CStreamWriter;
}
if (!stop)
{
GuiLogMessage(((settings.Action == 0) ? "Encryption" : "Decryption") + " complete! (in: " + InputStream.Length + " bytes, out: " + outputStreamWriter.Length + " bytes)", NotificationLevel.Info);
GuiLogMessage("Time used: " + duration, NotificationLevel.Debug);
OnPropertyChanged("OutputStream");
}
else
{
GuiLogMessage("Aborted!", NotificationLevel.Info);
}
}
catch (CryptographicException cryptographicException)
{
// TODO: For an unknown reason p_crypto_stream can not be closed after exception.
// Trying so makes p_crypto_stream throw the same exception again. So in Dispose
// the error messages will be doubled.
// As a workaround we set p_crypto_stream to null here.
p_crypto_stream = null;
GuiLogMessage(cryptographicException.Message, NotificationLevel.Error);
}
catch (Exception exception)
{
GuiLogMessage(exception.Message, NotificationLevel.Error);
}
finally
{
ProgressChanged(1, 1);
}
}
public string Cifrar(Byte modo, string cadena)
{
try
{
Byte[] plaintext;
string VecI = "20270430";
Byte Algoritmo = 3;
string key = "Visa-Preferida";
/*** Procedimiento de cifrado ***/
//encriptar
if (modo == 1)
{
plaintext = Encoding.ASCII.GetBytes(cadena);
}
else
{
//desencriptar
plaintext = Convert.FromBase64String(cadena);
}
Byte[] keys = Encoding.ASCII.GetBytes(key);
MemoryStream memdata = new MemoryStream();
ICryptoTransform transforma = null;
switch (Algoritmo)
{
case 1:
/*** DES ***/
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
des.Mode = CipherMode.CBC;
des.Padding = PaddingMode.PKCS7;
if (modo == 1)
{
transforma = des.CreateEncryptor(keys, Encoding.ASCII.GetBytes(VecI));
}
else
{
if (modo == 2)
{
transforma = des.CreateDecryptor(keys, Encoding.ASCII.GetBytes(VecI));
}
else
{
transforma = des.CreateDecryptor(keys, Encoding.ASCII.GetBytes(VecI));
}
}
break;
case 2:
/*** TripleDES ***/
TripleDESCryptoServiceProvider des3 = new TripleDESCryptoServiceProvider();
des3.Mode = CipherMode.CBC;
des3.Padding = PaddingMode.PKCS7;
if (modo == 1)
{
transforma = des3.CreateEncryptor(keys, Encoding.ASCII.GetBytes(VecI));
}
else
{
if (modo == 2)
{
transforma = des3.CreateDecryptor(keys, Encoding.ASCII.GetBytes(VecI));
}
else
{
transforma = des3.CreateDecryptor(keys, Encoding.ASCII.GetBytes(VecI));
}
}
break;
case 3:
/*** RC2 ***/
RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider();
rc2.Mode = CipherMode.CBC;
rc2.Padding = PaddingMode.PKCS7;
if (modo == 1)
{
transforma = rc2.CreateEncryptor(keys, Encoding.ASCII.GetBytes(VecI));
}
else
{
if (modo == 2)
{
transforma = rc2.CreateDecryptor(keys, Encoding.ASCII.GetBytes(VecI));
}
else
{
transforma = rc2.CreateDecryptor(keys, Encoding.ASCII.GetBytes(VecI));
}
}
break;
case 4:
/*** Rijndael ***/
RijndaelManaged rj = new RijndaelManaged();
rj.Mode = CipherMode.CBC;
rj.Padding = PaddingMode.PKCS7;
if (modo == 1)
{
transforma = rj.CreateEncryptor(keys, Encoding.ASCII.GetBytes(VecI));
}
else
{
if (modo == 2)
{
transforma = rj.CreateDecryptor(keys, Encoding.ASCII.GetBytes(VecI));
}
else
{
transforma = rj.CreateDecryptor(keys, Encoding.ASCII.GetBytes(VecI));
}
}
break;
}
CryptoStream encstream = new CryptoStream(memdata, transforma, CryptoStreamMode.Write);
encstream.Write(plaintext, 0, plaintext.Length);
encstream.FlushFinalBlock();
encstream.Close();
if (modo == 1)
{
cadena = Convert.ToBase64String(memdata.ToArray());
}
else
{
if (modo == 2)
{
cadena = Encoding.ASCII.GetString(memdata.ToArray());
}
else
{
cadena = Convert.ToBase64String(memdata.ToArray());
}
}
return(cadena);
}
catch (Exception)
{
throw;
}
}
public RC2EncryptionService(string plainTxt)
{
rc2Instance = new RC2CryptoServiceProvider();
plainText = plainTxt;
}
public void Test36()
{
UInt16 userId = 65535;
DateTime now = DateTime.Now;
DateTime y2010 = new DateTime(2010, 1, 1);
DateTime y2040 = new DateTime(2040, 1, 1);
TimeSpan span = y2040 - y2010;
Assert.IsTrue(span.TotalSeconds < UInt32.MaxValue);
UInt32 secs = (uint)span.TotalSeconds;
byte[] userBytes = BitConverter.GetBytes(userId);
byte[] secsBytes = BitConverter.GetBytes(secs);
byte[] magicBytes = new byte[8];
// userBytes.CopyTo(magicBytes, 0);
// secsBytes.CopyTo(magicBytes, 2);
UInt64 magic = BitConverter.ToUInt64(magicBytes, 0);
ulong i = UInt64.MaxValue;
ulong p;
ulong reminder;
uint bas = 36;
List <ulong> rems = new List <ulong>();
while (true)
{
p = i / bas;
reminder = i % bas;
i = p;
rems.Add(reminder);
if (p == 0)
{
break;
}
}
StringBuilder sb = new StringBuilder();
// foreach (ulong rem in rems)
// {
// sb.Append(ConvertTo36((byte) rem));
// }
MessageBox.Show(sb.ToString() + " " + rems.Count);
RC2CryptoServiceProvider aes = new RC2CryptoServiceProvider();
MemoryStream ms = new MemoryStream();
byte[] rgbKey = Encoding.Default.GetBytes("cjkywtqwertyuiop");
byte[] rgbIV = Encoding.Default.GetBytes("cdtnbnasdfghjklz");;
CryptoStream cryptoStream = new CryptoStream(ms, aes.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
foreach (byte b in BitConverter.GetBytes(int.MaxValue))
{
cryptoStream.WriteByte(b);
}
cryptoStream.Close();
byte[] cipherTextinBytes = ms.ToArray();
}
public string Decrypt(EncoderType type, string decrypt)
{
string ret = "";
byte[] inputByteArray = Convert.FromBase64String(decrypt);
byte[] rgbKey = Convert.FromBase64String(Key);
byte[] rgbIV = Convert.FromBase64String(IV);
switch (type)
{
//可逆編碼(對稱金鑰)
case EncoderType.AES:
using (AesCryptoServiceProvider csp = new AesCryptoServiceProvider())
{
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, csp.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write))
{
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
ret = Encoding.UTF8.GetString(ms.ToArray());
}
}
}
break;
case EncoderType.DES:
using (DESCryptoServiceProvider csp = new DESCryptoServiceProvider())
{
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, csp.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write))
{
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
ret = Encoding.UTF8.GetString(ms.ToArray());
}
}
}
break;
case EncoderType.RC2:
using (RC2CryptoServiceProvider csp = new RC2CryptoServiceProvider())
{
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, csp.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write))
{
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
ret = Encoding.UTF8.GetString(ms.ToArray());
}
}
}
break;
case EncoderType.TripleDES:
using (TripleDESCryptoServiceProvider csp = new TripleDESCryptoServiceProvider())
{
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, csp.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write))
{
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
ret = Encoding.UTF8.GetString(ms.ToArray());
}
}
}
break;
//可逆編碼(非對稱金鑰)
case EncoderType.RSA:
using (RSACryptoServiceProvider csp = new RSACryptoServiceProvider())
{
csp.FromXmlString(Key);
ret = Encoding.UTF8.GetString(csp.Decrypt(inputByteArray, false));
}
break;
}
return(ret);
}
public void SetUp()
{
rc2 = new RC2CryptoServiceProvider();
}
public string Encrypt(EncoderType type, string encrypt)
{
string ret = "";
byte[] inputByteArray = Encoding.UTF8.GetBytes(encrypt);
byte[] rgbKey = Convert.FromBase64String(Key);
byte[] rgbIV = Convert.FromBase64String(IV);
switch (type)
{
case EncoderType.AES:
using (AesCryptoServiceProvider csp = new AesCryptoServiceProvider())
{
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, csp.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write))
{
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
ret = Convert.ToBase64String(ms.ToArray());
}
}
}
break;
case EncoderType.DES:
using (DESCryptoServiceProvider csp = new DESCryptoServiceProvider())
{
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, csp.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write))
{
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
ret = Convert.ToBase64String(ms.ToArray());
}
}
}
break;
case EncoderType.RC2:
using (RC2CryptoServiceProvider csp = new RC2CryptoServiceProvider())
{
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, csp.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write))
{
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
ret = Convert.ToBase64String(ms.ToArray());
}
}
}
break;
case EncoderType.TripleDES:
using (TripleDESCryptoServiceProvider csp = new TripleDESCryptoServiceProvider())
{
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, csp.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write))
{
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
ret = Convert.ToBase64String(ms.ToArray());
}
}
}
break;
case EncoderType.RSA:
using (RSACryptoServiceProvider csp = new RSACryptoServiceProvider())
{
csp.FromXmlString(Key);
ret = Convert.ToBase64String(csp.Encrypt(inputByteArray, false));
}
break;
case EncoderType.MD5:
using (MD5CryptoServiceProvider csp = new MD5CryptoServiceProvider())
{
ret = BitConverter.ToString(csp.ComputeHash(inputByteArray)).Replace("-", string.Empty);
}
break;
case EncoderType.SHA1:
using (SHA1CryptoServiceProvider csp = new SHA1CryptoServiceProvider())
{
ret = BitConverter.ToString(csp.ComputeHash(inputByteArray)).Replace("-", string.Empty);
}
break;
case EncoderType.SHA256:
using (SHA256CryptoServiceProvider csp = new SHA256CryptoServiceProvider())
{
ret = BitConverter.ToString(csp.ComputeHash(inputByteArray)).Replace("-", string.Empty);
}
break;
case EncoderType.SHA384:
using (SHA384CryptoServiceProvider csp = new SHA384CryptoServiceProvider())
{
ret = BitConverter.ToString(csp.ComputeHash(inputByteArray)).Replace("-", string.Empty);
}
break;
case EncoderType.SHA512:
using (SHA512CryptoServiceProvider csp = new SHA512CryptoServiceProvider())
{
ret = BitConverter.ToString(csp.ComputeHash(inputByteArray)).Replace("-", string.Empty);
}
break;
}
return(ret);
}
public object Crypt(CryptMethod _method, CryptClass _class, object _input, string _key)
{
SymmetricAlgorithm control;
switch (_class)
{
case CryptClass.AES:
control = new AesManaged();
break;
case CryptClass.RC2:
control = new RC2CryptoServiceProvider();
break;
case CryptClass.RIJ:
control = new RijndaelManaged();
break;
case CryptClass.DES:
control = new DESCryptoServiceProvider();
break;
case CryptClass.TDES:
control = new TripleDESCryptoServiceProvider();
break;
default:
return(false);
}
control.Key = UTF8Encoding.UTF8.GetBytes(_key);
control.Padding = PaddingMode.PKCS7;
control.Mode = CipherMode.ECB;
ICryptoTransform cTransform = null;
byte[] resultArray;
if (_method == CryptMethod.ENCRYPT)
{
cTransform = control.CreateEncryptor();
}
else if (_method == CryptMethod.DECRYPT)
{
cTransform = control.CreateDecryptor();
}
if (_input is string)
{
byte[] inputArray = UTF32Encoding.UTF8.GetBytes(_input as string);
resultArray = cTransform.TransformFinalBlock(inputArray, 0, inputArray.Length);
control.Clear();
return(Convert.ToBase64String(resultArray, 0, resultArray.Length));
}
else if (_input is byte[])
{
resultArray = cTransform.TransformFinalBlock((_input as byte[]), 0, (_input as byte[]).Length);
control.Clear();
return(resultArray);
}
return(false);
}
public ICryptoTransform GetCryptoTransform()
{
bool bHasSecuityKey = false;
if (SecurityKey.Length != 0)
{
bHasSecuityKey = true;
}
byte[] key = Encoding.ASCII.GetBytes(SecurityKey);
switch (algorithmID)
{
case EncryptionAlgorithm.DES:
DES des = new DESCryptoServiceProvider();
if (bHasSecuityKey)
{
des.Key = key;
}
if (bHasIV)
{
des.IV = IV;
}
return(des.CreateDecryptor());
case EncryptionAlgorithm.Rc2:
RC2 rc = new RC2CryptoServiceProvider();
if (bHasSecuityKey)
{
rc.Key = key;
}
if (bHasIV)
{
rc.IV = IV;
}
return(rc.CreateDecryptor());
case EncryptionAlgorithm.Rijndael:
Rijndael rj = new RijndaelManaged();
if (bHasSecuityKey)
{
rj.Key = key;
}
if (bHasIV)
{
rj.IV = IV;
}
;
return(rj.CreateDecryptor());
case EncryptionAlgorithm.TripleDes:
TripleDES tDes = new TripleDESCryptoServiceProvider();
if (bHasSecuityKey)
{
tDes.Key = key;
}
if (bHasIV)
{
tDes.IV = IV;
}
return(tDes.CreateDecryptor());
default:
throw new CryptographicException("Algorithm ID '" + algorithmID + "' not supported.");
}
}
private static byte[] _Encrypt(byte[] Content)
{
if (!IsHashAlgorithm && _key == null)
{
throw new CryptographicException(ERR_NO_KEY);
}
if (_algorithm.Equals(-1))
{
throw new CryptographicException(ERR_NO_ALGORITHM);
}
if (Content == null || Content.Equals(string.Empty))
{
throw new CryptographicException(ERR_NO_CONTENT);
}
byte[] cipherBytes = null;
int NumBytes = 0;
if (_algorithm == Algorithm.RSA)
{
//This is an asymmetric call, which has to be treated differently
try {
cipherBytes = RSAEncrypt(Content);
}
catch (CryptographicException ex) {
throw ex;
}
}
else
{
SymmetricAlgorithm provider = null;
switch (_algorithm)
{
case Algorithm.DES:
provider = new DESCryptoServiceProvider();
NumBytes = KeySize.DES;
break;
case Algorithm.TripleDES:
provider = new TripleDESCryptoServiceProvider();
NumBytes = KeySize.TripleDES;
break;
case Algorithm.Rijndael:
provider = new RijndaelManaged();
NumBytes = KeySize.AES;
break;
case Algorithm.RC2:
provider = new RC2CryptoServiceProvider();
NumBytes = KeySize.RC2;
break;
default:
throw new CryptographicException(ERR_INVALID_PROVIDER);
}
try {
//Encrypt the string
cipherBytes = SymmetricEncrypt(provider, Content, _key, NumBytes);
}
catch (CryptographicException ex) {
throw new CryptographicException(ex.Message, ex.InnerException);
}
finally {
//Free any resources held by the SymmetricAlgorithm provider
provider.Clear();
}
}
return(cipherBytes);
}
/// <summary>
/// 获取密钥
/// Key为密钥，Value为向量(IV)
/// </summary>
/// <returns></returns>
public static KeyValuePair <string, string> RC2Key()
{
RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider();
return(new KeyValuePair <string, string>(Convert.ToBase64String(rc2.Key), Convert.ToBase64String(rc2.IV)));
}
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.");
}
}
}
/// <summary>
/// 加密
/// </summary>
/// <param name="str">原字符串</param>
/// <returns></returns>
public static string Encrypt(this string str)
{
if (string.IsNullOrEmpty(str))
return null;
var sBuffer = Encoding.UTF8.GetBytes(str);
var provider = new RC2CryptoServiceProvider();
var rgbIV = Encoding.ASCII.GetBytes(IV);
var rgbKey = Encoding.ASCII.GetBytes(Key);
var encryptor = provider.CreateEncryptor(rgbKey, rgbIV);
using (var ms = new MemoryStream()) {
using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write)) {
cs.Write(sBuffer, 0, sBuffer.Length);
cs.FlushFinalBlock();
}
byte[] buffer = ms.ToArray();
str = Convert.ToBase64String(buffer);
}
return HttpUtility.HtmlEncode(str.Trim());
}
/// <summary> Function to decrypt an one content bytes
/// </summary>
/// <param name="content">To be encrypted content</param>
/// <returns>Array of bytes</returns>
public byte[] Decrypt(byte[] content)
{
if (IsHashAlgorithm)
{
throw new CryptographicException(Resources.Cypher_DecryptHash);
}
if (_key == null)
{
throw new CryptographicException(Resources.Cypher_NoKey);
}
if (content == null || content.Equals(String.Empty))
{
throw new CryptographicException(Resources.Cypher_NoContent);
}
string encText = System.Text.Encoding.UTF8.GetString(content, 0, content.Length);
if (_encodingType == EncodingType.Base64)
{
//We need to convert the content to Hex before decryption
encText = BytesToHex(System.Convert.FromBase64String(encText));
}
byte[] clearBytes = null;
int NumBytes = 0;
#if !CompactFramework
if (_algorithm == Algorithm.RSA)
{
clearBytes = RSADecrypt(encText);
}
else
#endif
{
SymmetricAlgorithm provider;
switch (_algorithm)
{
case Algorithm.DES:
provider = new DESCryptoServiceProvider();
NumBytes = Convert.ToInt32(AlgorithmKeySize.DES);
break;
case Algorithm.TripleDES:
provider = new TripleDESCryptoServiceProvider();
NumBytes = Convert.ToInt32(AlgorithmKeySize.TripleDES);
break;
case Algorithm.Rijndael:
provider = new RijndaelManaged();
NumBytes = Convert.ToInt32(AlgorithmKeySize.Rijndael);
break;
case Algorithm.RC2:
provider = new RC2CryptoServiceProvider();
NumBytes = Convert.ToInt32(AlgorithmKeySize.RC2);
break;
default:
throw new CryptographicException(Resources.Cypher_InvalidProvider);
}
try
{
clearBytes = SymmetricDecrypt(provider, encText, _key, NumBytes);
}
finally
{
//Free any resources held by the SymmetricAlgorithm provider
provider.Clear();
}
}
//Now return the plain text content
return(clearBytes);
}
/// <summary>
/// 解密
/// </summary>
/// <param name="str">原字符串</param>
/// <returns></returns>
public static string Decrypt(this string str)
{
try {
if (string.IsNullOrEmpty(str))
return null;
var decodeStr = HttpUtility.HtmlDecode(str);
var sBuffer = Convert.FromBase64String(decodeStr);
var provider = new RC2CryptoServiceProvider();
var rgbIV = Encoding.ASCII.GetBytes(IV);
var rgbKey = Encoding.ASCII.GetBytes(Key);
var decryptor = provider.CreateDecryptor(rgbKey, rgbIV);
using (var ms = new MemoryStream()) {
using (var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Write)) {
cs.Write(sBuffer, 0, sBuffer.Length);
cs.FlushFinalBlock();
}
byte[] buffer = ms.ToArray();
str = Encoding.UTF8.GetString(buffer);
}
return str;
} catch (Exception ex) {
throw new DecryptException(ex);
}
}
internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey)
{
ICryptoTransform iCryptoTransform;
switch (algorithmID)
{
case EncryptionAlgorithm.Des:
DES dES = new DESCryptoServiceProvider();
dES.Mode = CipherMode.CBC;
if (bytesKey == null)
{
encKey = dES.Key;
}
else
{
dES.Key = bytesKey;
encKey = dES.Key;
}
if (initVec == null)
{
initVec = dES.IV;
}
else
{
dES.IV = initVec;
}
iCryptoTransform = dES.CreateEncryptor();
break;
case EncryptionAlgorithm.TripleDes:
TripleDES tripleDES = new TripleDESCryptoServiceProvider();
tripleDES.Mode = CipherMode.CBC;
if (bytesKey == null)
{
encKey = tripleDES.Key;
}
else
{
tripleDES.Key = bytesKey;
encKey = tripleDES.Key;
}
if (initVec == null)
{
initVec = tripleDES.IV;
}
else
{
tripleDES.IV = initVec;
}
iCryptoTransform = tripleDES.CreateEncryptor();
break;
case EncryptionAlgorithm.Rc2:
RC2 rC2 = new RC2CryptoServiceProvider();
rC2.Mode = CipherMode.CBC;
if (bytesKey == null)
{
encKey = rC2.Key;
}
else
{
rC2.Key = bytesKey;
encKey = rC2.Key;
}
if (initVec == null)
{
initVec = rC2.IV;
}
else
{
rC2.IV = initVec;
}
iCryptoTransform = rC2.CreateEncryptor();
break;
case EncryptionAlgorithm.Rijndael:
Rijndael rijndael = new RijndaelManaged();
rijndael.Mode = CipherMode.CBC;
if (bytesKey == null)
{
encKey = rijndael.Key;
}
else
{
rijndael.Key = bytesKey;
encKey = rijndael.Key;
}
if (initVec == null)
{
initVec = rijndael.IV;
}
else
{
rijndael.IV = initVec;
}
iCryptoTransform = rijndael.CreateEncryptor();
break;
default:
throw new CryptographicException(String.Concat("Algorithm ID \'", algorithmID, "\' not supported."));
}
return(iCryptoTransform);
}
/// <summary>対称アルゴリズム暗号化サービスプロバイダ生成</summary>
/// <param name="esa">EnumSymmetricAlgorithm</param>
/// <param name="cm">CipherMode</param>
/// <param name="pm">PaddingMode</param>
/// <returns>SymmetricAlgorithm</returns>
private SymmetricAlgorithm CreateSymmetricAlgorithm(EnumSymmetricAlgorithm esa, CipherMode cm, PaddingMode pm)
{
#region Constructor
SymmetricAlgorithm sa = null;
#region Aes
if (esa.HasFlag(EnumSymmetricAlgorithm.AES_CSP))
{
// AesCryptoServiceProviderサービスプロバイダ
sa = AesCryptoServiceProvider.Create(); // devps(1703)
}
else if (esa.HasFlag(EnumSymmetricAlgorithm.AES_M))
{
// AesManagedサービスプロバイダ
sa = AesManaged.Create(); // devps(1703)
}
#if NET45 || NET46
#else
else if (esa.HasFlag(EnumSymmetricAlgorithm.AES_CNG))
{
// AesCngサービスプロバイダ
sa = AesCng.Create(); // devps(1703)
}
#endif
#endregion
#region TripleDES
else if (esa.HasFlag(EnumSymmetricAlgorithm.TDES_CSP))
{
// TripleDESCryptoServiceProviderサービスプロバイダ
sa = TripleDESCryptoServiceProvider.Create(); // devps(1703)
}
#if NET45 || NET46
#else
else if (esa.HasFlag(EnumSymmetricAlgorithm.TDES_CNG))
{
// TripleDESCngサービスプロバイダ
sa = TripleDESCng.Create(); // devps(1703)
}
#endif
#endregion
#region Others
else if (esa.HasFlag(EnumSymmetricAlgorithm.DES_CSP))
{
// DESCryptoServiceProviderサービスプロバイダ
sa = DESCryptoServiceProvider.Create(); // devps(1703)
}
else if (esa.HasFlag(EnumSymmetricAlgorithm.RC2_CSP))
{
// RC2CryptoServiceProviderサービスプロバイダ
sa = RC2CryptoServiceProvider.Create(); // devps(1703)
}
else if (esa.HasFlag(EnumSymmetricAlgorithm.Rijndael_M))
{
// RijndaelManagedサービスプロバイダ
sa = RijndaelManaged.Create(); // devps(1703)
}
#endregion
else
{
throw new ArgumentException(
PublicExceptionMessage.ARGUMENT_INCORRECT, "EnumSymmetricAlgorithm esa");
}
#endregion
#region Options
// cmが設定されている場合。
if (cm != 0)
{
sa.Mode = cm;
}
// pmが設定されている場合。
if (pm != 0)
{
sa.Padding = pm;
}
#endregion
return(sa);
}
/// <summary>
/// 복호화
/// </summary>
/// <param name="cipherText">암호문</param>
/// <param name="DecryptCheck">암호화 해시 함수</param>
/// <param name="DecryptType">암호화 알고리즘</param>
public static string DecryptText(string cipherText, string DecryptCheck, string DecryptType, string CryptoKey)
{
byte[] keyArray;
byte[] toEncryptArray = Convert.FromBase64String(cipherText);
string key = CryptoKey;
switch (DecryptCheck.Trim().ToUpper().ToString())
{
case "MD5":
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
hashmd5.Clear();
break;
case "SHA1":
SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
keyArray = sha1.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
sha1.Clear();
break;
case "SHA256":
SHA256Managed sha256 = new SHA256Managed();
keyArray = sha256.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
sha256.Clear();
break;
case "SHA384":
SHA384Managed sha384 = new SHA384Managed();
keyArray = sha384.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
sha384.Clear();
break;
case "SHA512":
SHA512Managed sha512 = new SHA512Managed();
keyArray = sha512.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
sha512.Clear();
break;
default:
keyArray = UTF8Encoding.UTF8.GetBytes(key);
break;
}
byte[] resultArray = null;
if (keyArray.Length > 16)
{
byte[] temp = new byte[16];
for (int i = 0; i < 16; i++)
{
temp[i] = keyArray[i];
}
keyArray = temp;
}
if (keyArray.Length < 16)
{
byte[] temp = new byte[16];
for (int j = keyArray.Length; j < 16; j++)
{
temp[j] = keyArray[0];
}
keyArray = temp;
}
switch (DecryptType.Trim().ToUpper().ToString())
{
case "RC2":
RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider();
rc2.Key = keyArray;
rc2.Mode = CipherMode.ECB;
rc2.Padding = PaddingMode.PKCS7;
ICryptoTransform rc2Transform = rc2.CreateDecryptor();
resultArray = rc2Transform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
rc2.Clear();
break;
case "TRIPLE":
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform tdesTransform = tdes.CreateDecryptor();
resultArray = tdesTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
tdes.Clear();
break;
case "DES":
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
des.Key = UTF8Encoding.UTF8.GetBytes(key.Substring(0, 8).ToString().Trim());
des.Mode = CipherMode.ECB;
des.Padding = PaddingMode.PKCS7;
ICryptoTransform desTransform = des.CreateDecryptor();
resultArray = desTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
des.Clear();
break;
case "AES":
RijndaelManaged Rijndae = new RijndaelManaged();
Rijndae.Key = keyArray;
Rijndae.Mode = CipherMode.ECB;
Rijndae.Padding = PaddingMode.PKCS7;
ICryptoTransform RijndaeTransform = Rijndae.CreateDecryptor();
resultArray = RijndaeTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
Rijndae.Clear();
break;
}
return(UTF8Encoding.UTF8.GetString(resultArray));
}
/// <summary>
/// Define un objeto para la operaciones básicas de transformaciones
/// criptográficas.
/// </summary>
/// <param name="Key">Clave de encripción.</param>
/// <param name="IV">Vector de inicialización.</param>
/// <returns>Devuelve el objeto que implementa la interfaz ICryptoTransform.
/// </returns>
internal ICryptoTransform GetServiceProvider(byte[] Key, byte[] IV)
{
// creamos la variable que contendrá al objeto ICryptoTransform.
ICryptoTransform transform = null;
// dependiendo del algoritmo seleccionado, se devuelve el objeto adecuado.
switch (this.algorithm)
{
// Algoritmo DES.
case CryptoProvider.DES:
// dependiendo de la acción a realizar.
// creamos el objeto adecuado.
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
switch (cAction)
{
case CryptoAction.Encrypt: // si estamos cifrando,
// creamos el objeto cifrador.
transform = des.CreateEncryptor(Key, IV);
break;
case CryptoAction.Desencrypt: // sí estamos descifrando,
// creamos el objeto descifrador.
transform = des.CreateDecryptor(Key, IV);
break;
}
// devolvemos el objeto transform correspondiente.
return(transform);
// algoritmo TripleDES.
case CryptoProvider.TripleDES:
TripleDESCryptoServiceProvider des3 = new TripleDESCryptoServiceProvider();
switch (cAction)
{
case CryptoAction.Encrypt:
transform = des3.CreateEncryptor(Key, IV);
break;
case CryptoAction.Desencrypt:
transform = des3.CreateDecryptor(Key, IV);
break;
}
return(transform);
// algoritmo RC2.
case CryptoProvider.RC2:
RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider();
switch (cAction)
{
case CryptoAction.Encrypt:
transform = rc2.CreateEncryptor(Key, IV);
break;
case CryptoAction.Desencrypt:
transform = rc2.CreateDecryptor(Key, IV);
break;
}
return(transform);
// algoritmo Rijndael.
case CryptoProvider.Rijndael:
Rijndael rijndael = new RijndaelManaged();
switch (cAction)
{
case CryptoAction.Encrypt:
transform = rijndael.CreateEncryptor(Key, IV);
break;
case CryptoAction.Desencrypt:
transform = rijndael.CreateDecryptor(Key, IV);
break;
}
return(transform);
default:
// en caso que no exista el proveedor seleccionado, generamos
// una excepción para informarlo.
throw new CryptographicException("Error al inicializar al proveedor de cifrado");
}
}
private void okB_Click(object sender, RoutedEventArgs e)
{
codeEnc = codeT.Password;
if (codeEnc != "" && codeEnc.Length > 4 && codeEnc.Length < 17)
{
StreamReader encReader = new StreamReader(way2);
string encrypted = encReader.ReadToEnd();
encReader.Close();
RC2CryptoServiceProvider rc2CSP = new RC2CryptoServiceProvider();
byte[] key = Encoding.Default.GetBytes(codeT.Password);
rc2CSP.Key = key;
byte[] IV = { 156, 158, 224, 153, 115, 56, 171, 196 };
rc2CSP.IV = IV;
ICryptoTransform decryptor = rc2CSP.CreateDecryptor(key, rc2CSP.IV);
byte[] toEncrypt = Encoding.Default.GetBytes(encrypted);
MemoryStream msDecrypt = new MemoryStream(toEncrypt);
CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read);
StringBuilder roundtrip = new StringBuilder();
int b = 0;
try
{
do
{
b = csDecrypt.ReadByte();
if (b != -1)
{
roundtrip.Append((char)b);
}
} while (b != -1);
msDecrypt.Close();
csDecrypt.Close();
}
catch (Exception a)
{ }
FileInfo fileInf = new FileInfo(way);
if (fileInf.Exists)
{
fileInf.Delete();
}
FileStream wtf = fileInf.Create();
wtf.Dispose();
wtf.Close();
StreamWriter myWriter = new StreamWriter(way);
myWriter.Write(roundtrip.ToString());
myWriter.Close();
StreamReader myReader = new StreamReader(way);
string line = myReader.ReadLine();
string[] data;
do
{
data = line.Split('|');
if (data[0] == "admin")
{
adminF = !adminF;
break;
}
line = myReader.ReadLine();
} while (line != null);
myReader.Close();
if (adminF)
{
MessageBox.Show("Код верен!", "Добро пожаловать!");
this.Close();
}
else
{
fileInf.Delete();
MessageBox.Show("Код неверен!", "Ошибка!");
this.Close();
}
}
else
{
MessageBox.Show("Код неверен!", "Ошибка!");
this.Close();
}
}
public static Boolean TestKnown()
{
Boolean bRes = true;
Byte[] IV = new Byte[8];
Byte[] PlainText = {0,1,2,3,4,5,6,7};
Byte[] KnownVector = {0x7A, 0x50, 0x39, 0x82, 0xB5, 0x0E, 0xB0, 0x0D, 0x1F, 0x37, 0x9D, 0xC8, 0x36, 0x09, 0xD3, 0xFF};
PasswordDeriveBytes pdb = new PasswordDeriveBytes("simplepassword", null);
Byte[] the_key = pdb.CryptDeriveKey("RC2", "MD5", 40, IV);
RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider();
ICryptoTransform sse = rc2.CreateEncryptor(the_key, IV);
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, sse, CryptoStreamMode.Write);
cs.Write(PlainText,0,PlainText.Length);
cs.FlushFinalBlock();
byte[] ciphertext = ms.ToArray();
cs.Close();
Console.WriteLine("--- Cipher Text : ----");
PrintByteArray(ciphertext);
Console.WriteLine("--- Known vector : ----");
PrintByteArray(KnownVector);
if(!Compare(ciphertext, KnownVector)) {
Console.WriteLine("Known and calculated values differ!");
bRes = false;
}
return bRes;
}
/// <summary>
/// this function provide to Get CryptoServiceProvider
/// </summary>
/// <param name="bytesKey">key</param>
/// <returns>CryptoServiceProvider</returns>
internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey)
{
// 选取提供程序。
switch (algorithmID)
{
case EncryptionAlgorithm.Des:
{
DES des = new DESCryptoServiceProvider();
des.Mode = CipherMode.CBC;
// 查看是否提供了密钥
if (null == bytesKey)
{
encKey = des.Key;
}
else
{
des.Key = bytesKey;
encKey = des.Key;
}
// 查看客户端是否提供了初始化向量
if (null == initVec)
{
// 让算法创建一个
initVec = des.IV;
}
else
{
//不，将它提供给算法
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)
{
encKey = des3.Key;
}
else
{
des3.Key = bytesKey;
encKey = des3.Key;
}
// 查看客户端是否提供了初始化向量
if (null == initVec)
{
//是，让算法创建一个
initVec = des3.IV;
}
else
{
//不，将它提供给算法。
des3.IV = initVec;
}
return(des3.CreateEncryptor());
}
case EncryptionAlgorithm.Rc2:
{
RC2 rc2 = new RC2CryptoServiceProvider();
rc2.Mode = CipherMode.CBC;
// 测试是否提供了密钥
if (null == bytesKey)
{
encKey = rc2.Key;
}
else
{
rc2.Key = bytesKey;
encKey = rc2.Key;
}
// 查看客户端是否提供了初始化向量
if (null == initVec)
{
//是，让算法创建一个
initVec = rc2.IV;
}
else
{
//不，将它提供给算法。
rc2.IV = initVec;
}
return(rc2.CreateEncryptor());
}
case EncryptionAlgorithm.Rijndael:
{
Rijndael rijndael = new RijndaelManaged();
rijndael.Mode = CipherMode.CBC;
// 测试是否提供了密钥
if (null == bytesKey)
{
encKey = rijndael.Key;
}
else
{
rijndael.Key = bytesKey;
encKey = rijndael.Key;
}
// 查看客户端是否提供了初始化向量
if (null == initVec)
{
// 是，让算法创建一个
initVec = rijndael.IV;
}
else
{
// 不，将它提供给算法。
rijndael.IV = initVec;
}
return(rijndael.CreateEncryptor());
}
case EncryptionAlgorithm.Md5:
{
MD5 md5 = new MD5CryptoServiceProvider();
return(md5);
}
default:
{
throw new CryptographicException("算法 ID '" + algorithmID + "' 不受支持");
}
}
}
/// <summary>
/// 创建一个对称加密算法提供者实例
/// </summary>
/// <param name="symmetricAlgorithmType"></param>
/// <returns></returns>
SymmetricAlgorithm CreateSymmetricAlgorithmProvider(SymmetricAlgorithmType symmetricAlgorithmType)
{
SymmetricAlgorithm symmetricAlgorithm = null;
switch (symmetricAlgorithmType)
{
case SymmetricAlgorithmType.DES:
//<key:64,block:64,feedback:8>,key[64,64<skip:0>],block[64,64<skip:0>] ; IV[8byte],KEY[8byte]
symmetricAlgorithm = new DESCryptoServiceProvider();
multiKey = 8;
multiIV = 8;
break;
case SymmetricAlgorithmType.RC2_40:
//<key:128,block:64,feedback:8>,key[40,128<skip:8>],block[64,64<skip:0>] ; IV[8byte],KEY[16byte]
symmetricAlgorithm = new RC2CryptoServiceProvider();
multiKey = 5;
multiIV = 8;
break;
case SymmetricAlgorithmType.RC2_64:
//<key:128,block:64,feedback:8>,key[40,128<skip:8>],block[64,64<skip:0>] ; IV[8byte],KEY[16byte]
symmetricAlgorithm = new RC2CryptoServiceProvider();
multiKey = 8;
multiIV = 8;
break;
case SymmetricAlgorithmType.RC2_96:
//<key:128,block:64,feedback:8>,key[40,128<skip:8>],block[64,64<skip:0>] ; IV[8byte],KEY[16byte]
symmetricAlgorithm = new RC2CryptoServiceProvider();
multiKey = 12;
multiIV = 8;
break;
case SymmetricAlgorithmType.RC2_128:
//<key:128,block:64,feedback:8>,key[40,128<skip:8>],block[64,64<skip:0>] ; IV[8byte],KEY[16byte]
symmetricAlgorithm = new RC2CryptoServiceProvider();
multiKey = 16;
multiIV = 8;
break;
case SymmetricAlgorithmType.Rijndael_128:
//<key:256,block:128,feedback:128>,key[128,256<skip:64>],block[128,256<skip:64>] ; IV[16byte],KEY[32byte]
symmetricAlgorithm = new RijndaelManaged();
multiKey = 16;
multiIV = 16;
break;
case SymmetricAlgorithmType.Rijndael_192:
//<key:256,block:128,feedback:128>,key[128,256<skip:64>],block[128,256<skip:64>] ; IV[16byte],KEY[32byte]
symmetricAlgorithm = new RijndaelManaged();
multiKey = 24;
multiIV = 16;
break;
case SymmetricAlgorithmType.Rijndael_256:
//<key:256,block:128,feedback:128>,key[128,256<skip:64>],block[128,256<skip:64>] ; IV[16byte],KEY[32byte]
symmetricAlgorithm = new RijndaelManaged();
multiKey = 32;
multiIV = 16;
break;
case SymmetricAlgorithmType.TripleDES_128:
//<key:192,block:64,feedback:8>,key[128,192<skip:64>],block[64,64<skip:0>] ; IV[8byte],KEY[24byte]
symmetricAlgorithm = new TripleDESCryptoServiceProvider();
multiKey = 16;
multiIV = 8;
break;
case SymmetricAlgorithmType.TripleDES_192:
//<key:192,block:64,feedback:8>,key[128,192<skip:64>],block[64,64<skip:0>] ; IV[8byte],KEY[24byte]
symmetricAlgorithm = new TripleDESCryptoServiceProvider();
multiKey = 24;
multiIV = 8;
break;
default:
break;
}
symmetricAlgorithm.KeySize = factorKey * multiKey;
symmetricAlgorithm.BlockSize = factorIV * multiIV;
return symmetricAlgorithm;
}
/// <summary>
/// Gets the crypto service provider.
/// </summary>
/// <param name="bytesKey">The bytes key.</param>
/// <returns></returns>
internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey)
{
switch (algorithmID)
{
case EncryptionAlgorithm.Des:
DES des = new DESCryptoServiceProvider();
des.Mode = CipherMode.CBC;
if (null == bytesKey)
{
encKey = des.Key;
}
else
{
des.Key = bytesKey;
encKey = des.Key;
}
if (null == initVec)
{
initVec = des.IV;
}
else
{
des.IV = initVec;
}
return(des.CreateEncryptor());
case EncryptionAlgorithm.TripleDes:
TripleDES des3 = new TripleDESCryptoServiceProvider();
des3.Mode = CipherMode.CBC;
if (null == bytesKey)
{
encKey = des3.Key;
}
else
{
des3.Key = bytesKey;
encKey = des3.Key;
}
if (null == initVec)
{
initVec = des3.IV;
}
else
{
des3.IV = initVec;
}
return(des3.CreateEncryptor());
case EncryptionAlgorithm.Rc2:
RC2 rc2 = new RC2CryptoServiceProvider();
rc2.Mode = CipherMode.CBC;
if (null == bytesKey)
{
encKey = rc2.Key;
}
else
{
rc2.Key = bytesKey;
encKey = rc2.Key;
}
if (null == initVec)
{
initVec = rc2.IV;
}
else
{
rc2.IV = initVec;
}
return(rc2.CreateEncryptor());
case EncryptionAlgorithm.Rijndael:
Rijndael rijndael = new RijndaelManaged();
rijndael.Mode = CipherMode.CBC;
if (null == bytesKey)
{
encKey = rijndael.Key;
}
else
{
rijndael.Key = bytesKey;
encKey = rijndael.Key;
}
if (null == initVec)
{
initVec = rijndael.IV;
}
else
{
rijndael.IV = initVec;
}
return(rijndael.CreateEncryptor());
default:
throw new CryptographicException("Algorithm ID '" + algorithmID + "' not supported!");
}
}
static public bool RC2_CBC_Symmetry_Decode_Byte(byte[] decryptByte, uint startPos, uint inLen, ref byte[] outBytes, byte[] rgbKey)
{
try
{
RC2CryptoServiceProvider m_RC2Provider = new RC2CryptoServiceProvider();
MemoryStream m_stream = new MemoryStream();
CryptoStream m_cstream = new CryptoStream(m_stream, m_RC2Provider.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
m_cstream.Write(decryptByte, (int)startPos, (int)inLen);
m_cstream.FlushFinalBlock();
outBytes = m_stream.ToArray();
m_stream.Close();
m_stream.Dispose();
m_cstream.Close();
m_cstream.Dispose();
return true;
}
catch
{
return false;
}
}
