public byte[] Encrypt(byte[] bytes) { using (MemoryStream ms = new MemoryStream()) using (CryptoStream cs = new CryptoStream(ms, rijndael.CreateEncryptor(), CryptoStreamMode.Write)) { cs.Write(bytes, 0, bytes.Length); //cs.FlushFinalBlock(); cs.Close(); return(ms.ToArray()); } }
public string Encrypt(string str) { byte[] bytes = Encoding.Unicode.GetBytes(str); MemoryStream ms = new MemoryStream(); CryptoStream cs = new CryptoStream(ms, rijndael.CreateEncryptor(), CryptoStreamMode.Write); cs.Write(bytes, 0, bytes.Length); cs.Close(); bytes = ms.ToArray(); return(Convert.ToBase64String(bytes)); }
/// <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); }
/// <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(); }
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)); }
/// <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); } }
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); }
// 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 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())); } } }
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(); }
public void setUpRijndael(byte[] key, byte[] iv) { _rijndael = new RijndaelManaged(); _rijndael.Key = key; _rijndael.IV = iv; _rijEncryptor = _rijndael.CreateEncryptor(_rijndael.Key, _rijndael.IV); _rijDecryptor = _rijndael.CreateDecryptor(_rijndael.Key, _rijndael.IV); }
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 byte[] AES_Encrypt(byte[] clearData, 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.CreateEncryptor(), System.Security.Cryptography.CryptoStreamMode.Write); cryptoStream.Write(clearData, 0, clearData.Length); cryptoStream.Close(); return(memoryStream.ToArray()); }
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(); }
internal 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(); alg.Key = Key; alg.IV = IV; System.Security.Cryptography.CryptoStream cs = new System.Security.Cryptography.CryptoStream(ms, alg.CreateEncryptor(), System.Security.Cryptography.CryptoStreamMode.Write); cs.Write(clearData, 0, clearData.Length); cs.Close(); byte[] encryptedData = ms.ToArray(); return(encryptedData); }
internal static void Encrypt(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.CreateEncryptor(), 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); // encrypt it cs.Write(buffer, 0, bytesRead); } while (bytesRead != 0); cs.Close(); fsIn.Close(); }
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()); }
/// <summary> /// This method returns a writeable data stream. /// </summary> /// <returns></returns> protected virtual Stream DataStreamWrite() { Stream outStream = null; ; RijndaelAlg = new RijndaelManaged(); try { mFileStream = new FileStream(BinaryDataFileName, FileMode.CreateNew, FileAccess.Write, FileShare.None); outStream = mFileStream; if (Encrypted) { mEncrStream = new CryptoStream(outStream, RijndaelAlg.CreateEncryptor(), CryptoStreamMode.Write); outStream = mEncrStream; } if (Compressed) { mCompStream = new GZipStream(outStream, CompressionMode.Compress); outStream = mCompStream; } outStream = new StreamCounter(outStream); } catch (Exception ex) { //Just make sure that we don't leave anything open in case there is an error. if (outStream != null) outStream.Close(); mFileStream = null; mEncrStream = null; mCompStream = null; } return outStream; }
public static string Encrypt(string strEncrypt, bool retStrOriginal) { byte[] bytes = System.Text.Encoding.UTF8.GetBytes(Secret.AES.Key); byte[] bytes2 = System.Text.Encoding.UTF8.GetBytes(Secret.AES.IV); byte[] bytes3 = System.Text.Encoding.UTF8.GetBytes(strEncrypt); string result = string.Empty; System.Security.Cryptography.Rijndael rijndael = System.Security.Cryptography.Rijndael.Create(); try { using (MemoryStream memoryStream = new MemoryStream()) { using (System.Security.Cryptography.CryptoStream cryptoStream = new System.Security.Cryptography.CryptoStream(memoryStream, rijndael.CreateEncryptor(bytes, bytes2), System.Security.Cryptography.CryptoStreamMode.Write)) { cryptoStream.Write(bytes3, 0, bytes3.Length); cryptoStream.FlushFinalBlock(); result = Convert.ToBase64String(memoryStream.ToArray()); } } } catch { if (retStrOriginal) { result = strEncrypt; } else { result = string.Empty; } } rijndael.Clear(); return(result); }