public static bool DecryptBase64(string cliperText, string key, out string originText) { byte[] inputData = Convert.FromBase64String(cliperText); var aes = new AesManaged() { Padding = _padding, Mode = _cipherMode, IV = ORIGIN_IV, Key = Encoding.UTF8.GetBytes(key.PadRight(KEY_LENGTH, PADDING_CHAR).Substring(0, KEY_LENGTH)) }; var decryptor = aes.CreateDecryptor(); bool decryptSuccess = true; try { byte[] decryptedData = decryptor.TransformFinalBlock(inputData, 0, inputData.Length); originText = Encoding.UTF8.GetString(decryptedData); } catch { decryptSuccess = false; originText = string.Empty; } finally { decryptor.Dispose(); if (aes != null) { aes.Clear(); } } return decryptSuccess; }
/// <summary> /// Decrypts the ciphertext using the Key. /// </summary> /// <param name="ciphertext">The ciphertext to decrypt.</param> /// <param name="password">The plain text encryption key.</param> /// <returns>The decrypted text.</returns> public static byte[] Decrypt(byte[] cipherText, string password) { if (cipherText == null || cipherText.Length == 0) throw new ArgumentNullException("cipherText"); if (string.IsNullOrEmpty(password)) throw new ArgumentNullException("password"); // Extract the salt from our ciphertext var saltBytes = cipherText.Take(SaltSize).ToArray(); var ciphertextBytes = cipherText.Skip(SaltSize).ToArray(); using (var keyDerivationFunction = new Rfc2898DeriveBytes(password, saltBytes)) { // Derive the previous Key and IV from the password and salt var keyBytes = keyDerivationFunction.GetBytes(32); var ivBytes = keyDerivationFunction.GetBytes(16); using (var aesManaged = new AesManaged()) using (var decryptor = aesManaged.CreateDecryptor(keyBytes, ivBytes)) using (var memoryStream = new MemoryStream(ciphertextBytes)) using (var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read)) using (var outputStream = new StreamReader(cryptoStream)) using (var outMemoryStream = new MemoryStream()) { outputStream.BaseStream.CopyTo(outMemoryStream); return outMemoryStream.ToArray(); } } }
public static string DecryptStringFromBytes_Aes(byte[] cipherText, byte[] Key, byte[] IV) { 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("Key"); string plaintext = null; using (AesManaged aesAlg = new AesManaged()) { aesAlg.Key = Key; aesAlg.IV = IV; ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV); using (MemoryStream msDecrypt = new MemoryStream(cipherText)) { using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)) { using (StreamReader srDecrypt = new StreamReader(csDecrypt)) { plaintext = srDecrypt.ReadToEnd(); } } } } return plaintext; }
internal static byte[] Decrypt(byte[] data) { byte[] output = null; using (var aes = new AesManaged()) { using (var decryptor = aes.CreateDecryptor(Configuration.Default.EncryptionKey, Configuration.Default.EncryptionIV)) { using (var dataStream = new MemoryStream()) { using (var encryptionStream = new CryptoStream(dataStream, decryptor, CryptoStreamMode.Write)) { encryptionStream.Write(data, 0, data.Length); encryptionStream.FlushFinalBlock(); dataStream.Position = 0; byte[] transformedBytes = new byte[dataStream.Length]; dataStream.Read(transformedBytes, 0, transformedBytes.Length); encryptionStream.Close(); dataStream.Close(); output = transformedBytes; } } } } return output; }
private void CreateCrytoTransform() { // Get shared secret GetSharedSecret(ref key, ref iv); if (key.Length == 0) { return; } // Set transform AesManaged aes = new System.Security.Cryptography.AesManaged(); AesManaged aes_decrypt = new AesManaged(); aes.Key = key; aes.IV = iv; aes.Mode = System.Security.Cryptography.CipherMode.CBC; aes.Padding = System.Security.Cryptography.PaddingMode.PKCS7; aes.BlockSize = 128; transform = aes.CreateEncryptor(); aes_decrypt.Key = key; aes_decrypt.IV = iv; aes_decrypt.Mode = System.Security.Cryptography.CipherMode.CBC; aes_decrypt.Padding = System.Security.Cryptography.PaddingMode.None; aes_decrypt.BlockSize = 128; decryptTransform = aes_decrypt.CreateDecryptor(); }
public void OFB_NotAllowed () { // this check is normally (e.g. RijndaelManaged) done later using (var aes = new AesManaged ()) { aes.Mode = CipherMode.OFB; } }
/// <summary> /// AES解密 /// </summary> /// <param name="hashedData">密文字节</param> /// <returns>返回解密后的字符串</returns> public static string AESDecrypt(string hashedData) { //分组加密算法 string result = string.Empty; SymmetricAlgorithm des; System.Security.Cryptography.AesManaged aesmanaged = new System.Security.Cryptography.AesManaged(); try { des = aesmanaged as SymmetricAlgorithm; des.Key = Encoding.UTF8.GetBytes(GetKey()); des.IV = _key1; byte[] cipherText = Convert.FromBase64String(hashedData); byte[] decryptBytes = new byte[cipherText.Length]; MemoryStream ms = new MemoryStream(cipherText); CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Read); cs.Read(decryptBytes, 0, decryptBytes.Length); cs.Close(); ms.Close(); result = System.Text.Encoding.UTF8.GetString(decryptBytes, 0, decryptBytes.Length); } catch (Exception ex) { SMT.Foundation.Log.Tracer.Debug(ex.Message); ex.Message.ToString(); } return(string.IsNullOrEmpty(result) ? string.Empty : result); }
public byte[] Encrypt(string plainText, byte[] Key, byte[] IV) { byte[] encrypted; // Create a new AesManaged. using (System.Security.Cryptography.AesManaged aes = new System.Security.Cryptography.AesManaged()) { // Create encryptor System.Security.Cryptography.ICryptoTransform encryptor = aes.CreateEncryptor(Key, IV); // Create MemoryStream using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { // Create crypto stream using the CryptoStream class. This class is the key to encryption // and encrypts and decrypts data from any given stream. In this case, we will pass a memory stream // to encrypt using (System.Security.Cryptography.CryptoStream cs = new System.Security.Cryptography.CryptoStream(ms, encryptor, System.Security.Cryptography.CryptoStreamMode.Write)) { // Create StreamWriter and write data to a stream using (System.IO.StreamWriter sw = new System.IO.StreamWriter(cs)) sw.Write(plainText); encrypted = ms.ToArray(); } } } // Return encrypted data return(encrypted); }
public static int Main() { List<byte[]>[] inputs = new List<byte[]>[] { GenerateInput(new int[] { 3, 1 }), GenerateInput(new int[] { 2, 2 }), GenerateInput(new int[] { 2, 1, 1 }), GenerateInput(new int[] { 1, 3}), GenerateInput(new int[] { 1, 2, 1}), GenerateInput(new int[] { 1, 1, 2 }), GenerateInput(new int[] { 1, 1, 1, 1 }) }; foreach (PaddingMode paddingMode in PaddingModes) { List<byte[]> results = new List<byte[]>(); // AESCSP is not supported on Win2k so just round-trip with AesManaged in this case // Aes aes1 = (AesCSPSupported()) ? (Aes) new AesCryptoServiceProvider() : (Aes) new AesManaged(); aes1.Padding = paddingMode; Aes aes2 = new AesManaged(); aes2.Padding = paddingMode; aes1.Key = aes2.Key; aes1.IV = aes2.IV; aes1.Mode = aes2.Mode; for (int i = 0; i < inputs.Length; i++) { byte[] result = null; if (!TestRoundTrip(aes1, aes2, inputs[i], out result)) { Console.WriteLine("Test Fail - roundtrip fails"); return FailCode; } results.Add(result); } for(int i = 0; i < results.Count - 1; i++) { if (!CompareBytes(results[i], results[i + 1])) { Console.WriteLine("Test Fail - mismatch"); Console.WriteLine("Result {0}: {1}", i, ByteArrayToString(results[i])); Console.WriteLine("Result {0}: {1}", i+1, ByteArrayToString(results[i+1])); Console.WriteLine("Key: {0}", ByteArrayToString(aes1.Key)); Console.WriteLine("IV: {0}", ByteArrayToString(aes1.IV)); Console.WriteLine("Cipher mode: {0}", aes1.Mode.ToString()); Console.WriteLine("Padding mode: {0}", aes1.Padding.ToString()); return FailCode; } } } Console.WriteLine("Test Passed"); return PassCode; }
/// <summary> /// 加密 /// </summary> public static string AESEncrypt(string input) { byte[] data = System.Text.UTF8Encoding.UTF8.GetBytes(input); byte[] salt = System.Text.UTF8Encoding.UTF8.GetBytes(saltValue); // AesManaged - 高级加密标准(AES) 对称算法的管理类 System.Security.Cryptography.AesManaged aes = new System.Security.Cryptography.AesManaged( ); // Rfc2898DeriveBytes - 通过使用基于 HMACSHA1 的伪随机数生成器,实现基于密码的密钥派生功能 (PBKDF2 - 一种基于密码的密钥派生函数) // 通过 密码 和 salt 派生密钥 System.Security.Cryptography.Rfc2898DeriveBytes rfc = new System.Security.Cryptography.Rfc2898DeriveBytes(pwdValue, salt); aes.BlockSize = aes.LegalBlockSizes[0].MaxSize; aes.KeySize = aes.LegalKeySizes[0].MaxSize; aes.Key = rfc.GetBytes(aes.KeySize / 8); aes.IV = rfc.GetBytes(aes.BlockSize / 8); // 用当前的 Key 属性和初始化向量 IV 创建对称加密器对象 System.Security.Cryptography.ICryptoTransform encryptTransform = aes.CreateEncryptor( ); // 加密后的输出流 System.IO.MemoryStream encryptStream = new System.IO.MemoryStream( ); // 将加密后的目标流(encryptStream)与加密转换(encryptTransform)相连接 System.Security.Cryptography.CryptoStream encryptor = new System.Security.Cryptography.CryptoStream (encryptStream, encryptTransform, System.Security.Cryptography.CryptoStreamMode.Write); // 将一个字节序列写入当前 CryptoStream (完成加密的过程) encryptor.Write(data, 0, data.Length); encryptor.Close( ); // 将加密后所得到的流转换成字节数组,再用Base64编码将其转换为字符串 string encryptedString = Convert.ToBase64String(encryptStream.ToArray( )); return(encryptedString); }
/// <summary> /// Returns a platform-specific algorithm that conforms to the prescribed platform-neutral algorithm. /// </summary> /// <returns> /// The platform-specific algorithm. /// </returns> private Platform.SymmetricAlgorithm GetAlgorithm() { #if SILVERLIGHT if (this.Name == SymmetricAlgorithmName.Aes && this.Mode == SymmetricAlgorithmMode.Cbc && this.Padding == SymmetricAlgorithmPadding.PKCS7) { return(new Platform.AesManaged()); } else { throw new NotSupportedException(); } #else Platform.SymmetricAlgorithm platform = null; #if __IOS__ if (this.Name == SymmetricAlgorithmName.Aes) { platform = new Platform.AesManaged(); } #else platform = Platform.SymmetricAlgorithm.Create(this.Name.GetString()); #endif if (platform == null) { throw new NotSupportedException(); } platform.Mode = GetMode(this.Mode); platform.Padding = GetPadding(this.Padding); return(platform); #endif }
/// <summary> /// Encrypts the plainText input using the given Key. /// A 128 bit random salt will be generated and prepended to the ciphertext before it is returned. /// </summary> /// <param name="plainText">The plain text to encrypt.</param> /// <param name="password">The plain text encryption key.</param> /// <returns>The salt and the ciphertext</returns> public static byte[] Encrypt(byte[] plainText, string password) { if (plainText == null || plainText.Length == 0) throw new ArgumentNullException("plainText"); if (string.IsNullOrEmpty(password)) throw new ArgumentNullException("password"); // Derive a new Salt, Key, and IV from the password using (var keyDerivationFunction = new Rfc2898DeriveBytes(password, SaltSize)) { var saltBytes = keyDerivationFunction.Salt; var keyBytes = keyDerivationFunction.GetBytes(32); var ivBytes = keyDerivationFunction.GetBytes(16); using (var aesManaged = new AesManaged()) using (var encryptor = aesManaged.CreateEncryptor(keyBytes, ivBytes)) using (var memoryStream = new MemoryStream()) using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write)) { using (var streamWriter = new BinaryWriter(cryptoStream)) { streamWriter.Write(plainText); } var cipherTextBytes = memoryStream.ToArray(); Array.Resize(ref saltBytes, saltBytes.Length + cipherTextBytes.Length); Array.Copy(cipherTextBytes, 0, saltBytes, SaltSize, cipherTextBytes.Length); return saltBytes; } } }
public static void DecryptFile(string inputFile, string outputFile, string keyIV) { byte[] array = new byte[0x20]; byte[] buffer2 = new byte[0x10]; HexStringToByteArray(keyIV, array, 0); HexStringToByteArray(keyIV, buffer2, 0x40); FileStream stream = File.Open(inputFile, System.IO.FileMode.Open); FileStream stream2 = File.Open(outputFile, System.IO.FileMode.CreateNew); AesManaged managed = new AesManaged { Key = array, IV = buffer2 }; CryptoStream stream3 = new CryptoStream(stream, managed.CreateDecryptor(managed.Key, managed.IV), CryptoStreamMode.Read); try { int num; byte[] buffer = new byte[0xa000]; while ((num = stream3.Read(buffer, 0, buffer.Length)) > 0) { stream2.Write(buffer, 0, num); } } finally { stream3.Close(); stream.Close(); stream2.Close(); } }
public void Can_Send_Encrypted_Message() { var client = CreateClient(); var request = new HelloSecure { Name = "World" }; var aes = new AesManaged { KeySize = AesUtils.KeySize }; var aesKeyBytes = aes.Key.Combine(aes.IV); var rsaEncAesKeyBytes = RsaUtils.Encrypt(aesKeyBytes, SecureConfig.PublicKeyXml); var timestamp = DateTime.UtcNow.ToUnixTime(); var requestBody = timestamp + " POST " + typeof(HelloSecure).Name + " " + request.ToJson(); var encryptedMessage = new EncryptedMessage { EncryptedSymmetricKey = Convert.ToBase64String(rsaEncAesKeyBytes), EncryptedBody = AesUtils.Encrypt(requestBody, aes.Key, aes.IV) }; var encResponse = client.Post(encryptedMessage); var responseJson = AesUtils.Decrypt(encResponse.EncryptedBody, aes.Key, aes.IV); var response = responseJson.FromJson<HelloSecureResponse>(); Assert.That(response.Result, Is.EqualTo("Hello, World!")); }
public static Stream Decrypt(Stream source, Headers headers, byte[] masterKey) { byte[] easKey; using (var buffer = new MemoryStream()) { var masterSeed = headers.MasterSeed; buffer.Write(masterSeed, 0, masterSeed.Length); buffer.Write(masterKey, 0, masterKey.Length); easKey = BufferEx.GetHash(buffer.ToArray()); } var eas = new AesManaged { KeySize = 256, Key = BufferEx.Clone(easKey), IV = BufferEx.Clone(headers.EncryptionIV) }; Stream stream = new CryptoStream(source, eas.CreateDecryptor(), CryptoStreamMode.Read); if (!VerifyStartBytes(headers, stream)) return null; stream = new HashedBlockStream(stream, true); return headers.Compression == Compressions.GZip ? new GZipInputStream(stream) : stream; }
/// <summary> /// Decrypt encrypted string /// </summary> /// <param name="Str">Encrypted string</param> /// <param name="Password">Password used for encryption</param> /// <param name="Salt">Salt string used for encryption (at least 8 bytes)</param> /// <returns>Decrypted string if success; otherwise - empty string</returns> public static string DecryptString(string Str, string Password = "******", string Salt = "tdcm1234") { try { using (Aes aes = new AesManaged()) { Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(Password, Encoding.UTF8.GetBytes(Salt)); 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(Str); decrypt.Write(encryptedData, 0, encryptedData.Length); decrypt.Flush(); } byte[] decryptedData = decryptionStream.ToArray(); return UTF8Encoding.UTF8.GetString(decryptedData, 0, decryptedData.Length); } } } catch (Exception ex) { Debug.WriteLine("Error : AES ~ DecryptString ; " + ex.Message); return ""; } }
/// <summary> /// this algorithm uses the AES algorithm to decrypt the given cipherText /// </summary> /// <param name="cipherText"></param> /// <param name="sharedSecret"></param> /// <returns></returns> public static string DecryptCipherAES(string cipherText, string sharedSecret) { if (string.IsNullOrEmpty(cipherText)) { return cipherText; } AesManaged aesAlg = null; string plaintext = null; // generate the key from the shared secret and the salt Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(sharedSecret, salt); // Create the streams used for decryption. byte[] bytes = Convert.FromBase64String(cipherText); using (MemoryStream memoryDecrypt = new MemoryStream(bytes)) { aesAlg = new AesManaged(); aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8); // Get the initialization vector from the encrypted stream aesAlg.IV = ReadByteArray(memoryDecrypt); // Create a decrytor to perform the stream transform. ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV); using (CryptoStream cryptoDecrypt = new CryptoStream(memoryDecrypt, decryptor, CryptoStreamMode.Read)) { using (StreamReader streamDecrypt = new StreamReader(cryptoDecrypt)) { plaintext = streamDecrypt.ReadToEnd(); } } } return plaintext; }
/// <summary> /// Encrypt a string using AES /// </summary> /// <param name="Str">String to encrypt</param> /// <param name="Password">Encryption password</param> /// <param name="Salt">A salt string (at least 8 bytes)</param> /// <returns>Encrypted string in case of success; otherwise - empty string</returns> public static string EncryptString(string Str, string Password = "******", string Salt = "tdcm1234") { try { using (Aes aes = new AesManaged()) { Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(Password, Encoding.UTF8.GetBytes(Salt)); aes.Key = deriveBytes.GetBytes(128 / 8); aes.IV = aes.Key; using (MemoryStream encryptionStream = new MemoryStream()) { using (CryptoStream encrypt = new CryptoStream(encryptionStream, aes.CreateEncryptor(), CryptoStreamMode.Write)) { byte[] utfD1 = UTF8Encoding.UTF8.GetBytes(Str); encrypt.Write(utfD1, 0, utfD1.Length); encrypt.FlushFinalBlock(); } return Convert.ToBase64String(encryptionStream.ToArray()); } } } catch (Exception ex) { Debug.WriteLine("Error : AES ~ EncryptString ; " + ex.Message); return ""; } }
/// <summary> /// konstruktor obiektu Server /// </summary> public Server() { requestReceived += Server_requestReceived; aesKeyGenerator = new AesManaged(); hashAlgorithm = new SHA256Managed(); rsaKeyGenerator = new RSACryptoServiceProvider(); }
public static void Register() { using (var manifestResourceStream = typeof(SettingsRegister).Assembly.GetManifestResourceStream("Raven.Studio.Settings.dat")) { if (manifestResourceStream == null || manifestResourceStream.Length == 0) { return; } using (var reader = new BinaryReader(manifestResourceStream)) using (var aes = new AesManaged()) { aes.Key = reader.ReadBytes(32); aes.IV = reader.ReadBytes(16); using (var cryptoStream = new CryptoStream(manifestResourceStream, aes.CreateDecryptor(), CryptoStreamMode.Read)) using (var cryptoReader = new BinaryReader(cryptoStream)) { var licensee = cryptoReader.ReadString(); var licenseKey = cryptoReader.ReadString(); ActiproSoftware.Products.ActiproLicenseManager.RegisterLicense(licensee, licenseKey); } } } }
public static MyWallet Load(string path, string password) { MyWallet wallet = new MyWallet(); byte[] aes_key = Encoding.UTF8.GetBytes(password).Sha256().Sha256(); byte[] aes_iv = new byte[16]; using (AesManaged aes = new AesManaged()) using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read)) { fs.Read(aes_iv, 0, aes_iv.Length); using (ICryptoTransform decryptor = aes.CreateDecryptor(aes_key, aes_iv)) using (CryptoStream cs = new CryptoStream(fs, decryptor, CryptoStreamMode.Read)) using (BinaryReader reader = new BinaryReader(cs)) { int count = (int)reader.ReadVarInt(); for (int i = 0; i < count; i++) { byte[] privateKey = reader.ReadBytes(32); bool compressed = reader.ReadBoolean(); ECPoint publicKey = ECCurve.Secp256k1.G * privateKey; UInt160 publicKeyHash = publicKey.EncodePoint(compressed).ToScriptHash(); wallet.accounts.Add(new WalletEntry(privateKey, publicKey, publicKeyHash, compressed)); } } } Array.Clear(aes_key, 0, aes_key.Length); return wallet; }
/// <summary> /// Encrypt the data /// </summary> /// <param name="input">String to encrypt</param> /// <returns>Encrypted string</returns> public static string Encrypt(string input, string password) { byte[] utfData = UTF8Encoding.UTF8.GetBytes(input); byte[] saltBytes = Encoding.UTF8.GetBytes(password); string encryptedString = string.Empty; using (AesManaged aes = new AesManaged()) { Rfc2898DeriveBytes rfc = new Rfc2898DeriveBytes(password, saltBytes); aes.BlockSize = aes.LegalBlockSizes[0].MaxSize; aes.KeySize = aes.LegalKeySizes[0].MaxSize; aes.Key = rfc.GetBytes(aes.KeySize / 8); aes.IV = rfc.GetBytes(aes.BlockSize / 8); using (ICryptoTransform encryptTransform = aes.CreateEncryptor()) { using (MemoryStream encryptedStream = new MemoryStream()) { using (CryptoStream encryptor = new CryptoStream(encryptedStream, encryptTransform, CryptoStreamMode.Write)) { encryptor.Write(utfData, 0, utfData.Length); encryptor.Flush(); encryptor.Close(); byte[] encryptBytes = encryptedStream.ToArray(); encryptedString = Convert.ToBase64String(encryptBytes); } } } } return encryptedString; }
/// <summary> /// Decrypt a string /// </summary> /// <param name="input">Input string in base 64 format</param> /// <returns>Decrypted string</returns> public static string Decrypt(string input, string password) { byte[] encryptedBytes = Convert.FromBase64String(input); byte[] saltBytes = Encoding.UTF8.GetBytes(password); string decryptedString = string.Empty; using (var aes = new AesManaged()) { Rfc2898DeriveBytes rfc = new Rfc2898DeriveBytes(password, saltBytes); aes.BlockSize = aes.LegalBlockSizes[0].MaxSize; aes.KeySize = aes.LegalKeySizes[0].MaxSize; aes.Key = rfc.GetBytes(aes.KeySize / 8); aes.IV = rfc.GetBytes(aes.BlockSize / 8); using (ICryptoTransform decryptTransform = aes.CreateDecryptor()) { using (MemoryStream decryptedStream = new MemoryStream()) { CryptoStream decryptor = new CryptoStream(decryptedStream, decryptTransform, CryptoStreamMode.Write); decryptor.Write(encryptedBytes, 0, encryptedBytes.Length); decryptor.Flush(); decryptor.Close(); byte[] decryptBytes = decryptedStream.ToArray(); decryptedString = UTF8Encoding.UTF8.GetString(decryptBytes, 0, decryptBytes.Length); } } } return decryptedString; }
public static string decrypt(string valueToDecrypt) { using (Aes aes = new AesManaged()) { aes.Padding = PaddingMode.PKCS7; aes.KeySize = 128; // in bits aes.Key = new byte[128 / 8]; // 16 bytes for 128 bit encryption aes.IV = new byte[128 / 8]; // AES needs a 16-byte IV // Should set Key and IV here. Good approach: derive them from // a password via Cryptography.Rfc2898DeriveBytes byte[] cipherText = Convert.FromBase64String(valueToDecrypt); byte[] plainText = null; using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, aes.CreateDecryptor(), CryptoStreamMode.Write)) { cs.Write(cipherText, 0, cipherText.Length); } plainText = ms.ToArray(); } return UTF8Encoding.UTF8.GetString(plainText); } }
public static string Encrypt(string plainText, string key) { if (string.IsNullOrEmpty(plainText)) throw new ArgumentNullException("plainText"); if (string.IsNullOrEmpty(key)) throw new ArgumentNullException("key"); using (var keyDerivationFunction = new Rfc2898DeriveBytes(key, _saltSize)) { var saltBytes = keyDerivationFunction.Salt; var keyBytes = keyDerivationFunction.GetBytes(32); var ivBytes = keyDerivationFunction.GetBytes(16); using (var aesManaged = new AesManaged()) using (var encryptor = aesManaged.CreateEncryptor(keyBytes, ivBytes)) using (var memoryStream = new MemoryStream()) { using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write)) using (var streamWriter = new StreamWriter(cryptoStream)) streamWriter.Write(plainText); var cipherTextBytes = memoryStream.ToArray(); Array.Resize(ref saltBytes, saltBytes.Length + cipherTextBytes.Length); Array.Copy(cipherTextBytes, 0, saltBytes, _saltSize, cipherTextBytes.Length); return Convert.ToBase64String(saltBytes); } } }
public static string Decrypt(string ciphertext, string key) { if (string.IsNullOrEmpty(ciphertext)) throw new ArgumentNullException("cipherText"); if (string.IsNullOrEmpty(key)) throw new ArgumentNullException("key"); var allTheBytes = Convert.FromBase64String(ciphertext); var saltBytes = allTheBytes.Take(_saltSize).ToArray(); var ciphertextBytes = allTheBytes.Skip(_saltSize).Take(allTheBytes.Length - _saltSize).ToArray(); using (var keyDerivationFunction = new Rfc2898DeriveBytes(key, saltBytes)) { var keyBytes = keyDerivationFunction.GetBytes(32); var ivBytes = keyDerivationFunction.GetBytes(16); using (var aesManaged = new AesManaged()) using (var decryptor = aesManaged.CreateDecryptor(keyBytes, ivBytes)) using (var memoryStream = new MemoryStream(ciphertextBytes)) using (var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read)) using (var streamReader = new StreamReader(cryptoStream)) { return streamReader.ReadToEnd(); } } }
static Boolean Test() { Boolean bResult; Console.WriteLine("Testing AesManaged encrypt/decrypt..."); AesManaged aes = new AesManaged(); EncDec ed = new EncDec(); EncDecMul edm = new EncDecMul(); bResult = ed.TestAlgorithm(aes); bResult = edm.TestAlgorithm(aes) && bResult; if (AesCSPSupported()) { Console.WriteLine("Testing AesCryptoServiceProvider encrypt/decrypt..."); AesCryptoServiceProvider aescsp = new AesCryptoServiceProvider(); ed = new EncDec(); edm = new EncDecMul(); bResult = ed.TestAlgorithm(aescsp); bResult = edm.TestAlgorithm(aescsp) && bResult; } return bResult; }
///<summary>Encrypts signature text and returns a base 64 string so that it can go directly into the database.</summary> public static string Encrypt(string str,byte[] key){ //No need to check RemotingRole; no call to db. if(str==""){ return ""; } byte[] ecryptBytes=Encoding.UTF8.GetBytes(str); MemoryStream ms=new MemoryStream(); CryptoStream cs=null; Aes aes=new AesManaged(); aes.Key=key; aes.IV=new byte[16]; ICryptoTransform encryptor=aes.CreateEncryptor(aes.Key,aes.IV); cs=new CryptoStream(ms,encryptor,CryptoStreamMode.Write); cs.Write(ecryptBytes,0,ecryptBytes.Length); cs.FlushFinalBlock(); byte[] encryptedBytes=new byte[ms.Length]; ms.Position=0; ms.Read(encryptedBytes,0,(int)ms.Length); cs.Dispose(); ms.Dispose(); if(aes!=null) { aes.Clear(); } return Convert.ToBase64String(encryptedBytes); }
public int dbEncrypt(String partition, int size, String data, out String dataOut) { AesManaged aes = null; MemoryStream memoryStream = null; CryptoStream cryptoStream = null; try { aes = new AesManaged(); aes.Key = readKeyFromFile(partition); memoryStream = new MemoryStream(); cryptoStream = new CryptoStream(memoryStream, aes.CreateEncryptor(), CryptoStreamMode.Write); byte[] buf = Encoding.UTF8.GetBytes(data); cryptoStream.Write(buf, 0, buf.Length); cryptoStream.FlushFinalBlock(); dataOut = Convert.ToBase64String(memoryStream.ToArray()); } finally { if (cryptoStream != null) cryptoStream.Close(); if (memoryStream != null) memoryStream.Close(); if (aes != null) aes.Clear(); } return getErrorCode() == 0 ? 1 : 0; }
public UniRx.IObservable <Sas.Net.HTTPResult> SignUp(AccountSignupParam param) { return(Observable.Range(0, 1) .SelectMany(_ => { var req = new AccountSignUpReqParam(); using (var aes = new System.Security.Cryptography.AesManaged()) { using (var iv = SecureHelper.APP_IV) { aes.IV = iv.GetByte(Convert.FromBase64String); } using (var key = SecureHelper.APP_KEY) { aes.Key = key.GetByte(Convert.FromBase64String); } req.authentication = authentication; req.token = param.password.GetByte(aes.Encrypt); req.email = param.email.GetByte(aes.Encrypt); using (var rsa = new System.Security.Cryptography.RSACryptoServiceProvider()) { req.public_key = aes.Encrypt(rsa.ToXmlString(false)); req.private_key = rsa.ExportPrivateKey().GetByte(aes.Encrypt); req.test = param.email.GetByte(rsa.Encrypt); } } var json = JObject.FromObject(req); return context.Post("/Account/SignUp", json); })); }
public Secret Encrypt(string plainText) { Secret result = new Secret(); using (MemoryStream ms = new MemoryStream()) { using (Aes aesAlg = new AesManaged()) { aesAlg.Key = _key; result.IV = aesAlg.IV; ICryptoTransform encryptor = aesAlg.CreateEncryptor(); using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write)) { byte[] rawPlaintext = Encoding.Unicode.GetBytes(plainText); cs.Write(rawPlaintext, 0, rawPlaintext.Length); cs.FlushFinalBlock(); // get the encrypted text ms.Seek(0, SeekOrigin.Begin); byte[] content = new byte[ms.Length]; ms.Read(content, 0, content.Length); result.Data = content; } } } return result; }
// should be used to encrypt a key with another key public static string EncryptWithKey(this string plaintext, string hexkey, string iv) { byte[] key = hexkey.ToByteArray (); byte[] byte_iv = iv.ToByteArray (); var aes = new AesManaged (); if (key.Length != 16 && key.Length != 20 && key.Length != 32) throw new Exception ("Key must be 128, 192 or 256 bits"); ICryptoTransform encryptor = aes.CreateEncryptor (key, byte_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); } var encrypted = msEncrypt.ToArray(); return encrypted.ToHexString (); } } }
public string Decrypt(Secret secret) { string plainText = null; using (MemoryStream msDecrypt = new MemoryStream(secret.Data)) { // Create an AesManaged object with the specified key and IV. using (Aes aesAlg = new AesManaged()) { aesAlg.Key = _key; aesAlg.IV = secret.IV; // Create a decrytor to perform the stream transform. ICryptoTransform decryptor = aesAlg.CreateDecryptor(); using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)) { using (StreamReader srDecrypt = new StreamReader(csDecrypt, Encoding.Unicode)) { // Read the decrypted bytes from the decrypting stream // and place them in a string. plainText = srDecrypt.ReadToEnd(); } } } } return plainText; }
public static string Encrypt(string plainText, string key) { if(string.IsNullOrEmpty(plainText)) { throw new ArgumentNullException("plainText"); } if(string.IsNullOrEmpty(key)) { throw new ArgumentNullException("key"); } using(var keyDerivationFunction = new Rfc2898DeriveBytes(key, SALT_SIZE)) { byte[] saltBytes = keyDerivationFunction.Salt; byte[] keyBytes = keyDerivationFunction.GetBytes(32); byte[] ivBytes = keyDerivationFunction.GetBytes(16); using(var aesManaged = new AesManaged()) { aesManaged.KeySize = 256; using(var encryptor = aesManaged.CreateEncryptor(keyBytes, ivBytes)) { MemoryStream memoryStream = null; CryptoStream cryptoStream = null; return WriteMemoryStream(plainText, ref saltBytes, encryptor, ref memoryStream, ref cryptoStream); } } } }
/// <summary> /// 解密 /// </summary> public static string AESDecrypt(string input) { byte[] encryptBytes = Convert.FromBase64String(input); byte[] salt = Encoding.UTF8.GetBytes(saltValue); System.Security.Cryptography.AesManaged aes = new System.Security.Cryptography.AesManaged( ); System.Security.Cryptography.Rfc2898DeriveBytes rfc = new System.Security.Cryptography.Rfc2898DeriveBytes(pwdValue, salt); aes.BlockSize = aes.LegalBlockSizes[0].MaxSize; aes.KeySize = aes.LegalKeySizes[0].MaxSize; aes.Key = rfc.GetBytes(aes.KeySize / 8); aes.IV = rfc.GetBytes(aes.BlockSize / 8); // 用当前的 Key 属性和初始化向量 IV 创建对称解密器对象 System.Security.Cryptography.ICryptoTransform decryptTransform = aes.CreateDecryptor( ); // 解密后的输出流 System.IO.MemoryStream decryptStream = new System.IO.MemoryStream( ); // 将解密后的目标流(decryptStream)与解密转换(decryptTransform)相连接 System.Security.Cryptography.CryptoStream decryptor = new System.Security.Cryptography.CryptoStream( decryptStream, decryptTransform, System.Security.Cryptography.CryptoStreamMode.Write); // 将一个字节序列写入当前 CryptoStream (完成解密的过程) decryptor.Write(encryptBytes, 0, encryptBytes.Length); decryptor.Close( ); // 将解密后所得到的流转换为字符串 byte[] decryptBytes = decryptStream.ToArray( ); string decryptedString = UTF8Encoding.UTF8.GetString(decryptBytes, 0, decryptBytes.Length); return(decryptedString); }
public void DecryptFile(string sourceFilename, string destinationFilename, string password) { AesManaged aes = new AesManaged(); aes.BlockSize = aes.LegalBlockSizes[0].MaxSize; aes.KeySize = aes.LegalKeySizes[0].MaxSize; // NB: Rfc2898DeriveBytes initialization and subsequent calls to GetBytes must be eactly the same, including order, on both the encryption and decryption sides. Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(password, salt, iterations); aes.Key = key.GetBytes(aes.KeySize / 8); aes.IV = key.GetBytes(aes.BlockSize / 8); aes.Mode = CipherMode.CBC; ICryptoTransform transform = aes.CreateDecryptor(aes.Key, aes.IV); using (FileStream destination = new FileStream(destinationFilename, FileMode.CreateNew, FileAccess.Write, FileShare.None)) { using (CryptoStream cryptoStream = new CryptoStream(destination, transform, CryptoStreamMode.Write)) { try { using (FileStream source = new FileStream(sourceFilename, FileMode.Open, FileAccess.Read, FileShare.Read)) { source.CopyTo(cryptoStream); } } catch (CryptographicException exception) { if (exception.Message == "Padding is invalid and cannot be removed.") throw new ApplicationException("Universal Microsoft Cryptographic Exception (Not to be believed!)", exception); else throw; } } } }
public String EncryptIt(String s) { Encoding byteEncoder = Encoding.UTF8; byte[] rijnKey = byteEncoder.GetBytes("h504lXb1erd4ilw7"); //this is key for encrypt data byte[] rijnIV = byteEncoder.GetBytes("4hx7e4bwM15d0CrL"); //this is iv for encrypt data String result; AesManaged rijn = new AesManaged(); //Using AES-128 rijn.KeySize = 128; rijn.BlockSize = 128; using (MemoryStream msEncrypt = new MemoryStream()) { using (ICryptoTransform encryptor = rijn.CreateEncryptor(rijnKey, rijnIV)) { using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)) { using (StreamWriter swEncrypt = new StreamWriter(csEncrypt)) { swEncrypt.Write(s); } } } result = Convert.ToBase64String(msEncrypt.ToArray()); } rijn.Clear(); return result; }
public static byte[] GenerateIV() { var aes = new System.Security.Cryptography.AesManaged(); aes.KeySize = 256; aes.GenerateIV(); return(aes.IV); }
internal ReferenceAttributeCollection() { #if WINDOWS_PHONE m_hash = new HASH(); #else m_hash = HASH.Create(); #endif }
public byte[] Decrypt(byte[] B, String PSW) { System.Security.Cryptography.PasswordDeriveBytes pdb = new System.Security.Cryptography.PasswordDeriveBytes(PSW, new Byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }); System.IO.MemoryStream ms = new System.IO.MemoryStream(); System.Security.Cryptography.Aes AESE = new System.Security.Cryptography.AesManaged(); AESE.Key = pdb.GetBytes(AESE.KeySize / 8); AESE.IV = pdb.GetBytes(AESE.BlockSize / 8); System.Security.Cryptography.CryptoStream cs = new System.Security.Cryptography.CryptoStream(ms, AESE.CreateDecryptor(), System.Security.Cryptography.CryptoStreamMode.Write); cs.Write(B, 0, B.Length); cs.Close(); return(ms.ToArray()); }
static byte[] MakeAuthentication(JToken token) { var cipher = token.ToObject <byte[]> (); using (var aes = new System.Security.Cryptography.AesManaged()) { using (var key = Sas.SecureHelper.APP_KEY) aes.Key = key.GetByte(Convert.FromBase64String); using (var iv = Sas.SecureHelper.APP_IV) aes.IV = iv.GetByte(Convert.FromBase64String); using (var question = aes.Decrypt(cipher.ToArray())) { var val = SasUtil.Evaluate(question.GetByte(b => b)); question.AppendChar('='); foreach (var ch in val.ToString()) { question.AppendChar(ch); } return(question.GetByte(aes.Encrypt)); } } }
UniRx.IObservable <Net.HTTPResult> LoginAsSas(AccountLoginParam param) { return(Observable.Range(0, 1) .SelectMany(_ => { var req = new AccountLoginReqParam(); using (var aes = new System.Security.Cryptography.AesManaged()) { using (var iv = SecureHelper.APP_IV) { aes.IV = iv.GetByte(Convert.FromBase64String); } using (var key = SecureHelper.APP_KEY) { aes.Key = key.GetByte(Convert.FromBase64String); } req.email = param.email.GetByte(aes.Encrypt); req.token = param.password.GetByte(aes.Encrypt); } var json = JObject.FromObject(req); return context.Post("/Account/Login", json); })); }
public string Decrypt(byte[] cipherText, byte[] Key, byte[] IV) { string plaintext = null; // Create AesManaged using (System.Security.Cryptography.AesManaged aes = new System.Security.Cryptography.AesManaged()) { // Create a decryptor System.Security.Cryptography.ICryptoTransform decryptor = aes.CreateDecryptor(Key, IV); // Create the streams used for decryption. using (System.IO.MemoryStream ms = new System.IO.MemoryStream(cipherText)) { // Create crypto stream using (System.Security.Cryptography.CryptoStream cs = new System.Security.Cryptography.CryptoStream(ms, decryptor, System.Security.Cryptography.CryptoStreamMode.Read)) { // Read crypto stream using (System.IO.StreamReader reader = new System.IO.StreamReader(cs)) plaintext = reader.ReadToEnd(); } } } return(plaintext); }
protected static void SecurityAesDecrypt(BlamVersion game, Blam.CacheSectionType section_type, byte[] input, out byte[] output, GetAesParametersProc GetAesParameters) { output = null; using (var aesm = new Crypt.AesManaged()) { aesm.KeySize = 128; aesm.Padding = Crypt.PaddingMode.Zeros; aesm.Mode = Crypt.CipherMode.CBC; byte[] key, iv; GetAesParameters(game, section_type, out key, out iv); if (key != null && iv != null) { using (var ctx = aesm.CreateDecryptor(key, iv)) { output = ctx.TransformFinalBlock(input, 0, input.Length); } } } }
/// <summary> /// Returns a platform-specific algorithm that conforms to the prescribed platform-neutral algorithm. /// </summary> /// <returns> /// The platform-specific algorithm. /// </returns> private Platform.SymmetricAlgorithm GetAlgorithm() { Platform.SymmetricAlgorithm?platform = null; #if __IOS__ if (this.Name == SymmetricAlgorithmName.Aes) { platform = new Platform.AesManaged(); } #elif NETCOREAPP1_0 platform = Platform.Aes.Create(); #else platform = Platform.SymmetricAlgorithm.Create(this.Name.GetString()); #endif if (platform == null) { throw new PlatformNotSupportedException(); } platform.Mode = GetMode(this.Mode); platform.Padding = GetPadding(this.Padding); return(platform); }
void Start() { AES = new System.Security.Cryptography.AesManaged(); }