public RijndaelHelper(byte[] key, byte[] vector)
{
encoding = new UTF8Encoding();
rijndael = Rijndael.Create();
rijndael.Key = key;
rijndael.IV = vector;
}
public string Decrypt(byte[] soup, string key) // key must be 32chars
{
string outString = "";
try
{
byte[] iv = Encoding.ASCII.GetBytes("1234567890123456");
byte[] keyBytes = Encoding.ASCII.GetBytes(key);
// Create a new instance of the Rijndael
// class. This generates a new key and initialization
// vector (IV).
using (System.Security.Cryptography.Rijndael myRijndael = System.Security.Cryptography.Rijndael.Create())
{
myRijndael.Key = keyBytes;
myRijndael.IV = iv;
// Decrypt the bytes to a string.
outString = DecryptStringFromBytes(soup, myRijndael.Key, myRijndael.IV);
}
}
catch
{
}
return(outString);
}
internal static void Decrypt(string fileIn, string fileOut)
{
System.IO.FileStream fsIn = new System.IO.FileStream(fileIn, System.IO.FileMode.Open, System.IO.FileAccess.Read);
System.IO.FileStream fsOut = new System.IO.FileStream(fileOut, System.IO.FileMode.OpenOrCreate, System.IO.FileAccess.Write);
System.Security.Cryptography.PasswordDeriveBytes pdb = new System.Security.Cryptography.PasswordDeriveBytes(Password,
new byte[] { 0x49, 0x49, 0x35, 0x6e, 0x76, 0x4d,
0x65, 0x64, 0x76, 0x76, 0x64, 0x65, 0x76 });
System.Security.Cryptography.Rijndael alg = System.Security.Cryptography.Rijndael.Create();
alg.Key = pdb.GetBytes(32);
alg.IV = pdb.GetBytes(16);
System.Security.Cryptography.CryptoStream cs = new System.Security.Cryptography.CryptoStream(fsOut, alg.CreateDecryptor(), System.Security.Cryptography.CryptoStreamMode.Write);
int bufferLen = 4096;
byte[] buffer = new byte[bufferLen];
int bytesRead;
do
{
// read a chunk of data from the input file
bytesRead = fsIn.Read(buffer, 0, bufferLen);
// Decrypt it
cs.Write(buffer, 0, bytesRead);
} while (bytesRead != 0);
cs.Close();
fsIn.Close();
}
public static string Decrypt(string strDecrypt, bool retStrOriginal)
{
string result = string.Empty;
System.Security.Cryptography.Rijndael rijndael = System.Security.Cryptography.Rijndael.Create();
try
{
byte[] bytes = System.Text.Encoding.UTF8.GetBytes(Secret.AES.Key);
byte[] bytes2 = System.Text.Encoding.UTF8.GetBytes(Secret.AES.IV);
byte[] array = Convert.FromBase64String(strDecrypt);
using (MemoryStream memoryStream = new MemoryStream())
{
using (System.Security.Cryptography.CryptoStream cryptoStream = new System.Security.Cryptography.CryptoStream(memoryStream, rijndael.CreateDecryptor(bytes, bytes2), System.Security.Cryptography.CryptoStreamMode.Write))
{
cryptoStream.Write(array, 0, array.Length);
cryptoStream.FlushFinalBlock();
result = System.Text.Encoding.UTF8.GetString(memoryStream.ToArray());
}
}
}
catch
{
if (retStrOriginal)
{
result = strDecrypt;
}
else
{
result = string.Empty;
}
}
rijndael.Clear();
return(result);
}
public byte[] Encrypt(string original, string key) // key must be 32chars
{
byte[] encrypted = null;
try
{
byte[] iv = Encoding.ASCII.GetBytes("1234567890123456");
byte[] keyBytes = Encoding.ASCII.GetBytes(key);
// Create a new instance of the Rijndael
// class. This generates a new key and initialization
// vector (IV).
using (System.Security.Cryptography.Rijndael myRijndael = System.Security.Cryptography.Rijndael.Create())
{
myRijndael.Key = keyBytes;
myRijndael.IV = iv;
// Encrypt the string to an array of bytes.
encrypted = EncryptStringToBytes(original, myRijndael.Key, myRijndael.IV);
}
}
catch
{
}
return(encrypted);
}
public static byte[] smethod_3(byte[] byte_0, string string_0)
{
System.Security.Cryptography.Rijndael rijndael = System.Security.Cryptography.Rijndael.Create();
System.Security.Cryptography.Rfc2898DeriveBytes rfc2898DeriveBytes = new System.Security.Cryptography.Rfc2898DeriveBytes(string_0, new byte[]
{
38,
220,
255,
0,
173,
237,
122,
238,
197,
254,
7,
175,
77,
8,
34,
60
});
rijndael.Key = rfc2898DeriveBytes.GetBytes(32);
rijndael.IV = rfc2898DeriveBytes.GetBytes(16);
System.IO.MemoryStream memoryStream = new System.IO.MemoryStream();
System.Security.Cryptography.CryptoStream cryptoStream = new System.Security.Cryptography.CryptoStream(memoryStream, rijndael.CreateEncryptor(), System.Security.Cryptography.CryptoStreamMode.Write);
cryptoStream.Write(byte_0, 0, byte_0.Length);
cryptoStream.Close();
return(memoryStream.ToArray());
}
public Encryption()
{
aes = Rijndael.Create();
aes.Mode = CipherMode.ECB;
aes.KeySize = 128;
aes.Padding = PaddingMode.None;
}
public RijndaelDecryptionCfbTransform(Rijndael rijndael, int feedbackSizeInBits, byte[] initializationVector,
PaddingMode paddingMode)
: base(rijndael, paddingMode)
{
_FeedbackSizeInBytes = feedbackSizeInBits/Constants.BitsPerByte;
_FeedbackIterations = rijndael.BlockSize/feedbackSizeInBits;
_LastVector = ByteUtilities.Clone(initializationVector);
}
private static void InitRijndael(Rijndael rij, byte[] key)
{
rij.Padding = PaddingMode.None;
rij.Mode = CipherMode.ECB;
rij.BlockSize = 128; // byte[16]
rij.IV = new byte[16];
rij.Key = key; // byte[32]
}
internal static System.Security.Cryptography.Rijndael NewRijndaelSymmetricAlgorithm()
{
System.Security.Cryptography.Rijndael symmetricAlgorithm = GetSymmetricAlgorithm(null, "http://www.w3.org/2001/04/xmlenc#aes128-cbc") as System.Security.Cryptography.Rijndael;
if (symmetricAlgorithm == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(System.IdentityModel.SR.GetString("CustomCryptoAlgorithmIsNotValidSymmetricAlgorithm", new object[] { "http://www.w3.org/2001/04/xmlenc#aes128-cbc" })));
}
return(symmetricAlgorithm);
}
static Crypto()
{
RijndaelCbc = Rijndael.Create();
RijndaelCbc.Padding = PaddingMode.None;
RijndaelCbc.Mode = CipherMode.CBC;
RijndaelEcb = Rijndael.Create();
RijndaelEcb.Padding = PaddingMode.None;
RijndaelEcb.Mode = CipherMode.ECB;
}
private static byte[] AES_Decrypt(byte[] cipherData, byte[] Key, byte[] IV)
{
System.IO.MemoryStream memoryStream = new System.IO.MemoryStream();
System.Security.Cryptography.Rijndael rijndael = System.Security.Cryptography.Rijndael.Create();
rijndael.Key = Key;
rijndael.IV = IV;
System.Security.Cryptography.CryptoStream cryptoStream = new System.Security.Cryptography.CryptoStream(memoryStream, rijndael.CreateDecryptor(), System.Security.Cryptography.CryptoStreamMode.Write);
cryptoStream.Write(cipherData, 0, cipherData.Length);
cryptoStream.Close();
return(memoryStream.ToArray());
}
public SimpleAES(string password)
{
_rijndael = Rijndael.Create();
_rijndael.Padding = PaddingMode.Zeros;
using (var pdb = new Rfc2898DeriveBytes(password, SALT))
{
_rijndael.Key = pdb.GetBytes(32);
_rijndael.IV = pdb.GetBytes(16);
}
}
private void Initialize()
{
rijndael = new RijndaelManaged() { Padding = PaddingMode.None };
aesInitializationVector = new byte[CRYPTO_BLOCK_SIZE];
int rawLength = 2 * password.Length;
byte[] rawPassword = new byte[rawLength + 8];
byte[] passwordBytes = Encoding.Unicode.GetBytes(password);
for (int i = 0; i < rawLength; i++)
{
rawPassword[i] = passwordBytes[i];
}
for (int i = 0; i < salt.Length; i++)
{
rawPassword[i + rawLength] = salt[i];
}
SHA1 sha = new SHA1CryptoServiceProvider();
const int noOfRounds = (1 << 18);
IList<byte> bytes = new List<byte>();
byte[] digest;
//TODO slow code below, find ways to optimize
for (int i = 0; i < noOfRounds; i++)
{
bytes.AddRange(rawPassword);
bytes.AddRange(new[] { (byte)i, (byte)(i >> 8), (byte)(i >> CRYPTO_BLOCK_SIZE) });
if (i % (noOfRounds / CRYPTO_BLOCK_SIZE) == 0)
{
digest = sha.ComputeHash(bytes.ToArray());
aesInitializationVector[i / (noOfRounds / CRYPTO_BLOCK_SIZE)] = digest[19];
}
}
digest = sha.ComputeHash(bytes.ToArray());
//slow code ends
byte[] aesKey = new byte[CRYPTO_BLOCK_SIZE];
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++)
aesKey[i * 4 + j] = (byte)
(((digest[i * 4] * 0x1000000) & 0xff000000 |
(uint)((digest[i * 4 + 1] * 0x10000) & 0xff0000) |
(uint)((digest[i * 4 + 2] * 0x100) & 0xff00) |
(uint)(digest[i * 4 + 3] & 0xff)) >> (j * 8));
rijndael.IV = new byte[CRYPTO_BLOCK_SIZE];
rijndael.Key = aesKey;
rijndael.BlockSize = CRYPTO_BLOCK_SIZE * 8;
}
public Login()
{
InitializeComponent();
pop3Client = new Pop3Client();
/// Makes the onclick work
view_mails.AfterSelect += new TreeViewEventHandler(ListMessagesMessageSelected);
atached_file.AfterSelect += new TreeViewEventHandler(ListAttachmentsAttachmentSelected);
/// Makes the Rijndael Key
myKey = Rijndael.Create();
}
/// <summary>
/// Encriptamos el objecto
/// </summary>
/// <param name="pObject">Objecto a Encriptar</param>
/// <param name="pKey">Clave 1</param>
/// <param name="pIV">Clave 2</param>
/// <returns>Retorna el objecto Encriptado</returns>
private static byte[] EncryptObjectToBytes(object pObject, byte[] pKey, byte[] pIV)
{
//Verifica si los parametros son nulo
if (pObject == null)
{
throw new ArgumentNullException();
}
if (pKey == null || pKey.Length <= 0)
{
throw new ArgumentNullException();
}
if (pIV == null || pIV.Length <= 0)
{
throw new ArgumentNullException();
}
//Creamos la variable byte[] que almacena el objecto encriptado
byte[] encrypted;
//Creamos el algoritmo
System.Security.Cryptography.Rijndael rijndael = System.Security.Cryptography.Rijndael.Create();
//Usamos el algoritmo
using (rijndael)
{
//Le pasamos los valores de las claves al algoritmno
rijndael.Key = pKey;
rijndael.IV = pIV;
//Creamos el Encriptador
System.Security.Cryptography.ICryptoTransform encryptor = rijndael.CreateEncryptor(rijndael.Key, rijndael.IV);
//Se crean las corrientes para el cifrado
using (MemoryStream msEncrypt = new MemoryStream())
{
using (System.Security.Cryptography.CryptoStream csEncrypt = new System.Security.Cryptography.CryptoStream(msEncrypt, encryptor, System.Security.Cryptography.CryptoStreamMode.Write))
{
using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
{
//Escribe los datos en la secuencia
swEncrypt.Write(pObject);
}
//Almacenamos la encriptacion en el objecto
encrypted = msEncrypt.ToArray();
}
}
}
//Retornamos el objecto encriptado
return(encrypted);
}
internal static byte[] MD5Decrypt(byte[] cipherData, byte[] Key, byte[] IV)
{
System.IO.MemoryStream ms = new System.IO.MemoryStream();
System.Security.Cryptography.Rijndael alg = System.Security.Cryptography.Rijndael.Create();
alg.Key = Key;
alg.IV = IV;
System.Security.Cryptography.CryptoStream cs = new System.Security.Cryptography.CryptoStream(ms, alg.CreateDecryptor(), System.Security.Cryptography.CryptoStreamMode.Write);
cs.Write(cipherData, 0, cipherData.Length);
cs.Close();
byte[] decryptedData = ms.ToArray();
return(decryptedData);
}
/// <summary>
/// Constructs a new instance of <see cref="AesCrypto"/> from the specified values.
/// </summary>
/// <param name="salt">The <see cref="Salt"/> used in encryption.</param>
/// <param name="passphrase">The <see cref="Passphrase"/> used in encryption.</param>
public AesCrypto(string passphrase, byte[] salt)
{
Passphrase = passphrase;
Salt = salt;
_encryptor = Rijndael.Create();
_encryptor.Padding = PaddingMode.PKCS7;
_pdb = new Rfc2898DeriveBytes(Passphrase, Salt);
_encryptor.Key = _pdb.GetBytes(_encryptor.KeySize / 8);
_encryptor.IV = _pdb.GetBytes(_encryptor.BlockSize / 8);
_encryptorTransform = _encryptor.CreateEncryptor();
_decryptorTransform = _encryptor.CreateDecryptor();
}
/// <summary>
/// Desencripta un objecto
/// </summary>
/// <param name="pObject">Objecto Encriptado</param>
/// <param name="pKey">Clave 1</param>
/// <param name="pIV">Clave 2</param>
/// <returns>Retorna el Objecto Desencriptado</returns>
private static object DecryptObjectFromBytes(byte[] pObject, byte[] pKey, byte[] pIV)
{
//Verifica si los parametros son nulo
if (pObject == null || pObject.Length <= 0)
{
throw new ArgumentNullException();
}
if (pKey == null || pKey.Length <= 0)
{
throw new ArgumentNullException();
}
if (pIV == null || pIV.Length <= 0)
{
throw new ArgumentNullException();
}
//Variable que almacenara el valor del objecto encritado
object vlDecodeObject = null;
//Creamos el algoritmo
System.Security.Cryptography.Rijndael rijndael = System.Security.Cryptography.Rijndael.Create();
//Usamos el algoritmo
using (rijndael)
{
//Le pasamos los valores de las claves al algoritmno
rijndael.Key = pKey;
rijndael.IV = pIV;
//Creamos el Desencriptador
System.Security.Cryptography.ICryptoTransform decryptor = rijndael.CreateDecryptor(rijndael.Key, rijndael.IV);
//Se crean las corrientes para el cifrado
using (MemoryStream msDecrypt = new MemoryStream(pObject))
{
using (System.Security.Cryptography.CryptoStream csDecrypt = new System.Security.Cryptography.CryptoStream(msDecrypt, decryptor, System.Security.Cryptography.CryptoStreamMode.Read))
{
using (StreamReader srDecrypt = new StreamReader(csDecrypt))
{
//Escribe los datos en la secuencia, como un objecto (string)
vlDecodeObject = srDecrypt.ReadToEnd();
}
}
}
}
//Retornamos el objecto desencriptado
return(vlDecodeObject);
}
/// <summary>
/// Decode a string endoced using Rijndael with specified password and IV strings.
/// </summary>
/// <param name="sourceString">The string to decode</param>
/// <param name="password">The password string</param>
/// <param name="IV">The IV string</param>
/// <returns>The decoded string</returns>
public string DecodeString(string sourceString, string password, String IV)
{
if (string.IsNullOrEmpty(password))
{
throw new ArgumentException("Please specify the password", nameof(password));
}
if (string.IsNullOrEmpty(IV))
{
throw new ArgumentException("Please specify the Initialize Vector", nameof(IV));
}
if (!string.IsNullOrEmpty(sourceString))
{
byte[] cipherText = Convert.FromBase64String(sourceString);
string plaintext = null;
// Create an Rijndael object
// with the specified key and IV.
using (System.Security.Cryptography.Rijndael rijAlg = System.Security.Cryptography.Rijndael.Create())
{
rijAlg.Key = GeneratePassword(password);
rijAlg.IV = GeneratePassword(IV);
// Create a decrytor to perform the stream transform.
ICryptoTransform decryptor = rijAlg.CreateDecryptor(rijAlg.Key, rijAlg.IV);
// Create the streams used for decryption.
using (MemoryStream msDecrypt = new MemoryStream(cipherText))
{
using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
{
using (StreamReader srDecrypt = new StreamReader(csDecrypt))
{
// Read the decrypted bytes from the decrypting stream
// and place them in a string.
plaintext = srDecrypt.ReadToEnd();
}
}
}
}
return(plaintext);
}
else
{
return(string.Empty);
}
}
public string Encrypt(string value)
{
System.Security.Cryptography.Rijndael rijndael = System.Security.Cryptography.Rijndael.Create();
byte[] tmp = null;
ICryptoTransform encryptor = rijndael.CreateEncryptor(key, iv);
using (MemoryStream ms = new MemoryStream()) {
using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write)) {
StreamWriter writer = new StreamWriter(cs);
writer.Write(value);
writer.Flush();
}
tmp = ms.ToArray();
}
return(Convert.ToBase64String(tmp));
}
public static string DecryptStringFromBytes(byte[] cipherText, byte[] Key, byte[] IV)
{
// Check arguments.
if (cipherText == null || cipherText.Length <= 0)
{
throw new ArgumentNullException("cipherText");
}
if (Key == null || Key.Length <= 0)
{
throw new ArgumentNullException("Key");
}
if (IV == null || IV.Length <= 0)
{
throw new ArgumentNullException("IV");
}
// Declare the string used to hold
// the decrypted text.
string plaintext = null;
// Create an Rijndael object
// with the specified key and IV.
using (System.Security.Cryptography.Rijndael rijAlg = System.Security.Cryptography.Rijndael.Create())
{
rijAlg.Key = Key;
rijAlg.IV = IV;
// Create a decryptor to perform the stream transform.
ICryptoTransform decryptor = rijAlg.CreateDecryptor(rijAlg.Key, rijAlg.IV);
// Create the streams used for decryption.
using (MemoryStream msDecrypt = new MemoryStream(cipherText))
{
using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
{
using (StreamReader srDecrypt = new StreamReader(csDecrypt))
{
// Read the decrypted bytes from the decrypting stream
// and place them in a string.
plaintext = srDecrypt.ReadToEnd();
}
}
}
}
return(plaintext);
}
private void Initialize()
{
int i;
byte[] buffer3;
RijndaelManaged managed = new RijndaelManaged();
managed.Padding = PaddingMode.None;
this.rijndael = managed;
this.aesInitializationVector = new byte[0x10];
int num = 2 * this.password.Length;
byte[] source = new byte[num + 8];
byte[] bytes = Encoding.Unicode.GetBytes(this.password);
for (i = 0; i < num; i++)
{
source[i] = bytes[i];
}
for (i = 0; i < this.salt.Length; i++)
{
source[i + num] = this.salt[i];
}
SHA1 sha = new SHA1CryptoServiceProvider();
IList<byte> destination = new List<byte>();
for (i = 0; i < 0x40000; i++)
{
Utility.AddRange<byte>(destination, source);
Utility.AddRange<byte>(destination, new byte[] { (byte) i, (byte) (i >> 8), (byte) (i >> 0x10) });
if ((i % 0x4000) == 0)
{
buffer3 = sha.ComputeHash(Enumerable.ToArray<byte>(destination));
this.aesInitializationVector[i / 0x4000] = buffer3[0x13];
}
}
buffer3 = sha.ComputeHash(Enumerable.ToArray<byte>(destination));
byte[] buffer4 = new byte[0x10];
for (i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
buffer4[(i * 4) + j] = (byte) ((((((buffer3[i * 4] * 0x1000000) & 0xff000000L) |
((uint) ((buffer3[(i * 4) + 1] * 0x10000) & 0xff0000))) |
((uint) ((buffer3[(i * 4) + 2] * 0x100) & 0xff00))) |
((uint) (buffer3[(i * 4) + 3] & 0xff))) >> (j * 8));
}
}
this.rijndael.IV = new byte[0x10];
this.rijndael.Key = buffer4;
this.rijndael.BlockSize = 0x80;
}
/// <summary>
/// Encode a string using Rijndael with specified password and IV strings.
/// </summary>
/// <param name="sourceString">The string to encode</param>
/// <param name="password">The password string</param>
/// <param name="IV">The IV string</param>
/// <returns>The encoded string</returns>
public string EncodeString(string sourceString, string password, String IV)
{
if (string.IsNullOrEmpty(password))
{
throw new ArgumentException("Please specify the password", nameof(password));
}
if (string.IsNullOrEmpty(IV))
{
throw new ArgumentException("Please specify the Initialize Vector", nameof(IV));
}
if (!string.IsNullOrEmpty(sourceString))
{
byte[] encrypted;
// Create an Rijndael object
// with the specified key and IV.
using (System.Security.Cryptography.Rijndael rijAlg = System.Security.Cryptography.Rijndael.Create())
{
rijAlg.Key = GeneratePassword(password);
rijAlg.IV = GeneratePassword(IV);
// Create a decrytor to perform the stream transform.
ICryptoTransform encryptor = rijAlg.CreateEncryptor(rijAlg.Key, rijAlg.IV);
// Create the streams used for encryption.
using (MemoryStream msEncrypt = new MemoryStream())
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
{
//Write all data to the stream.
swEncrypt.Write(sourceString);
}
encrypted = msEncrypt.ToArray();
}
}
}
return(Convert.ToBase64String(encrypted));
}
else
{
return(string.Empty);
}
}
public static RijndaelTransform Create(Rijndael rijndael, CipherMode mode, byte[] initializationVector,
int feedbackSizeInBits, PaddingMode paddingMode)
{
switch (mode)
{
case CipherMode.ECB:
return new RijndaelEncryptionEcbTransform(rijndael, paddingMode);
case CipherMode.CBC:
return new RijndaelEncryptionCbcTransform(rijndael, initializationVector, paddingMode);
case CipherMode.OFB:
return new RijndaelOfbTransform(rijndael, initializationVector, paddingMode);
case CipherMode.CFB:
return new RijndaelEncryptionCfbTransform(rijndael, feedbackSizeInBits, initializationVector,
paddingMode);
default:
throw new NotImplementedException(mode + " has not been implemented");
}
}
static byte[] EncryptStringToBytes(string plainText, byte[] Key, byte[] IV)
{
// Check arguments.
if (plainText == null || plainText.Length <= 0)
{
throw new ArgumentNullException("plainText");
}
if (Key == null || Key.Length <= 0)
{
throw new ArgumentNullException("Key");
}
if (IV == null || IV.Length <= 0)
{
throw new ArgumentNullException("IV");
}
byte[] encrypted;
// Create an Rijndael object
// with the specified key and IV.
using (System.Security.Cryptography.Rijndael rijAlg = System.Security.Cryptography.Rijndael.Create())
{
rijAlg.Key = Key;
rijAlg.IV = IV;
// Create an encryptor to perform the stream transform.
ICryptoTransform encryptor = rijAlg.CreateEncryptor(rijAlg.Key, rijAlg.IV);
// Create the streams used for encryption.
using (MemoryStream msEncrypt = new MemoryStream())
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
{
//Write all data to the stream.
swEncrypt.Write(plainText);
}
encrypted = msEncrypt.ToArray();
}
}
}
// Return the encrypted bytes from the memory stream.
return(encrypted);
}
/// <summary>
/// Manda a encriptar un objecto
/// </summary>
/// <param name="pObject">Objecto a encriptar</param>
/// <returns>Retorna el Objecto Encriptado con las Claves</returns>
public static object Encode(object pObject)
{
//Creamos el algoritmo
System.Security.Cryptography.Rijndael rijndael = System.Security.Cryptography.Rijndael.Create();
//Almacenamos las claves
object vlKey = rijndael.Key;
object vlIV = rijndael.IV;
//Usamos el algoritmo
using (rijndael)
{
//Encriptamos el objecto
object vlEncrypted = EncryptObjectToBytes(pObject, rijndael.Key, rijndael.IV);
//Almacenamos en un string[] el objecto encritado
string[] vlEnEncrypted = ((IEnumerable)vlEncrypted).Cast <object>()
.Select(x => x.ToString())
.ToArray();
//Almacenamos en un string[] la clave 1
string[] vlEnKey = ((IEnumerable)vlKey).Cast <object>()
.Select(x => x.ToString())
.ToArray();
//Almacenamos en un string[] la clave 2
string[] vlEnIV = ((IEnumerable)vlIV).Cast <object>()
.Select(x => x.ToString())
.ToArray();
//Creamos el string con los datos encriptados
string vlValueEncode = string.Empty;
vlValueEncode = vlValueEncode + string.Join(",", vlEnEncrypted);
vlValueEncode = vlValueEncode + "/" + string.Join(",", vlEnKey);
vlValueEncode = vlValueEncode + "/" + string.Join(",", vlEnIV);
//Almacenamos en un objecto el string
object vlValueFinal = vlValueEncode;
//Retornamos el objecto
return(vlValueFinal);
}
}
// Encrypt a byte array into a byte array using a key and an IV
public static byte[] Encrypt(byte[] clearData, byte[] Key, byte[] IV)
{
System.IO.MemoryStream ms = new System.IO.MemoryStream();
System.Security.Cryptography.Rijndael alg = System.Security.Cryptography.Rijndael.Create();
// Algorithm. Rijndael is available on all platforms.
alg.Key = Key;
alg.IV = IV;
System.Security.Cryptography.CryptoStream cs =
new System.Security.Cryptography.CryptoStream(ms, alg.CreateEncryptor(),
System.Security.Cryptography.CryptoStreamMode.Write);
//CryptoStream is for pumping our data.
cs.Write(clearData, 0, clearData.Length);
cs.Close();
byte[] encryptedData = ms.ToArray();
return(encryptedData);
}
public SimpleAES(string password)
{
_rijndael = Rijndael.Create();
_rijndael.Padding = PaddingMode.Zeros;
Rfc2898DeriveBytes pdb = null;
try
{
pdb = new Rfc2898DeriveBytes(password, SALT);
_rijndael.Key = pdb.GetBytes(32);
_rijndael.IV = pdb.GetBytes(16);
}
finally
{
IDisposable disp = pdb as IDisposable;
if (disp != null)
{
disp.Dispose();
}
}
}
public string Encode(string input)
{
System.Security.Cryptography.Rijndael alg = System.Security.Cryptography.Rijndael.Create();
alg.Key = Encoding.UTF8.GetBytes("kaudkwudhtbenwnakaudkwudhtbenwna");
alg.IV = Encoding.UTF8.GetBytes("HR$2pIjHR$2pIj12");
alg.Padding = PaddingMode.Zeros;
ICryptoTransform encryptor = alg.CreateEncryptor(alg.Key, alg.IV);
using (MemoryStream msEncrypt = new MemoryStream())
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
{
swEncrypt.Write(input);
}
return(Encoding.Unicode.GetString(msEncrypt.ToArray()));
}
}
}
public string Decode(string input)
{
System.Security.Cryptography.Rijndael alg = System.Security.Cryptography.Rijndael.Create();
alg.Key = Encoding.UTF8.GetBytes("kaudkwudhtbenwnakaudkwudhtbenwna");
alg.IV = Encoding.UTF8.GetBytes("HR$2pIjHR$2pIj12");
alg.Padding = PaddingMode.Zeros;
string result;
ICryptoTransform decryptor = alg.CreateDecryptor(alg.Key, alg.IV);
using (MemoryStream msDecrypt = new MemoryStream(Encoding.Unicode.GetBytes(input)))
{
using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
{
using (StreamReader srDecrypt = new StreamReader(csDecrypt))
{
result = srDecrypt.ReadToEnd();
}
}
}
return(result);
}
public bool Decrypt(ref string value)
{
string result = string.Empty;
System.Security.Cryptography.Rijndael rijndael = System.Security.Cryptography.Rijndael.Create();
ICryptoTransform decryptor = rijndael.CreateDecryptor(key, iv);
using (MemoryStream ms = new MemoryStream(Convert.FromBase64String(value))) {
try {
using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read)) {
StreamReader reader = new StreamReader(cs);
result = reader.ReadLine();
reader.Close();
}
} catch (System.Security.Cryptography.CryptographicException ex) {
value = ex.Message;
return(false);
}
}
value = result;
return(true);
}
private void btnEncrypt_Click(object sender, RoutedEventArgs e)
{
if (_ifEncrypted)
return;
DateTime dt = DateTime.UtcNow;
switch(AlgIndex)
{
case (int)EnumAlgorithm.AES:
algAES = new AesManaged();
encrypted = Encrypt.EncryptStringToBytes_Aes(TextPlain.Text, algAES.Key, algAES.IV);
TextEncrypted.Text = Encoding.Unicode.GetString(encrypted);
break;
case (int)EnumAlgorithm.DES:
tripleDES = new TripleDESCryptoServiceProvider();
encrypted = Encrypt.EncryptStringToBytes_Des(TextPlain.Text, tripleDES.Key, tripleDES.IV);
TextEncrypted.Text = Encoding.Unicode.GetString(encrypted);
break;
case (int)EnumAlgorithm.RIJ:
algRIJ = Rijndael.Create();
encrypted = Encrypt.EncryptStringToBytes_Rij(TextPlain.Text, algRIJ.Key, algRIJ.IV);
TextEncrypted.Text = Encoding.Unicode.GetString(encrypted);
break;
case (int)EnumAlgorithm.DSA:
break;
case (int)EnumAlgorithm.RSA:
rsaCrypt = new RSACryptoServiceProvider();
string publickeyRSA = rsaCrypt.ToXmlString(false);//公钥
encrypted = Encrypt.EncryptStringToBytes_Rsa(TextPlain.Text, publickeyRSA);
TextEncrypted.Text = Encoding.Unicode.GetString(encrypted);
break;
default:
break;
}
lbTime.Content = DateTime.UtcNow.Subtract(dt).ToString();
_ifEncrypted = true;
}
protected virtual Stream GetOutputStream(Rijndael alg, AppServerConfigOptions options, string configFilePath)
{
Stream outStream = new FileStream(configFilePath, FileMode.CreateNew);
switch (options)
{
case AppServerConfigOptions.FileEncrypted:
outStream = new CryptoStream(outStream, alg.CreateEncryptor(), CryptoStreamMode.Write);
outStream = new GZipStream(outStream, CompressionMode.Compress);
break;
}
return outStream;
}
private static void SetupEncryption()
{
rijn = Rijndael.Create();
rijn.KeySize = ENC_Key.Length * 8;
rijn.Key = ENC_Key;
rijn.IV = ENC_IV;
rijn.Padding = PaddingMode.ISO10126;
rijn.Mode = CipherMode.CBC;
encryptor = rijn.CreateEncryptor();
decryptor = rijn.CreateDecryptor();
}
protected virtual void ConfigurationWriteCompletionBinary(Rijndael alg, AppServerConfigOptions options, int size,
string configFileConfirmPath, Stream outgoing, Guid ApplicationID)
{
byte[] data = null;
switch (options)
{
case AppServerConfigOptions.FileDigitallySigned:
data = GenerateHash(outgoing);
break;
case AppServerConfigOptions.FileEncrypted:
byte[] buffer = GenerateCryptoBlob(alg, size);
if (buffer != null)
{
data = ProtectedData.Protect(buffer, ApplicationID.ToByteArray(), DataProtectionScope.LocalMachine);
}
break;
}
if (data != null)
File.WriteAllBytes(configFileConfirmPath, data);
}
internal RijndaelManagedTransform(Rijndael algo, bool encryption, byte[] key, byte[] iv)
{
_st = new RijndaelTransform(algo, encryption, key, iv);
_bs = algo.BlockSize;
}
public static String Encrypt(byte[] clearText, String publicKey, Rijndael aes)
{
StringWriter cipherText = new StringWriter();
ArrayList message = new ArrayList();
message.AddRange(RSAEncrypt(aes.Key, publicKey));
message.AddRange(RSAEncrypt(aes.IV, publicKey));
message.AddRange(AESEncrypt(clearText, aes.CreateEncryptor()));
String messageArmor = Convert.ToBase64String((byte[]) message.ToArray(Type.GetType("System.Byte")));
cipherText.WriteLine(BeginMessage);
cipherText.WriteLine("Version: PractiSES {0} (Win32)",
Assembly.GetExecutingAssembly().GetName().Version.ToString(2));
cipherText.WriteLine();
cipherText.WriteLine(Util.Wrap(messageArmor, Wrap));
cipherText.WriteLine(EndMessage);
return cipherText.ToString();
}
/// <summary>Creates a cryptographic object to perform the <see cref="T:System.Security.Cryptography.Rijndael" /> algorithm.</summary>
/// <returns>A cryptographic object.</returns>
/// <exception cref="T:System.Reflection.TargetInvocationException">The algorithm was used with Federal Information Processing Standards (FIPS) mode enabled, but is not FIPS compatible.</exception>
// Token: 0x06002314 RID: 8980 RVA: 0x0007DD99 File Offset: 0x0007BF99
public new static Rijndael Create()
{
return(Rijndael.Create("System.Security.Cryptography.Rijndael"));
}
public Seguridad()
{
rijndael = Rijndael.Create();
key = UTF8Encoding.UTF8.GetBytes("C80BA5028D1E81E3042EBF1649D8ED31");//LLave maestra
iv = UTF8Encoding.UTF8.GetBytes("serviciosWeb2015");// Semilla
}
public Rijndael()
{
this._r = System.Security.Cryptography.Rijndael.Create();
}
public RijndaelEncryptionCbcTransform(Rijndael rijndael, byte[] initializationVector, PaddingMode paddingMode)
: base(rijndael, paddingMode)
{
_LastVector = ByteUtilities.Clone(initializationVector);
}
public EDObject(Rijndael _rijindael)
{
rijndael = _rijindael;
}
protected virtual byte[] GenerateCryptoBlob(Rijndael alg, int size)
{
byte[] blob = new byte[12 + alg.Key.Length + alg.IV.Length];
int position = 0;
position = WriteInt32(alg.Key.Length, blob, 0);
position = WriteInt32(alg.IV.Length, blob, position);
position = WriteInt32(size, blob, position);
Buffer.BlockCopy(alg.Key, 0, blob, position, alg.Key.Length);
position += alg.Key.Length;
Buffer.BlockCopy(alg.IV, 0, blob, position, alg.IV.Length);
return blob;
}
//initialize from an encrypted file
public TimeBomb(String file, Rijndael crypt, DetonateHandler detonate, DecryptFile decrypt)
{
//read the date time value from the file
BinaryReader reader = decrypt.Invoke(file, crypt);
String str = reader.ReadString();
this.detonateTime = DateTime.Parse(str);//reader.ReadLine()
this.detonate.detonate += detonate;
thrd = new Thread(new ThreadStart(() => {
while (true) {
//if we are past time to detonate, then detonate
if (detonateTime.CompareTo(DateTime.Now) < 0) {
this.detonate.OnDetonateEvent();
return;
}
Thread.Sleep(1000);
}//end loop
}));
thrd.Priority = ThreadPriority.Lowest;
thrd.Start();
}
public RijndaelDecryptionEcbTransform(Rijndael rijndael, PaddingMode paddingMode)
: base(rijndael, paddingMode)
{
}
/// <summary>
/// This is the reset method to set the content.
/// </summary>
public override void Reset()
{
if (mDataStream != null)
mDataStream.Close();
mDataStream = null;
mFileStream = null;
mCompressed = true;
mCompStream = null;
mEncrypted = false;
mEncrStream = null;
mRijndaelAlg = null;
mHashed = true;
mDataHash = null;
mCreateTime = null;
mDataStoreLocation = null;
mMessageID = null;
base.Reset();
}
public void Dispose()
{
if (_rijndael != null)
{
_rijndael.Clear();
_rijndael = null;
}
}
internal RijndaelManagedTransform (Rijndael algo, bool encryption, byte[] key, byte[] iv)
{
_st = new RijndaelTransform (algo, encryption, key, iv);
_bs = algo.BlockSize;
}
/// <summary>
/// This method reads the metadata from the metadata stream.
/// </summary>
/// <param name="r">The binary reader for the stream.</param>
public virtual void Read(BinaryReader r)
{
mEncrypted = r.ReadBoolean();
if (Encrypted)
{
byte[] mRijndaelAlgKey, mRijndaelAlgIV;
ReadVal(r, out mRijndaelAlgKey);
ReadVal(r, out mRijndaelAlgIV);
RijndaelAlg = new RijndaelManaged();
RijndaelAlg.Key = mRijndaelAlgKey;
RijndaelAlg.IV = mRijndaelAlgIV;
}
mHashed = r.ReadBoolean();
if (Hashed)
{
ReadVal(r, out mDataHash);
}
mCompressed = r.ReadBoolean();
Length = r.ReadInt64();
ReadVal(r, out mCreateTime);
}
public static BinaryReader Decrypt(String file, Rijndael crypt)
{
ICryptoTransform transform = crypt.CreateDecryptor();
FileStream fs = new FileStream(file, FileMode.Open, FileAccess.Read);
CryptoStream cs = new CryptoStream(fs, transform, CryptoStreamMode.Read);
return new BinaryReader(cs);
}
public void SetUp ()
{
aes = Rijndael.Create ();
}
protected RijndaelTransform(Rijndael rijndael, PaddingMode paddingMode)
{
_Rijndael = rijndael;
_PaddingMode = paddingMode;
}
