private void Decrypt (ICryptoTransform trans, byte[] input, byte[] output)
{
int bs = trans.InputBlockSize;
int full = input.Length / bs;
int partial = input.Length % bs;
int pos = 0;
for (int i=0; i < full; i++) {
trans.TransformBlock (input, pos, bs, output, pos);
pos += bs;
}
if (partial > 0) {
byte[] final = trans.TransformFinalBlock (input, pos, partial);
Array.Copy (final, 0, output, pos, partial);
}
}
private static void EncryptDecryptAndDispose(ICryptoTransform crypto, ICryptoTransform decrypto, byte[] data)
{
var encryptedData = crypto.TransformFinalBlock(data, 0, data.Length);
var decryptedData = decrypto.TransformFinalBlock(encryptedData, 0, encryptedData.Length);
// NOTE: no need to check if they are equal
//if (!decryptedData.AllEqual(data))
// throw new InvalidProgramException();
crypto.Dispose();
decrypto.Dispose();
}
private void InvalidInput_Base64Transform(ICryptoTransform transform)
{
byte[] data_4bytes = Text.Encoding.ASCII.GetBytes("aaaa");
Assert.Throws<ArgumentNullException>("inputBuffer", () => transform.TransformBlock(null, 0, 0, null, 0));
Assert.Throws<ArgumentOutOfRangeException>("inputOffset", () => transform.TransformBlock(Array.Empty<byte>(), -1, 0, null, 0));
Assert.Throws<ArgumentNullException>("dst", () => transform.TransformBlock(data_4bytes, 0, 4, null, 0));
Assert.Throws<ArgumentException>(null, () => transform.TransformBlock(Array.Empty<byte>(), 0, 1, null, 0));
Assert.Throws<ArgumentException>(null, () => transform.TransformBlock(Array.Empty<byte>(), 1, 0, null, 0));
Assert.Throws<ArgumentNullException>("inputBuffer", () => transform.TransformFinalBlock(null, 0, 0));
Assert.Throws<ArgumentOutOfRangeException>("inputOffset", () => transform.TransformFinalBlock(Array.Empty<byte>(), -1, 0));
Assert.Throws<ArgumentOutOfRangeException>("inputOffset", () => transform.TransformFinalBlock(Array.Empty<byte>(), -1, 0));
Assert.Throws<ArgumentException>(null, () => transform.TransformFinalBlock(Array.Empty<byte>(), 1, 0));
}
private BufferChunk SymmetricEncryption(RtpPacket packet,ICryptoTransform crypto)
{
BufferChunk payload = packet.Payload;
byte[] data = crypto.TransformFinalBlock(payload.Buffer, payload.Index, payload.Length);
return new BufferChunk(data);
}
/// <summary>
/// Decrypts the informed string
/// </summary>
/// <param name="str">The string that will be decrypted</param>
/// <returns>The decrypted string</returns>
public static string Decrypt(string str)
{
try
{
arrResult = new byte[0];
arrKey = md5.ComputeHash(utf8.GetBytes(key));
tripleDES.Key = arrKey;
tripleDES.Mode = CipherMode.ECB;
tripleDES.Padding = PaddingMode.PKCS7;
arrBytes = Convert.FromBase64String(str);
cryptoTransform = tripleDES.CreateDecryptor();
arrResult = cryptoTransform.TransformFinalBlock(arrBytes, 0, arrBytes.Length);
return utf8.GetString(arrResult);
}
catch (Exception e)
{
Console.WriteLine("Error while decrypting: " + e.Message);
return string.Empty;
}
}
/// <summary>
/// 解密数据
/// </summary>
/// <param name="text">待解密的字符串</param>
/// <param name="sKey">解密密钥</param>
/// <returns></returns>
public static string Decrypt(string text, string sKey)
{
defaultIV = "4R38WE5E";
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
des.Key = ASCIIEncoding.ASCII.GetBytes(sKey);
des.IV = ASCIIEncoding.ASCII.GetBytes(defaultIV);
des.Mode = CipherMode.ECB;
des.Padding = PaddingMode.PKCS7;
ICryptoTransform DESDecrypt = des.CreateDecryptor();
string result = string.Empty;
try
{
byte[] Buffer = Convert.FromBase64String(text);
result = ASCIIEncoding.ASCII.GetString(DESDecrypt.TransformFinalBlock(Buffer, 0, Buffer.Length));
}
catch (System.Exception ex)
{
throw ex;
}
return(result);
}
/// <summary>
/// AES256位加密
/// </summary>
/// <param name="toEncrypt"></param>
/// <returns></returns>
public static string AESEncrypt(string toEncrypt)
{
byte[] keyArray = UTF8Encoding.UTF8.GetBytes(aeskey);
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
RijndaelManaged rDel = new RijndaelManaged();
rDel.Key = keyArray;
rDel.Mode = CipherMode.ECB;
rDel.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = rDel.CreateEncryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
// return Convert.ToBase64String(resultArray, 0, resultArray.Length);
StringBuilder ret = new StringBuilder();
foreach (byte b in resultArray)
{
ret.AppendFormat("{0:X2}", b);
}
return(ret.ToString());
}
/// <summary>
/// Encrypts a string
/// </summary>
public string Encrypt(string originalString)
{
var returnValue = TypeExtension.DefaultString;
try
{
var saltedString = originalString + this.Salt;
TripleDES des = CreateDes();
ICryptoTransform encryptor = des.CreateEncryptor();
var encryptedByte = Encoding.Unicode.GetBytes(saltedString);
// Final encryption and return
returnValue = Convert.ToBase64String(encryptor.TransformFinalBlock(encryptedByte, 0, encryptedByte.Length));
if (this.EncodeForURL)
{
returnValue = UrlEncoder.Encode(returnValue);
}
}
catch
{
returnValue = TypeExtension.DefaultString;
}
return(returnValue);
}
private static void DoesNotSupportMode(CipherMode mode)
{
using (Aes aes = AesFactory.Create())
{
// One of the following should throw:
// aes.Mode = invalidMode
// aes.CreateEncryptor() (with an invalid Mode value)
// transform.Transform[Final]Block() (with an invalid Mode value)
Assert.Throws <CryptographicException>(
() =>
{
aes.Mode = mode;
// If assigning the Mode property did not fail, then it should reflect what we asked for.
Assert.Equal(mode, aes.Mode);
using (ICryptoTransform transform = aes.CreateEncryptor())
{
transform.TransformFinalBlock(Array.Empty <byte>(), 0, 0);
}
});
}
}
/// <summary>
/// 解密
/// </summary>
/// <param name="txt"></param>
/// <param name="key"></param>
/// <returns></returns>
public static string Decrypt(string txt, string key)
{
try
{
byte[] inputBuffer = Convert.FromBase64String(txt);
Rijndael rijndael = new RijndaelManaged();
MD5 md = new MD5CryptoServiceProvider();
rijndael.BlockSize = 0x80;
rijndael.KeySize = 0x80;
rijndael.Mode = CipherMode.CBC;
rijndael.Padding = PaddingMode.PKCS7;
rijndael.IV = new byte[0x10];
rijndael.Key = md.ComputeHash(Encoding.UTF8.GetBytes(key));
ICryptoTransform transform = rijndael.CreateDecryptor();
byte[] byteResult = transform.TransformFinalBlock(inputBuffer, 0, inputBuffer.Length);
return(Encoding.UTF8.GetString(byteResult));
}
catch (Exception ex)
{
var log = LogManager.GetLogger("EncryptUtils.Decrypt");
log.Error(ex);
return(string.Empty);
}
}
public string AesDecryption(string toDecrypt, string key)
{
byte[] keyArray = UTF8Encoding.UTF8.GetBytes(key);
byte[] toEncryptArray = Convert.FromBase64String(toDecrypt);
RijndaelManaged rDel = new RijndaelManaged();
rDel.Key = keyArray;
rDel.Mode = CipherMode.ECB;
rDel.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = rDel.CreateDecryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
return(UTF8Encoding.UTF8.GetString(resultArray));
}
public static string AESEncrypt(string str, string strkey, string strivKey, bool isVasEncrypt = false)
{
var aesCipher = new AesManaged
{
KeySize = 128,
BlockSize = 128,
Mode = CipherMode.CBC,
Padding = PaddingMode.PKCS7
};
var keyStr = KeyGenerator(strkey);
var key = Convert.FromBase64String(keyStr);
var ivKey = Encoding.UTF8.GetBytes(strivKey);
var input = str;
var ivStr = Convert.ToBase64String(ivKey);
aesCipher.Key = key;
aesCipher.IV = ivKey;
byte[] b = System.Text.Encoding.UTF8.GetBytes(str); // plain text to be encrypted
ICryptoTransform encryptTransform = aesCipher.CreateEncryptor();
byte[] cipherText = encryptTransform.TransformFinalBlock(b, 0, b.Length);
return(Convert.ToBase64String(cipherText));
}
// encryption with AES-128
static byte[] encryptWithAES128(string input, byte[] key, byte[] IV)
{
// convert input string to byte array
byte[] byteInput = Encoding.Default.GetBytes(input);
// create AES object from System.Security.Cryptography
RijndaelManaged aesObject = new RijndaelManaged();
// since we want to use AES-128
aesObject.KeySize = 128;
// block size of AES is 128 bits
aesObject.BlockSize = 128;
// mode -> CipherMode.*
aesObject.Mode = CipherMode.CFB;
// feedback size should be equal to block size
aesObject.FeedbackSize = 128;
// set the key
aesObject.Key = key;
// set the IV
aesObject.IV = IV;
// create an encryptor with the settings provided
ICryptoTransform encryptor = aesObject.CreateEncryptor();
byte[] result = null;
try
{
result = encryptor.TransformFinalBlock(byteInput, 0, byteInput.Length);
}
catch (Exception e) // if encryption fails
{
Console.WriteLine(e.Message); // display the cause
}
return(result);
}
public string Decrypt(string decryptText, string decryptKey = null, bool useHashing = false)
{
byte[] keyArray;
byte[] toEncryptArray = Convert.FromBase64String(decryptText);
System.Configuration.AppSettingsReader settingsReader = new AppSettingsReader();
if (string.IsNullOrEmpty(decryptKey))
{
decryptKey = (string)settingsReader.GetValue("SecurityKey", typeof(string));
}
if (useHashing)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(decryptKey));
hashmd5.Clear();
}
else
{
keyArray = UTF8Encoding.UTF8.GetBytes(decryptKey);
}
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateDecryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
tdes.Clear();
return(UTF8Encoding.UTF8.GetString(resultArray));
}
private byte[] BuildPack(CMD c, byte[] data)
{
byte[] cmd = BitConverter.GetBytes((uint)c);
byte[] src = new byte[cmd.Length + data.Length];
Array.Copy(cmd, 0, src, 0, cmd.Length);
Array.Copy(data, 0, src, cmd.Length, data.Length);
byte[] result;
try
{
ICryptoTransform cTransform = m_aes.CreateEncryptor();
result = cTransform.TransformFinalBlock(src, 0, src.Length);
}
catch (Exception e)
{
Logger.Trace(e);
return(null);
}
byte[] ret = new byte[result.Length + 4];
Array.Copy(BitConverter.GetBytes(result.Length), ret, 4);
Array.Copy(result, 0, ret, 4, result.Length);
return(ret);
}
public static string Encrypt256(string text)
{
// AesCryptoServiceProvider
AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
aes.BlockSize = 128;
aes.KeySize = 256;
aes.IV = Encoding.UTF8.GetBytes(AesIV256);
aes.Key = Encoding.UTF8.GetBytes(AesKey256);
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.PKCS7;
// Convert string to byte array
byte[] src = Encoding.Unicode.GetBytes(text);
// encryption
using (ICryptoTransform encrypt = aes.CreateEncryptor())
{
byte[] dest = encrypt.TransformFinalBlock(src, 0, src.Length);
// Convert byte array to Base64 strings
return(Convert.ToBase64String(dest));
}
}
/// <summary>
/// DeCrypt a string using dual encryption method. Return a DeCrypted clear string
/// </summary>
/// <param name="cipherString">encrypted string</param>
/// <param name="useHashing">Did you use hashing to encrypt this data? pass true is yes</param>
/// <returns></returns>
public static string Decrypt(string cipherString, bool useHashing)
{
byte[] keyArray;
cipherString = cipherString.Replace(" ", "+");
byte[] toEncryptArray = Convert.FromBase64String(cipherString);
System.Configuration.AppSettingsReader settingsReader = new AppSettingsReader();
//Get your key from config file to open the lock!
string key = "kj@18231";
//string key = (string)settingsReader.GetValue("SecurityKey", typeof(String));
if (useHashing)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
hashmd5.Clear();
}
else
{
keyArray = UTF8Encoding.UTF8.GetBytes(key);
}
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateDecryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
tdes.Clear();
return(UTF8Encoding.UTF8.GetString(resultArray));
}
// encrypt or decrypt a string
// for encrypt type=true
// for decrypt type=false
public string EncryptOrDecrypt(bool type, string plainStr)
{
RijndaelManaged aesEncryption = new RijndaelManaged();
aesEncryption.KeySize = 256;
aesEncryption.BlockSize = 128;
aesEncryption.Mode = CipherMode.CBC;
aesEncryption.Padding = PaddingMode.PKCS7;
aesEncryption.IV = ASCIIEncoding.UTF8.GetBytes("0123456789012345");
aesEncryption.Key = md5(this.CIPHER_KEY);
if (type)
{
ICryptoTransform crypto = aesEncryption.CreateEncryptor();
byte[] plainText = ASCIIEncoding.UTF8.GetBytes(plainStr);
byte[] cipherText = crypto.TransformFinalBlock(plainText, 0, plainText.Length);
return(Convert.ToBase64String(cipherText));
}
else
{
ICryptoTransform decrypto = aesEncryption.CreateDecryptor();
byte[] encryptedBytes = Convert.FromBase64CharArray(plainStr.ToCharArray(), 0, plainStr.Length);
return(ASCIIEncoding.UTF8.GetString(decrypto.TransformFinalBlock(encryptedBytes, 0, encryptedBytes.Length)));
}
}
//AES-256 Encrypt
private string Encrypt256(string text, string key, string IV)
{
// AesCryptoServiceProvider
AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
aes.BlockSize = 128;
aes.KeySize = 256;
aes.Key = Encoding.ASCII.GetBytes(key);
aes.IV = Encoding.ASCII.GetBytes(IV);
aes.Mode = CipherMode.ECB;
aes.Padding = PaddingMode.None;
// Convert string to byte array
byte[] src = Encoding.Default.GetBytes(text);
// encryption
using (ICryptoTransform encrypt = aes.CreateEncryptor(aes.Key, aes.IV))
{
byte[] dest = encrypt.TransformFinalBlock(src, 0, src.Length);
// Convert byte array to Base64 strings
return(Convert.ToBase64String(dest));
}
}
/// <summary>
/// AES加密 EBC PKCS7 HEX UTF8 加密
/// </summary>
/// <param name="text">明文字符串</param>
/// <param name="key">秘钥</param>
/// <returns>密文</returns>
public static string AesStr_EPHU(string text, string key, string iv = null)
{
RijndaelManaged rijndaelCipher = new RijndaelManaged();
rijndaelCipher.Mode = CipherMode.ECB;
rijndaelCipher.Padding = PaddingMode.PKCS7;
rijndaelCipher.KeySize = 128;
rijndaelCipher.BlockSize = 128;
byte[] pwdBytes = System.Text.Encoding.UTF8.GetBytes(key);
byte[] keyBytes = new byte[16];
int len = pwdBytes.Length;
if (len > keyBytes.Length)
len = keyBytes.Length;
System.Array.Copy(pwdBytes, keyBytes, len);
rijndaelCipher.Key = keyBytes;
if (!string.IsNullOrEmpty(iv))
{
byte[] ivBytes = System.Text.Encoding.UTF8.GetBytes(iv);
rijndaelCipher.IV = ivBytes;
}
ICryptoTransform transform = rijndaelCipher.CreateEncryptor();
byte[] plainText = Encoding.UTF8.GetBytes(text);
byte[] cipherBytes = transform.TransformFinalBlock(plainText, 0, plainText.Length);
return ToHexString(cipherBytes);
}
public static string AesDecryptHex(string text, string key)
{
try
{
using (RijndaelManaged rm = new RijndaelManaged())
{
rm.Key = Encoding.UTF8.GetBytes(key);
rm.Mode = CipherMode.ECB;
rm.Padding = PaddingMode.PKCS7;
using (ICryptoTransform cTransform = rm.CreateDecryptor())
{
byte[] bytes = ConvertUtil.HexStringToBytes(text);
byte[] results = cTransform.TransformFinalBlock(bytes, 0, bytes.Length);
return(Encoding.UTF8.GetString(results));
}
}
}
catch
{
return(null);
}
}
public string Encrypt(string text, string password)
{
if (text == null)
{
return(null);
}
using (var aesProvider = new AesCryptoServiceProvider())
{
aesProvider.Mode = CipherMode.CBC;
aesProvider.Padding = PaddingMode.PKCS7;
var Rfc = new Rfc2898DeriveBytes(Encoding.UTF8.GetBytes(password), Encoding.UTF8.GetBytes("phi lookup request"), 1000);
byte[] bytes = Rfc.GetBytes(16);
aesProvider.IV = bytes;
aesProvider.Key = bytes;
ICryptoTransform encryptor = aesProvider.CreateEncryptor();
byte[] inputBytes = Encoding.UTF8.GetBytes(text);
byte[] outputBytes = encryptor.TransformFinalBlock(inputBytes, 0, inputBytes.Length);
return(Convert.ToBase64String(outputBytes));
}
}
/// <summary>
/// DES3
/// </summary>
/// <param name="encryptionStr"></param>
/// <param name="key"></param>
/// <returns></returns>
public string Des3Encryption(string encryptionStr, string key)
{
TripleDESCryptoServiceProvider _pTripDes = new TripleDESCryptoServiceProvider();
_pTripDes.Key = Encoding.UTF8.GetBytes(key);
_pTripDes.Mode = CipherMode.ECB;
_pTripDes.Padding = System.Security.Cryptography.PaddingMode.PKCS7;
try
{
ICryptoTransform ery = _pTripDes.CreateEncryptor();
byte[] buffer = Encoding.UTF8.GetBytes(encryptionStr);
return(Convert.ToBase64String(ery.TransformFinalBlock(buffer, 0, buffer.Length)));
}
catch
{
return(string.Empty);
}
}
public static string Decrypt(string key, string cipherString, bool useHashing = true)
{
byte[] resultArray = null;
try
{
byte[] keyArray;
byte[] toEncryptArray = Convert.FromBase64String(cipherString);
if (useHashing)
{
using (MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider())
{
keyArray = hashmd5.ComputeHash(Encoding.UTF8.GetBytes(key));
}
}
else
{
keyArray = Encoding.UTF8.GetBytes(key);
}
using (TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider())
{
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateDecryptor();
resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
}
}
catch (Exception ex)
{
LoggerHelper.Log(ex);
}
return(Encoding.UTF8.GetString(resultArray));
}
/// <summary>
/// Deobfuscate a string on UNIX.
/// </summary>
/// <param name="value">The string to deobfuscate</param>
/// <returns>The clear string</returns>
private static string UnixDeobfuscate(string value)
{
#if __MonoCS__
try
{
using (PasswordDeriveBytes pdb = new PasswordDeriveBytes(
GetCryptoKey(), new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }))
using (AesManaged myAes = new AesManaged())
{
myAes.Key = pdb.GetBytes(myAes.KeySize / 8);
myAes.IV = pdb.GetBytes(myAes.BlockSize / 8);
using (ICryptoTransform decryptor = myAes.CreateDecryptor())
{
byte[] data = Convert.FromBase64String(value);
byte[] uncrypt = decryptor.TransformFinalBlock(data, 0, data.Length);
return(System.Text.Encoding.UTF8.GetString(uncrypt));
}
}
}
catch (Exception e)
{
if (e is CryptographicException || e is FormatException || e is ArgumentException)
{
Console.WriteLine("Your password is not obfuscated yet.");
Console.WriteLine("Using unobfuscated value directly might be deprecated soon, so please delete your local directories and recreate them. Thank you for your understanding.");
return(value);
}
else
{
throw;
}
}
#else
throw new ApplicationException("Should never be reached");
#endif
}
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MensagemModel mensagemModel = db.Mensagens.Find(id);
if (mensagemModel == null)
{
return(HttpNotFound());
}
AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
aes.BlockSize = 128;
aes.KeySize = 256;
aes.IV = Encoding.UTF8.GetBytes(AesIV256BD);
aes.Key = Encoding.UTF8.GetBytes(AesKey256BD);
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.PKCS7;
string msgE = mensagemModel.Mensagem;
byte[] src = Convert.FromBase64String(mensagemModel.Mensagem);
using (ICryptoTransform decrypt = aes.CreateDecryptor())
{
byte[] dest = decrypt.TransformFinalBlock(src, 0, src.Length);
mensagemModel.Mensagem = Encoding.Unicode.GetString(dest);
}
string msgD = mensagemModel.Mensagem;
TempData["msgE"] = msgE;
TempData["msgD"] = msgD;
//return RedirectToAction(nameof(Details));
return(View());
}
/// <summary>
/// Aes解密
/// </summary>
/// <param name="source">源字符串</param>
/// <param name="key">aes密钥，长度必须32位</param>
/// <returns>解密后的字符串</returns>
public static string DecryptAes(string source, string key)
{
using (AesCryptoServiceProvider aesProvider = new AesCryptoServiceProvider())
{
aesProvider.Key = GetAesKey(key);
aesProvider.Mode = CipherMode.ECB;
aesProvider.Padding = PaddingMode.PKCS7;
using (ICryptoTransform cryptoTransform = aesProvider.CreateDecryptor())
{
try
{
byte[] inputBuffers = Convert.FromBase64String(source);
byte[] results = cryptoTransform.TransformFinalBlock(inputBuffers, 0, inputBuffers.Length);
aesProvider.Clear();
return(Encoding.UTF8.GetString(results));
}
catch (FormatException ex)
{
//throw new UserFriendlyException("密文格式错误")
throw new Exception("密文格式错误");
}
}
}
}
public static string MD5Decrypt(this string password)
{
byte[] keyArray;
//convierte el texto en una secuencia de bytes
byte[] Array_a_Descifrar =
Convert.FromBase64String(password);
//se llama a las clases que tienen los algoritmos
//de encriptación se le aplica hashing
//algoritmo MD5
MD5CryptoServiceProvider hashmd5 =
new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(
UTF8Encoding.UTF8.GetBytes(key));
hashmd5.Clear();
TripleDESCryptoServiceProvider tdes =
new TripleDESCryptoServiceProvider();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform =
tdes.CreateDecryptor();
byte[] resultArray =
cTransform.TransformFinalBlock(Array_a_Descifrar,
0, Array_a_Descifrar.Length);
tdes.Clear();
//se regresa en forma de cadena
return(UTF8Encoding.UTF8.GetString(resultArray));
}
/// <summary>
/// aes解密 2.0 由62进制解密
/// </summary>
/// <param name="toDecrypt"></param>
/// <param name="key"></param>
/// <returns></returns>
public static string AESDecrypt62(string toDecrypt, string key)
{
key = checkKeyLength(key);
byte[] keyArray = UTF8Encoding.UTF8.GetBytes(key);
// byte[] toEncryptArray = Convert.FromBase64String(toDecrypt);
int halfInputLength = toDecrypt.Length / 2;
byte[] toDecryptArray = new byte[halfInputLength];
for (int x = 0; x < halfInputLength; x++)
{
Int64 i = ConvertSixtytwoToTen(toDecrypt.Substring(x * 2, 2));
toDecryptArray[x] = (byte)i;
}
RijndaelManaged rDel = new RijndaelManaged();
rDel.Key = keyArray;
rDel.Mode = CipherMode.ECB;
rDel.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = rDel.CreateDecryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toDecryptArray, 0, toDecryptArray.Length);
return(UTF8Encoding.UTF8.GetString(resultArray));
}
/// <summary>
///
/// </summary>
/// <param name="str">f527e75a9cf89ecb23a32fa3e8b2c650</param>
/// <param name="key">16位</param>
/// <returns></returns>
public static string AesDecrypt(string str, string key)
{
if (string.IsNullOrEmpty(str))
{
return(null);
}
List <string> list = new List <string>();
for (int i = 0; i < str.Length; i = i + 2)
{
list.Add(str.Substring(i, 2));
}
string a4 = (string.Join("-", list.ToArray()));
String[] arr2 = a4.ToUpper().Split('-');
byte[] toEncryptArray = new byte[arr2.Length];
for (int i = 0; i < arr2.Length; i++)
{
toEncryptArray[i] = Convert.ToByte(arr2[i], 16);
}
//Byte[] toEncryptArray = Convert.FromBase64String(content);
RijndaelManaged rm = new RijndaelManaged
{
Key = Encoding.UTF8.GetBytes(key),
Mode = CipherMode.ECB,
Padding = PaddingMode.PKCS7
};
ICryptoTransform cTransform = rm.CreateDecryptor();
Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
return(Encoding.UTF8.GetString(resultArray));
}
public void Encriptar(string filename)
{
byte[] plano = Encoding.UTF8.GetBytes(File.ReadAllText(filename));
using (var md5 = new MD5CryptoServiceProvider())
{
byte[] code = md5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
md5.Clear();
using (var des = new TripleDESCryptoServiceProvider())
{
des.Key = code;
des.Mode = CipherMode.ECB;
des.Padding = PaddingMode.PKCS7;
using (var memo = new MemoryStream())
{
ICryptoTransform crypt = des.CreateEncryptor();
byte[] encrypt = crypt.TransformFinalBlock(plano, 0, plano.Length);
des.Clear();
File.WriteAllBytes(filename, encrypt.ToArray());
}
}
}
}
/// <summary>
/// AES Str类型 EBC PKCS7 HEX UTF8 NoIV解密
/// </summary>
/// <param name="data">待解密</param>
/// <param name="keyVal">密钥值16字节</param>
/// <returns></returns>
public static string UnAesStr_EPHU(string data, string keyVal, string iv = null)
{
RijndaelManaged rijndaelCipher = new RijndaelManaged();
rijndaelCipher.Mode = CipherMode.ECB;
rijndaelCipher.Padding = PaddingMode.PKCS7;
rijndaelCipher.KeySize = 128;
rijndaelCipher.BlockSize = 128;
byte[] encryptedData = StrToHexByte(data);
byte[] pwdBytes = Encoding.UTF8.GetBytes(keyVal);
byte[] keyBytes = new byte[16];
int len = pwdBytes.Length;
if (len > keyBytes.Length)
len = keyBytes.Length;
System.Array.Copy(pwdBytes, keyBytes, len);
rijndaelCipher.Key = keyBytes;
if (!string.IsNullOrEmpty(iv))
{
byte[] ivBytes = System.Text.Encoding.UTF8.GetBytes(iv);
rijndaelCipher.IV = ivBytes;
}
ICryptoTransform transform = rijndaelCipher.CreateDecryptor();
byte[] plainText = transform.TransformFinalBlock(encryptedData, 0, encryptedData.Length);
return Encoding.UTF8.GetString(plainText);
}
public void send(byte[] data)
{
try
{
lock (_encLock)
{
if (_secured)
{
data = _encryptor.TransformFinalBlock(data, 0, data.Length);
}
}
NetworkStream stream = _client.GetStream();
lock (stream)
_formatter.Serialize(stream, data);
if (OnDataSentEvent != null)
{
OnDataSentEvent(this, data);
}
}
catch { }
}
/// <summary>
/// 3des解密字符串
/// </summary>
/// <param name="text">要解密的字符串</param>
/// <param name="key">密钥</param>
/// <param name="encoding">编码方式</param>
/// <returns>解密后的字符串</returns>
/// <remarks>静态方法，指定编码方式</remarks>
public static string Decrypt(string text, string key, Encoding encoding)
{
TripleDESCryptoServiceProvider DES = new TripleDESCryptoServiceProvider();
MD5CryptoServiceProvider hashMD5 = new MD5CryptoServiceProvider();
DES.Key = hashMD5.ComputeHash(encoding.GetBytes(key));
DES.Mode = CipherMode.ECB;
ICryptoTransform DESDecrypt = DES.CreateDecryptor();
string result = string.Empty;
try
{
byte[] Buffer = Convert.FromBase64String(text);
result = encoding.GetString(DESDecrypt.TransformFinalBlock
(Buffer, 0, Buffer.Length));
}
catch (Exception e)
{
throw (new Exception("Invalid Key or input string is not a valid base64 string", e));
}
return(result);
}
private static byte[] Encrypt(byte[] toEncrypt, byte[] key)
{
List <byte> te = toEncrypt.ToList();
while (te.Count % 16 != 0)
{
te.Add(0x00);
}
toEncrypt = te.ToArray();
AesCryptoServiceProvider aes = CreateProvider(key);
List <byte> K = new List <byte>();
K = key.ToList();
while (K.Count < 32)
{
K.Add(0x00);
}
key = K.ToArray();
ICryptoTransform cTransform = aes.CreateEncryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toEncrypt, 0, toEncrypt.Length);
aes.Clear();
return(resultArray);
}
internal static byte[] GenericTransform(ICryptoTransform transform,
byte[] data)
{
List<byte> byteList = new List<byte>();
byte[] outputBytes;
int inputLength = data.Length;
int inputBlockSize = transform.InputBlockSize;
if (typeof(FromBase64Transform).IsInstanceOfType(transform)) {
// workaround for apparent bug where FromBase64Transform.InputBlockSize
// returns 1 when it should return 4
inputBlockSize = 4;
}
int inputOffset = 0;
outputBytes = new byte[transform.OutputBlockSize];
if (!transform.CanTransformMultipleBlocks) {
while (inputLength - inputOffset > inputBlockSize) {
transform.TransformBlock(data, inputOffset, inputBlockSize,
outputBytes, 0);
byteList.AddRange(outputBytes);
inputOffset += inputBlockSize;
}
}
outputBytes = transform.TransformFinalBlock(data, inputOffset,
inputLength - inputOffset);
byteList.AddRange(outputBytes);
byte[] result = byteList.ToArray();
ClearByteList(byteList);
return result;
}
/// <summary>
/// Encrypt message by AES with given secret key and key size.
/// </summary>
/// <param name="encryptor">A symmetric encryptor object with key and IV</param>
/// <param name="message">Message to be encrypted.</param>
/// <returns>Message has been encrypted.</returns>
private static byte[] EncrypteMessageByAes(ICryptoTransform encryptor, byte[] message)
{
byte[] encryptedMessage = new byte[16];
byte[] encryptedBytes = encryptor.TransformFinalBlock(message, 0, message.Length).ToArray();
for (int i = 0; i < 16; i++)
{
encryptedMessage[i] = encryptedBytes[i];
}
return encryptedMessage;
}
private static byte[] Encrypt(ICryptoTransform crypto, byte[] data)
{
return crypto.TransformFinalBlock(data, 0, data.Length);
}
/// <summary>
/// Does the actual work of pulling the filestreams in
/// and passing the blocks into the crytoprovider
/// </summary>
/// <param name="filenames">An array of String objects, each containing a filename</param>
/// <param name="cryptoInterface">An <see cref="ICryptoTransform"/> interface pointing to a cryptoprovider</param>
/// <param name="blockSize">Size in bytes of the transform block / read buffer</param>
protected void ComputeHashes(String[] filenames, ICryptoTransform cryptoInterface, int blockSize)
{
for (int loop = 0; loop <= filenames.GetUpperBound(0); loop++)
{
using (FileStream inputFile = new FileStream(filenames[loop], FileMode.Open, FileAccess.Read))
{
byte[] readBuffer = new byte[(int)blockSize];
byte[] copyBuffer;
long fileLength = inputFile.Length;
int bytesRead = 0;
long totalBytesRead = 0;
while (totalBytesRead < fileLength)
{
bytesRead = inputFile.Read(readBuffer, 0, (int)blockSize);
if (bytesRead == blockSize) { copyBuffer = readBuffer; }
else
{
copyBuffer = new byte[bytesRead];
Array.Copy(readBuffer, copyBuffer, bytesRead);
}
totalBytesRead += bytesRead;
if (totalBytesRead == fileLength && loop == filenames.GetUpperBound(0))
{
// Last block of the last file
cryptoInterface.TransformFinalBlock(copyBuffer, 0, copyBuffer.Length);
}
else
{
cryptoInterface.TransformBlock(copyBuffer, 0, copyBuffer.Length, copyBuffer, 0);
}
// Report progress and
// check for cancellation request
OnHashBlockProcessed(new HasherEventArgs(HasherEventReportType.ProgressReport,
filenames.Length,
loop + 1,
totalBytesRead,
fileLength));
if (this.cancelRequested == true)
{
throw new OperationCanceledException();
}
}
}
}
// Report hash computed
OnHashComputed(new HasherEventArgs(HasherEventReportType.Completed, null, null, null, null));
}
private unsafe byte[] Encrypt2(UnmanagedArray<byte> bytes, ICryptoTransform transform)
{
byte[] managedBytes = new byte[bytes.Length];
fixed (byte* dummy = managedBytes)
{
try
{
SecurityUtil.UnmanagedBytesToManagedBytes(bytes, managedBytes);
byte[] rv = transform.TransformFinalBlock(managedBytes, 0, managedBytes.Length);
return rv;
}
finally
{
SecurityUtil.Clear(managedBytes);
}
}
}
private unsafe UnmanagedArray<byte> Decrypt2(byte[] bytes, ICryptoTransform transform)
{
byte[] managedBytes = transform.TransformFinalBlock(bytes, 0, bytes.Length);
//pin it ASAP. this is a small race condition that is unavoidable due
//to the way the crypto API's return byte[].
fixed (byte* dummy = managedBytes)
{
try
{
UnmanagedByteArray rv = new UnmanagedByteArray(managedBytes.Length);
for (int i = 0; i < rv.Length; i++)
{
rv[i] = managedBytes[i];
}
return rv;
}
finally
{
SecurityUtil.Clear(managedBytes);
}
}
}
public string AesDecrypt(ICryptoTransform decrypter, string encryptedString)
{
var inBytes = Convert.FromBase64String(encryptedString);
byte[] outBlock = decrypter.TransformFinalBlock(inBytes, 0, inBytes.Length);
return Encoding.Unicode.GetString(outBlock);
}
public string AesEncrypt(ICryptoTransform encryptor, string plainText)
{
byte[] inBlock = Encoding.Unicode.GetBytes(plainText);
byte[] outBlock = encryptor.TransformFinalBlock(inBlock, 0, inBlock.Length);
return Convert.ToBase64String(outBlock);
}
public static byte[] Encrypt(ICryptoTransform transform, byte[] buffer)
{
return transform.TransformFinalBlock(buffer, 0, buffer.Length);
}
public static GStruct2 smethod_4(ICryptoTransform icryptoTransform_1, byte[] byte_0)
{
GStruct2 result;
byte_0 = icryptoTransform_1.TransformFinalBlock(byte_0, 0, byte_0.Length);
MemoryStream memoryStream_0 = new MemoryStream(byte_0);
BinaryReader binaryReader_0 = new BinaryReader(memoryStream_0);
if (binaryReader_0.ReadBoolean())
{
int num = binaryReader_0.ReadInt32();
DeflateStream deflateStream = new DeflateStream(memoryStream_0, CompressionMode.Decompress, false);
byte[] array = new byte[num - 1 + 1];
deflateStream.Read(array, 0, array.Length);
deflateStream.Close();
memoryStream_0 = new MemoryStream(array);
binaryReader_0 = new BinaryReader(memoryStream_0);
}
GStruct2 gStruct = default(GStruct2);
gStruct.byte_0 = binaryReader_0.ReadByte();
gStruct.byte_1 = binaryReader_0.ReadByte();
List<object> list_0 = new List<object>();
if (binaryReader_0.ReadBoolean())
{
gStruct.guid_0 = new Guid(binaryReader_0.ReadBytes(16));
}
while (memoryStream_0.Position != memoryStream_0.Length)
{
switch (binaryReader_0.ReadByte())
{
case 0:
list_0.Add(binaryReader_0.ReadBoolean());
break;
case 1:
list_0.Add(binaryReader_0.ReadByte());
break;
case 2:
list_0.Add(binaryReader_0.ReadBytes(binaryReader_0.ReadInt32()));
break;
case 3:
list_0.Add(binaryReader_0.ReadChar());
break;
case 4:
list_0.Add(binaryReader_0.ReadString().ToCharArray());
break;
case 5:
list_0.Add(binaryReader_0.ReadDecimal());
break;
case 6:
list_0.Add(binaryReader_0.ReadDouble());
break;
case 7:
list_0.Add(binaryReader_0.ReadInt32());
break;
case 8:
list_0.Add(binaryReader_0.ReadInt64());
break;
case 9:
list_0.Add(binaryReader_0.ReadSByte());
break;
case 10:
list_0.Add(binaryReader_0.ReadInt16());
break;
case 11:
list_0.Add(binaryReader_0.ReadSingle());
break;
case 12:
list_0.Add(binaryReader_0.ReadString());
break;
case 13:
list_0.Add(binaryReader_0.ReadUInt32());
break;
case 14:
list_0.Add(binaryReader_0.ReadUInt64());
break;
case 15:
list_0.Add(binaryReader_0.ReadUInt16());
break;
case 16:
list_0.Add(DateTime.FromBinary(binaryReader_0.ReadInt64()));
break;
case 17:
{
string[] array2 = new string[binaryReader_0.ReadInt32() - 1 + 1];
int arg_381_0 = 0;
int num2 = array2.Length - 1;
for (int i = arg_381_0; i <= num2; i++)
{
array2[i] = binaryReader_0.ReadString();
}
list_0.Add(array2);
break;
}
case 18:
{
List<object> arg_3D0_0 = list_0;
Guid guid = new Guid(binaryReader_0.ReadBytes(16));
arg_3D0_0.Add(guid);
break;
}
case 19:
{
List<object> arg_401_0 = list_0;
Size size = new Size(binaryReader_0.ReadInt32(), binaryReader_0.ReadInt32());
arg_401_0.Add(size);
break;
}
case 20:
{
List<object> arg_443_0 = list_0;
Rectangle rectangle = new Rectangle(binaryReader_0.ReadInt32(), binaryReader_0.ReadInt32(), binaryReader_0.ReadInt32(), binaryReader_0.ReadInt32());
arg_443_0.Add(rectangle);
break;
}
case 21:
list_0.Add(new Version(binaryReader_0.ReadString()));
break;
}
}
gStruct.object_0 = list_0.ToArray();
result = gStruct;
list_0.Clear();
binaryReader_0.Close();
return result;
}
internal static void AssertTransformsEqual(byte[] plainTextBytes, ICryptoTransform decryptor, byte[] encryptedBytes)
{
byte[] decrypted = decryptor.TransformFinalBlock(encryptedBytes, 0, encryptedBytes.Length);
Assert.Equal(plainTextBytes, decrypted);
}
private static byte[] TransformRecordBytes(BulkCipherAlgorithmType cipherType, ICryptoTransform transform, byte[] input)
{
if (cipherType != BulkCipherAlgorithmType.AEAD) {
// In case of non-AEAD cipher algorithm, check that data matches block size
if (input.Length % transform.InputBlockSize != 0) {
throw new Exception("Input data size doesn't match block size");
}
}
int blockCount = input.Length / transform.InputBlockSize;
if (cipherType == BulkCipherAlgorithmType.AEAD) {
// Make sure there is enough data at TransformFinalBlock, because
// decryption requires that the authentication tag is present
if (blockCount > 0) {
blockCount--;
}
}
byte[] output = new byte[blockCount * transform.OutputBlockSize];
if (transform.CanTransformMultipleBlocks) {
transform.TransformBlock(input, 0, blockCount*transform.InputBlockSize, output, 0);
} else {
for (int i=0; i<blockCount; i++) {
transform.TransformBlock(input, i*transform.InputBlockSize,
transform.InputBlockSize,
output, i*transform.OutputBlockSize);
}
}
if (cipherType == BulkCipherAlgorithmType.AEAD) {
int currentPosition = blockCount*transform.InputBlockSize;
// Transfer the last block when encrypting or authentication tag when decrypting
byte[] finalBytes = transform.TransformFinalBlock(input, currentPosition, input.Length-currentPosition);
if (finalBytes == null) {
return null;
} else if (finalBytes.Length > 0) {
byte[] finalOutput = new byte[output.Length + finalBytes.Length];
Buffer.BlockCopy(output, 0, finalOutput, 0, output.Length);
Buffer.BlockCopy(finalBytes, 0, finalOutput, output.Length, finalBytes.Length);
output = finalOutput;
}
}
return output;
}
private static bool TestKeyDecryption(ICryptoTransform desEngine, byte[] r, int keyOffset, int hashOffset)
{
var testKey = desEngine.TransformFinalBlock(r.Copy(keyOffset, 8), 0, 8);
var testHash = r.Copy(hashOffset, 20);
return SHA1.Create().ComputeHash(testKey).IsEqualTo(testHash);
}
