/// <summary>
/// DES/3DES加密
/// </summary>
/// <param name="reqData"></param>
/// <param name="encryptKey"></param>
/// <returns></returns>
public static byte[] desEncrypt(byte[] reqDataBytes, byte[] encryptKeyBytes)
{
int desMode = 0; //1:3des,2:des
byte[] encryptDataBytes = null; //加密后的数据
if (encryptKeyBytes.Length == 8)
{
desMode = 2;
}
else if (encryptKeyBytes.Length == 16 || encryptKeyBytes.Length == 24)
{
desMode = 1;
}
//3DES加密
if (desMode == 1)
{
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
des.Padding = PaddingMode.None;
//通过反射赋值，绕开弱密钥检查
FieldInfo fi = des.GetType().GetField("KeyValue", BindingFlags.Instance | BindingFlags.NonPublic);
fi.SetValue(des, encryptKeyBytes);
fi = des.GetType().GetField("KeySizeValue", BindingFlags.Instance | BindingFlags.NonPublic);
fi.SetValue(des, encryptKeyBytes.Length * 8);
Type t = Type.GetType("System.Security.Cryptography.CryptoAPITransformMode");
object obj = t.GetField("Encrypt", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly).GetValue(t);
MethodInfo mi = des.GetType().GetMethod("_NewEncryptor", BindingFlags.Instance | BindingFlags.NonPublic);
ICryptoTransform encryptor = (ICryptoTransform)mi.Invoke(des, new object[] { encryptKeyBytes, CipherMode.ECB, null, 0, obj });
encryptDataBytes = encryptor.TransformFinalBlock(reqDataBytes, 0, reqDataBytes.Length);
}
//DES加密
else if (desMode == 2)
{
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
//des.IV = encryptKeyBytes;
des.Padding = PaddingMode.None;
//通过反射赋值，绕开弱密钥检查
FieldInfo fi = des.GetType().GetField("KeyValue", BindingFlags.Instance | BindingFlags.NonPublic);
fi.SetValue(des, encryptKeyBytes);
fi = des.GetType().GetField("KeySizeValue", BindingFlags.Instance | BindingFlags.NonPublic);
fi.SetValue(des, encryptKeyBytes.Length * 8);
Type t = Type.GetType("System.Security.Cryptography.CryptoAPITransformMode");
object obj = t.GetField("Encrypt", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly).GetValue(t);
MethodInfo mi = des.GetType().GetMethod("_NewEncryptor", BindingFlags.Instance | BindingFlags.NonPublic);
ICryptoTransform encryptor = (ICryptoTransform)mi.Invoke(des, new object[] { encryptKeyBytes, CipherMode.ECB, null, 0, obj });
encryptDataBytes = encryptor.TransformFinalBlock(reqDataBytes, 0, reqDataBytes.Length);
}
return(encryptDataBytes);
}
public static ICryptoTransform CreateWeakEncryptor(this DESCryptoServiceProvider cryptoProvider, byte[] key, byte[] iv, int mode)
{
MethodInfo mi = cryptoProvider.GetType().GetMethod("_NewEncryptor", BindingFlags.NonPublic | BindingFlags.Instance);
object[] Par = { key, cryptoProvider.Mode, iv, cryptoProvider.FeedbackSize, mode };
ICryptoTransform trans = mi.Invoke(cryptoProvider, Par) as ICryptoTransform;
return(trans);
}
// Mode = 0 encrypt, 1 decrypt
public static ICryptoTransform CreateWeakEncryptor(this DESCryptoServiceProvider cryptoProvider, byte[] key, byte[] iv, int mode = 0)
{
// reflective way of doing what CreateEncryptor() does, bypassing the check for weak keys
MethodInfo mi = cryptoProvider.GetType().GetMethod("_NewEncryptor", BindingFlags.NonPublic | BindingFlags.Instance);
object[] Par = { key, cryptoProvider.Mode, iv, cryptoProvider.FeedbackSize, mode };
ICryptoTransform trans = mi.Invoke(cryptoProvider, Par) as ICryptoTransform;
return(trans);
}
public static ICryptoTransform CreateWeakDesEncryptor(CipherMode mode, byte[] rgbKey, byte[] rgbIV)
{
DES des = DES.Create();
des.Mode = mode;
DESCryptoServiceProvider sm = des as DESCryptoServiceProvider;
MethodInfo mi = sm.GetType().GetMethod("_NewEncryptor", BindingFlags.NonPublic | BindingFlags.Instance);
object[] Par = { rgbKey, mode, rgbIV, sm.FeedbackSize, 0 };
ICryptoTransform trans = mi.Invoke(sm, Par) as ICryptoTransform;
return(trans);
}
public static byte[] DESEncrypt(byte[] plaintext, byte[] key)
{
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
des.Padding = PaddingMode.None;
MemoryStream mStream = new MemoryStream();
FieldInfo fi = des.GetType().GetField("FeedbackSizeValue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
var FeedbackSizeValue = fi.GetValue(des);
Type t = Type.GetType("System.Security.Cryptography.CryptoAPITransformMode");
object cryptoAPITransformMode = t.GetField("Encrypt", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly).GetValue(t);
MethodInfo mi = des.GetType().GetMethod("_NewEncryptor", BindingFlags.Instance | BindingFlags.NonPublic);
ICryptoTransform desCrypt = mi.Invoke(des, new object[] { key, CipherMode.ECB, null, FeedbackSizeValue, cryptoAPITransformMode }) as ICryptoTransform;
CryptoStream cStream = new CryptoStream(mStream, desCrypt, CryptoStreamMode.Write);
cStream.Write(plaintext, 0, plaintext.Length);
cStream.FlushFinalBlock();
return(mStream.ToArray());
}
/// <summary>
/// DES字节数组解密，可以使用弱密钥
/// </summary>
/// <param name="source"></param>
/// <param name="key"></param>
/// <returns></returns>
public static byte[] Decrypt(byte[] source, byte[] key)
{
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
des.Padding = PaddingMode.None;
Type type = Type.GetType("System.Security.Cryptography.CryptoAPITransformMode");
object obj = type.GetField("Decrypt", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly).GetValue(type);
MethodInfo mi = des.GetType().GetMethod("_NewEncryptor", BindingFlags.Instance | BindingFlags.NonPublic);
ICryptoTransform desCrypt = (ICryptoTransform)mi.Invoke(des, new object[] { key, CipherMode.ECB, null, 0, obj });
return(desCrypt.TransformFinalBlock(source, 0, source.Length));
}
public static string DesCBCDe(string cipher, string key, string icv = "0000000000000000")
{
cipher = ConvertTool.RemoveSpace(cipher);
key = ConvertTool.RemoveSpace(key);
icv = ConvertTool.RemoveSpace(icv);
if (key.Length != 16)
{
throw new Exception("Invalid Key, Not 8 bytes");
}
if (cipher.Length % 16 != 0 || cipher.Length == 0)
{
throw new Exception("Invalid Cipher, Not 8*n bytes");
}
if (icv.Length != 16)
{
throw new Exception("Invalid IV, Not 8 bytes");
}
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
des.Padding = PaddingMode.None;
Type t = Type.GetType("System.Security.Cryptography.CryptoAPITransformMode");
object obj = t.GetField("Decrypt", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly).GetValue(t);
MethodInfo mi = des.GetType().GetMethod("_NewEncryptor", BindingFlags.Instance | BindingFlags.NonPublic);
ICryptoTransform desCrypt = (ICryptoTransform)mi.Invoke(des, new object[] { ConvertTool.String2Bytes(key), CipherMode.CBC, ConvertTool.String2Bytes(icv), 0, obj });
byte[] result = desCrypt.TransformFinalBlock(ConvertTool.String2Bytes(cipher), 0, ConvertTool.String2Bytes(cipher).Length);
return(BitConverter.ToString(result).Replace("-", ""));
/* DESCryptoServiceProvider des = new DESCryptoServiceProvider();
* byte[] inputByteArray = ConvertTool.String2Bytes(cipher);
* des.Key = ConvertTool.String2Bytes(key);
* des.IV = ConvertTool.String2Bytes(icv);
* des.Mode = CipherMode.CBC;
* des.Padding = System.Security.Cryptography.PaddingMode.None;
* MemoryStream ms = new MemoryStream();
* CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
* cs.Write(inputByteArray, 0, inputByteArray.Length);
* cs.FlushFinalBlock();
* StringBuilder ret = new StringBuilder();
* foreach (byte b in ms.ToArray())
* ret.AppendFormat("{0:X2}", b);
*
* return ret.ToString();*/
}
public static string DES_DecryptData(byte[] indata, byte[] desKey, CipherMode cm, PaddingMode pm)
{
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
byte[] outdata = new byte[des.FeedbackSize];
byte[] resdata = new byte[((indata.Length % 8) == 0) ? indata.Length : ((indata.Length / 8) + 1) * 8];
byte[] iv = new byte[des.BlockSize / 8];
int i = 0, o = 0;
for (i = 0; i < des.BlockSize / 8; i++)
{
iv[i] = 0;
}
des.Mode = cm;
des.Padding = pm;
ICryptoTransform ct = null;
if (System.Security.Cryptography.DES.IsWeakKey(desKey))
{
MethodInfo mi = des.GetType().GetMethod("_NewDecryptor", BindingFlags.NonPublic | BindingFlags.Instance);
object[] par = { desKey, des.Mode, iv, des.FeedbackSize, 0 };
ct = (ICryptoTransform)mi.Invoke(des, par);
}
else
{
ct = des.CreateDecryptor(desKey, iv);
}
i = 0; o = 0;
while ((i + des.BlockSize / 8) < indata.Length)
{
ct.TransformBlock(indata, i, des.BlockSize / 8, outdata, 0);
Array.Copy(outdata, 0, resdata, o, des.BlockSize / 8);
i += des.BlockSize / 8;
o += des.BlockSize / 8;
}
byte[] temp = ct.TransformFinalBlock(indata, i, indata.Length - i);
Array.Copy(temp, 0, resdata, o, temp.Length);
des.Clear();
return(Utils.Bin2AHex(resdata));
}
public static byte[] EncryptECBAnyKey(byte[] data, byte[] key, byte[] iv)
{
if (key.Length != 8)
{
throw new Exception("key长度应为8字节");
}
if (iv.Length != 8)
{
throw new Exception("iv长度应为8字节");
}
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
des.Padding = PaddingMode.None;
Type t = Type.GetType("System.Security.Cryptography.CryptoAPITransformMode");
object obj = t.GetField("Encrypt", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly).GetValue(t);
MethodInfo mi = des.GetType().GetMethod("_NewEncryptor", BindingFlags.Instance | BindingFlags.NonPublic);
ICryptoTransform desCrypt = (ICryptoTransform)mi.Invoke(des, new object[] { key, CipherMode.ECB, iv, 0, obj });
byte[] result = desCrypt.TransformFinalBlock(data, 0, data.Length);
return(result);
}
/// <summary>
/// DES½âÃÜ
/// </summary>
/// <param name="decryptString">ÃÜÎÄ</param>
/// <param name="decryptKey">Ãܳף¨8룩</param>
/// <returns></returns>
public static byte[] DESDecrypt(byte[] byteDecrypt, byte[] byteKey)
{
if (byteKey.Length != 8)
{
throw new Exception("Key length error!");
}
byte[] result = new byte[0];
try
{
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
des.Padding = PaddingMode.None;
Type t = Type.GetType("System.Security.Cryptography.CryptoAPITransformMode");
object obj = t.GetField("Decrypt", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly).GetValue(t);
MethodInfo mi = des.GetType().GetMethod("_NewEncryptor", BindingFlags.Instance | BindingFlags.NonPublic);
ICryptoTransform desCrypt = (ICryptoTransform)mi.Invoke(des, new object[] { byteKey, CipherMode.ECB, null, 0, obj });
result = desCrypt.TransformFinalBlock(byteDecrypt, 0, byteDecrypt.Length);
}
catch (Exception ex)
{
throw ex;
}
return(result);
}
public int GenerateBlackboxOutputBit(int[] IV, int[] key, int length)
{
// public bits := plaintext
// secret bits := key
SymmetricAlgorithm p_alg = new DESCryptoServiceProvider();
string secretBits = string.Empty;
string publicBits = string.Empty;
// save public and secret bits as string
for (int i = 0; i < key.Length; i++)
{
secretBits += key[i];
}
for (int i = 0; i < IV.Length; i++)
{
publicBits += IV[i];
}
// convert secret bits to byte array
int[] arrInt = new int[8];
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
if (secretBits[(8 * i) + j] == '1')
{
arrInt[i] += (int)Math.Pow(2, 7 - j);
}
}
}
byte[] keyByte = new byte[8];
for (int i = 0; i < arrInt.Length; i++)
{
keyByte[i] = (byte)arrInt[i];
}
// convert public bits to byte array
arrInt = new int[8];
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
if (publicBits[(8 * i) + j] == '1')
{
arrInt[i] += (int)Math.Pow(2, 7 - j);
}
}
}
byte[] publicByte = new byte[8];
for (int i = 0; i < arrInt.Length; i++)
{
publicByte[i] = (byte)arrInt[i];
}
ICryptoTransform p_encryptor;
p_alg.IV = new byte[8];
p_alg.Padding = PaddingMode.Zeros;
try
{
p_alg.Key = keyByte;
}
catch
{
//dirty hack to allow weak keys:
FieldInfo field = p_alg.GetType().GetField("KeyValue", BindingFlags.NonPublic | BindingFlags.Instance);
field.SetValue(p_alg, keyByte);
}
try
{
p_encryptor = p_alg.CreateEncryptor();
}
catch
{
//dirty hack to allow weak keys:
MethodInfo mi = p_alg.GetType().GetMethod("_NewEncryptor", BindingFlags.NonPublic | BindingFlags.Instance);
object[] Par = { p_alg.Key, p_alg.Mode, p_alg.IV, p_alg.FeedbackSize, 0 };
p_encryptor = mi.Invoke(p_alg, Par) as ICryptoTransform;
}
Stream inputPublic = new MemoryStream(publicByte);
// starting encryption
CryptoStream p_crypto_stream = new CryptoStream(inputPublic, p_encryptor, CryptoStreamMode.Read);
byte[] buffer = new byte[p_alg.BlockSize / 8];
p_crypto_stream.Read(buffer, 0, buffer.Length);
// convert encrypted block to binary string
string strBytes = string.Empty;
for (int i = 0; i < buffer.Length; i++)
{
for (int j = 7; j >= 0; j--)
{
strBytes += (buffer[i] & 1 << j) > 0 ? 1 : 0;
}
}
p_crypto_stream.Flush();
// return single output bit
return(Int32.Parse(strBytes.Substring(length - 1, 1)));
}
