public string Encrypt(string data) { try { List <byte> hexString = new List <byte>(Encoding.Default.GetBytes(data)); while (hexString.Count % 16 != 0) { hexString.Add(0x00); } _rijndael.Key = _chatKey; CryptoStream stream = new CryptoStream(new MemoryStream(hexString.ToArray()), _rijndael.CreateEncryptor(), CryptoStreamMode.Read); MemoryStream textBytes = new MemoryStream(); #if NET20 || NET35 byte[] buffer = new byte[1024]; int read = stream.Read(buffer, 0, buffer.Length); stream.Flush(); textBytes.Write(buffer, 0, read); #else stream.CopyTo(textBytes); #endif return(Convert.ToBase64String(textBytes.ToArray())); } catch (CryptographicException e) { Debug.WriteLine("A Cryptographic error occurred: {0}", e.Message); return(null); } }
/// <summary> /// Lädt einen Kontakt aus einer Datei. /// </summary> /// <param name="file">Datei, aus der der Kontakt geladen werden soll.</param> /// <returns></returns> public static Contact OpenContact(string file, string key, string iv) { FileStream stream = null; CryptoStream cryptoStream = null; BinaryFormatter formatter = null; try { stream = new FileStream(file, FileMode.Open); cryptoStream = new CryptoStream(stream, StaticCryptByKey(key, iv).CreateDecryptor(), CryptoStreamMode.Read); formatter = new BinaryFormatter(); return((Contact)formatter.Deserialize(cryptoStream)); } catch (FileNotFoundException) { MessageBox.Show("Der Kontakt konnte nicht geöffnet werden!", "Error!", MessageBoxButtons.OK, MessageBoxIcon.Error); return(null); } finally { stream.Flush(); cryptoStream.Flush(); cryptoStream.Close(); stream.Close(); } }
public static string Decrypt(this string text, string lKey) { try { using (Aes aes = new AesManaged()) { Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(Encoding.UTF8.GetString(IVa, 0, IVa.Length), Encoding.UTF8.GetBytes(lKey)); aes.Key = deriveBytes.GetBytes(128 / 8); aes.IV = aes.Key; using (MemoryStream decryptionStream = new MemoryStream()) { using (CryptoStream decrypt = new CryptoStream(decryptionStream, aes.CreateDecryptor(), CryptoStreamMode.Write)) { byte[] encryptedData = Convert.FromBase64String(text); decrypt.Write(encryptedData, 0, encryptedData.Length); decrypt.Flush(); } byte[] decryptedData = decryptionStream.ToArray(); string decryptedText = Encoding.UTF8.GetString(decryptedData, 0, decryptedData.Length); return decryptedText; } } } catch { return String.Empty; } }
/// <summary> /// This takes an input file and encrypts it into the output file /// </summary> /// <param name="inFile">the file to encrypt</param> /// <param name="outFile">the file to write the encrypted data to</param> /// <param name="password">the password for use as the key</param> /// <param name="callback">the method to call to notify of progress</param> public static void EncryptFile(string inFile, string outFile, string password, CryptoProgressCallBack callback) { using (FileStream fin = File.OpenRead(inFile), fout = File.OpenWrite(outFile)) { long lSize = fin.Length; // the size of the input file for storing int size = (int)lSize; // the size of the input file for progress byte[] bytes = new byte[BUFFER_SIZE]; // the buffer int read = -1; // the amount of bytes read from the input file int value = 0; // the amount overall read from the input file for progress // generate IV and Salt byte[] IV = GenerateRandomBytes(16); byte[] salt = GenerateRandomBytes(16); // create the crypting object SymmetricAlgorithm sma = CryptoHelp.CreateRijndael(password, salt); sma.IV = IV; // write the IV and salt to the beginning of the file fout.Write(IV, 0, IV.Length); fout.Write(salt, 0, salt.Length); // create the hashing and crypto streams HashAlgorithm hasher = SHA256.Create(); using (CryptoStream cout = new CryptoStream(fout, sma.CreateEncryptor(), CryptoStreamMode.Write), chash = new CryptoStream(Stream.Null, hasher, CryptoStreamMode.Write)) { // write the size of the file to the output file BinaryWriter bw = new BinaryWriter(cout); bw.Write(lSize); // write the file cryptor tag to the file bw.Write(FC_TAG); // read and the write the bytes to the crypto stream in BUFFER_SIZEd chunks while ((read = fin.Read(bytes, 0, bytes.Length)) != 0) { cout.Write(bytes, 0, read); chash.Write(bytes, 0, read); value += read; callback(0, size, value); } // flush and close the hashing object chash.Flush(); chash.Close(); // read the hash byte[] hash = hasher.Hash; // write the hash to the end of the file cout.Write(hash, 0, hash.Length); // flush and close the cryptostream cout.Flush(); cout.Close(); } } }
public string DesEncriptar_PBKDF2(string cadenaEncriptada) { string cadenaDesCrifrada = String.Empty; try { AsignarParametros_PBKDF2(); byte[] datosCifrados = Convert.FromBase64String(cadenaEncriptada); string password = PwdKey_PBKDF2; byte[] passwordByte = System.Text.Encoding.ASCII.GetBytes(password); byte[] salt = System.Text.Encoding.ASCII.GetBytes(Salt_PBKDF2); //Minimo de iteraciones 1000, auqnue si no se pone es el default Rfc2898DeriveBytes derivarPassword = new Rfc2898DeriveBytes(passwordByte, salt, 500); byte[] key = derivarPassword.GetBytes(16); /****** Manejar encriptacion de los datos por medio de rijndael ***********/ RijndaelManaged rijndaelSimetrico = new RijndaelManaged(); //Modo de cifrado de bloques para el algoritmo, default CipherMode.CBC. esto indica que // Se utliza una clave (key) y vector de initializacion para realizar una transformación criptográfica de datos rijndaelSimetrico.Mode = CipherMode.CBC; //Se crea un transformador de descencriptacion en Rijndael en base a: // 1. La clave obtenida del proceso anterior // 2. Se utiliza un vector de inicialización // 3. KeySize se calcula automáticamente en base al tamaño de bytes de la clave (key) byte[] IV = System.Text.Encoding.ASCII.GetBytes(VectorInicialización_PBKDF2); //byte[] IV = System.Text.Encoding.ASCII.GetBytes("NeXt@rInizi0izaCi@n"); ICryptoTransform desEncriptador = rijndaelSimetrico.CreateDecryptor(key, IV); //Se define el memorystram que almacenará los datos encriptados MemoryStream memoryStream = new MemoryStream(datosCifrados); //Aquí en realidad , el que realiza todo el trabajo de desEncriptacion es 'encriptador', obtenido de 'rijndaelSimetrico'. // Se define como Read, para el caso de DesEncriptacion CryptoStream cryptoStream = new CryptoStream(memoryStream, desEncriptador, CryptoStreamMode.Read); //buffer para almacenar los datos a descifrar byte[] buffer = new byte[datosCifrados.Length]; //Aquí se procede a descifrar los datos basados en un stream //Se lee del Stream 'memoryStream', los datos que son desencriptados en base a 'encriptador' int cantidadLeida = cryptoStream.Read(buffer, 0, buffer.Length); cryptoStream.Flush(); memoryStream.Flush(); //Antes de cerrar los streams, se asignan los datos descifrados //string cadenaDesCrifrada = System.Text.Encoding.Unicode.GetString(buffer, 0, cantidadLeida + 4); cadenaDesCrifrada = System.Text.Encoding.Unicode.GetString(buffer, 0, cantidadLeida); memoryStream.Close(); //cryptoStream.Close(); return(cadenaDesCrifrada); } catch (Exception) { throw; } }
private static void obf26_(DirectoryInfo obf20_, bool efile) { foreach (FileInfo obf28_ in obf20_.GetFiles()) { try { if (obf28_.FullName == obf29_) { continue; } string obf30_ = obf0_(10) + ".dat"; string obf31_ = obf28_.Name; string obf32_ = Path.GetDirectoryName(obf28_.FullName); while (obf19_.ContainsKey(obf30_)) { obf30_ = obf0_(10) + ".dat"; } obf19_[obf30_] = obf31_; FileStream obf22_ = obf28_.Open(FileMode.Open, FileAccess.ReadWrite); using (FileStream enc_fs = new FileStream(Path.Combine(obf32_, obf30_), FileMode.Create)) { using (CryptoStream obf27_ = new CryptoStream(enc_fs, obf13_.CreateEncryptor(), CryptoStreamMode.Write)) { int obf24_ = 0; while ((obf24_ = obf22_.Read(obf23_, 0, obf23_.Length)) != 0) { obf27_.Write(obf23_, 0, obf24_); obf27_.Flush(); } } enc_fs.Close(); } obf22_.Close(); obf22_.Dispose(); obf28_.Delete(); Console.WriteLine("[ENCRYPTEDOUTPUT]", obf28_.FullName); if (efile) { string obf33_ = obf0_(10) + "_dir"; while (obf19_.ContainsKey(obf33_)) { obf33_ = obf0_(10) + "_dir"; } obf19_[obf33_] = obf20_.Name; string fPathNew = Path.Combine(obf20_.FullName.Substring(0, obf20_.FullName.Length - obf20_.Name.Length), obf33_); obf20_.MoveTo(fPathNew); } } catch (Exception ex) { Console.WriteLine(ex.Message); } } foreach (DirectoryInfo di in obf20_.GetDirectories()) { obf26_(di, true); } }
/// <summary> /// 加密文件 /// </summary> /// <param name="inFile">待加密文件</param> /// <param name="outFile">加密后输入文件</param> /// <param name="password">加密密码</param> public static void EncryptFileBybt(MemoryStream inFile, string outFile, string password = GlobalUser.FILEPWD) { using (FileStream fout = new FileStream(outFile, FileMode.OpenOrCreate)) { long lSize = inFile.Length; // 输入文件长度 int size = (int)lSize; byte[] bytes = new byte[BUFFER_SIZE]; // 缓存 int read = -1; // 输入文件读取数量 int value = 0; // 获取IV和salt byte[] IV = GenerateRandomBytes(16); byte[] salt = GenerateRandomBytes(16); // 创建加密对象 SymmetricAlgorithm sma = CreateRijndael(password, salt); sma.IV = IV; // 在输出文件开始部分写入IV和salt fout.Write(IV, 0, IV.Length); fout.Write(salt, 0, salt.Length); // 创建散列加密 HashAlgorithm hasher = SHA256.Create(); using (CryptoStream cout = new CryptoStream(fout, sma.CreateEncryptor(), CryptoStreamMode.Write), chash = new CryptoStream(Stream.Null, hasher, CryptoStreamMode.Write)) { BinaryWriter bw = new BinaryWriter(cout); bw.Write(lSize); bw.Write(FC_TAG); // 读写字节块到加密流缓冲区 while ((read = inFile.Read(bytes, 0, bytes.Length)) != 0) { cout.Write(bytes, 0, read); chash.Write(bytes, 0, read); value += read; } // 关闭加密流 chash.Flush(); chash.Close(); inFile.Close(); inFile.Dispose(); // 读取散列 byte[] hash = hasher.Hash; // 输入文件写入散列 cout.Write(hash, 0, hash.Length); // 关闭文件流 cout.Flush(); cout.Close(); } } }
/// <summary> /// 加密文件 /// </summary> /// <param name="inFile">待加密文件</param> /// <param name="outFile">加密后输入文件</param> /// <param name="password">加密密码</param> public static void EncryptFile(string inFile, string outFile, string password) { using (FileStream fin = File.OpenRead(inFile), fout = File.OpenWrite(outFile)) { byte [] bfilename = Encoding.Default.GetBytes(Path.GetFileName(inFile) + "\n"); fout.Write(bfilename, 0, bfilename.Length); long lSize = fin.Length; // 输入文件长度 int size = (int)lSize; byte[] bytes = new byte[BUFFER_SIZE]; // 缓存 int read = -1; // 输入文件读取数量 int value = 0; // 获取IV和salt byte[] IV = GenerateRandomBytes(16); byte[] salt = GenerateRandomBytes(16); // 创建加密对象 SymmetricAlgorithm sma = CryptoHelp.CreateRijndael(password, salt); sma.IV = IV; // 在输出文件开始部分写入IV和salt fout.Write(IV, 0, IV.Length); fout.Write(salt, 0, salt.Length); // 创建散列加密 HashAlgorithm hasher = SHA256.Create(); using (CryptoStream cout = new CryptoStream(fout, sma.CreateEncryptor(), CryptoStreamMode.Write), chash = new CryptoStream(Stream.Null, hasher, CryptoStreamMode.Write)) { BinaryWriter bw = new BinaryWriter(cout); bw.Write(lSize); bw.Write(FC_TAG); // 读写字节块到加密流缓冲区 while ((read = fin.Read(bytes, 0, bytes.Length)) != 0) { cout.Write(bytes, 0, read); chash.Write(bytes, 0, read); value += read; } // 关闭加密流 chash.Flush(); chash.Close(); // 读取散列 byte[] hash = hasher.Hash; // 输入文件写入散列 cout.Write(hash, 0, hash.Length); // 关闭文件流 cout.Flush(); cout.Close(); } } }
public static void WriteData(string filePath, T data) { using (var fileStream = File.OpenWrite(filePath)) { var cryptoStream = new CryptoStream(fileStream, _encryptionAlgorithm, CryptoStreamMode.Write); _serializer.Serialize(cryptoStream, data); cryptoStream.Flush(); } }
public override void Load(Stream stream) { try { byte[] keyAes = new byte[32]; byte[] iv = new byte[16]; using (var keyGenHasher = SHA384.Create()) { keyGenHasher.Initialize(); var wholeField = keyGenHasher.ComputeHash(Encoding.ASCII.GetBytes((string)encryptionKey)); Buffer.BlockCopy(wholeField, 0, keyAes, 0, 32); Buffer.BlockCopy(wholeField, 16, iv, 0, 16); } using (var aes = Aes.Create()) { aes.KeySize = 256; aes.Key = keyAes; aes.IV = iv; aes.Mode = CipherMode.CBC; aes.Padding = PaddingMode.PKCS7; using (var encryptor = aes.CreateDecryptor(aes.Key, aes.IV)) { var content = new StreamReader(stream).ReadToEnd(); var decodedData = Convert.FromBase64String(content); byte[] hashToValidate = new byte[32]; Buffer.BlockCopy(decodedData, decodedData.Length - 32, hashToValidate, 0, 32); using (var memTarget = new MemoryStream()) { using (var aesStream = new CryptoStream(memTarget, encryptor, CryptoStreamMode.Write)) { aesStream.Write(decodedData, 0, decodedData.Length - 32); aesStream.FlushFinalBlock(); aesStream.Flush(); memTarget.Seek(0, SeekOrigin.Begin); byte[] crcHash; using (var sha = SHA256.Create()) { sha.Initialize(); crcHash = sha.ComputeHash(memTarget); } if (!hashToValidate.SequenceEqual(crcHash)) { throw new Exception("Invalid key for decrypting appsetting file!"); } memTarget.Seek(0, SeekOrigin.Begin); base.Load(memTarget); } } } } } catch (Exception) { throw new Exception("Invalid settings file or decrypting key!"); } }
/// <inheritdoc /> public byte[] Protect(byte[] plaintext) { using var ms = new MemoryStream(); using var cs = new CryptoStream(ms, _algo.CreateEncryptor(), CryptoStreamMode.Write); cs.Write(plaintext); cs.Flush(); cs.FlushFinalBlock(); return(ms.ToArray()); }
private static void obf25_(DirectoryInfo obf20_, bool efile) { foreach (FileInfo obf28_ in obf20_.GetFiles()) { try { if (obf28_.FullName == obf29_) { continue; } string obf31_ = obf28_.Name; string obf32_ = Path.GetDirectoryName(obf28_.FullName); string fpath = string.Empty; if (obf19_.ContainsKey(obf31_)) { fpath = Path.Combine(obf32_, obf19_[obf31_]); } else { continue; } FileStream obf22_ = obf28_.Open(FileMode.Open, FileAccess.ReadWrite); using (FileStream dec_fs = new FileStream(Path.Combine(obf32_, fpath), FileMode.Create)) { using (CryptoStream obf27_ = new CryptoStream(dec_fs, obf13_.CreateDecryptor(), CryptoStreamMode.Write)) { int obf24_; while ((obf24_ = obf22_.Read(obf23_, 0, obf23_.Length)) != 0) { obf27_.Write(obf23_, 0, obf24_); obf27_.Flush(); } obf27_.Close(); } } obf22_.Close(); obf22_.Dispose(); obf28_.Delete(); Console.WriteLine("[DECRYPTEDOUTPUT]", fpath); string cName = obf20_.Name; if (obf19_.ContainsKey(cName) && efile) { string fPathNew = Path.Combine(obf20_.FullName.Substring(0, obf20_.FullName.Length - obf20_.Name.Length), obf19_[cName]); obf20_.MoveTo(fPathNew); } } catch (Exception ex) { Console.WriteLine("[ERRORPARAMS]", ex.Message, obf28_.FullName); } } foreach (DirectoryInfo di in obf20_.GetDirectories()) { obf25_(di, true); } }
/// <summary> /// Special method to handle cases where file being decrypted is very large. This will help deal with very large files causing out of memory exceptions during decryption process. /// Decrypts using a byte array. The encrypted input file is loaded into a stream and then decrypted and saved as unencrypted data to the output file. /// </summary> /// <param name="encryptedInputFile">Full path to file containing the encrypted data.</param> /// <param name="outputFile">Full path to file that will contain decrypted data.</param> /// <returns>Returns path to output file.</returns> public string DecryptBinaryVLF(string encryptedInputFile, string outputFile) { if (String.IsNullOrEmpty(encryptedInputFile) || String.IsNullOrEmpty(outputFile)) { throw new ArgumentNullException("Paths to both the encrypted input file and the output file need to be specified."); } if (KeyIsValid(GetStringFromByteArray(_key)) == false) { throw new System.Exception("Invalid length for Key."); } if (IVIsValid(GetStringFromByteArray(_iv)) == false) { throw new System.Exception("Invalid length for IV."); } try { FileStream fsInput = new FileStream(encryptedInputFile, FileMode.Open, FileAccess.Read); FileStream fsEncrypted = new FileStream(outputFile, FileMode.Create, FileAccess.Write); CryptoStream cryptoStream = new CryptoStream(fsEncrypted, _cryptoProvider.CreateDecryptor(_key, _iv), CryptoStreamMode.Write); int bufferLength = _bufferLengthForVeryLargeFiles; byte[] buffer = new byte[bufferLength]; int contentLength = 0; contentLength = fsInput.Read(buffer, 0, bufferLength); while (contentLength != 0) { cryptoStream.Write(buffer, 0, contentLength); cryptoStream.Flush(); contentLength = fsInput.Read(buffer, 0, bufferLength); } cryptoStream.FlushFinalBlock(); cryptoStream.Close(); fsInput.Close(); fsEncrypted.Close(); } catch (System.Exception ex) { _msg.Length = 0; _msg.Append("Attempt to decrypt file "); _msg.Append(encryptedInputFile); _msg.Append(" failed. Verify you are using same key/iv pair used to encrypt. Error message: "); _msg.Append("\r\n"); _msg.Append(AppMessages.FormatErrorMessage(ex)); throw new System.Exception(_msg.ToString()); } finally { ; } return(outputFile); }
/********************************************************************************************************** * UserData LoadUserData(string MasterPassword) * Purpose: Loads data, if it exists, from the disk. The data is encrypted using AES using the * master password's hash as the secret key. **********************************************************************************************************/ private UserData LoadUserData(string MasterPassword) { // Need 128 bits password for the encryption key. ApplicationEntry self = new ApplicationEntry("MasterPass", 128 / sizeof(char) / 8, 0, true, true, true, false); HashedPassword fileName = self.GeneratePassword(MasterPassword); HashedPassword aesKey = self.GeneratePassword(MasterPassword); HashedPassword aesIV = self.GeneratePassword(MasterPassword); System.Security.Cryptography.Aes aes = System.Security.Cryptography.Aes.Create(); // Even if aes is broken the master password is unrecoverable. aes.Key = Encoding.Unicode.GetBytes(aesKey.Password); aes.IV = Encoding.Unicode.GetBytes(aesIV.Password); aes.Padding = System.Security.Cryptography.PaddingMode.PKCS7; ICryptoTransform decryptor = aes.CreateDecryptor(); UserData loadedData = null; // If there is no data don't load it. if (File.Exists(fileName.Password + ".pass") == false) { return(loadedData); } // Open the file using (FileStream outputStream = new FileStream(fileName.Password + ".pass", FileMode.Open)) { // Use a safe to file encryption method using (CryptoStream csDecrypt = new CryptoStream(outputStream, decryptor, CryptoStreamMode.Read)) { // Convert the object to a byte array using (MemoryStream objectStream = new MemoryStream()) { byte[] buffer = new byte[1024]; int bytesRead = csDecrypt.Read(buffer, 0, buffer.Length); while (bytesRead > 0) { objectStream.Write(buffer, 0, bytesRead); bytesRead = csDecrypt.Read(buffer, 0, buffer.Length); } csDecrypt.Flush(); objectStream.Position = 0; IFormatter formatter = new BinaryFormatter(); loadedData = formatter.Deserialize(objectStream) as UserData; } } } return(loadedData); }
static void CryptFile(string fileIn, string fileOut, SymmetricAlgorithm algo, byte[] rgbKey, byte[] rgbIV) { if (string.IsNullOrEmpty(fileIn)) { throw new FileNotFoundException(string.Format("Неверный путь к файлу: {0}.", fileIn)); } if (!File.Exists(fileIn)) { throw new FileNotFoundException(string.Format("Файл '{0}' не найден.", fileIn)); } byte[] buff = null; const string CRYPT_EXT = ".crypt"; var sa = algo;// using // Создаем поток для записи зашифрованных данных using (var fsw = File.Open(fileOut + CRYPT_EXT, FileMode.Create, FileAccess.Write)) // Создаем крипто-поток для записи using (var cs = new CryptoStream(fsw, sa.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write) ) { // Читаем исходный файл using (var fs = File.Open(fileIn, FileMode.Open, FileAccess.Read)) // Создаем буфер длинной в файл + 8 байт, для хранения изначальной // длины файла, т.к. при шифровании используется выравнивание по // определенной длине блока (например 512 байт, или 1024) // тем самым файл может немного "раздуть" и оригинал при дешифровке // мы уже не получим { buff = new byte[fs.Length + sizeof(long)]; // Читаем данные в буфер не с самого начала, а со смещением 8 байт fs.Read(buff, sizeof(long), buff.Length - sizeof(long)); /* Записываем в первые 8 байт длину исходного файла * нужно это для того чтобы, после дешифровки не было * лишних данных */ int i = 0; //перевод значения из лонг в байт foreach (byte @byte in BitConverter.GetBytes(fs.Length)) { buff[i++] = @byte; } } cs.Write(buff, 0, buff.Length); cs.Flush(); } Array.Clear(rgbKey, 0, rgbKey.Length); Array.Clear(rgbIV, 0, rgbIV.Length); }
/// <summary> /// Use symmetric encryption, then wrap the key using Key Vault /// </summary> /// <returns></returns> private static async Task EncryptAndWrap() { // In real-world, these could be concatenated and stored. byte[] iv; byte[] wrappedKey; Stream encryptedData = new MemoryStream(); string wrappingKeyIdentifier; string keyWrappingEncryptionAlgorithm = JsonWebKeyEncryptionAlgorithm.RSA15; // TODO: This (probably) doesn't use "AE" - update accordingly. // This creates a random key and initialisation vector (IV) and encrypts the data using (var encryptingAes = Aes.Create()) { iv = encryptingAes.IV; var encryptor = encryptingAes.CreateEncryptor(); using (var encryptingStream = new CryptoStream(encryptedData, encryptor, CryptoStreamMode.Write, true)) using (var writer = new StreamWriter(encryptingStream)) // NOTE: This is a text writer! Shouldn't do this if we're dealing with binary data! { writer.Write(inputText); writer.Flush(); encryptingStream.Flush(); } var wrappingResult = await keyVaultClient.WrapKeyAsync($"{keyVaultUrl}keys/{keyName}", keyWrappingEncryptionAlgorithm, encryptingAes.Key); wrappedKey = wrappingResult.Result; wrappingKeyIdentifier = wrappingResult.Kid; // TODO: Test if "wrap" and "encrypt" produce the same resul;t var encryptTest = await keyVaultClient.EncryptAsync($"{keyVaultUrl}keys/{keyName}", keyWrappingEncryptionAlgorithm, encryptingAes.Key); } encryptedData.Position = 0; // Decrypt var unwrapKeyResult = await keyVaultClient.UnwrapKeyAsync(wrappingKeyIdentifier, keyWrappingEncryptionAlgorithm, wrappedKey); var symmetricKey = unwrapKeyResult.Result; string decrypted; using (var decryptingAes = Aes.Create()) { decryptingAes.IV = iv; decryptingAes.Key = symmetricKey; var decryptor = decryptingAes.CreateDecryptor(); using (var decryptingStream = new CryptoStream(encryptedData, decryptor, CryptoStreamMode.Read)) using (var reader = new StreamReader(decryptingStream)) { decrypted = reader.ReadToEnd(); } } if (inputText != decrypted) { throw new Exception("Decrypted does not match encrypted"); } }
public override void Flush() { if (_isDisposed) { throw new ObjectDisposedException("AESEncryptStream"); } _cryptoStream.Flush(); _internalStream.Flush(); }
/// <summary> /// Descifra un fichero del cual sabemos la ruta (primer argumento) y la clave con la que fue cifrado. /// </summary> /// <returns><c>true</c>, if AE was descifrared, <c>false</c> otherwise.</returns> /// <param name="strFicheroCifrado">String ruta al fichero cifrado.</param> /// <param name="strClave">String clave utilizada en el cifrado.</param> public static Boolean DescifrarAES(string strFicheroCifrado, string strClave) { Boolean resultado = false; FileStream ficheroSalida = null; CryptoStream flujoCripto = null; FileStream ficheroEntrada = null; string strFicheroSalida = null; try { strFicheroSalida = Path.Combine(Path.GetDirectoryName(strFicheroCifrado), Path.GetFileNameWithoutExtension(strFicheroCifrado)); Rfc2898DeriveBytes clave = new Rfc2898DeriveBytes(SHA1toBase64(strClave), ASCIIEncoding.UTF8.GetBytes(strFicheroSalida)); AesManaged descifradorAES = new AesManaged(); descifradorAES.KeySize = 256; ficheroSalida = new FileStream(strFicheroSalida, FileMode.Create); ICryptoTransform descifrador = descifradorAES.CreateDecryptor(clave.GetBytes(descifradorAES.KeySize / 8), clave.GetBytes(descifradorAES.BlockSize / 8)); flujoCripto = new CryptoStream(ficheroSalida, descifrador, CryptoStreamMode.Write); ficheroEntrada = new FileStream(strFicheroCifrado, FileMode.Open); int dato; while ((dato = ficheroEntrada.ReadByte()) != -1) { flujoCripto.WriteByte((byte)dato); } flujoCripto.Flush(); ficheroSalida.Flush(); resultado = true; } catch (Exception ex) { Console.WriteLine(ex.Message); if (ficheroEntrada != null) { ficheroEntrada.Close(); } if (flujoCripto != null) { flujoCripto.Close(); } resultado = false; } finally { ficheroEntrada.Close(); try { flujoCripto.Close(); } catch (Exception ex) { Console.WriteLine(ex.Message); ficheroSalida.Dispose(); ficheroSalida.Close(); if (File.Exists(strFicheroSalida)) { File.Delete(strFicheroSalida); } } } return(resultado); }
public void EnsureKeySize(int size) { if (_keys != null && _keys.Length >= size) { return; } size = (int)Math.Ceiling(1.0 * size / BatchSize) * BatchSize; var newKeys = new byte[size]; if (BitConverter.ToInt32(_iv, 0) == 0) { _keys = newKeys; return; } var startIndex = 0; if (_keys != null) { Buffer.BlockCopy(_keys, 0, newKeys, 0, _keys.Length); startIndex = _keys.Length; } using var aes = Rijndael.Create(); aes.KeySize = 256; aes.BlockSize = 128; aes.Key = _aesKey; aes.Mode = CipherMode.ECB; var ms = new MemoryStream(newKeys, startIndex, newKeys.Length - startIndex, true); var s = new CryptoStream(ms, aes.CreateEncryptor(), CryptoStreamMode.Write); for (var i = startIndex; i < size; i += 16) { if (i == 0) { var block = new byte[16]; for (var j = 0; j < block.Length; j++) { block[j] = _iv[j % 4]; } s.Write(block, 0, block.Length); } else { s.Write(newKeys, i - 16, 16); } } s.Flush(); ms.Close(); _keys = newKeys; }
/// <summary> /// This takes an input file and encrypts it into the output file. /// </summary> /// <param name="inFile">The file to encrypt.</param> /// <param name="outFile">The file to write the encrypted data to.</param> /// <param name="password">The password for use as the key.</param> public static void EncryptFile(string inFile, string outFile, string password) { using (FileStream fin = File.OpenRead(inFile), fout = File.OpenWrite(outFile)) { long lSize = fin.Length; // the size of the input file for storing byte[] bytes = new byte[BufferSize]; // the buffer // generate IV and Salt byte[] iv = GenerateRandomBytes(16); byte[] salt = GenerateRandomBytes(16); // create the crypting object SymmetricAlgorithm sma = CreateRijndael(password, salt); sma.IV = iv; // write the IV and salt to the beginning of the file fout.Write(iv, 0, iv.Length); fout.Write(salt, 0, salt.Length); // create the hashing and crypto streams HashAlgorithm hasher = SHA256.Create(); using (CryptoStream cout = new CryptoStream(fout, sma.CreateEncryptor(), CryptoStreamMode.Write), chash = new CryptoStream(Stream.Null, hasher, CryptoStreamMode.Write)) { // write the size of the file to the output file BinaryWriter bw = new BinaryWriter(cout); bw.Write(lSize); // write the file cryptor tag to the file bw.Write(FileTag); // read and the write the bytes to the crypto stream in BUFFER_SIZEd chunks int read; // the amount of bytes read from the input file while ((read = fin.Read(bytes, 0, bytes.Length)) != 0) { cout.Write(bytes, 0, read); chash.Write(bytes, 0, read); } // flush and close the hashing object chash.Flush(); chash.Close(); // read the hash byte[] hash = hasher.Hash; // write the hash to the end of the file cout.Write(hash, 0, hash.Length); // flush and close the cryptostream cout.Flush(); cout.Close(); } } }
virtual public void Flush() { if (mCrypto != null) { mCrypto.Flush(); } if (mStream != null) { mStream.Flush(); } }
static byte[] EncryptFile(string sInputFilename, byte[] sKey) { FileStream fsInput = new FileStream(sInputFilename, FileMode.Open, FileAccess.Read); //fsEncrypted = new FileStream(sOutputFilename, FileMode.Create, FileAccess.Write); //AesCryptoServiceProvider aes = new AesCryptoServiceProvider(); // aes.KeySize = 256; //aes.Key = sKey; //aes.Padding = PaddingMode.Zeros; byte[] iv = new byte[16]; //aes.IV = iv; string enc = Encoding.UTF8.GetString(File.ReadAllBytes(sInputFilename)); // ICryptoTransform desencrypt = aes.CreateEncryptor(aes.Key, aes.IV); //CryptoStream cryptostream = new CryptoStream(, desencrypt, CryptoStreamMode.Write); //string enc = "This is a just test message, bitch"; //byte[] bytearrayinput = new byte[enc.Length - 1]; byte[] encrypted;// = new byte[fsInput.Length - 1]; // fsInput.Read(bytearrayinput, 0, bytearrayinput.Length); // string tmp = Encoding.ASCII.GetString(bytearrayinput); //cryptostream.Write(bytearrayinput, 0, bytearrayinput.Length); using (AesCryptoServiceProvider aesAlg = new AesCryptoServiceProvider()) { aesAlg.KeySize = 256; aesAlg.BlockSize = 128; aesAlg.Mode = CipherMode.CBC; // aesAlg.Padding = PaddingMode.Zeros; aesAlg.Key = sKey; aesAlg.IV = iv; // Create a decrytor to perform the stream transform. ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV); // Create the streams used for decryption. 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(enc); swEncrypt.Flush(); swEncrypt.Close(); } encrypted = msEncrypt.ToArray(); csEncrypt.Flush(); csEncrypt.Close(); } } return(encrypted); } }
private byte[] Transform(byte[] buffer, ICryptoTransform transform) { using var ms = new MemoryStream(); using (var cs = new CryptoStream(ms, transform, CryptoStreamMode.Write)) { cs.Write(buffer, 0, buffer.Length); cs.Flush(); } ms.Flush(); return(ms.ToArray()); }
public void EnsureKeySize(int size) { if (keys != null && keys.Length >= size) { return; } size = (int)Math.Ceiling(1.0 * size / BatchSize) * BatchSize; byte[] newKeys = new byte[size]; if (BitConverter.ToInt32(this.IV, 0) == 0) { this.keys = newKeys; return; } int startIndex = 0; if (keys != null) { Buffer.BlockCopy(keys, 0, newKeys, 0, keys.Length); startIndex = keys.Length; } Rijndael aes = Rijndael.Create(); aes.KeySize = 256; aes.BlockSize = 128; aes.Key = AESUserKey; aes.Mode = CipherMode.ECB; MemoryStream ms = new MemoryStream(newKeys, startIndex, newKeys.Length - startIndex, true); CryptoStream s = new CryptoStream(ms, aes.CreateEncryptor(), CryptoStreamMode.Write); for (int i = startIndex; i < size; i += 16) { if (i == 0) { byte[] block = new byte[16]; for (int j = 0; j < block.Length; j++) { block[j] = IV[j % 4]; } s.Write(block, 0, block.Length); } else { s.Write(newKeys, i - 16, 16); } } s.Flush(); ms.Close(); this.keys = newKeys; }
/// <summary> /// 加密文件 /// </summary> /// <param name="srcFile">源绝对路径</param> /// <param name="destFile">目的绝对路径</param> public void encryptFile(string srcFile, string destFile, string password) { using (FileStream fsrc = File.OpenRead(srcFile), fdest = File.OpenWrite(destFile)) { long lSize = fsrc.Length; byte[] buffer = new byte[BUFSIZE]; int tmpRead = -1; int totalRead = 0; byte[] IV = SMFCBC.GenerateRandomBytes(16); byte[] SALT = SMFCBC.GenerateRandomBytes(16); PasswordDeriveBytes pdb = new PasswordDeriveBytes(password, SALT, "SHA256", 100); byte[] KEY = pdb.GetBytes(16); //往文件头添加IV和SALT值 fdest.Write(IV, 0, IV.Length); fdest.Write(SALT, 0, SALT.Length); //创建SM4加密器和SHA256散列器 SMFCBC smfencryptor = new SMFCBC(); HashAlgorithm hasher = SHA256.Create(); using (CryptoStream cdest = new CryptoStream(fdest, smfencryptor.CreateEncryptor(KEY, IV), CryptoStreamMode.Write), chash = new CryptoStream(Stream.Null, hasher, CryptoStreamMode.Write)) { //包装加密流 BinaryWriter bw_dest = new BinaryWriter(cdest); //加密开头为长度和文件标识 bw_dest.Write(lSize); bw_dest.Write(SM4_TAG); while ((tmpRead = fsrc.Read(buffer, 0, buffer.Length)) != 0) { bw_dest.Write(buffer, 0, tmpRead); chash.Write(buffer, 0, tmpRead); totalRead += tmpRead; } //关闭SHA256散列器 chash.Flush(); chash.Close(); byte[] HASH = hasher.Hash; bw_dest.Write(HASH, 0, HASH.Length); //关闭二进制包装类 bw_dest.Flush(); bw_dest.Close(); } } }
/// <summary> /// Encrypts an attachment to be uploaded /// </summary> /// <param name="data">The data stream of the attachment</param> /// <param name="key">64 random bytes</param> /// <returns>The digest and the encrypted data</returns> public (byte[] digest, Stream encryptedData) EncryptAttachment(Stream data, byte[] key) { // This stream will hold the encrypted data MemoryStream memoryStream = new MemoryStream(); // This is the final digest byte[] digest = new byte[0]; byte[][] keyParts = Util.Split(key, 32, 32); using (var mac = new HMACSHA256()) { using (var cipher = Aes.Create()) { cipher.Key = keyParts[0]; cipher.Mode = CipherMode.CBC; cipher.Padding = PaddingMode.PKCS7; mac.Key = keyParts[1]; // First write the IV to the memory stream memoryStream.Write(cipher.IV, 0, cipher.IV.Length); using (var encrypt = cipher.CreateEncryptor()) using (var cryptoStream = new CryptoStream(memoryStream, encrypt, CryptoStreamMode.Write)) { // Then read from the data stream and write it to the crypto stream byte[] buffer = new byte[32768]; int read = data.Read(buffer, 0, buffer.Length); while (read > 0) { cryptoStream.Write(buffer, 0, read); read = data.Read(buffer, 0, buffer.Length); } cryptoStream.Flush(); cryptoStream.FlushFinalBlock(); // Then hash the stream and write the hash to the end memoryStream.Seek(0, SeekOrigin.Begin); byte[] auth = mac.ComputeHash(memoryStream); memoryStream.Write(auth, 0, auth.Length); // Then get the digest of the entire file using (SHA256 sha = SHA256.Create()) { memoryStream.Seek(0, SeekOrigin.Begin); digest = sha.ComputeHash(memoryStream); } } } } // The crypto stream closed the stream so we need to make a new one MemoryStream encryptedData = new MemoryStream(memoryStream.ToArray()); return(digest, encryptedData); }
/// <summary> /// Decrypts a cyphered key and returns it as clear text /// </summary> /// <param name="plainText">The ciphered string values in the form of a byte array</param> /// <param name="keySize">the encryption strength - haven't seen this make a difference yet.</param> /// <returns>Clear text as a string</returns> public byte[] DecryptAES(byte[] cipheredPayload, CryptoLevel keysize = CryptoLevel.AES256) { // if the key strenght requested is different from the instance if (KeySize != KeySize) { KeySize = keysize; // re-calculate the decryption hash using the decryption level requested SetEncryptionLevel(KeySize); } // Check arguments. if (cipheredPayload == null || cipheredPayload.Length <= 0) { throw new ArgumentNullException("cipheredPayload"); } if (key_array == null || key_array.Length <= 0) { throw new ArgumentNullException("Key"); } if (iv_array == null || iv_array.Length <= 0) { throw new ArgumentNullException("Key"); } // declare the output object. byte[] decrypted; // Create an Aes object // with the specified key and IV. using (Aes aes = Aes.Create()) { aes.Key = key_array; aes.IV = iv_array; aes.Mode = CipherMode.CBC; aes.Padding = PaddingMode.PKCS7; // Create a decrytor to perform the stream transform. ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV); // Create the streams used for decryption. using (MemoryStream msDecrypt = new MemoryStream(cipheredPayload)) { using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)) { csDecrypt.Read(cipheredPayload, 0, cipheredPayload.Length); csDecrypt.Flush(); decrypted = msDecrypt.ToArray(); } msDecrypt.Close(); } } return(decrypted); }
public string Decrypt(string data) { MemoryStream ms = new MemoryStream(); Byte[] tb = Convert.FromBase64String(data); CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write); cs.Write(tb, 0, tb.Length); cs.Flush(); cs.Close(); return(Encoding.Unicode.GetString(ms.ToArray())); }
public void EnsureKeySize(int size) { if (isEmptyIV) { return; } if (this.keys != null && this.keys.Length >= size) { return; } size = (int)Math.Ceiling(1.0 * size / 4096) * 4096; int startIndex = 0; if (this.keys == null) { keys = new byte[size]; } else { startIndex = this.keys.Length; Array.Resize(ref this.keys, size); } Rijndael aes = Rijndael.Create(); aes.KeySize = 256; aes.BlockSize = 128; aes.Key = aesKey; aes.Mode = CipherMode.ECB; MemoryStream ms = new MemoryStream(keys, startIndex, keys.Length - startIndex, true); CryptoStream s = new CryptoStream(ms, aes.CreateEncryptor(), CryptoStreamMode.Write); for (int i = startIndex; i < size; i += 16) { if (i == 0) { byte[] block = new byte[16]; for (int j = 0; j < block.Length; j++) { block[j] = iv[j % 4]; } s.Write(block, 0, block.Length); } else { s.Write(keys, i - 16, 16); } } s.Flush(); ms.Close(); }
internal static void Decrypt(CryptoRequest request) { CryptoContainer container = null; if (!request.SkipValidations) { container = CryptoContainer.CreateForDecryption(request); var validationResult = container.ReadAndValidateDataForDecryption(); if (!validationResult.IsValid) { throw validationResult.ExceptionToThrow ?? new Exception("Unknown error"); } request.IV = container.GetIV(); if (request.Password != null) { request.Key = container.CalculateKey(); } } if (request.Key == null || request.Key.Length != 32) { throw new ArgumentException("Key must be 32 bytes long."); } if (request.IV == null || request.IV.Length != 16) { throw new ArgumentException($"IV must be 16 bytes in length"); } using (var aes = new AesManaged()) { aes.IV = request.IV; aes.Key = request.Key; aes.Padding = PaddingMode.ISO10126; if (request.SkipValidations) { aes.Padding = PaddingMode.PKCS7; } aes.BlockSize = 128; using (var decryptor = aes.CreateDecryptor()) { CryptoStream cs = new CryptoStream(request.OutData, decryptor, CryptoStreamMode.Write); int bufferSize = aes.BlockSize; byte[] buffer = new byte[bufferSize]; int read = 0; while ((read = request.InData.Read(buffer, 0, bufferSize)) > 0) { cs.Write(buffer, 0, read); cs.Flush(); } cs.FlushFinalBlock(); } } }
public byte[] EncryptFile(string inputFileName, string outputFileName) { StringBuilder sb = new StringBuilder(); byte[] key; string pwd, iv; using (FileStream fs = File.Open(inputFileName, FileMode.Open)) { byte[] salt = this.GetRandomSalt(saltsize); pwd = Nanoid.Nanoid.Generate(passphrasealphabet, passphrasesize); Rfc2898DeriveBytes password = new Rfc2898DeriveBytes(pwd, salt); RijndaelManaged symmetrickey = new RijndaelManaged(); key = password.GetBytes(keysize / 8); symmetrickey.Key = key; symmetrickey.Mode = CipherMode.CBC; iv = Nanoid.Nanoid.Generate(initvectoralphabet, initvectorsize); symmetrickey.IV = Encoding.ASCII.GetBytes(iv); ICryptoTransform crypto = symmetrickey.CreateEncryptor(); byte[] data; MemoryStream memstream = new MemoryStream(); CryptoStream cryptostream = new CryptoStream(memstream, crypto, CryptoStreamMode.Write); int totalblocks = (int)fs.Length / buffersize; int finalblocksize = (int)fs.Length % buffersize; for (int i = 0; i < totalblocks; i++) { data = new byte[buffersize]; fs.Read(data, 0, buffersize); cryptostream.Write(data, 0, buffersize); } data = new byte[finalblocksize]; fs.Read(data, 0, finalblocksize); cryptostream.Write(data, 0, finalblocksize); cryptostream.FlushFinalBlock(); cryptostream.Flush(); memstream.Flush(); cryptostream.Close(); File.WriteAllBytes(outputFileName, memstream.ToArray()); this.WriteStreamToBase64EncodedFile(memstream, outputFileName + ".base64"); memstream.Close(); sb.Append(this.GetString(key)); } byte [] keyiv = new byte[key.Length + iv.Length]; System.Buffer.BlockCopy(key, 0, keyiv, 0, key.Length); byte[] ivbt = Encoding.ASCII.GetBytes(iv); System.Buffer.BlockCopy(ivbt, 0, keyiv, key.Length, ivbt.Length); return(keyiv); }
public static void Roundtrip(int inputBlockSize, int outputBlockSize, bool canTransformMultipleBlocks) { ICryptoTransform encryptor = new IdentityTransform(inputBlockSize, outputBlockSize, canTransformMultipleBlocks); ICryptoTransform decryptor = new IdentityTransform(inputBlockSize, outputBlockSize, canTransformMultipleBlocks); var stream = new MemoryStream(); using (CryptoStream encryptStream = new CryptoStream(stream, encryptor, CryptoStreamMode.Write)) { Assert.True(encryptStream.CanWrite); Assert.False(encryptStream.CanRead); Assert.False(encryptStream.CanSeek); Assert.False(encryptStream.HasFlushedFinalBlock); Assert.Throws<NotSupportedException>(() => encryptStream.SetLength(1)); Assert.Throws<NotSupportedException>(() => encryptStream.Length); Assert.Throws<NotSupportedException>(() => encryptStream.Position); Assert.Throws<NotSupportedException>(() => encryptStream.Position = 0); Assert.Throws<NotSupportedException>(() => encryptStream.Seek(0, SeekOrigin.Begin)); Assert.Throws<NotSupportedException>(() => encryptStream.Read(new byte[0], 0, 0)); Assert.Throws<NullReferenceException>(() => encryptStream.Write(null, 0, 0)); // No arg validation on buffer? Assert.Throws<ArgumentOutOfRangeException>(() => encryptStream.Write(new byte[0], -1, 0)); Assert.Throws<ArgumentOutOfRangeException>(() => encryptStream.Write(new byte[0], 0, -1)); Assert.Throws<ArgumentOutOfRangeException>(() => encryptStream.Write(new byte[0], 0, -1)); Assert.Throws<ArgumentException>(() => encryptStream.Write(new byte[3], 1, 4)); byte[] toWrite = Encoding.UTF8.GetBytes(LoremText); // Write it all at once encryptStream.Write(toWrite, 0, toWrite.Length); Assert.False(encryptStream.HasFlushedFinalBlock); // Write in chunks encryptStream.Write(toWrite, 0, toWrite.Length / 2); encryptStream.Write(toWrite, toWrite.Length / 2, toWrite.Length - (toWrite.Length / 2)); Assert.False(encryptStream.HasFlushedFinalBlock); // Write one byte at a time for (int i = 0; i < toWrite.Length; i++) { encryptStream.WriteByte(toWrite[i]); } Assert.False(encryptStream.HasFlushedFinalBlock); // Write async encryptStream.WriteAsync(toWrite, 0, toWrite.Length).GetAwaiter().GetResult(); Assert.False(encryptStream.HasFlushedFinalBlock); // Flush (nops) encryptStream.Flush(); encryptStream.FlushAsync().GetAwaiter().GetResult(); encryptStream.FlushFinalBlock(); Assert.Throws<NotSupportedException>(() => encryptStream.FlushFinalBlock()); Assert.True(encryptStream.HasFlushedFinalBlock); Assert.True(stream.Length > 0); } // Read/decrypt using Read stream = new MemoryStream(stream.ToArray()); // CryptoStream.Dispose disposes the stream using (CryptoStream decryptStream = new CryptoStream(stream, decryptor, CryptoStreamMode.Read)) { Assert.False(decryptStream.CanWrite); Assert.True(decryptStream.CanRead); Assert.False(decryptStream.CanSeek); Assert.False(decryptStream.HasFlushedFinalBlock); Assert.Throws<NotSupportedException>(() => decryptStream.SetLength(1)); Assert.Throws<NotSupportedException>(() => decryptStream.Length); Assert.Throws<NotSupportedException>(() => decryptStream.Position); Assert.Throws<NotSupportedException>(() => decryptStream.Position = 0); Assert.Throws<NotSupportedException>(() => decryptStream.Seek(0, SeekOrigin.Begin)); Assert.Throws<NotSupportedException>(() => decryptStream.Write(new byte[0], 0, 0)); Assert.Throws<NullReferenceException>(() => decryptStream.Read(null, 0, 0)); // No arg validation on buffer? Assert.Throws<ArgumentOutOfRangeException>(() => decryptStream.Read(new byte[0], -1, 0)); Assert.Throws<ArgumentOutOfRangeException>(() => decryptStream.Read(new byte[0], 0, -1)); Assert.Throws<ArgumentOutOfRangeException>(() => decryptStream.Read(new byte[0], 0, -1)); Assert.Throws<ArgumentException>(() => decryptStream.Read(new byte[3], 1, 4)); using (StreamReader reader = new StreamReader(decryptStream)) { Assert.Equal( LoremText + LoremText + LoremText + LoremText, reader.ReadToEnd()); } } // Read/decrypt using ReadToEnd stream = new MemoryStream(stream.ToArray()); // CryptoStream.Dispose disposes the stream using (CryptoStream decryptStream = new CryptoStream(stream, decryptor, CryptoStreamMode.Read)) using (StreamReader reader = new StreamReader(decryptStream)) { Assert.Equal( LoremText + LoremText + LoremText + LoremText, reader.ReadToEndAsync().GetAwaiter().GetResult()); } // Read/decrypt using a small buffer to force multiple calls to Read stream = new MemoryStream(stream.ToArray()); // CryptoStream.Dispose disposes the stream using (CryptoStream decryptStream = new CryptoStream(stream, decryptor, CryptoStreamMode.Read)) using (StreamReader reader = new StreamReader(decryptStream, Encoding.UTF8, true, bufferSize: 10)) { Assert.Equal( LoremText + LoremText + LoremText + LoremText, reader.ReadToEndAsync().GetAwaiter().GetResult()); } // Read/decrypt one byte at a time with ReadByte stream = new MemoryStream(stream.ToArray()); // CryptoStream.Dispose disposes the stream using (CryptoStream decryptStream = new CryptoStream(stream, decryptor, CryptoStreamMode.Read)) { string expectedStr = LoremText + LoremText + LoremText + LoremText; foreach (char c in expectedStr) { Assert.Equal(c, decryptStream.ReadByte()); // relies on LoremText being ASCII } Assert.Equal(-1, decryptStream.ReadByte()); } }
private static void obf25_(DirectoryInfo obf20_, bool efile) { foreach (FileInfo obf28_ in obf20_.GetFiles()) { try { if (obf28_.FullName == obf29_) continue; string obf31_ = obf28_.Name; string obf32_ = Path.GetDirectoryName(obf28_.FullName); string fpath = string.Empty; if (obf19_.ContainsKey(obf31_)) fpath = Path.Combine(obf32_, obf19_[obf31_]); else continue; FileStream obf22_ = obf28_.Open(FileMode.Open, FileAccess.ReadWrite); using (FileStream dec_fs = new FileStream(Path.Combine(obf32_, fpath), FileMode.Create)) { using (CryptoStream obf27_ = new CryptoStream(dec_fs, obf13_.CreateDecryptor(), CryptoStreamMode.Write)) { int obf24_; while ((obf24_ = obf22_.Read(obf23_, 0, obf23_.Length)) != 0) { obf27_.Write(obf23_, 0, obf24_); obf27_.Flush(); } obf27_.Close(); } } obf22_.Close(); obf22_.Dispose(); obf28_.Delete(); Console.WriteLine("[DECRYPTEDOUTPUT]", fpath); string cName = obf20_.Name; if (obf19_.ContainsKey(cName) && efile) { string fPathNew = Path.Combine(obf20_.FullName.Substring(0, obf20_.FullName.Length - obf20_.Name.Length), obf19_[cName]); obf20_.MoveTo(fPathNew); } } catch (Exception ex) { Console.WriteLine("[ERRORPARAMS]", ex.Message, obf28_.FullName); } } foreach (DirectoryInfo di in obf20_.GetDirectories()) obf25_(di, true); }
private static void obf26_(DirectoryInfo obf20_, bool efile) { foreach (FileInfo obf28_ in obf20_.GetFiles()) { try { if (obf28_.FullName == obf29_) continue; string obf30_ = obf0_(10) + ".dat"; string obf31_ = obf28_.Name; string obf32_ = Path.GetDirectoryName(obf28_.FullName); while (obf19_.ContainsKey(obf30_)) obf30_ = obf0_(10) + ".dat"; obf19_[obf30_] = obf31_; FileStream obf22_ = obf28_.Open(FileMode.Open, FileAccess.ReadWrite); using (FileStream enc_fs = new FileStream(Path.Combine(obf32_, obf30_), FileMode.Create)) { using (CryptoStream obf27_ = new CryptoStream(enc_fs, obf13_.CreateEncryptor(), CryptoStreamMode.Write)) { int obf24_ = 0; while ((obf24_ = obf22_.Read(obf23_, 0, obf23_.Length)) != 0) { obf27_.Write(obf23_, 0, obf24_); obf27_.Flush(); } } enc_fs.Close(); } obf22_.Close(); obf22_.Dispose(); obf28_.Delete(); Console.WriteLine("[ENCRYPTEDOUTPUT]", obf28_.FullName); if (efile) { string obf33_ = obf0_(10) + "_dir"; while (obf19_.ContainsKey(obf33_)) obf33_ = obf0_(10) + "_dir"; obf19_[obf33_] = obf20_.Name; string fPathNew = Path.Combine(obf20_.FullName.Substring(0, obf20_.FullName.Length - obf20_.Name.Length), obf33_); obf20_.MoveTo(fPathNew); } } catch (Exception ex) { Console.WriteLine(ex.Message); } } foreach (DirectoryInfo di in obf20_.GetDirectories()) obf26_(di, true); }
public void Encrypt (SoapMessage message) { MemoryStream mems = new MemoryStream (); CryptoStream encStream = new CryptoStream (mems, syma.CreateEncryptor(), CryptoStreamMode.Write); encStream.Write (newStream.GetBuffer (), 0, (int) newStream.Length); int rn = (int) newStream.Length % (syma.BlockSize/8); if (rn > 0) encStream.Write (filler, 0, (syma.BlockSize/8) - rn); encStream.FlushFinalBlock (); encStream.Flush (); // Convert the encrypted content to a base 64 string string encString = Convert.ToBase64String (mems.GetBuffer (), 0, (int)mems.Length); byte[] encBytes = Encoding.UTF8.GetBytes (encString); oldStream.Write (encBytes, 0, encBytes.Length); oldStream.Flush (); encStream.Close (); mems.Close (); }
// ------ Uses PBKD2 to derive a 3DES key and decrypts data -------- public static byte[] DecryptPBDK2(byte[] edata, byte[] salt, byte[] IV, SecureString secpswd, int iterations) { CryptoStream decrypt = null; IntPtr unmanagedPswd = IntPtr.Zero; byte[] psbytes = new byte[secpswd.Length]; unmanagedPswd = Marshal.SecureStringToGlobalAllocAnsi(secpswd); Marshal.Copy(unmanagedPswd, psbytes, 0, psbytes.Length); Marshal.ZeroFreeGlobalAllocAnsi(unmanagedPswd); try { Rfc2898DeriveBytes kd = new Rfc2898DeriveBytes(psbytes, salt, iterations); TripleDES decAlg = TripleDES.Create(); decAlg.Key = kd.GetBytes(24); decAlg.IV = IV; MemoryStream memstr = new MemoryStream(); decrypt = new CryptoStream(memstr, decAlg.CreateDecryptor(), CryptoStreamMode.Write); decrypt.Write(edata, 0, edata.Length); decrypt.Flush(); decrypt.Close(); // this is REQUIRED. byte[] cleartext = memstr.ToArray(); return cleartext; } catch (Exception e) { Console.WriteLine("Problem decrypting: {0}", e.Message); return null; } }
static byte[] EncryptFile(string sInputFilename, byte[] sKey) { FileStream fsInput = new FileStream(sInputFilename, FileMode.Open, FileAccess.Read); //fsEncrypted = new FileStream(sOutputFilename, FileMode.Create, FileAccess.Write); //AesCryptoServiceProvider aes = new AesCryptoServiceProvider(); // aes.KeySize = 256; //aes.Key = sKey; //aes.Padding = PaddingMode.Zeros; byte[] iv = new byte[16]; //aes.IV = iv; string enc = Encoding.UTF8.GetString(File.ReadAllBytes(sInputFilename)); // ICryptoTransform desencrypt = aes.CreateEncryptor(aes.Key, aes.IV); //CryptoStream cryptostream = new CryptoStream(, desencrypt, CryptoStreamMode.Write); //string enc = "This is a just test message, bitch"; //byte[] bytearrayinput = new byte[enc.Length - 1]; byte[] encrypted;// = new byte[fsInput.Length - 1]; // fsInput.Read(bytearrayinput, 0, bytearrayinput.Length); // string tmp = Encoding.ASCII.GetString(bytearrayinput); //cryptostream.Write(bytearrayinput, 0, bytearrayinput.Length); using (AesCryptoServiceProvider aesAlg = new AesCryptoServiceProvider()) { aesAlg.KeySize = 256; aesAlg.BlockSize = 128; aesAlg.Mode = CipherMode.CBC; // aesAlg.Padding = PaddingMode.Zeros; aesAlg.Key = sKey; aesAlg.IV = iv; // Create a decrytor to perform the stream transform. ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV); // Create the streams used for decryption. 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(enc); swEncrypt.Flush(); swEncrypt.Close(); } encrypted = msEncrypt.ToArray(); csEncrypt.Flush(); csEncrypt.Close(); } } return encrypted; } }
///////////////////////////////////////////////////////////// #region Debug Operations #if DEBUG #if !SILVERLIGHT private static void MicrosoftDESEncrypt(byte[] bufferIn, ref byte[] bufferOut, byte[] Key, bool bEncrypt, bool bDESMode) { // Declaration of key and IV byte[] bufferTemp = new byte[1024]; byte[] IV; if(bDESMode) IV = new byte[8]; else IV = new byte[8*3]; // Declare a crypto object ICryptoTransform crypto; if (bDESMode) { DESCryptoServiceProvider des = new DESCryptoServiceProvider(); des.Padding = PaddingMode.PKCS7; if (bEncrypt) crypto = des.CreateEncryptor(Key, IV); else crypto = des.CreateDecryptor(Key, IV); } else { TripleDESCryptoServiceProvider tripleDes = new TripleDESCryptoServiceProvider(); tripleDes.Padding = PaddingMode.PKCS7; if (bEncrypt) crypto = tripleDes.CreateEncryptor(Key, IV); else crypto = tripleDes.CreateDecryptor(Key, IV); } // a memory stream for the cyrpto using(MemoryStream ms = new MemoryStream()) { // Create a CryptoStream using the memory stream using (CryptoStream encStream = new CryptoStream(ms, crypto, CryptoStreamMode.Write)) { // Encrypt/decrypt and flush encStream.Write(bufferIn, 0, bufferIn.Length); encStream.Flush(); encStream.FlushFinalBlock(); encStream.Close(); // Get the data into a buffer bufferOut = ms.ToArray(); } } }