private byte[] DecryptManaged(byte[] Key, byte[] Vector, byte[] Data, PaddingMode Padding = PaddingMode.Zeros)
{
byte[] decryptedBytes;
int count = 0;
using (MemoryStream stream = new MemoryStream(Data))
{
using (RijndaelManaged cipher = new RijndaelManaged())
{
cipher.Mode = CipherMode.CBC;
cipher.Padding = Padding;
cipher.KeySize = Key.Length * 8;
cipher.BlockSize = Vector.Length * 8;
using (ICryptoTransform decryptor = cipher.CreateDecryptor(Key, Vector))
{
using (CryptoStream reader = new CryptoStream(stream, decryptor, CryptoStreamMode.Read))
{
decryptedBytes = new byte[stream.Length];
count = reader.Read(decryptedBytes, 0, decryptedBytes.Length);
}
}
cipher.Clear();
}
}
return decryptedBytes;
}
/// <summary>
/// AES解密(无向量)
/// </summary>
/// <param name="encryptedBytes">被加密的明文</param>
/// <param name="key">密钥</param>
/// <returns>明文</returns>
public static string AESDecryptWithoutVector(String Data, String Key)
{
Byte[] encryptedBytes = Convert.FromBase64String(Data);
Byte[] bKey = new Byte[32];
Array.Copy(Encoding.UTF8.GetBytes(Key.PadRight(bKey.Length)), bKey, bKey.Length);
MemoryStream mStream = new MemoryStream(encryptedBytes);
//mStream.Write( encryptedBytes, 0, encryptedBytes.Length );
//mStream.Seek( 0, SeekOrigin.Begin );
RijndaelManaged aes = new RijndaelManaged();
aes.Mode = CipherMode.ECB;
aes.Padding = PaddingMode.PKCS7;
aes.KeySize = 128;
aes.Key = bKey;
//aes.IV = _iV;
CryptoStream cryptoStream = new CryptoStream(mStream, aes.CreateDecryptor(), CryptoStreamMode.Read);
try
{
byte[] tmp = new byte[encryptedBytes.Length + 32];
int len = cryptoStream.Read(tmp, 0, encryptedBytes.Length + 32);
byte[] ret = new byte[len];
Array.Copy(tmp, 0, ret, 0, len);
return Encoding.UTF8.GetString(ret);
}
finally
{
cryptoStream.Close();
mStream.Close();
aes.Clear();
}
}
public static string Descriptografar(string codigo)
{
try
{
if (string.IsNullOrEmpty(codigo))
return String.Empty;
string retorno;
var chave = new Rfc2898DeriveBytes(Segredo, Complemento);
var algoritimo = new RijndaelManaged();
algoritimo.Key = chave.GetBytes(algoritimo.KeySize / 8);
algoritimo.IV = chave.GetBytes(algoritimo.BlockSize / 8);
var descriptografor = algoritimo.CreateDecryptor(algoritimo.Key, algoritimo.IV);
var bytes = Convert.FromBase64String(codigo);
using (var memoryStream = new MemoryStream(bytes))
using (var cryptoStream = new CryptoStream(memoryStream, descriptografor, CryptoStreamMode.Read))
using (var streamReader = new StreamReader(cryptoStream))
retorno = streamReader.ReadToEnd();
algoritimo.Clear();
return retorno;
}
catch (Exception)
{
return "DEU PAU";
}
}
private static String encrypt (Dictionary<String, String> data, String api_key)
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
String json_data = serializer.Serialize(data);
String iv = api_key.Substring(16, 16);
api_key = api_key.Substring(0, 16);
byte[] data_bytes = Encoding.UTF8.GetBytes(json_data);
byte[] api_bytes = Encoding.ASCII.GetBytes(api_key);
byte[] iv_bytes = Encoding.ASCII.GetBytes(iv);
RijndaelManaged AES = new RijndaelManaged();
AES.Padding = PaddingMode.PKCS7;
AES.Mode = CipherMode.CBC;
AES.BlockSize = 128;
AES.KeySize = 128;
MemoryStream memStream = new MemoryStream();
CryptoStream cryptoStream = new CryptoStream(memStream, AES.CreateEncryptor(api_bytes, iv_bytes), CryptoStreamMode.Write);
cryptoStream.Write(data_bytes, 0, data_bytes.Length);
cryptoStream.FlushFinalBlock();
byte[] encryptedMessageBytes = new byte[memStream.Length];
memStream.Position = 0;
memStream.Read(encryptedMessageBytes, 0, encryptedMessageBytes.Length);
string encryptedMessage = System.Convert.ToBase64String(encryptedMessageBytes);
return HttpUtility.UrlEncode(encryptedMessage);
}
// Methods
public EncryptionHelper()
{
RijndaelManaged managed = new RijndaelManaged();
this.EncryptorTransform = managed.CreateEncryptor(this.Key, this.Vector);
this.DecryptorTransform = managed.CreateDecryptor(this.Key, this.Vector);
this.UTFEncoder = new UTF8Encoding();
}
/// <summary>
/// Encrypts a string
/// </summary>
/// <param name="plaintext">Text to be encrypted</param>
/// <param name="password">Password to encrypt with</param>
/// <param name="salt">Salt to encrypt with</param>
/// <returns>An encrypted string</returns>
public static string Encrypt(string plaintext, string password, string salt)
{
string Result = "";
PasswordDeriveBytes DerivedPassword = new PasswordDeriveBytes(Encoding.ASCII.GetBytes(password), Encoding.ASCII.GetBytes(salt), "SHA512", 12345);
using (RijndaelManaged SymmetricKey = new RijndaelManaged())
{
SymmetricKey.Mode = CipherMode.CBC;
using (ICryptoTransform Encryptor = SymmetricKey.CreateEncryptor(DerivedPassword.GetBytes(32), DerivedPassword.GetBytes(16)))
{
using (MemoryStream MemStream = new MemoryStream())
{
using (CryptoStream CryptoStream = new CryptoStream(MemStream, Encryptor, CryptoStreamMode.Write))
{
byte[] PlainTextBytes = Encoding.ASCII.GetBytes(plaintext);
CryptoStream.Write(PlainTextBytes, 0, PlainTextBytes.Length);
CryptoStream.FlushFinalBlock();
Result = Convert.ToBase64String(MemStream.ToArray());
}
}
}
}
return Result;
}
public AesEncryption(byte[] Key, byte[] Vector)
{
RijndaelManaged rijndaelManaged = new RijndaelManaged();
this.EncryptorTransform = rijndaelManaged.CreateEncryptor(Key, Vector);
this.DecryptorTransform = rijndaelManaged.CreateDecryptor(Key, Vector);
this.UTFEncoder = new UTF8Encoding();
}
public static string Criptografar(string texto)
{
if(string.IsNullOrEmpty(texto))
return String.Empty;
string outStr;
RijndaelManaged aesAlg = null;
try
{
var key = new Rfc2898DeriveBytes(Segredo, Complemento);
aesAlg = new RijndaelManaged();
aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8);
aesAlg.IV = key.GetBytes(aesAlg.BlockSize / 8);
var encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
using (var msEncrypt = new MemoryStream())
{
using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (var swEncrypt = new StreamWriter(csEncrypt))
{
swEncrypt.Write(texto);
}
}
outStr = Convert.ToBase64String(msEncrypt.ToArray());
}
}
finally
{
if (aesAlg != null)
aesAlg.Clear();
}
return outStr;
}
public byte[] AES_Encrypt(byte[] bytesToBeEncrypted, byte[] passwordBytes)
{
byte[] encryptedBytes = null;
// Set your salt here, change it to meet your flavor:
// The salt bytes must be at least 8 bytes.
byte[] saltBytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
using (MemoryStream ms = new MemoryStream())
{
using (RijndaelManaged AES = new RijndaelManaged())
{
AES.KeySize = 256;
AES.BlockSize = 128;
var key = new Rfc2898DeriveBytes(passwordBytes, saltBytes, 1000);
AES.Key = key.GetBytes(AES.KeySize / 8);
AES.IV = key.GetBytes(AES.BlockSize / 8);
AES.Mode = CipherMode.CBC;
using (var cs = new CryptoStream(ms, AES.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(bytesToBeEncrypted, 0, bytesToBeEncrypted.Length);
cs.Close();
}
encryptedBytes = ms.ToArray();
}
}
return encryptedBytes;
}
public static void DecryptFile(string strKey, string pathCypheredTextFile, string pathPlainTextFile)
{
// Place la clé de déchiffrement dans un tableau d'octets
byte[] key = GenerateAlgotihmInputs(strKey);
// Place le vecteur d'initialisation dans un tableau d'octets
byte[] iv = GenerateAlgotihmInputs(strKey);
// Filestream of the new file that will be decrypted.
Directory.CreateDirectory(Directory.GetParent(pathPlainTextFile).FullName);
FileStream fsCrypt = new FileStream(pathPlainTextFile, FileMode.Create);
RijndaelManaged rijndael = new RijndaelManaged();
rijndael.Mode = CipherMode.CBC;
rijndael.Key = key;
rijndael.IV = iv;
ICryptoTransform aesDecryptor = rijndael.CreateDecryptor();
CryptoStream cs = new CryptoStream(fsCrypt, aesDecryptor, CryptoStreamMode.Write);
// FileStream of the file that is currently encrypted.
FileStream fsIn = new FileStream(pathCypheredTextFile, FileMode.OpenOrCreate);
int data;
while ((data = fsIn.ReadByte()) != -1)
cs.WriteByte((byte)data);
cs.Close();
fsIn.Close();
fsCrypt.Close();
}
public static string Encrypt(string plainText, string passPhrase)
{
// Salt and IV is randomly generated each time, but is preprended to encrypted cipher text
// so that the same Salt and IV values can be used when decrypting.
var saltStringBytes = Generate256BitsOfRandomEntropy();
var ivStringBytes = Generate256BitsOfRandomEntropy();
var plainTextBytes = Encoding.UTF8.GetBytes(plainText);
var password = new Rfc2898DeriveBytes(passPhrase, saltStringBytes, DerivationIterations);
var keyBytes = password.GetBytes(Keysize / 8);
using (var symmetricKey = new RijndaelManaged())
{
symmetricKey.BlockSize = 256;
symmetricKey.Mode = CipherMode.CBC;
symmetricKey.Padding = PaddingMode.PKCS7;
using (var encryptor = symmetricKey.CreateEncryptor(keyBytes, ivStringBytes))
{
using (var memoryStream = new MemoryStream())
{
using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
{
cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
cryptoStream.FlushFinalBlock();
// Create the final bytes as a concatenation of the random salt bytes, the random iv bytes and the cipher bytes.
var cipherTextBytes = saltStringBytes;
cipherTextBytes = cipherTextBytes.Concat(ivStringBytes).ToArray();
cipherTextBytes = cipherTextBytes.Concat(memoryStream.ToArray()).ToArray();
memoryStream.Close();
cryptoStream.Close();
return Convert.ToBase64String(cipherTextBytes);
}
}
}
}
}
public static string EncryptString(
string plainText,
string passPhrase,
string saltValue,
int passwordIterations,
string initVector,
int keySize)
{
byte[] initVectorBytes = initVector == null ? new byte[16] : Encoding.ASCII.GetBytes(initVector);
byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
byte[] keyBytes = GetKeyBytes(passPhrase, saltValue, passwordIterations, keySize);
RijndaelManaged symmetricKey = new RijndaelManaged();
symmetricKey.Mode = CipherMode.CBC;
ICryptoTransform encryptor = symmetricKey.CreateEncryptor(keyBytes, initVectorBytes);
byte[] cipherTextBytes;
using (MemoryStream memoryStream = new MemoryStream())
{
using (CryptoStream cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
{
cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
cryptoStream.FlushFinalBlock();
cipherTextBytes = memoryStream.ToArray();
}
}
string cipherText = Convert.ToBase64String(cipherTextBytes);
return cipherText;
}
protected static string DecryptString(string InputText, string Password)
{
try
{
RijndaelManaged RijndaelCipher = new RijndaelManaged();
byte[] EncryptedData = Convert.FromBase64String(InputText);
byte[] Salt = Encoding.ASCII.GetBytes(Password.Length.ToString());
PasswordDeriveBytes SecretKey = new PasswordDeriveBytes(Password, Salt);
// Create a decryptor from the existing SecretKey bytes.
ICryptoTransform Decryptor = RijndaelCipher.CreateDecryptor(SecretKey.GetBytes(16), SecretKey.GetBytes(16));
MemoryStream memoryStream = new MemoryStream(EncryptedData);
// Create a CryptoStream. (always use Read mode for decryption).
CryptoStream cryptoStream = new CryptoStream(memoryStream, Decryptor, CryptoStreamMode.Read);
// Since at this point we don't know what the size of decrypted data
// will be, allocate the buffer long enough to hold EncryptedData;
// DecryptedData is never longer than EncryptedData.
byte[] PlainText = new byte[EncryptedData.Length];
// Start decrypting.
int DecryptedCount = cryptoStream.Read(PlainText, 0, PlainText.Length);
memoryStream.Close();
cryptoStream.Close();
// Convert decrypted data into a string.
string DecryptedData = Encoding.Unicode.GetString(PlainText, 0, DecryptedCount);
// Return decrypted string.
return DecryptedData;
}
catch (Exception exception)
{
return (exception.Message);
}
}
/// <summary>
/// Decrypts the specified data using a 128-bit cipher. The key can be any length.
/// </summary>
/// <param name="Data">The data to be decrypted.</param>
/// <param name="Key">The key used to decrypt the data.</param>
/// <returns>A string containing the decoded data.</returns>
public static byte[] Decrypt128Byte(byte[] Data, byte[] Key)
{
RijndaelManaged AES = null;
var MS = new MemoryStream(Data);
CryptoStream CS = null;
StreamReader DS = null;
try
{
//Get the IV and length corrected Key.
KeyData KeyData = GenerateKeyIV128(Key);
//Create the AES crytpograhy object.
AES = new RijndaelManaged { BlockSize = 128, KeySize = 128, Key = KeyData.Key, IV = KeyData.IV, Mode = CipherMode.CBC, Padding = PaddingMode.PKCS7 };
CS = new CryptoStream(MS, AES.CreateDecryptor(), CryptoStreamMode.Read);
DS = new StreamReader(CS);
var D = new byte[CS.Length];
CS.Read(D, 0, (int)CS.Length - 1);
return D;
}
finally
{
if (AES != null) AES.Clear();
MS.Dispose();
if (CS != null) CS.Dispose();
if (DS != null) DS.Dispose();
}
}
/// -------------- Two Utility Methods (not used but may be useful) -----------
/// Generates an encryption key.
public static byte[] GenerateEncryptionKey()
{
//Generate a Key.
RijndaelManaged rm = new RijndaelManaged();
rm.GenerateKey();
return rm.Key;
}
/// <summary>
/// AES解密
/// </summary>
/// <param name="text"></param>
/// <param name="password"></param>
/// <param name="iv"></param>
/// <returns></returns>
public static string AESDecrypt(string text, string password, string iv)
{
var rijndaelCipher = new RijndaelManaged
{
Mode = CipherMode.CBC,
Padding = PaddingMode.PKCS7,
KeySize = 128,
BlockSize = 128
};
var encryptedData = Convert.FromBase64String(text);
var pwdBytes = System.Text.Encoding.UTF8.GetBytes(password);
var keyBytes = new byte[24];
var len = pwdBytes.Length;
if (len > keyBytes.Length) len = keyBytes.Length;
System.Array.Copy(pwdBytes, keyBytes, len);
rijndaelCipher.Key = keyBytes;
var ivBytes = System.Text.Encoding.UTF8.GetBytes(iv);
rijndaelCipher.IV = ivBytes;
var transform = rijndaelCipher.CreateDecryptor();
var plainText = transform.TransformFinalBlock(encryptedData, 0, encryptedData.Length);
return Encoding.UTF8.GetString(plainText);
}
public static string DecryptString(String cipherText, string Key)
{
byte[] tmpCipherText = Convert.FromBase64String(cipherText);
byte[] tmpKey = GenerateAlgotihmInputs(Key);
using (RijndaelManaged alg = new RijndaelManaged())
{
alg.Key = tmpKey;
alg.IV = tmpKey;
// Create a decrytor to perform the stream transform.
ICryptoTransform decryptor = alg.CreateDecryptor(alg.Key, alg.IV);
// Create the streams used for decryption.
using (MemoryStream msDecrypt = new MemoryStream(tmpCipherText))
{
using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
{
// Place les données déchiffrées dans un tableau d'octet
byte[] plainTextData = new byte[tmpCipherText.Length];
int decryptedByteCount = csDecrypt.Read(plainTextData, 0, plainTextData.Length);
return Encoding.UTF8.GetString(plainTextData, 0, decryptedByteCount);
}
}
}
}
public static string Encrypt(string plainText, string passPhrase)
{
byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
using (PasswordDeriveBytes password = new PasswordDeriveBytes(passPhrase, null))
{
byte[] keyBytes = password.GetBytes(keysize / 8);
using (RijndaelManaged symmetricKey = new RijndaelManaged())
{
symmetricKey.Mode = CipherMode.CBC;
using (ICryptoTransform encryptor = symmetricKey.CreateEncryptor(keyBytes, initVectorBytes))
{
using (MemoryStream memoryStream = new MemoryStream())
{
using (CryptoStream cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
{
cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
cryptoStream.FlushFinalBlock();
byte[] cipherTextBytes = memoryStream.ToArray();
return Convert.ToBase64String(cipherTextBytes);
}
}
}
}
}
}
public static string Decrypt(string cipherText, string passPhrase)
{
// Get the complete stream of bytes that represent:
// [32 bytes of Salt] + [32 bytes of IV] + [n bytes of CipherText]
var cipherTextBytesWithSaltAndIv = Convert.FromBase64String(cipherText);
// Get the saltbytes by extracting the first 32 bytes from the supplied cipherText bytes.
var saltStringBytes = cipherTextBytesWithSaltAndIv.Take(Keysize / 8).ToArray();
// Get the IV bytes by extracting the next 32 bytes from the supplied cipherText bytes.
var ivStringBytes = cipherTextBytesWithSaltAndIv.Skip(Keysize / 8).Take(Keysize / 8).ToArray();
// Get the actual cipher text bytes by removing the first 64 bytes from the cipherText string.
var cipherTextBytes = cipherTextBytesWithSaltAndIv.Skip((Keysize / 8) * 2).Take(cipherTextBytesWithSaltAndIv.Length - ((Keysize / 8) * 2)).ToArray();
var password = new Rfc2898DeriveBytes(passPhrase, saltStringBytes, DerivationIterations);
var keyBytes = password.GetBytes(Keysize / 8);
using (var symmetricKey = new RijndaelManaged())
{
symmetricKey.BlockSize = 256;
symmetricKey.Mode = CipherMode.CBC;
symmetricKey.Padding = PaddingMode.PKCS7;
using (var decryptor = symmetricKey.CreateDecryptor(keyBytes, ivStringBytes))
{
using (var memoryStream = new MemoryStream(cipherTextBytes))
{
using (var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
{
var plainTextBytes = new byte[cipherTextBytes.Length];
var decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);
memoryStream.Close();
cryptoStream.Close();
return Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount);
}
}
}
}
}
/// <summary>
/// Finishes the Writing Process
/// </summary>
public void Finish()
{
if (encrypt)
{
byte[] plainText = Encoding.UTF8.GetBytes(EFile);
byte[] cryptText;
RijndaelManaged rm = new RijndaelManaged(){ Padding = PaddingMode.Zeros };
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, rm.CreateEncryptor(Key, Key ), CryptoStreamMode.Write)){
cs.Write(plainText, 0, plainText.Length);
cs.FlushFinalBlock();
cryptText = ms.ToArray();
cs.Close();
}
ms.Close();
}
sw.Write(Convert.ToBase64String(cryptText));
}
}
byte[] EncryptKeyForArchival(byte[] keyToExport, string passphrase, byte[] salt)
{
RijndaelManaged archivalEncryptionAlgorithm = new RijndaelManaged();
byte[] rgbKey = this.GenerateArchivalKey(archivalEncryptionAlgorithm, passphrase, salt);
byte[] rgbIV = new byte[archivalEncryptionAlgorithm.BlockSize / 8];
return CryptographyUtility.Transform(archivalEncryptionAlgorithm.CreateEncryptor(rgbKey, rgbIV), keyToExport);
}
public string Decrypt(string strEncryptedText)
{
if (strEncryptedText == null || strEncryptedText.Equals(""))
return strEncryptedText;
string strDecryptedText = null;
RijndaelManaged rijndael = new RijndaelManaged();
ICryptoTransform decryptor = rijndael.CreateDecryptor(Key, IV);
byte[] byteEncryptedText = Convert.FromBase64String(strEncryptedText);
MemoryStream memStream = new MemoryStream(byteEncryptedText);
CryptoStream decryptStream = null;
try
{
decryptStream = new CryptoStream(memStream, decryptor, CryptoStreamMode.Read);
byte[] byteDecryptedText = new byte[byteEncryptedText.Length];
int decryptedByteCount = decryptStream.Read(byteDecryptedText, 0, byteDecryptedText.Length);
strDecryptedText = Encoding.UTF8.GetString(byteDecryptedText, 0, decryptedByteCount);
}
finally
{
if (rijndael != null) rijndael.Clear();
if (decryptor != null) decryptor.Dispose();
if (memStream != null) memStream.Close();
if (decryptStream != null) decryptStream.Close();
}
if (UseSalt)
strDecryptedText = strDecryptedText.Substring(8);
return strDecryptedText;
}
public static SymmetricAlgorithm GetAlgorithmByName(String algorithmName)
{
SymmetricAlgorithm symmetricAlgorithm = null;
String algorithmNameLoverCase = algorithmName.ToLower();
switch (algorithmNameLoverCase)
{
case "aes":
symmetricAlgorithm = new System.Security.Cryptography.AesCryptoServiceProvider();
break;
case "des":
symmetricAlgorithm = new System.Security.Cryptography.DESCryptoServiceProvider();
break;
case "rc2":
symmetricAlgorithm = new System.Security.Cryptography.RC2CryptoServiceProvider();
break;
case "rijndael":
symmetricAlgorithm = new System.Security.Cryptography.RijndaelManaged();
break;
}
return(symmetricAlgorithm);
}
public static string AesEncrypt(string str)
{
if (string.IsNullOrEmpty(str))
{
return(null);
}
Byte[] toEncryptArray = Encoding.UTF8.GetBytes(str);
Byte[] tmpArray = { };
//加密数据不足16位时用0补齐
if (toEncryptArray.Length % 16 != 0)
{
int len = 16 - (toEncryptArray.Length % 16);
tmpArray = Enumerable.Repeat((byte)0, len).ToArray();
}
toEncryptArray = toEncryptArray.Concat(tmpArray).ToArray();
System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged
{
Key = Encoding.UTF8.GetBytes(Key),
Mode = System.Security.Cryptography.CipherMode.ECB,
Padding = System.Security.Cryptography.PaddingMode.None
};
System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateEncryptor();
Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
return(Convert.ToBase64String(resultArray, 0, resultArray.Length));
}
/// <summary>
/// Encrypts a string
/// </summary>
/// <param name="plainText">Text to be encrypted</param>
/// <param name="password">Password to encrypt with</param>
/// <param name="salt">Salt to encrypt with</param>
/// <param name="hashAlgorithm">Can be either SHA1 or MD5</param>
/// <param name="passwordIterations">Number of iterations to do. The number of times the algorithm is run on the text. </param>
/// <param name="initialVector">Needs to be 16 ASCII characters long</param>
/// <param name="keySize">Can be 128, 192, or 256</param>
/// <returns>An encrypted string</returns>
public static string Encrypt(string plainText, string password, string salt = "69ad1bfbd6605f3f6a3011460cdfb9db7757e0f9", string hashAlgorithm = "SHA1", int passwordIterations = 2, string initialVector = "OFRna73m*aze01xY", int keySize = 256)
{
if (string.IsNullOrEmpty(plainText))
return "";
byte[] initialVectorBytes = Encoding.ASCII.GetBytes(initialVector);
byte[] saltValueBytes = Encoding.ASCII.GetBytes(salt);
byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
var derivedPassword = new PasswordDeriveBytes(password, saltValueBytes, hashAlgorithm, passwordIterations);
byte[] keyBytes = derivedPassword.GetBytes(keySize / 8);
var symmetricKey = new RijndaelManaged {Mode = CipherMode.CBC};
byte[] cipherTextBytes;
using (ICryptoTransform encryptor = symmetricKey.CreateEncryptor(keyBytes, initialVectorBytes))
{
using (MemoryStream memStream = new MemoryStream())
{
using (CryptoStream cryptoStream = new CryptoStream(memStream, encryptor, CryptoStreamMode.Write))
{
cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
cryptoStream.FlushFinalBlock();
cipherTextBytes = memStream.ToArray();
memStream.Close();
cryptoStream.Close();
}
}
}
symmetricKey.Clear();
return Convert.ToBase64String(cipherTextBytes);
}
/// <summary>
/// AES解密，与JAVA通用
/// </summary>
/// <param name="str"></param>
/// <param name="key"></param>
/// <returns></returns>
public static string AesDecrypt(string str, string key)
{
if (string.IsNullOrEmpty(str))
{
return("");
}
try
{
Byte[] toEncryptArray = Convert.FromBase64String(str);
System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged
{
Key = Encoding.UTF8.GetBytes(key),
Mode = System.Security.Cryptography.CipherMode.ECB,
Padding = System.Security.Cryptography.PaddingMode.PKCS7
};
System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateDecryptor();
Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
return(Encoding.UTF8.GetString(resultArray));
}
catch (Exception e)
{
Log.Error(e.Message);
return("");
}
}
public static byte[] DecryptAES(byte[] input, string key)
{
System.Security.Cryptography.RijndaelManaged AES = new System.Security.Cryptography.RijndaelManaged();
System.Security.Cryptography.MD5CryptoServiceProvider Hash_AES = new System.Security.Cryptography.MD5CryptoServiceProvider();
byte[] decrypted;
try
{
byte[] hash = new byte[32];
byte[] temp = Hash_AES.ComputeHash(System.Text.ASCIIEncoding.ASCII.GetBytes(key));
Array.Copy(temp, 0, hash, 0, 16);
Array.Copy(temp, 0, hash, 15, 16);
AES.Key = hash;
AES.Mode = System.Security.Cryptography.CipherMode.ECB;
System.Security.Cryptography.ICryptoTransform DESDecrypter = AES.CreateDecryptor();
//byte[] Buffer = Convert.FromBase64String(input);
//byte[] Buffer = Convert.for;
//decrypted = System.Text.ASCIIEncoding.UTF8.GetString(DESDecrypter.TransformFinalBlock(Buffer, 0, Buffer.Length));
decrypted = DESDecrypter.TransformFinalBlock(input, 0, input.Length);
return(decrypted);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 暗号化された文字列を復号化する
/// </summary>
/// <param name="sourceString">暗号化された文字列</param>
/// <returns>復号化された文字列</returns>
public static string DecryptString(string sourceString)
{
//RijndaelManagedオブジェクトを作成
System.Security.Cryptography.RijndaelManaged rijndael =
new System.Security.Cryptography.RijndaelManaged();
//パスワードから共有キーと初期化ベクタを作成
byte[] key, iv;
GenerateKeyFromPassword(
rijndael.KeySize, out key, rijndael.BlockSize, out iv);
rijndael.Key = key;
rijndael.IV = iv;
//文字列をバイト型配列に戻す
byte[] strBytes = System.Convert.FromBase64String(sourceString);
//対称暗号化オブジェクトの作成
System.Security.Cryptography.ICryptoTransform decryptor =
rijndael.CreateDecryptor();
//バイト型配列を復号化する
//復号化に失敗すると例外CryptographicExceptionが発生
byte[] decBytes = decryptor.TransformFinalBlock(strBytes, 0, strBytes.Length);
//閉じる
decryptor.Dispose();
//バイト型配列を文字列に戻して返す
return(System.Text.Encoding.UTF8.GetString(decBytes));
}
/// <summary>
/// 文字列を暗号化する
/// </summary>
/// <param name="sourceString">暗号化する文字列</param>
/// <returns>暗号化された文字列</returns>
public static string EncryptString(string sourceString)
{
//RijndaelManagedオブジェクトを作成
System.Security.Cryptography.RijndaelManaged rijndael =
new System.Security.Cryptography.RijndaelManaged();
//パスワードから共有キーと初期化ベクタを作成
byte[] key, iv;
GenerateKeyFromPassword(
rijndael.KeySize, out key, rijndael.BlockSize, out iv);
rijndael.Key = key;
rijndael.IV = iv;
//文字列をバイト型配列に変換する
byte[] strBytes = System.Text.Encoding.UTF8.GetBytes(sourceString);
//対称暗号化オブジェクトの作成
System.Security.Cryptography.ICryptoTransform encryptor =
rijndael.CreateEncryptor();
//バイト型配列を暗号化する
byte[] encBytes = encryptor.TransformFinalBlock(strBytes, 0, strBytes.Length);
//閉じる
encryptor.Dispose();
//バイト型配列を文字列に変換して返す
return(System.Convert.ToBase64String(encBytes));
}
/// <summary>
/// Cryptographic transformation
/// </summary>
/// <param name="password"></param>
/// <param name="encrypt"></param>
/// <returns></returns>
private static ICryptoTransform GetTransform(bool Encrypt)
{
// Create an instance of the Rihndael class.
RijndaelManaged Cipher = new System.Security.Cryptography.RijndaelManaged();
// Calculate salt to make it harder to guess key by using a dictionary attack.
byte[] Salt = SaltFromPassword();
// Generate Secret Key from the password and salt.
// Note: Set number of iterations to 10 in order for JavaScript example to work faster.
Rfc2898DeriveBytes SecretKey = new System.Security.Cryptography.Rfc2898DeriveBytes(Keys.KEY, Salt, 10);
// Create a encryptor from the existing SecretKey bytes by using
// 32 bytes (256 bits) for the secret key and
// 16 bytes (128 bits) for the initialization vector (IV).
byte[] SecretKeyBytes = SecretKey.GetBytes(32);
byte[] InitializationVectorBytes = SecretKey.GetBytes(16);
ICryptoTransform Cryptor = null;
if (Encrypt)
{
Cryptor = Cipher.CreateEncryptor(SecretKeyBytes, InitializationVectorBytes);
}
else
{
Cryptor = Cipher.CreateDecryptor(SecretKeyBytes, InitializationVectorBytes);
}
return(Cryptor);
}
/// <summary>
/// Método para encriptar em AES
/// </summary>
/// <param name="plaintext"></param>
/// <param name="text"></param>
/// <returns></returns>
public static byte[] Encrypt(byte[] plaintext, string text)
{
/*
* Block Length: 128bit
* Block Mode: ECB
* Data Padding: Padded by bytes which Asc() equal for number of padded bytes (done automagically)
* Key Padding: 0x00 padded to multiple of 16 bytes
* IV: None
*/
byte[] key = System.Text.ASCIIEncoding.ASCII.GetBytes(text);
System.Security.Cryptography.RijndaelManaged AES = new System.Security.Cryptography.RijndaelManaged();
AES.BlockSize = 128;
AES.Mode = System.Security.Cryptography.CipherMode.ECB;
AES.Key = key;
System.Security.Cryptography.ICryptoTransform encryptor = AES.CreateEncryptor();
MemoryStream mem = new MemoryStream();
System.Security.Cryptography.CryptoStream cryptStream = new System.Security.Cryptography.CryptoStream(mem, encryptor,
System.Security.Cryptography.CryptoStreamMode.Write);
cryptStream.Write(plaintext, 0, plaintext.Length);
cryptStream.FlushFinalBlock();
byte[] cypher = mem.ToArray();
cryptStream.Close();
cryptStream = null;
encryptor.Dispose();
AES = null;
return(cypher);
}
/// <summary>
/// AES 解密
/// </summary>
/// <param name="str">需解密字符串</param>
/// <param name="key">密钥</param>
/// <param name="isDecodeUrl">是否需要URL解码</param>
/// <returns></returns>
public static string AesDecrypt(string str, string key, bool isDecodeUrl = true)
{
if (string.IsNullOrEmpty(str))
{
return(null);
}
if (isDecodeUrl)
{
str = System.Web.HttpUtility.UrlDecode(str);
}
Byte[] toEncryptArray = Convert.FromBase64String(str);
System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged
{
Key = Encoding.UTF8.GetBytes(key),
Mode = System.Security.Cryptography.CipherMode.ECB,
Padding = System.Security.Cryptography.PaddingMode.PKCS7
};
System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateDecryptor();
Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
return(Encoding.UTF8.GetString(resultArray));
}
public static string AES_Decrypt(string input_text)
{
//Please dont change or EDIT ANY PART of THIS CODE
// ''' security_Code= [email protected]
string securitycode = "[email protected]";
System.Security.Cryptography.RijndaelManaged AES = new System.Security.Cryptography.RijndaelManaged();
System.Security.Cryptography.MD5CryptoServiceProvider Hash_AES = new System.Security.Cryptography.MD5CryptoServiceProvider();
string decrypted = "";
try
{
byte[] hash = new byte[32];
byte[] temp = Hash_AES.ComputeHash(System.Text.ASCIIEncoding.ASCII.GetBytes(securitycode));
Array.Copy(temp, 0, hash, 0, 16);
Array.Copy(temp, 0, hash, 15, 16);
AES.Key = hash;
AES.Mode = CipherMode.ECB;
// Security.Cryptography.CipherMode.ECB
System.Security.Cryptography.ICryptoTransform DESDecrypter = AES.CreateDecryptor();
byte[] Buffer = Convert.FromBase64String(input_text);
decrypted = System.Text.ASCIIEncoding.ASCII.GetString(DESDecrypter.TransformFinalBlock(Buffer, 0, Buffer.Length));
}
catch (Exception ex)
{
throw ex;
}
return(decrypted);
}
/// <summary>
/// AES 加密
/// </summary>
/// <param name="encryptKey"></param>
/// <param name="bizContent"></param>
/// <param name="charset"></param>
/// <returns></returns>
public static string AesEncrypt(string encryptKey, string bizContent, string charset)
{
Byte[] keyArray = Convert.FromBase64String(encryptKey);
Byte[] toEncryptArray = null;
if (string.IsNullOrEmpty(charset))
{
toEncryptArray = Encoding.UTF8.GetBytes(bizContent);
}
else
{
toEncryptArray = Encoding.GetEncoding(charset).GetBytes(bizContent);
}
System.Security.Cryptography.RijndaelManaged rDel = new System.Security.Cryptography.RijndaelManaged();
rDel.Key = keyArray;
rDel.Mode = System.Security.Cryptography.CipherMode.CBC;
rDel.Padding = System.Security.Cryptography.PaddingMode.PKCS7;
rDel.IV = AES_IV;
System.Security.Cryptography.ICryptoTransform cTransform = rDel.CreateEncryptor(rDel.Key, rDel.IV);
Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
return(Convert.ToBase64String(resultArray));
}
public static string Decrypt(string TextToBeDecrypted)
{
RijndaelManaged RijndaelCipher = new RijndaelManaged();
string Password = "******";
string DecryptedData;
try
{
byte[] EncryptedData = Convert.FromBase64String(TextToBeDecrypted);
byte[] Salt = Encoding.ASCII.GetBytes(Password.Length.ToString());
//Making of the key for decryption
PasswordDeriveBytes SecretKey = new PasswordDeriveBytes(Password, Salt);
//Creates a symmetric Rijndael decryptor object.
ICryptoTransform Decryptor = RijndaelCipher.CreateDecryptor(SecretKey.GetBytes(32), SecretKey.GetBytes(16));
MemoryStream memoryStream = new MemoryStream(EncryptedData);
//Defines the cryptographics stream for decryption.THe stream contains decrpted data
CryptoStream cryptoStream = new CryptoStream(memoryStream, Decryptor, CryptoStreamMode.Read);
byte[] PlainText = new byte[EncryptedData.Length];
int DecryptedCount = cryptoStream.Read(PlainText, 0, PlainText.Length);
memoryStream.Close();
cryptoStream.Close();
//Converting to string
DecryptedData = Encoding.Unicode.GetString(PlainText, 0, DecryptedCount);
}
catch
{
DecryptedData = TextToBeDecrypted;
}
return DecryptedData;
}
private string SaveConfig(string connectionstr)
{
string result;
try
{
Configuration configuration = System.Web.Configuration.WebConfigurationManager.OpenWebConfiguration(System.Web.HttpContext.Current.Request.ApplicationPath);
using (System.Security.Cryptography.RijndaelManaged cryptographer = this.GetCryptographer())
{
configuration.AppSettings.Settings["IV"].Value = System.Convert.ToBase64String(cryptographer.IV);
configuration.AppSettings.Settings["Key"].Value = System.Convert.ToBase64String(cryptographer.Key);
}
System.Web.Configuration.MachineKeySection machineKeySection = (System.Web.Configuration.MachineKeySection)configuration.GetSection("system.web/machineKey");
machineKeySection.ValidationKey = Isv.CreateKey(20);
machineKeySection.DecryptionKey = Isv.CreateKey(24);
machineKeySection.Validation = System.Web.Configuration.MachineKeyValidation.SHA1;
machineKeySection.Decryption = "3DES";
configuration.ConnectionStrings.ConnectionStrings["HidistroSqlServer"].ConnectionString = connectionstr;
configuration.ConnectionStrings.SectionInformation.ProtectSection("DataProtectionConfigurationProvider");
configuration.Save();
configuration = System.Web.Configuration.WebConfigurationManager.OpenWebConfiguration(System.Web.HttpContext.Current.Request.ApplicationPath);
configuration.AppSettings.Settings.Remove("Installer");
configuration.Save();
result = "";
}
catch (System.Exception ex)
{
result = ex.Message;
}
return(result);
}
//add near end of Terraria.Player.LoadPlayer before accessory check
internal static void ReadModFile(Player player, string path, bool isCloudSave)
{
path = Path.ChangeExtension(path, ".tplr");
RijndaelManaged rijndaelManaged = new RijndaelManaged();
rijndaelManaged.Padding = PaddingMode.None;
if (!FileUtilities.Exists(path, isCloudSave))
{
return;
}
byte[] buffer = FileUtilities.ReadAllBytes(path, isCloudSave);
using (MemoryStream stream = new MemoryStream(buffer))
{
using (CryptoStream cryptoStream = new CryptoStream(stream, rijndaelManaged.CreateDecryptor(Player.ENCRYPTION_KEY, Player.ENCRYPTION_KEY), CryptoStreamMode.Read))
{
using (BinaryReader reader = new BinaryReader(cryptoStream))
{
byte limit = reader.ReadByte();
if (limit == 0)
{
return;
}
byte[] flags = reader.ReadBytes(limit);
if (flags.Length < numFlagBytes)
{
Array.Resize(ref flags, numFlagBytes);
}
ReadModPlayer(player, flags, reader);
}
}
}
}
static void Main(string[] args)
{
byte[] bytes = System.Text.Encoding.Unicode.GetBytes(args[0]);
System.Security.Cryptography.RijndaelManaged rijndaelManaged = new System.Security.Cryptography.RijndaelManaged();
rijndaelManaged.Key = bytes;
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.PreserveWhitespace = true;
xmlDocument.Load("needfiles");
XmlElement xmlElement = xmlDocument.GetElementsByTagName("EncryptedData")[0] as XmlElement;
EncryptedData encryptedData = new EncryptedData();
encryptedData.LoadXml(xmlElement);
EncryptedXml encryptedXml = new EncryptedXml();
byte[] decryptedData = encryptedXml.DecryptData(encryptedData, rijndaelManaged);
encryptedXml.ReplaceData(xmlElement, decryptedData);
if (rijndaelManaged != null)
{
rijndaelManaged.Clear();
}
Console.WriteLine(xmlDocument.OuterXml);
}
private ICryptoTransform GetTransform(string password, bool encrypt)
{
// Create an instance of the Rihndael class.
RijndaelManaged cipher = new System.Security.Cryptography.RijndaelManaged();
// Calculate salt to make it harder to guess key by using a dictionary attack.
byte[] salt = SaltFromPassword(password);
WriteLog("// salt = " + System.BitConverter.ToString(salt).Replace("-", ""));
// Generate Secret Key from the password and salt.
// Note: Set number of iterations to 10 in order for JavaScript example to work faster.
Rfc2898DeriveBytes secretKey = new System.Security.Cryptography.Rfc2898DeriveBytes(password, salt, 10);
// Create a encryptor from the existing SecretKey bytes by using
// 32 bytes (256 bits) for the secret key and
// 16 bytes (128 bits) for the initialization vector (IV).
byte[] key = secretKey.GetBytes(32);
byte[] iv = secretKey.GetBytes(16);
WriteLog("// key = " + System.BitConverter.ToString(key).Replace("-", ""));
WriteLog("// iv = " + System.BitConverter.ToString(iv).Replace("-", ""));
ICryptoTransform cryptor = null;
if (encrypt)
{
cryptor = cipher.CreateEncryptor(key, iv);
}
else
{
cryptor = cipher.CreateDecryptor(key, iv);
}
return(cryptor);
}
/// <summary>
/// AES解密
/// </summary>
/// <param name="text"></param>
/// <param name="password"></param>
/// <param name="iv"></param>
/// <returns></returns>
public static string AESDecrypt(string text, string password, string iv)
{
RijndaelManaged rijndaelCipher = new RijndaelManaged();
rijndaelCipher.Mode = CipherMode.CBC;
rijndaelCipher.Padding = PaddingMode.PKCS7;
rijndaelCipher.KeySize = 128;
rijndaelCipher.BlockSize = 128;
byte[] encryptedData = Convert.FromBase64String(text);
byte[] pwdBytes = System.Text.Encoding.UTF8.GetBytes(password);
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;
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);
}
/// <summary>
/// Decrypts a string
/// </summary>
/// <param name="CipherText">Text to be decrypted</param>
/// <param name="Password">Password to decrypt with</param>
/// <param name="Salt">Salt to decrypt with</param>
/// <param name="HashAlgorithm">Can be either SHA1 or MD5</param>
/// <param name="PasswordIterations">Number of iterations to do</param>
/// <param name="InitialVector">Needs to be 16 ASCII characters long</param>
/// <param name="KeySize">Can be 128, 192, or 256</param>
/// <returns>A decrypted string</returns>
public static string Decrypt(string CipherText, string Password,
string Salt = "Kosher", string HashAlgorithm = "SHA1",
int PasswordIterations = 2, string InitialVector = "OFRna73m*aze01xY",
int KeySize = 256)
{
if (string.IsNullOrEmpty(CipherText))
return "";
byte[] InitialVectorBytes = Encoding.ASCII.GetBytes(InitialVector);
byte[] SaltValueBytes = Encoding.ASCII.GetBytes(Salt);
byte[] CipherTextBytes = Convert.FromBase64String(CipherText);
PasswordDeriveBytes DerivedPassword = new PasswordDeriveBytes(Password, SaltValueBytes, HashAlgorithm, PasswordIterations);
byte[] KeyBytes = DerivedPassword.GetBytes(KeySize / 8);
RijndaelManaged SymmetricKey = new RijndaelManaged();
SymmetricKey.Mode = CipherMode.CBC;
byte[] PlainTextBytes = new byte[CipherTextBytes.Length];
int ByteCount = 0;
using (ICryptoTransform Decryptor = SymmetricKey.CreateDecryptor(KeyBytes, InitialVectorBytes))
{
using (MemoryStream MemStream = new MemoryStream(CipherTextBytes))
{
using (CryptoStream CryptoStream = new CryptoStream(MemStream, Decryptor, CryptoStreamMode.Read))
{
ByteCount = CryptoStream.Read(PlainTextBytes, 0, PlainTextBytes.Length);
MemStream.Close();
CryptoStream.Close();
}
}
}
SymmetricKey.Clear();
return Encoding.UTF8.GetString(PlainTextBytes, 0, ByteCount);
}
public override SymmetricAlgorithm GetSymmetricAlgorithm(string algorithm)
{
SymmetricAlgorithm s = null;
switch (algorithm)
{
case SecurityAlgorithms.Aes128Encryption:
case SecurityAlgorithms.Aes192Encryption:
case SecurityAlgorithms.Aes256Encryption:
case SecurityAlgorithms.Aes128KeyWrap:
case SecurityAlgorithms.Aes192KeyWrap:
case SecurityAlgorithms.Aes256KeyWrap:
s = new AES();
break;
case SecurityAlgorithms.TripleDesEncryption:
case SecurityAlgorithms.TripleDesKeyWrap:
if (key.Length == 24)
{
throw new CryptographicException("The key size is 24 bytes, which known as vulnerable and thus not allowed.");
}
s = TripleDES.Create();
break;
default:
throw new NotSupportedException(String.Format("This symmetric security key does not support specified algorithm '{0}'", algorithm));
}
s.Mode = CipherMode.CBC;
s.GenerateIV();
s.Key = key;
return(s);
}
private void encryptFile(string inputFile, string cryptFile)
{
FileStream fsCrypt = null;
CryptoStream cryptStream = null;
try
{
UnicodeEncoding UE = new UnicodeEncoding();
byte[] key = UE.GetBytes(TPW);
fsCrypt = new FileStream(cryptFile, FileMode.Create);
RijndaelManaged RMCrypto = new RijndaelManaged();
cryptStream = new CryptoStream(fsCrypt,
RMCrypto.CreateEncryptor(key, key),
CryptoStreamMode.Write);
byte[] inBytes = File.ReadAllBytes(inputFile);
cryptStream.Write(inBytes, 0, inBytes.Length);
}
finally
{
if (cryptStream != null)
cryptStream.Close();
if ( fsCrypt != null )
fsCrypt.Close();
}
}
/// <summary>
/// AES加密
/// </summary>
/// <param name="encryptStr">明文</param>
/// <param name="key">密钥</param>
/// <returns></returns>
public static string Encrypt()
{
//获取mac地址
string str = GetFirstMacAddress();
//获取下一天日期
string key = DateTime.Now.AddDays(1).ToString("yyyyMMdd");
//补全key为16个字符的字符串
for (int i = key.Length; i < 16; i++)
{
key += "0";
}
if (string.IsNullOrEmpty(str))
{
return(null);
}
Byte[] toEncryptArray = Encoding.UTF8.GetBytes(str);
//开始AES加密
System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged
{
Key = Encoding.UTF8.GetBytes(key), //密钥
Mode = System.Security.Cryptography.CipherMode.ECB, //加密模式
Padding = System.Security.Cryptography.PaddingMode.PKCS7 //填白模式，对于AES, C# 框架中的 PKCS ＃７等同与Java框架中 PKCS #5
};
//字节编码， 将有特等含义的字符串转化为字节流
System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateEncryptor();
//加密
Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
//将加密后的字节流转化为字符串，以便网络传输与储存。
return(Convert.ToBase64String(resultArray, 0, resultArray.Length));
}
/// <summary>
/// AES加密
/// </summary>
/// <param name="text">加密字符</param>
/// <param name="password">加密的密码</param>
/// <param name="iv">密钥</param>
/// <returns></returns>
// 加密
/// <summary>
/// AES 加密
/// </summary>
/// <param name="str"></param>
/// <param name="key"></param>
/// <returns></returns>
public static string AesEncrypt(string str, string key)
{
if (key == null)
{
return("Key為空null");
}
// 判断Key是否为16位
if (key.Length != 16)
{
return("Key長度不是16位元");
}
if (string.IsNullOrEmpty(str))
{
return(null);
}
Byte[] toEncryptArray = Encoding.UTF8.GetBytes(str);
System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged
{
Key = Encoding.UTF8.GetBytes(key),
Mode = System.Security.Cryptography.CipherMode.ECB,
Padding = System.Security.Cryptography.PaddingMode.PKCS7
};
System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateEncryptor();
Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
return(Convert.ToBase64String(resultArray, 0, resultArray.Length));
}
public static string AES_Encrypt(string input_text, string security_Code)
{
// ''' security_Code= [email protected]
System.Security.Cryptography.RijndaelManaged AES = new System.Security.Cryptography.RijndaelManaged();
System.Security.Cryptography.MD5CryptoServiceProvider Hash_AES = new System.Security.Cryptography.MD5CryptoServiceProvider();
string encrypted = "";
try
{
byte[] hash = new byte[32];
byte[] temp = Hash_AES.ComputeHash(System.Text.ASCIIEncoding.ASCII.GetBytes(security_Code));
Array.Copy(temp, 0, hash, 0, 16);
Array.Copy(temp, 0, hash, 15, 16);
AES.Key = hash;
AES.Mode = System.Security.Cryptography.CipherMode.ECB;
//'Security.Cryptography.CipherMode.ECB
System.Security.Cryptography.ICryptoTransform DESEncrypter = AES.CreateEncryptor();
byte[] Buffer = System.Text.ASCIIEncoding.ASCII.GetBytes(input_text);
encrypted = Convert.ToBase64String(DESEncrypter.TransformFinalBlock(Buffer, 0, Buffer.Length));
}
catch (Exception ex)
{
}
return(encrypted);
}
private bool SaveConfig(out string errorMsg)
{
bool result;
try
{
Configuration configuration = System.Web.Configuration.WebConfigurationManager.OpenWebConfiguration(base.Request.ApplicationPath);
using (System.Security.Cryptography.RijndaelManaged cryptographer = this.GetCryptographer())
{
configuration.AppSettings.Settings["IV"].Value = System.Convert.ToBase64String(cryptographer.IV);
configuration.AppSettings.Settings["Key"].Value = System.Convert.ToBase64String(cryptographer.Key);
}
System.Web.Configuration.MachineKeySection machineKeySection = (System.Web.Configuration.MachineKeySection)configuration.GetSection("system.web/machineKey");
machineKeySection.ValidationKey = Install.CreateKey(20);
machineKeySection.DecryptionKey = Install.CreateKey(24);
machineKeySection.Validation = System.Web.Configuration.MachineKeyValidation.SHA1;
machineKeySection.Decryption = "3DES";
configuration.ConnectionStrings.ConnectionStrings["HidistroSqlServer"].ConnectionString = this.GetConnectionString();
configuration.ConnectionStrings.SectionInformation.ProtectSection("DataProtectionConfigurationProvider");
configuration.Save();
errorMsg = null;
result = true;
}
catch (System.Exception ex)
{
errorMsg = ex.Message;
result = false;
}
return(result);
}
/// <summary>
/// AES 加密
/// </summary>
/// <param name="str"></param>
/// <param name="key"></param>
/// <returns></returns>
public static byte[] AesEncrypt(byte[] str, int count_, int index_ = 0, string key = _key)
{
// *remark*: ignore
//if (string.IsNullOrEmpty(Encoding.UTF8.GetString(str, index_, count_))) return null;
//Byte[] toEncryptArray = str;
byte[] toEncryptArray = new byte[count_];
Array.Copy(str, index_, toEncryptArray, 0, count_);
System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged
{
Key = Encoding.ASCII.GetBytes(key),
Mode = System.Security.Cryptography.CipherMode.ECB,
Padding = System.Security.Cryptography.PaddingMode.PKCS7
};
System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateEncryptor();
Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
//return resultArray;
string ret = Convert.ToBase64String(resultArray, 0, resultArray.Length);
//UnityEngine.Debug.Log("<b>encrypted</b>:" + ret);
//return Encoding.Default.GetBytes(ret);
return(Encoding.ASCII.GetBytes(ret));
}
public void init(int mode, byte[] key, byte[] iv)
{
this.mode = mode;
rijndael = new RijndaelManaged();
rijndael.Mode = CipherMode.ECB;
rijndael.Padding = PaddingMode.None;
byte[] tmp;
if (iv.Length > ivsize)
{
tmp = new byte[ivsize];
Array.Copy(iv, 0, tmp, 0, tmp.Length);
iv = tmp;
}
if (key.Length > bsize)
{
tmp = new byte[bsize];
Array.Copy(key, 0, tmp, 0, tmp.Length);
key = tmp;
}
counter = new byte[iv.Length];
Array.Copy(iv, counter, iv.Length);
try {
cipher = rijndael.CreateEncryptor(key, null);
}
catch (Exception e) {
Console.WriteLine(e);
cipher = null;
}
}
/// <summary>
/// Recibe un texto plano y lo devuelve cifrado
/// Cifrado Simetrico
/// </summary>
/// <param name="contenido"></param>
/// <param name="clave"></param>
/// <returns></returns>
public static String Cifrar(String contenido, String clave)
{
var encoding = new UTF8Encoding();
var cripto = new RijndaelManaged(); // es un algotimo de cifrado, para cifrar
//var iv = cripto.GenerateIV(); // Vector de inicialización: es un vector que tiene la semilla de inicialización
// Este IV
byte[] cifrado;
byte[] retorno;
byte[] key = GetKey(clave); // recibo una clave alfanumerica y devuelvo los bytes desde una cadena UTF8
cripto.Key = key;
cripto.GenerateIV(); // genera numeros aleatorios (semillas)
// voy a crear el encriptador
byte[] aEncriptar = encoding.GetBytes(contenido); // recibo contenido y lo convierto a array de bites
// ya lo tengo cifrado
cifrado = cripto.CreateEncryptor().TransformFinalBlock(aEncriptar, 0, aEncriptar.Length); // transforma el contenido desde 0 hasta que termine
// creo mi retorno
retorno = new byte[cripto.IV.Length + cifrado.Length]; // longitud del IV + el tamaño del cifrado
cripto.IV.CopyTo(retorno, 0); // donde quiero copiar, en que posición quiero copiar
cifrado.CopyTo(retorno, cripto.IV.Length);
// la mejor forma es convertirlo a base 64, datos binarios, para almacenar array de bytes
return Convert.ToBase64String(retorno); // conjunto de bytes transformados en string
// muy util para guardar imagenes
}
/// <summary>
/// AES解密/ECB/NoPadding
/// </summary>
/// <param name="str"></param>
/// <param name="key"></param>
/// <returns></returns>
public static string AesDecrypt(string str, string key)
{
if (string.IsNullOrEmpty(str))
{
return(null);
}
Byte[] toEncryptArray = Convert.FromBase64String(str);
//key不足16位时用1补齐
if (key.Length % 16 != 0)
{
int keyLen = 16 - (key.Length % 16);
for (int i = 0; i < keyLen; i++)
{
key += "1";
}
}
System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged
{
Key = Encoding.UTF8.GetBytes(key),
Mode = System.Security.Cryptography.CipherMode.ECB,
Padding = System.Security.Cryptography.PaddingMode.None
};
System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateDecryptor();
Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
return(Encoding.UTF8.GetString(resultArray).Replace("\0", ""));
}
/// Generates a unique encryption vector
public static byte[] GenerateEncryptionVector()
{
//Generate a Vector
RijndaelManaged rm = new RijndaelManaged();
rm.GenerateIV();
return rm.IV;
}
static System.Security.Cryptography.SymmetricAlgorithm CreateCam(string key, string IV, bool rij = true)
{
System.Security.Cryptography.SymmetricAlgorithm a = null;
if (rij)
{
a = new System.Security.Cryptography.RijndaelManaged();
}
else
{
a = new System.Security.Cryptography.AesCryptoServiceProvider();
}
a.Mode = System.Security.Cryptography.CipherMode.CBC;
a.Padding = System.Security.Cryptography.PaddingMode.Zeros;
a.BlockSize = 128;
a.KeySize = 256;
if (null != IV)
{
a.IV = System.Convert.FromBase64String(IV);
}
else
{
a.GenerateIV();
}
if (null != key)
{
a.Key = System.Convert.FromBase64String(key);
}
return(a);
}
protected override SymmetricAlgorithm GetCryptProvider(string thePassword)
{
//Dim theAlgo As RijndaelManaged = New RijndaelManaged
SymmetricAlgorithm theAlgo = new System.Security.Cryptography.RijndaelManaged();
BuildCryptProvider(theAlgo, thePassword);
return(theAlgo);
}
private System.Security.Cryptography.RijndaelManaged GetCryptographer()
{
System.Security.Cryptography.RijndaelManaged rijndaelManaged = new System.Security.Cryptography.RijndaelManaged();
rijndaelManaged.KeySize = 128;
rijndaelManaged.GenerateIV();
rijndaelManaged.GenerateKey();
return(rijndaelManaged);
}
static Enc()
{
//RijndaelManagedオブジェクトを作成
rijndael = new System.Security.Cryptography.RijndaelManaged();
byte[] key, iv;
GenerateKeyFromPassword(rijndael.KeySize, out key, rijndael.BlockSize, out iv);
rijndael.Key = key;
rijndael.IV = iv;
}
// no error???
public void GetSymmetricAlgorithmWrongSize2()
{
AES aes = new AES();
aes.KeySize = 192;
aes.GenerateKey();
Key key = new Key(aes.Key);
Assert.IsNotNull(key.GetSymmetricAlgorithm(SecurityAlgorithms.Aes256Encryption));
}
public static String generateKey()
{
System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged
{
KeySize = 128,
Mode = System.Security.Cryptography.CipherMode.ECB,
Padding = System.Security.Cryptography.PaddingMode.PKCS7
};
rm.GenerateKey();
return(Convert.ToBase64String(rm.Key));
}
/// <summary>
/// AES加密 - 16进制
/// </summary>
public static String EncryptHex(String content, String key)
{
Byte[] keyArray = UTF8Encoding.UTF8.GetBytes(key);
Byte[] encryptArray = UTF8Encoding.UTF8.GetBytes(content);
System.Security.Cryptography.RijndaelManaged rDel = new System.Security.Cryptography.RijndaelManaged();
rDel.Key = keyArray;
rDel.Mode = System.Security.Cryptography.CipherMode.ECB;
rDel.Padding = System.Security.Cryptography.PaddingMode.PKCS7;
System.Security.Cryptography.ICryptoTransform cTransform = rDel.CreateEncryptor();
Byte[] resultArray = cTransform.TransformFinalBlock(encryptArray, 0, encryptArray.Length);
return(ByteUtil.BytesToHex(resultArray));
}
public static byte[] AESEncrypt(byte[] input, string Pass)
{
System.Security.Cryptography.RijndaelManaged AES = new System.Security.Cryptography.RijndaelManaged();
byte[] hash = new byte[32];
byte[] temp = new MD5CryptoServiceProvider().ComputeHash(System.Text.Encoding.ASCII.GetBytes(Pass));
Array.Copy(temp, 0, hash, 0, 16);
Array.Copy(temp, 0, hash, 15, 16);
AES.Key = hash;
AES.Mode = System.Security.Cryptography.CipherMode.ECB;
System.Security.Cryptography.ICryptoTransform DESEncrypter = AES.CreateEncryptor();
return(DESEncrypter.TransformFinalBlock(input, 0, input.Length));
}
