//Copyright (C) 2011, Dextrey (0xDEADDEAD)
public static byte[] PolyAESEncrypt(byte[] plainText, string Key)
{
byte[] salt;
SymmetricAlgorithm algo = new RijndaelManaged();
RNGCryptoServiceProvider rngAlgo = new RNGCryptoServiceProvider();
algo.Mode = CipherMode.CBC;
byte[] key = System.Text.Encoding.ASCII.GetBytes(Key);
algo.GenerateIV();
salt = new byte[32];
rngAlgo.GetBytes(salt);
Rfc2898DeriveBytes pwDeriveAlg = new Rfc2898DeriveBytes(key, salt, 2000);
algo.Key = pwDeriveAlg.GetBytes(32);
ICryptoTransform encTransform = algo.CreateEncryptor();
byte[] enced = encTransform.TransformFinalBlock(plainText, 0, plainText.Length);
int origLength = enced.Length;
Array.Resize(ref enced, enced.Length + salt.Length);
Buffer.BlockCopy(salt, 0, enced, origLength, salt.Length);
origLength = enced.Length;
Array.Resize(ref enced, enced.Length + algo.IV.Length);
Buffer.BlockCopy(algo.IV, 0, enced, origLength, algo.IV.Length);
return enced;
}
public AESEncryptStream(byte[] aesKey, Stream data, bool readMode)
{
if (readMode && !data.CanRead)
{
throw new ArgumentException("Underlying stream is not readable", "data");
}
if (!readMode && !data.CanWrite)
{
throw new ArgumentException("Underlying stream is not writable", "data");
}
_internalStream = data;
_isRead = readMode;
var aesProvider = new RijndaelManaged();
aesProvider.Key = aesKey;
aesProvider.GenerateIV();
var encryptor = aesProvider.CreateEncryptor();
_cryptoStream = new CryptoStream(data, encryptor, _isRead ? CryptoStreamMode.Read : CryptoStreamMode.Write);
_initialBytesWritten = 0;
_initialBytes = new byte[aesProvider.IV.Length + 4];
Buffer.BlockCopy(BitConverter.GetBytes(aesProvider.IV.Length), 0, _initialBytes, 0, 4);
Buffer.BlockCopy(aesProvider.IV, 0, _initialBytes, 4, aesProvider.IV.Length);
}
public IConfigCommand Encrypt(String password) {
// Hard error if no password is passed through, but the data is requested to be encrypted.
if (password == null || password.Length <= 0) throw new ArgumentNullException("password");
using (RijndaelManaged managed = new RijndaelManaged()) {
// Generate a new salt.
byte[] salt = this.GenerateSalt();
this.Salt = Convert.ToBase64String(salt);
// Generate new vector.
managed.GenerateIV();
this.Vector = Convert.ToBase64String(managed.IV);
// Derive a key
byte[] key = this.DeriveKey(password, salt);
using (StringWriter writer = new StringWriter()) {
Potato.Core.Shared.Serialization.JsonSerialization.Minimal.Serialize(writer, this.Command);
byte[] text = Encoding.UTF8.GetBytes(writer.ToString());
using (ICryptoTransform transform = managed.CreateEncryptor(key, managed.IV)) {
this.Data = Convert.ToBase64String(this.CryptoTransform(text, transform));
}
}
}
// Don't store the unencrypted data.
this.Command = null;
return this;
}
public static String Cifrar(String contenido, String clave)
{
//tipo de codificacion
var encoding = new UTF8Encoding();
//determina cual es el algoritmo de cifrado
var cripto = new RijndaelManaged();
//texto q yo quiero cifrar
byte[] cifrado;
//array que contiene el IV mas el txt cifrado
byte[] retorno;
//convierte la clave en array de bytes
byte[] key = GeyKey(clave);
cripto.Key = key;
//genera array de inicializacion
cripto.GenerateIV();
//el texto a encriptar lo convierte en array de byte
byte[] aEncriptar = encoding.GetBytes(contenido);
//con el IV y la clave crea un encriptador al final del bloque( el q transforma, dnd empieza, dnd termina)
cifrado = cripto.CreateEncryptor().TransformFinalBlock(aEncriptar, 0, aEncriptar.Length);
//prepara lo q va a devolver. Array de bytes q esta compuesto de la longitud del IV mas la longitud de lo q he cifrado
retorno = new byte[cripto.IV.Length + cifrado.Length];
//me copias el array del IV empezando en la longitud 0
cripto.IV.CopyTo(retorno, 0);
cifrado.CopyTo(retorno, cripto.IV.Length);
return Convert.ToBase64String(retorno);
}
public static byte[] GenerateIV()
{
RijndaelManaged provider = new RijndaelManaged();
provider.GenerateIV();
return provider.IV;
}
/// <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
}
public static string Cifrar(String contenido, String clave)
{
//para codificar el texto que quiero cifrar
var encoding = new UTF8Encoding();
var cripto=new RijndaelManaged();
byte[] cifrado;
byte[] retorno;
//clave generada en bytes
byte[] key = GetKey(clave);
//asigno la clave y ek IV
cripto.Key = key;
cripto.GenerateIV();
byte[] aEncriptar = encoding.GetBytes(contenido);
//Creo un encriptador CreateEncryptor() el array aEncriptar desde posicion 0
cifrado = cripto.CreateEncryptor().TransformFinalBlock(aEncriptar, 0, aEncriptar.Length);
//el array retorno sera = la suma del vector mas longitud del cifrado
retorno = new byte[cripto.IV.Length + cifrado.Length];
//copias IV desde la posicion 0
cripto.IV.CopyTo(retorno,0);
cifrado.CopyTo(retorno,cripto.IV.Length);
//convierto la cadena en base 64, por ejemplo una imagen, word, etc
//contienetodo el flujo de datos
return Convert.ToBase64String(retorno);
}
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);
}
public static byte[] Encrypt(byte[] input)
{
if (_key == null || _key.Length == 0) throw new Exception("Key can not be empty.");
if (input == null || input.Length == 0) throw new ArgumentException("Input can not be empty.");
byte[] data = input, encdata = new byte[0];
try
{
using (var ms = new MemoryStream())
{
using (var rd = new RijndaelManaged { Key = _key })
{
rd.GenerateIV();
using (var cs = new CryptoStream(ms, rd.CreateEncryptor(), CryptoStreamMode.Write))
{
ms.Write(rd.IV, 0, rd.IV.Length); // write first 16 bytes IV, followed by encrypted message
cs.Write(data, 0, data.Length);
}
}
encdata = ms.ToArray();
}
}
catch
{
}
return encdata;
}
/// encrypt a string message using a secret key that is known to both sender and recipient only;
/// need to give the initialization vector to the recipient as well;
static public bool Encrypt(byte[] ASecretKey, string AMessage, out string AEncryptedMessage, out string AInitializationVector)
{
Rijndael alg = new RijndaelManaged();
alg.Key = ASecretKey;
alg.GenerateIV();
MemoryStream ms = new MemoryStream();
CryptoStream encryptStream = new CryptoStream(
ms,
alg.CreateEncryptor(),
CryptoStreamMode.Write);
System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
byte[] toEncryptBytes = enc.GetBytes(AMessage);
encryptStream.Write(toEncryptBytes, 0, toEncryptBytes.Length);
encryptStream.Close();
AEncryptedMessage = Convert.ToBase64String(ms.ToArray());
AInitializationVector = Convert.ToBase64String(alg.IV);
return true;
}
/// Generates a unique encryption vector
public static byte[] GenerateEncryptionVector()
{
//Generate a Vector
RijndaelManaged rm = new RijndaelManaged();
rm.GenerateIV();
return rm.IV;
}
public static String Cifrar(String contenido, String clave)
{
var encoding = new UTF8Encoding();
var cripto = new RijndaelManaged();
//contenido cifrado
byte[] cifrado;
//array que contiene IV + texto cifrado
byte[] retorno;
byte[] key = GetKey(clave);
cripto.Key = key;
//IV es el patron a partir del cual el algoritmo genera el cifrado
cripto.GenerateIV();
byte[] aEncriptar = encoding.GetBytes(contenido);
cifrado = cripto.CreateEncryptor().TransformFinalBlock(aEncriptar, 0, aEncriptar.Length);
retorno = new byte[cripto.IV.Length + cifrado.Length];
cripto.IV.CopyTo(retorno, 0);
cifrado.CopyTo(retorno, cripto.IV.Length);
return Convert.ToBase64String(retorno);
}
public static IVCryptoStream Save(string path, byte[] key, byte[] iv)
{
FileStream file = new FileStream(path, FileMode.Create);
RijndaelManaged crypt = new RijndaelManaged();
crypt.Key = key;
if (iv == null)
crypt.GenerateIV();
else
{
Debug.Assert(iv.Length == crypt.IV.Length);
crypt.IV = iv;
}
try
{
file.Write(crypt.IV, 0, crypt.IV.Length);
}
catch
{
file.Dispose();
}
return new IVCryptoStream(file, crypt.CreateEncryptor(), CryptoStreamMode.Write);
}
EncryptedValue IEncryptionService.Encrypt(string value)
{
if (Key == null)
throw new InvalidOperationException("Cannot encrypt because a Key was not configured. Please specify 'RijndaelEncryptionServiceConfig' in your application's configuration file.");
using (var rijndael = new RijndaelManaged())
{
rijndael.Key = Key;
rijndael.Mode = CipherMode.CBC;
rijndael.GenerateIV();
using (var encryptor = rijndael.CreateEncryptor())
using (var memoryStream = new MemoryStream())
using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
using (var writer = new StreamWriter(cryptoStream))
{
writer.Write(value);
writer.Flush();
cryptoStream.Flush();
cryptoStream.FlushFinalBlock();
return new EncryptedValue
{
EncryptedBase64Value = Convert.ToBase64String(memoryStream.ToArray()),
Base64Iv = Convert.ToBase64String(rijndael.IV)
};
}
}
}
public static string Cifrar(string contenido, string clave)
{
var encoding=new UTF8Encoding();
//cifrado asimetrico: se usa cuando se quiera compartir con otros, cuando vaya a viajar
//y/o tenga que cifrar o descifrar con otra persona (en un trabajo en equipo)
//cifrado simetrico: yo mismo conmigo mismo.
var cripto=new RijndaelManaged();
byte[] cifrado;
byte[] retorno;
//la key es un valor fijo, que se define (por ej en el webconfig )
//y de una clave alfanumerica obtenemos su transformación en un array de bytes
var key = GetKey(clave);
//La clave se crea con la key que contiene el array de datos
cripto.Key = key;
//El IV es a partir de lo que genera la encriptaciópn. Es un array de bytes
cripto.GenerateIV();
byte[] aEncriptar = encoding.GetBytes(contenido);
//Crea toda la encriptación desde la posición 0 hasta toda la longitud.
cifrado = cripto.CreateEncryptor().TransformFinalBlock(aEncriptar, 0, aEncriptar.Length);
//El tamaño del array de retorno es la suma del tamaño de IV + tamaño del cifrado
retorno=new byte[cripto.IV.Length + cifrado.Length];
//Estas dos lineas son para copiar el contenido de IV y cifrado.
//CopyTo tiene dos argumentos, que son qué copiar y desde que posición
cripto.IV.CopyTo(retorno,0);
cifrado.CopyTo(retorno,cripto.IV.Length);
//Se devuelve el array de bytes de cifrado en forma de cadena de texto aunque se puede
//dejar en bytes para guardarlo en la base de datos
return Convert.ToBase64String(retorno);
}
public CryptoIV()
{
RijndaelManaged symmetricAlgorithm = new RijndaelManaged();
symmetricAlgorithm.GenerateIV();
_protectedIV = CryptoUtils.ProtectString(Convert.ToBase64String(symmetricAlgorithm.IV));
KeySize = symmetricAlgorithm.BlockSize / 8;
}
public EncryptedValue Encrypt(string value)
{
using (var rijndael = new RijndaelManaged())
{
rijndael.Key = Key;
rijndael.Mode = CipherMode.CBC;
rijndael.GenerateIV();
using (var encryptor = rijndael.CreateEncryptor())
using (var memoryStream = new MemoryStream())
using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
using (var writer = new StreamWriter(cryptoStream))
{
writer.Write(value);
writer.Flush();
cryptoStream.Flush();
cryptoStream.FlushFinalBlock();
return new EncryptedValue
{
EncryptedBase64Value = Convert.ToBase64String(memoryStream.ToArray()),
Base64Iv = Convert.ToBase64String(rijndael.IV)
};
}
}
}
public byte[] CreateIV()
{
var r = new RijndaelManaged();
r.GenerateIV();
var result = r.IV;
r.Dispose();
return result;
}
public static string Encrypt(string unencrypted)
{
var rm = new RijndaelManaged();
rm.GenerateIV();
var IV = rm.IV;
var cryptogram = IV.Concat(Encrypt(_encoder.GetBytes(unencrypted), IV));
return Convert.ToBase64String(cryptogram.ToArray());
}
public Base64EncodedRijndaelKeyVectorPair()
{
RijndaelManaged rm = new RijndaelManaged();
rm.GenerateKey();
rm.GenerateIV();
this.Key = Convert.ToBase64String(rm.Key);
this.IV = Convert.ToBase64String(rm.IV);
}
static void Main(string[] args)
{
RijndaelManaged rm = new RijndaelManaged();
rm.GenerateKey();
rm.GenerateIV();
string key = Convert.ToBase64String(rm.Key);
string iv = Convert.ToBase64String(rm.IV);
}
public static byte[] Encrypt(string unencryptedString) {
using (var myRijndael = new RijndaelManaged()) {
myRijndael.GenerateKey();
myRijndael.GenerateIV();
return EncryptStringToBytes(unencryptedString, myRijndael.Key, myRijndael.IV);
}
}
/// <summary>
/// Genera un vettore iniziale compatibile per la trasmissione in URL che deve essere utilizzato per poter decifrare un messaggio cifrato.
/// </summary>
/// <returns>Segreto</returns>
public string GeneraVettore()
{
using (var myRijndael = new RijndaelManaged())
{
myRijndael.GenerateIV();
return HttpServerUtility.UrlTokenEncode(myRijndael.IV);
}
}
public static string Decrypt(byte[] encryptedString) {
using (var myRijndael = new RijndaelManaged()) {
myRijndael.GenerateKey();
myRijndael.GenerateIV();
return DecryptStringFromBytes(encryptedString, myRijndael.Key, myRijndael.IV);
}
}
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);
}
public AESKeyAndIVGenerator ()
{
rijndaelManaged = new RijndaelManaged();
rijndaelManaged.KeySize = 256;
rijndaelManaged.GenerateKey ();
rijndaelManaged.GenerateIV ();
aesKey = rijndaelManaged.Key;
aesIV = rijndaelManaged.IV;
}
public String Encrypt(String StringToEncrypt, String Key32)
{
if (Key32.Length != 32) return String.Empty;
if (StringToEncrypt == String.Empty) return String.Empty;
RijndaelManaged myRijndael = new RijndaelManaged();
myRijndael.Key = str_to_bytes(Key32);
myRijndael.GenerateIV();
String encrypted = Convert.ToBase64String(encryptStringToBytes_AES(StringToEncrypt, myRijndael.Key, myRijndael.IV), Base64FormattingOptions.None);
String iv = Convert.ToBase64String(myRijndael.IV, Base64FormattingOptions.None);
return iv + "|" + encrypted;
}
/// <summary>
/// Generates a new salt
/// </summary>
public string GenerateNewIv()
{
var rijndael = new RijndaelManaged
{
Key = key
};
rijndael.GenerateIV();
return Convert.ToBase64String(rijndael.IV);
}
//[MenuItem("Hugula AES/GenerateIV", false, 13)]
public static void GenerateIV()
{
using (System.Security.Cryptography.RijndaelManaged myRijndael = new System.Security.Cryptography.RijndaelManaged()) {
myRijndael.GenerateIV();
byte[] IV = myRijndael.IV;
KeyVData KeyScri = ScriptableObject.CreateInstance <KeyVData>();
KeyScri.IV = IV;
AssetDatabase.CreateAsset(KeyScri, "Assets/Config/K81.asset");
Debug.Log("IV Generate " + IV.Length);
}
}
/// <summary>
/// 共通キーと初期化ベクトルを返す
/// </summary>
/// <param name="key">作成された共通キー</param>
/// <param name="IV">作成された初期化ベクトル</param>
public static void CreateKeys(out byte[] key, out byte[] IV)
{
using (RijndaelManaged aes = new RijndaelManaged())
{
aes.KeySize = 256;
aes.GenerateKey();
aes.GenerateIV();
key = aes.Key;
IV = aes.IV;
}
}
//[MenuItem("Hugula AES/GenerateIV", false, 13)]
public static void GenerateIV()
{
using (System.Security.Cryptography.RijndaelManaged myRijndael = new System.Security.Cryptography.RijndaelManaged()) {
myRijndael.GenerateIV ();
byte[] IV=myRijndael.IV;
KeyVData KeyScri=ScriptableObject.CreateInstance<KeyVData>();
KeyScri.IV=IV;
AssetDatabase.CreateAsset(KeyScri,"Assets/Config/K81.asset");
Debug.Log("IV Generate "+IV.Length);
}
}
byte[] GenerateIv()
{
using (var c = new RijndaelManaged()
{
KeySize = 256, // defaults to 256, it's better to be explicit.
BlockSize = 256, // defaults to 128 bits, so let's set this to 256 for better security
Mode = CipherMode.CBC,
Padding = PaddingMode.ISO10126, // adds random padding bytes which reduces the predictability of the plain text
})
{
c.GenerateIV();
return c.IV;
}
}
public static IV GenerateRandomIv(AllowedBlockSizes blockSize)
{
byte[] ivBytes = new byte[(int)blockSize / 8];
using (var rijndael = new RijndaelManaged())
{
rijndael.BlockSize = (int)blockSize;
rijndael.GenerateIV();
rijndael.IV.CopyTo(ivBytes, 0);
}
return new IV(ivBytes);
}
public static byte[] smethod_4(byte[] byte_0, string string_0)
{
System.Security.Cryptography.SymmetricAlgorithm symmetricAlgorithm = new System.Security.Cryptography.RijndaelManaged();
System.Security.Cryptography.RNGCryptoServiceProvider rNGCryptoServiceProvider = new System.Security.Cryptography.RNGCryptoServiceProvider();
symmetricAlgorithm.Mode = System.Security.Cryptography.CipherMode.CBC;
byte[] bytes = System.Text.Encoding.ASCII.GetBytes(string_0);
symmetricAlgorithm.GenerateIV();
byte[] array = new byte[32];
rNGCryptoServiceProvider.GetBytes(array);
System.Security.Cryptography.Rfc2898DeriveBytes rfc2898DeriveBytes = new System.Security.Cryptography.Rfc2898DeriveBytes(bytes, array, 2000);
symmetricAlgorithm.Key = rfc2898DeriveBytes.GetBytes(32);
System.Security.Cryptography.ICryptoTransform cryptoTransform = symmetricAlgorithm.CreateEncryptor();
byte[] array2 = cryptoTransform.TransformFinalBlock(byte_0, 0, byte_0.Length);
int dstOffset = array2.Length;
System.Array.Resize <byte>(ref array2, array2.Length + array.Length);
System.Buffer.BlockCopy(array, 0, array2, dstOffset, array.Length);
dstOffset = array2.Length;
System.Array.Resize <byte>(ref array2, array2.Length + symmetricAlgorithm.IV.Length);
System.Buffer.BlockCopy(symmetricAlgorithm.IV, 0, array2, dstOffset, symmetricAlgorithm.IV.Length);
return(array2);
}
public override void GenerateIV()
{
m_rijndael.GenerateIV();
}
