public CreateEncryptor ( ) : ICryptoTransform | ||
return | ICryptoTransform |
public DES(string key, string iv) { if (key.Length > 8) { key = key.Substring(0, 8); } if (iv.Length > 8) { iv = iv.Substring(0, 8); } this.Key = this.TextEncode.GetBytes(key); this.IV = this.TextEncode.GetBytes(iv); try { des = new System.Security.Cryptography.DESCryptoServiceProvider(); des.Mode = CipherMode.ECB; des.Key = Key; des.IV = IV; decryptor = des.CreateDecryptor(this.Key, this.IV); encryptor = des.CreateEncryptor(this.Key, this.IV); } catch (System.Exception ex) { log.Error(ex.ToString()); } }
public static string EncryptString(string Value, string parKey) { mCSP = SetEnc(); string iv = "PenS8UCVF7s="; mCSP.IV = Convert.FromBase64String(iv); string key = SetLengthString(parKey.ToString(), 32); mCSP.Key = Convert.FromBase64String(key); ICryptoTransform ct; MemoryStream ms; CryptoStream cs; Byte[] byt = new byte[64]; try { ct = mCSP.CreateEncryptor(mCSP.Key, mCSP.IV); byt = Encoding.UTF8.GetBytes(Value); ms = new MemoryStream(); cs = new CryptoStream(ms, ct, CryptoStreamMode.Write); cs.Write(byt, 0, byt.Length); cs.FlushFinalBlock(); cs.Close(); return Convert.ToBase64String(ms.ToArray()); } catch (Exception Ex) { throw (new Exception("An error occurred while encrypting string")); } }
/// <summary> /// 加密文件 /// </summary> /// <param name="inName">来源文件</param> /// <param name="outName">输出文件</param> /// <param name="Algorithm">对称算法</param> public static void EncryptFile(string inName, string outName, SymmetricAlgorithm Algorithm) { FileStream fin = new FileStream(inName, FileMode.Open, FileAccess.Read); using (FileStream fout = new FileStream(outName, FileMode.OpenOrCreate, FileAccess.Write)) { fout.SetLength(0); CryptoStream encStream = new CryptoStream(fout, Algorithm.CreateEncryptor(), CryptoStreamMode.Write); //Read from the input file, then encrypt and write to the output file. //Create variables to help with read and write. long rdlen = 0; //This is the total number of bytes written. int len; //This is the number of bytes to be written at a time. byte[] bin = new byte[FileReadStep]; while (rdlen < fin.Length) { len = fin.Read(bin, 0, FileReadStep); encStream.Write(bin, 0, len); rdlen += len; } encStream.Close(); fin.Close(); } }
public virtual byte[] Encrypt(byte[] byteArr) { ICryptoTransform cTransform = provider.CreateEncryptor(); byte[] resultArray = cTransform.TransformFinalBlock(byteArr, 0, byteArr.Length); return(resultArray); }
private void TestBlock() { System.Security.Cryptography.ICryptoTransform cryptor; WriteLog("DataBytes String: " + System.Text.Encoding.UTF8.GetString(DataBytes)); // ----------------------------------------------------- cryptor = Cipher.CreateEncryptor(); WriteLog("Cipher.FeedbackSize: " + Cipher.FeedbackSize.ToString()); byte[] encrypted = CipherBlock(cryptor, DataBytes); WriteLog("Encrypted Bytes: " + System.BitConverter.ToString(encrypted).Replace("-", "")); // ----------------------------------------------------- //Cipher.Padding = System.Security.Cryptography.PaddingMode.None; cryptor = Cipher.CreateDecryptor(); byte[] decrypted = CipherBlock(cryptor, encrypted); // ----------------------------------------------------- WriteLog("Decrypted String: " + System.Text.Encoding.UTF8.GetString(decrypted)); }
/// <summary> /// Initialize CipherTextStealingMode with a specific symmetric algorithm /// </summary> /// <param name="symmetricAlgorithm">The symmetric algorithm</param> public CipherTextStealingMode(SymmetricAlgorithm symmetricAlgorithm) { // in CTS Mode there is no padding symmetricAlgorithm.Padding = PaddingMode.None; // set the symmetric algorithm's mode to ECB // (for single block encryption and decryption) symmetricAlgorithm.Mode = CipherMode.ECB; // get the symmetric algorithm's block size in bytes blockSize = symmetricAlgorithm.BlockSize / 8; if (blockSize != symmetricAlgorithm.IV.Length) { throw new ArgumentException( "The IV size should equal to the block size."); } // initialize local IV iv = symmetricAlgorithm.IV; // initialize cipher state using the symmetric algorithms's IV cipherState = new byte[blockSize]; symmetricAlgorithm.IV.CopyTo(cipherState, 0); // create encryptor and decryptor encryptor = symmetricAlgorithm.CreateEncryptor(); decryptor = symmetricAlgorithm.CreateDecryptor(); }
public AES(string key, string iv) { this.Key = this.TextEncode.GetBytes(key); this.IV = this.TextEncode.GetBytes(iv); //System.Security.Cryptography.Aes aes = new System.Security.Cryptography.AesCryptoServiceProvider(); //aes = new System.Security.Cryptography.AesCryptoServiceProvider(); aes = new System.Security.Cryptography.RijndaelManaged(); aes.Key = Key; aes.IV = IV; aes.KeySize = 128; aes.Mode = CipherMode.CBC; aes.BlockSize = 128; aes.Padding = PaddingMode.Zeros; try { decryptor = aes.CreateDecryptor(this.Key, this.IV); encryptor = aes.CreateEncryptor(this.Key, this.IV); } catch (System.Exception ex) { log.Error(ex.ToString()); } }
public static string Encryption(string UserID) { try { string EncryptedID = ""; byte[] clearTextBytes = Encoding.UTF8.GetBytes(UserID); System.Security.Cryptography.SymmetricAlgorithm SymmetricAlgorithm = SymmetricAlgorithm.Create(); MemoryStream MemoryStream = new MemoryStream(); byte[] keyByte = Encoding.ASCII.GetBytes(key); CryptoStream cs = new CryptoStream(MemoryStream, SymmetricAlgorithm.CreateEncryptor(keyByte, keyByte), CryptoStreamMode.Write); cs.Write(clearTextBytes, 0, clearTextBytes.Length); cs.Close(); #region Convert byte[] to hex string byte[] byteArray = MemoryStream.ToArray(); var hex = new StringBuilder(byteArray.Length * 2); foreach (var b in byteArray) { hex.AppendFormat("{0:x2}", b); } #endregion EncryptedID = hex.ToString(); return(EncryptedID); } catch (Exception ex) { //Utility.LogError(ex, "Reem", "Encryption"); return(string.Empty); } }
public static byte[] Encrypt(string strText, SymmetricAlgorithm key) { // Create a memory stream. MemoryStream ms = new MemoryStream(); // Create a CryptoStream using the memory stream and the // CSP(cryptoserviceprovider) DES key. CryptoStream crypstream = new CryptoStream(ms, key.CreateEncryptor(), CryptoStreamMode.Write); // Create a StreamWriter to write a string to the stream. StreamWriter sw = new StreamWriter(crypstream); // Write the strText to the stream. sw.WriteLine(strText); // Close the StreamWriter and CryptoStream. sw.Close(); crypstream.Close(); // Get an array of bytes that represents the memory stream. byte[] buffer = ms.ToArray(); // Close the memory stream. ms.Close(); // Return the encrypted byte array. return buffer; }
public static byte[] EncryptBytes(SymmetricAlgorithm symAlg, byte[] inBlock) { ICryptoTransform xfrm = symAlg.CreateEncryptor(); byte[] outBlock = xfrm.TransformFinalBlock(inBlock, 0, inBlock.Length); return outBlock; }
private byte[] Encrypt (SymmetricAlgorithm algo, PaddingMode padding, byte[] data) { algo.IV = new byte [algo.BlockSize >> 3]; algo.Mode = CipherMode.CBC; algo.Padding = padding; ICryptoTransform ct = algo.CreateEncryptor (); return ct.TransformFinalBlock (data, 0, data.Length); }
private static byte[] EncryptEnvelopeKeyUsingSymmetricKey(SymmetricAlgorithm symmetricAlgorithm, byte[] envelopeKey) { symmetricAlgorithm.Mode = CipherMode.ECB; using (ICryptoTransform encryptor = symmetricAlgorithm.CreateEncryptor()) { return (encryptor.TransformFinalBlock(envelopeKey, 0, envelopeKey.Length)); } }
private static ICryptoTransform CreateCryptoTransform(SymmetricAlgorithm algorithm, CryptoAction action) { byte[] key = Encoding.ASCII.GetBytes(stringKey); byte[] vector = Encoding.ASCII.GetBytes(stringVector); return action == CryptoAction.Encrypt ? algorithm.CreateEncryptor(key, vector) : algorithm.CreateDecryptor(key, vector); }
private byte[] TransformByCryptoStream(SymmetricAlgorithm algorithm, byte[] bytes, bool encrypt) { algorithm.Clear(); if (encrypt) return TransformByCryptoStream(algorithm.CreateEncryptor(), bytes); else return TransformByCryptoStream(algorithm.CreateDecryptor(), bytes); }
internal WinzipAesCryptoStream(Stream stream, WinzipAesEncryptionData winzipAesEncryptionData, long length) { this.stream = stream; totalBytesLeftToRead = length; cipher = CreateCipher(winzipAesEncryptionData); var iv = new byte[BLOCK_SIZE_IN_BYTES]; transform = cipher.CreateEncryptor(winzipAesEncryptionData.KeyBytes, iv); }
public static byte[] Encrypt(SymmetricAlgorithm algorithm,byte[] data) { using (MemoryStream memory = new MemoryStream()) { using (CryptoStream encrypt = new CryptoStream(memory, algorithm.CreateEncryptor(algorithm.Key, algorithm.IV), CryptoStreamMode.Write)) { encrypt.Write(data, 0, data.Length); } return memory.ToArray(); } }
/// <summary> /// Encrypts the offline transaction file using the TripleDES cryptography. /// </summary> /// <param name="Password"></param> /// <returns></returns> public static string EncryptPassword(string Password) { string testPwd = string.Empty; DES = new TripleDESCryptoServiceProvider(); byte[] plaintext = Encoding.ASCII.GetBytes(Password); DES.Key = ParseKey(desKey); DES.IV = GetIV(); //string decPwd = DecryptPassword("Lw5AEvoSG+7VlrMK+XgmGw=="); byte[] encrypted = DES.CreateEncryptor().TransformFinalBlock(plaintext, 0, plaintext.Length); return Convert.ToBase64String(encrypted); }
public CtrModeCryptoTransform(SymmetricAlgorithm algorithm) { Contract.Requires(algorithm != null); algorithm.Mode = CipherMode.ECB; algorithm.Padding = PaddingMode.None; _algorithm = algorithm; _transform = algorithm.CreateEncryptor(); _iv = algorithm.IV; _block = new byte[algorithm.BlockSize >> 3]; }
public OfbStream(Stream parent, SymmetricAlgorithm algo, CryptoStreamMode mode) { if (algo.Mode != CipherMode.CBC) algo.Mode = CipherMode.CBC; if (algo.Padding != PaddingMode.None) algo.Padding = PaddingMode.None; _parent = parent; _cbcStream = new CryptoStream(new ZeroStream(), algo.CreateEncryptor(), CryptoStreamMode.Read); _mode = mode; _keyStreamBuffer = new byte[algo.BlockSize * Blocks]; _readWriteBuffer = new byte[_keyStreamBuffer.Length]; }
public static byte[] Encrypt(SymmetricAlgorithm algorithm, byte[] src) { using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, algorithm.CreateEncryptor(), CryptoStreamMode.Write)) { cs.Write(src, 0, src.Length); cs.FlushFinalBlock(); return ms.ToArray(); } } }
private static byte[] Encrypt(string PlainText, SymmetricAlgorithm key) { MemoryStream ms = new MemoryStream(); CryptoStream encStream = new CryptoStream(ms, key.CreateEncryptor(), CryptoStreamMode.Write); StreamWriter sw = new StreamWriter(encStream); sw.WriteLine(PlainText); sw.Close(); encStream.Close(); byte[] buffer = ms.ToArray(); ms.Close(); return buffer; }
/// <summary> /// Encrypt a given message, provided with key and IV /// </summary> /// <param name="aesAlg"></param> /// <param name="plainText"></param> /// <returns></returns> static byte[] Encrypt(System.Security.Cryptography.SymmetricAlgorithm aesAlg, string plainText) { var encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV); using (MemoryStream msEncrypt = new MemoryStream()) { using (StreamWriter swEncrypt = new StreamWriter(new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))) { swEncrypt.Write(plainText); } return(msEncrypt.ToArray()); } }
/// <summary> /// Constructor for AES class that takes byte arrays for the key and IV /// </summary> /// <param name="key">Cryptographic key</param> /// <param name="IV">Cryptographic initialization vector</param> public AES(byte[] key, byte[] IV) { // Initialize AESProvider with AES service provider AESProvider = new AesCryptoServiceProvider(); // Set the key and IV for AESProvider AESProvider.Key = key; AESProvider.IV = IV; // Initialize cryptographic transformers from AESProvider encryptor = AESProvider.CreateEncryptor(); decryptor = AESProvider.CreateDecryptor(); }
public static byte[] Encrypt(SymmetricAlgorithm aesAlg, string plainText) { ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV); using (MemoryStream msEncrypt = new MemoryStream()) { using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)) using (StreamWriter swEncrypt = new StreamWriter(csEncrypt)) { swEncrypt.Write(plainText); } return msEncrypt.ToArray(); } }
public static string EncodePassword(string source) { byte[] binarySource = Encoding.UTF8.GetBytes(source); System.Security.Cryptography.SymmetricAlgorithm rijn = System.Security.Cryptography.SymmetricAlgorithm.Create(); MemoryStream ms = new MemoryStream(); byte[] rgbIV = Encoding.ASCII.GetBytes("lkjhasdfyuiwhcnt"); byte[] key = Encoding.ASCII.GetBytes("tkw123aaaa"); CryptoStream cs = new CryptoStream(ms, rijn.CreateEncryptor(key, rgbIV), CryptoStreamMode.Write); cs.Write(binarySource, 0, binarySource.Length); cs.Close(); return(Convert.ToBase64String(ms.ToArray())); }
//private const string key1 = "aaaaaaaaaaaaaaaa"; //private const string key2 = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; private string EncryptString(string ClearText) { byte[] clearTextBytes = Encoding.UTF8.GetBytes(ClearText); System.Security.Cryptography.SymmetricAlgorithm rijn = SymmetricAlgorithm.Create(); MemoryStream ms = new MemoryStream(); byte[] rgbIV = Encoding.ASCII.GetBytes(key1); byte[] key = Encoding.ASCII.GetBytes(key2); CryptoStream cs = new CryptoStream(ms, rijn.CreateEncryptor(key, rgbIV), CryptoStreamMode.Write); cs.Write(clearTextBytes, 0, clearTextBytes.Length); cs.Close(); return(Convert.ToBase64String(ms.ToArray())); }
void TestEncryptDecrypt(SymmetricAlgorithm ealg, SymmetricAlgorithm dalg) { System.Diagnostics.Trace.WriteLine(String.Format("b={0}, k={1}, r={2}", ealg.BlockSize, ealg.KeySize, ealg is ModifiedRijndael ? ((ModifiedRijndael)ealg).Rounds : ((ModifiedRijndael)dalg).Rounds)); byte[] test = Encoding.ASCII.GetBytes("Testing 123"); byte[] copy; using (ICryptoTransform enc = ealg.CreateEncryptor()) copy = enc.TransformFinalBlock(test, 0, test.Length); using (ICryptoTransform dec = dalg.CreateDecryptor()) copy = dec.TransformFinalBlock(copy, 0, copy.Length); Assert.AreEqual(0, BinaryComparer.Compare(test, copy)); }
private byte[] Encrypt(SymmetricAlgorithm symmetricAlgorithm, string original) { ICryptoTransform encryptor = symmetricAlgorithm.CreateEncryptor(symmetricAlgorithm.Key, symmetricAlgorithm.IV); using (MemoryStream msEncrypt = new MemoryStream()) { using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)) { using (StreamWriter swEncrypt = new StreamWriter(csEncrypt)) { swEncrypt.Write(original); } return msEncrypt.ToArray(); } } }
/// <summary> /// Encrypts given text /// </summary> /// <param name="text">Text to encrypt</param> /// <param name="key">Key, used for encryption</param> /// <param name="iv">Initialization Vector</param> /// <param name="cryptoProvider">Cryptography algorithm</param> /// <returns>Encrypted text</returns> public static string Encrypt(string text, byte[] key, byte[] iv, SymmetricAlgorithm cryptoProvider) { //using (var cryptoProvider = Rijndael.Create()) using (cryptoProvider) using (var memoryStream = new MemoryStream()) using (var cryptoStream = new CryptoStream(memoryStream, cryptoProvider.CreateEncryptor(key, iv), CryptoStreamMode.Write)) using (var writer = new StreamWriter(cryptoStream)) { writer.Write(text); writer.Flush(); cryptoStream.FlushFinalBlock(); writer.Flush(); return Convert.ToBase64String(memoryStream.GetBuffer(), 0, (int)memoryStream.Length); } }
public static byte[] Encrypt(string str, SymmetricAlgorithm key) { MemoryStream ms = new MemoryStream(); CryptoStream cs = new CryptoStream(ms, key.CreateEncryptor(), CryptoStreamMode.Write); StreamWriter sw = new StreamWriter(cs); sw.WriteLine(str); sw.Close(); cs.Close(); byte[] buffer = ms.ToArray(); ms.Close(); return buffer; }
public string EncryptString(string clearText) { byte[] clearTextBytes = Encoding.UTF8.GetBytes(clearText); System.Security.Cryptography.SymmetricAlgorithm rijn = SymmetricAlgorithm.Create(); MemoryStream ms = new MemoryStream(); byte[] rgbIV = Encoding.ASCII.GetBytes("ryojvlzffalyglrj"); byte[] key = Encoding.ASCII.GetBytes("hcxilkqbbffffeultgbskdmaunivmfuo"); CryptoStream cs = new CryptoStream(ms, rijn.CreateEncryptor(key, rgbIV), CryptoStreamMode.Write); cs.Write(clearTextBytes, 0, clearTextBytes.Length); cs.Close(); return(Convert.ToBase64String(ms.ToArray())); }
/// <summary> /// Constructor for AES class that generates the key and IV from salted passwords /// </summary> /// <param name="keyPassword">Password used to generate the key</param> /// <param name="IVPassword">Password used to generate the IV</param> /// <param name="salt">Salt used to secure the passwords</param> public AES(string keyPassword, string IVPassword, string salt) { // Initialize AESProvider with AES service provider AESProvider = new AesCryptoServiceProvider(); // Initialize a hasher with the default MD5 algorithm MD5 md5 = System.Security.Cryptography.MD5.Create(); // Generate the key and IV for AESProvider from hashed, salted passwords AESProvider.Key = md5.ComputeHash(UnicodeEncoding.Unicode.GetBytes(keyPassword + salt)); AESProvider.IV = md5.ComputeHash(UnicodeEncoding.Unicode.GetBytes(IVPassword + salt)); // Initialize cryptographic transformers from AESProvider encryptor = AESProvider.CreateEncryptor(); decryptor = AESProvider.CreateDecryptor(); }
/// <summary> /// Encrypts the specified plain text. /// </summary> /// <param name="plainText">The plain text.</param> /// <returns>The encrypted value as a byte array.</returns> public byte[] Encrypt(byte[] plainText) { using var stream = new MemoryStream(); var iv = Range.GetBytes(_credential.IvSize); var encryptor = _algorithm.CreateEncryptor(_credential.GetKey(), iv); stream.WriteCipherTextHeader(iv); using var cryptoStream = new CryptoStream(stream, encryptor, CryptoStreamMode.Write); cryptoStream.Write(plainText, 0, plainText.Length); stream.Flush(); return(stream.ToArray()); }
/// <summary>Creates a new SymmetricEncryption handler for the passed in /// SymmetricAlgorithm.</summary> public SymmetricEncryption(SymmetricAlgorithm Algorithm) { if(Algorithm.Mode != CipherMode.CBC) { throw new Exception("SymmetricEncryption requires the symmetric algorithm to use CBC."); } rng = new RNGCryptoServiceProvider(); _sa = Algorithm; // We take care of PKCS7 padding here due to issues in the underlying implementations... _sa.Padding = PaddingMode.None; BlockSizeByte = _sa.BlockSize / 8; // Match the same size as our Window size... _decryptors = new Cache(64); _enc_iv = new byte[BlockSizeByte]; rng.GetBytes(_enc_iv); _enc = _sa.CreateEncryptor(_sa.Key, _enc_iv); _temp = new byte[BlockSizeByte]; }
public static string Encrypt(string PlainText) { byte[] PlainBytes = Encoding.UTF8.GetBytes(PlainText); System.Security.Cryptography.SymmetricAlgorithm Alg = System.Security.Cryptography.SymmetricAlgorithm.Create(); MemoryStream MemStr = new MemoryStream(); byte[] KeyBytes = Encoding.ASCII.GetBytes(KEY); byte[] KeyIIBytes = Encoding.ASCII.GetBytes(KEYII); CryptoStream CryptStr = new CryptoStream(MemStr, Alg.CreateEncryptor(KeyBytes, KeyIIBytes), CryptoStreamMode.Write); CryptStr.Write(PlainBytes, 0, PlainText.Length); CryptStr.Close(); return(Convert.ToBase64String(MemStr.ToArray())); }
static byte[] Encrypt(object value, object key, bool decrypt, SymmetricAlgorithm alg) { int size = 0; foreach (var legal in alg.LegalKeySizes) size = Math.Max(size, legal.MaxSize); var k = new byte[size / 8]; var keyBytes = ToByteArray(key); if (keyBytes.Length < k.Length) { var padded = new byte[k.Length]; keyBytes.CopyTo(padded, 0); keyBytes = padded; } for (int i = 0; i < k.Length; i++) k[i] = keyBytes[i]; try { alg.Key = k; } catch (CryptographicException) { ErrorLevel = 2; return new byte[] { }; } var iv = new byte[alg.IV.Length]; var hash = new SHA1Managed().ComputeHash(keyBytes, 0, iv.Length); for (int i = 0; i < Math.Min(iv.Length, hash.Length); i++) iv[i] = hash[i]; alg.IV = iv; var trans = decrypt ? alg.CreateDecryptor() : alg.CreateEncryptor(); var buffer = ToByteArray(value); var result = trans.TransformFinalBlock(buffer, 0, buffer.Length); return result; }
private static string Encrypt(string Key, string IV, string DataToEncrypt) { //Initialize a encoder/decoder that obtains the bytes from a string System.Text.UTF8Encoding encoder = new System.Text.UTF8Encoding(); string EncryptKey = CheckLength(Key); string EncryptIV = CheckLength(IV); string Data = DataToEncrypt.ToString(); byte[] BKey = new byte[16]; BKey = ConvertToByte(EncryptKey); byte[] BIV = new byte[16]; BIV = ConvertToByte(EncryptIV); byte[] BData = encoder.GetBytes(Data); // initialize the Algorithm object. System.Security.Cryptography.SymmetricAlgorithm myDES = System.Security.Cryptography.Rijndael.Create(); //Set the key and IV. myDES.Key = BKey; myDES.IV = BIV; //myDES.BlockSize = 512; // Create an encryptor object... ICryptoTransform encrypt = myDES.CreateEncryptor(); // use the memory stream to store the cipher text... System.IO.MemoryStream ms = new System.IO.MemoryStream(); // Use a cryptoSctream to encrypt the Data CryptoStream cs = new CryptoStream(ms, encrypt, CryptoStreamMode.Write); cs.Write(BData, 0, BData.Length); // Flush any residule in the final block cs.FlushFinalBlock(); // get the output and trim the '\0' bytes byte[] bytOut = ms.GetBuffer(); int i = bytOut.Length - 1; while (bytOut[i] == 0) { i--; } //Convert to Base64 because there is difficulty when it comes to normal characters using the normal string methods. string Result = System.Convert.ToBase64String(bytOut, 0, i + 1); return(Result); }
private static byte[] EncryptBytes(SymmetricAlgorithm alg, byte[] message) { if ((message == null) || (message.Length == 0)) { return message; } if (alg == null) { throw new ArgumentNullException("alg"); } using (var stream = new MemoryStream()) using (var encryptor = alg.CreateEncryptor()) using (var encrypt = new CryptoStream(stream, encryptor, CryptoStreamMode.Write)) { encrypt.Write(message, 0, message.Length); encrypt.FlushFinalBlock(); return stream.ToArray(); } }
public static string EncryptString(string ClearText) { byte[] clearTextBytes = Encoding.UTF8.GetBytes(ClearText); System.Security.Cryptography.SymmetricAlgorithm rijn = SymmetricAlgorithm.Create(); MemoryStream ms = new MemoryStream(); byte[] rgbIV = Encoding.ASCII.GetBytes("lbavittzoaofgcqz"); byte[] key = Encoding.ASCII.GetBytes("rymnwalaspjdbygwagsxhzzcroywhciu"); CryptoStream cs = new CryptoStream(ms, rijn.CreateEncryptor(key, rgbIV), CryptoStreamMode.Write); cs.Write(clearTextBytes, 0, clearTextBytes.Length); cs.Close(); return(Base32Encoding.ToString(ms.ToArray())); }
private static byte[] Encrypt(string texto, SymmetricAlgorithm objCript) { MemoryStream ms = new MemoryStream(); CryptoStream encStream = new CryptoStream(ms, objCript.CreateEncryptor(), CryptoStreamMode.Write); StreamWriter sw = new StreamWriter(encStream, Encoding.UTF8); sw.Write(texto); sw.Close(); encStream.Close(); byte[] buffer = ms.ToArray(); ms.Close(); return buffer; }
private byte[] EncryptDecrypt(bool encrypt, SymmetricAlgorithm alg, byte[] key, byte[] iv, byte[] data) { using (MemoryStream ms = new MemoryStream()) { byte[] rgbKey = new PasswordDeriveBytes(key, _salt).GetBytes(24); byte[] rgbIV = new PasswordDeriveBytes(iv, _salt).GetBytes(24); using (CryptoStream cs = new CryptoStream(ms, encrypt ? alg.CreateEncryptor(rgbKey, rgbIV) : alg.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write)) { cs.Write(data, 0, data.Length); cs.Close(); return ms.ToArray(); } } }
internal WinzipAesCryptoStream(Stream stream, WinzipAesEncryptionData winzipAesEncryptionData, long length, CryptoMode mode) { this.mode = mode; this.stream = stream; totalBytesLeftToRead = length; hmac = new HMACSHA1(winzipAesEncryptionData.IvBytes); cipher = CreateCipher(winzipAesEncryptionData); var iv = new byte[BLOCK_SIZE_IN_BYTES]; transform = cipher.CreateEncryptor(winzipAesEncryptionData.KeyBytes, iv); //if (_mode == CryptoMode.Encrypt) //{ // _iobuf = new byte[2048]; // _PendingWriteBlock = new byte[BLOCK_SIZE_IN_BYTES]; //} }
public static string EncryptString(string ClearText, string iv = "", string key = "") { iv = (iv + Röschti).Substring(0, 16); key = (key + Bradwurscht).Substring(0, 32); byte[] clearTextBytes = Encoding.UTF8.GetBytes(ClearText); System.Security.Cryptography.SymmetricAlgorithm rijn = SymmetricAlgorithm.Create(); MemoryStream ms = new MemoryStream(); byte[] ba_rgbIV = Encoding.ASCII.GetBytes(iv); byte[] ba_key = Encoding.ASCII.GetBytes(key); CryptoStream cs = new CryptoStream(ms, rijn.CreateEncryptor(ba_key, ba_rgbIV), CryptoStreamMode.Write); cs.Write(clearTextBytes, 0, clearTextBytes.Length); cs.Close(); rijn.Dispose(); rijn = null; return(Convert.ToBase64String(ms.ToArray())); }
public static string EncryptString(string ClearText) { string theKey = SystemInfo.deviceUniqueIdentifier; byte[] salt = new byte[] { 0x26, 0xdc, 0xff, 0x00, 0xad, 0xed, 0x7a, 0xee, 0xc5, 0xfe, 0x07, 0xaf, 0x4d, 0x08, 0x22, 0x3c }; Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(theKey, salt); byte[] key = pdb.GetBytes(32); byte[] iv = pdb.GetBytes(16); byte[] clearTextBytes = Encoding.UTF8.GetBytes(ClearText); System.Security.Cryptography.SymmetricAlgorithm rijn = SymmetricAlgorithm.Create(); MemoryStream ms = new MemoryStream(); CryptoStream cs = new CryptoStream(ms, rijn.CreateEncryptor(key, iv), CryptoStreamMode.Write); cs.Write(clearTextBytes, 0, clearTextBytes.Length); cs.Close(); return(Convert.ToBase64String(ms.ToArray())); }
private string Roundtrip (SymmetricAlgorithm sa, CipherMode mode) { sa.Key = GetKey (sa); sa.IV = GetIV (sa); sa.Mode = mode; // two full blocks int bs = (sa.BlockSize >> 3) * 2; byte[] data = new byte [bs]; // in bytes ICryptoTransform enc = sa.CreateEncryptor (); byte[] encdata = enc.TransformFinalBlock (data, 0, data.Length); string result = BitConverter.ToString (encdata); ICryptoTransform dec = sa.CreateDecryptor (); byte[] decdata = dec.TransformFinalBlock (encdata, 0, encdata.Length); for (int i = 0; i < bs; i++) Assert.AreEqual (data [i], decdata [i], i.ToString ()); return result; }
public static string EncryptString(string ClearText) { string retval; byte[] clearTextBytes = Encoding.UTF8.GetBytes(ClearText); System.Security.Cryptography.SymmetricAlgorithm rijn = SymmetricAlgorithm.Create(); using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, rijn.CreateEncryptor(key, rgbIV), CryptoStreamMode.Write)) { cs.Write(clearTextBytes, 0, clearTextBytes.Length); cs.Close(); } retval = Convert.ToBase64String(ms.ToArray()); } return(retval); }
public static string EncryptString(string ClearText, string Key) { byte[] clearTextBytes = Encoding.UTF8.GetBytes(ClearText); //byte[] clearTextBytes = Convert.FromBase64String(ClearText); System.Security.Cryptography.SymmetricAlgorithm rijn = SymmetricAlgorithm.Create(); MemoryStream ms = new MemoryStream(); byte[] rgbIV = Encoding.ASCII.GetBytes("ryojvlzmdalyglrj"); byte[] key = Encoding.ASCII.GetBytes(CompleteKey32(Key)); CryptoStream cs = new CryptoStream(ms, rijn.CreateEncryptor(key, rgbIV), CryptoStreamMode.Write); cs.Write(clearTextBytes, 0, clearTextBytes.Length); //ms.Position = 0; //StreamReader reader = new StreamReader(ms); cs.Close(); // return reader.ReadToEnd(); //return Encoding.UTF8.GetString(ms.ToArray()); return(Convert.ToBase64String(ms.ToArray())); }
public static string Encrypt(string inputText) { if (String.IsNullOrWhiteSpace(inputText)) { inputText = ""; } byte[] clearTextBytes = Encoding.UTF8.GetBytes(inputText); System.Security.Cryptography.SymmetricAlgorithm rijn = SymmetricAlgorithm.Create(); MemoryStream ms = new MemoryStream(); byte[] rgbIV = Encoding.ASCII.GetBytes(rgbIVValue); byte[] key = Encoding.ASCII.GetBytes(keyValue); CryptoStream cs = new CryptoStream(ms, rijn.CreateEncryptor(key, rgbIV), CryptoStreamMode.Write); cs.Write(clearTextBytes, 0, clearTextBytes.Length); cs.Close(); return(Convert.ToBase64String(ms.ToArray())); }
public static string AESEncrypt(string encryptStr, string encryptKey) { string result; if (string.IsNullOrWhiteSpace(encryptStr)) { result = string.Empty; } else { encryptKey = StringHelper.SubString(encryptKey, 32); encryptKey = encryptKey.PadRight(32, ' '); System.Security.Cryptography.SymmetricAlgorithm symmetricAlgorithm = System.Security.Cryptography.Rijndael.Create(); byte[] bytes = System.Text.Encoding.UTF8.GetBytes(encryptStr); symmetricAlgorithm.Key = System.Text.Encoding.UTF8.GetBytes(encryptKey); symmetricAlgorithm.IV = SecureHelper._aeskeys; byte[] inArray = null; using (System.IO.MemoryStream memoryStream = new System.IO.MemoryStream()) { using (System.Security.Cryptography.CryptoStream cryptoStream = new System.Security.Cryptography.CryptoStream(memoryStream, symmetricAlgorithm.CreateEncryptor(), System.Security.Cryptography.CryptoStreamMode.Write)) { cryptoStream.Write(bytes, 0, bytes.Length); cryptoStream.FlushFinalBlock(); inArray = memoryStream.ToArray(); cryptoStream.Close(); memoryStream.Close(); } } result = System.Convert.ToBase64String(inArray); } return(result); }
public override ICryptoTransform CreateEncryptor() { return(m_impl.CreateEncryptor()); }
public static byte[] smethod_1(byte[] byte_0, string string_0) { System.Array.Resize <byte>(ref byte_0, byte_0.Length + 1); byte_0[byte_0.Length - 1] = (byte)new System.Random().Next(0, 255); System.Security.Cryptography.SymmetricAlgorithm symmetricAlgorithm = System.Security.Cryptography.SymmetricAlgorithm.Create(); System.IO.MemoryStream memoryStream = new System.IO.MemoryStream(); byte[] bytes = System.Text.Encoding.ASCII.GetBytes(string_0); byte[] rgbIV = bytes; System.Security.Cryptography.CryptoStream cryptoStream = new System.Security.Cryptography.CryptoStream(memoryStream, symmetricAlgorithm.CreateEncryptor(bytes, rgbIV), System.Security.Cryptography.CryptoStreamMode.Write); cryptoStream.Write(byte_0, 0, byte_0.Length); cryptoStream.Close(); return(memoryStream.ToArray()); }