// ------------------------------------------------------------------------------- /// <summary> /// SimpleDecrypt the ciphertext. /// </summary> /// <param name="ciphertext">The ciphertext to be decrypted.</param> /// <returns>The decrypted ciphertext (-> plaintext).</returns> private byte[] SimpleDecrypt(byte[] ciphertext) { byte[] plaintext = null; string base64String = ByteArrayToAnsiString(ciphertext); byte[] binaryData = Convert.FromBase64String(base64String); MemoryStream memoryStream = new MemoryStream(binaryData, 16, binaryData.Length - 16); byte[] IV = new byte[16]; // get the initialization vector for (int i = 0; i < 16; i++) { IV[i] = binaryData[i]; } //Creates the default implementation, which is RijndaelManaged. SymmetricAlgorithm rijn = SymmetricAlgorithm.Create(); // creates a symmetric decryptor object with the specified Key and initialization vector (IV). ICryptoTransform decryptor = rijn.CreateDecryptor(this.key, IV); // prepare the Crypto Stream CryptoStream encryptedData = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read); // decrypt ciphertext MemoryStream decryptedData = this.GetBytes(encryptedData); decryptedData.Position = 0; plaintext = decryptedData.ToArray(); // Speicher frei geben memoryStream.Close(); decryptedData.Close(); encryptedData.Close(); decryptor.Dispose(); rijn.Clear(); return(plaintext); }
public SymmetricCryptoKey(Stream s) { BinaryReader bR = new BinaryReader(s); if (Encoding.ASCII.GetString(bR.ReadBytes(2)) != "SK") { throw new CryptoException("Invalid SymmetricCryptoKey format."); } byte version = bR.ReadByte(); switch (version) //version { case 1: case 2: //algorithm _cryptoAlgo = (SymmetricEncryptionAlgorithm)bR.ReadByte(); _symAlgo = SymmetricAlgorithm.Create(_cryptoAlgo.ToString()); //key _symAlgo.Key = bR.ReadBytes(bR.ReadByte()); //IV _symAlgo.IV = bR.ReadBytes(bR.ReadByte()); //padding if (version == 1) { _symAlgo.Padding = PaddingMode.ISO10126; } else { _symAlgo.Padding = (PaddingMode)bR.ReadByte(); } _symAlgo.Mode = CipherMode.CBC; break; default: throw new CryptoException("SymmetricCryptoKey format version not supported."); } }
/// <summary>Creates a SymmetricAlgorithm used by this SPI.</summary> public SymmetricAlgorithm CreateSymmetricAlgorithm() { SymmetricAlgorithm sa = null; if (Encryptor.Equals("NullEncryption")) { sa = new NullEncryption(); } else { sa = SymmetricAlgorithm.Create(Encryptor); } if (sa == null) { throw new Exception("Unsupported encryption algorithm: " + Encryptor); } return(sa); }
static byte[] SymmetricEncryption(string message) { //Encode string as Bytes byte[] messgeByte = Encoding.UTF8.GetBytes(message); //Create SymmetricAlgorithm object SymmetricAlgorithm symmAlgo = SymmetricAlgorithm.Create(); //Create encryptor using the SymmetricAlgorithm object ICryptoTransform encryptor = symmAlgo.CreateEncryptor(symmAlgo.Key, symmAlgo.IV); //Transform Byte encoding message to encryted byte byte[] encryptedByte = encryptor.TransformFinalBlock(messgeByte, 0, messgeByte.Length); //Encoding encypted byte as string for delivery //string encryptedStr = Encoding.UTF8.GetString(encryptedByte); return(encryptedByte); }
/* * public static HttpCookie EncodeCookie(HttpCookie cookie) * { * if (cookie == null) return null; * * char[] chars = { ',' }; * var splits = ConfigurationManager.AppSettings["CookieEncodingKey"].Split(chars); * var AlgorithmName = splits[0]; * var Key = new byte[Int32.Parse(splits[1])];// = KEY_64; * for (int i = 2; i < Key.Length + 2; i++) * Key[i - 2] = byte.Parse(splits[i].Trim()); * * var eCookie = new HttpCookie(cookie.Name); * * for (int i = 0; i < cookie.Values.Count; i++) * { * var value = HttpContext.Current.Server.UrlEncode(Encode(cookie.Values[i], Key, AlgorithmName)); * var name = HttpContext.Current.Server.UrlEncode(Encode(cookie.Values.GetKey(i), Key, AlgorithmName)); * eCookie.Values.Set(name, value); * } * return eCookie; * } */ public static string Encode(string value, Byte[] key, string AlgorithmName) { var ClearData = System.Text.Encoding.UTF8.GetBytes(value); var Algorithm = SymmetricAlgorithm.Create(AlgorithmName); Algorithm.Key = key; var Target = new MemoryStream(); Algorithm.GenerateIV(); Target.Write(Algorithm.IV, 0, Algorithm.IV.Length); using (var cs = new CryptoStream(Target, Algorithm.CreateEncryptor(), CryptoStreamMode.Write)) { cs.Write(ClearData, 0, ClearData.Length); cs.FlushFinalBlock(); return(Convert.ToBase64String(Target.GetBuffer(), 0, (int)Target.Length)); } }
public static BigInteger Transform(string name, bool encrypt, BigInteger key, BigInteger message) { using (var cipher = SymmetricAlgorithm.Create(name)) { var k = key.GetBytes(); //Credit goes to ichoes (https://github.com/ichoes) for fixing this issue (https://github.com/sgbj/Dukpt.NET/issues/5) //gets the next multiple of 8 cipher.Key = new byte[Math.Max(0, GetNearestWholeMultiple(k.Length, 8) - k.Length)].Concat(key.GetBytes()).ToArray(); cipher.IV = new byte[8]; cipher.Mode = CipherMode.CBC; cipher.Padding = PaddingMode.Zeros; using (var crypto = encrypt ? cipher.CreateEncryptor() : cipher.CreateDecryptor()) { var data = message.GetBytes(); //Added the GetNearestWholeMultiple here. data = new byte[Math.Max(0, GetNearestWholeMultiple(data.Length, 8) - data.Length)].Concat(message.GetBytes()).ToArray(); return(BigInt.FromBytes(crypto.TransformFinalBlock(data, 0, data.Length))); } } }
public static SymmetricAlgorithm GetSymmetricCryptoService(SymmetricProvider netSelected) { SymmetricAlgorithm algorithm = new DESCryptoServiceProvider(); switch (netSelected) { case SymmetricProvider.Default: return(SymmetricAlgorithm.Create()); case SymmetricProvider.DES: return(new DESCryptoServiceProvider()); case SymmetricProvider.RC2: return(new RC2CryptoServiceProvider()); case SymmetricProvider.Rijndael: return(new RijndaelManaged()); } return(algorithm); }
public static byte[] EncryptString(string data) { byte[] byteData = GetByte(data); SymmetricAlgorithm algo = SymmetricAlgorithm.Create(); algo.Key = GetByte(Key); algo.GenerateIV(); MemoryStream mStream = new MemoryStream(); mStream.Write(algo.IV, 0, algo.IV.Length); CryptoStream cStream = new CryptoStream(mStream, algo.CreateEncryptor(), CryptoStreamMode.Write); cStream.Write(byteData, 0, byteData.Length); cStream.FlushFinalBlock(); return(mStream.ToArray()); }
public static string EncryptString(this string clearText) { if (string.IsNullOrWhiteSpace(clearText)) { throw new ArgumentNullException("clearText"); } byte[] clearTextBytes = Encoding.UTF8.GetBytes(clearText); using (var rijn = SymmetricAlgorithm.Create()) using (var memory = new MemoryStream()) { using (var cs = new CryptoStream(memory, rijn.CreateEncryptor(keyString, IVString), CryptoStreamMode.Write)) { cs.Write(clearTextBytes, 0, clearTextBytes.Length); cs.Close(); } return(Convert.ToBase64String(memory.ToArray())); } }
/// <summary> /// Gets the cryptographic stream by using the given stream for reading encrypted data. (Decrypting) /// </summary> /// <param name="stream">The raw stream</param> /// <param name="password">The decryption password</param> /// <returns>A cryptographic stream wrapper which has an underlying <see cref="CryptoStream"/> for reading encrypted data</returns> public virtual SaveSystemCryptoStream GetReadStream(IStorageStream stream, string password) { var alg = SymmetricAlgorithm.Create(this.AlgorithmName); alg.Mode = CipherMode.CBC; alg.Padding = PaddingMode.PKCS7; var thisIV = new byte[ivSize]; // Read the IV from the stream stream.UnderlyingStream.Read(thisIV, 0, ivSize); alg.IV = thisIV; var key = new Rfc2898DeriveBytes(password, alg.IV, pwIterations); alg.Key = key.GetBytes(keySize); var decryptor = alg.CreateDecryptor(); return(new SaveSystemSymmetricCryptoStream(new CryptoStream(stream.UnderlyingStream, decryptor, CryptoStreamMode.Read), alg, decryptor)); }
public static string EncryptString(string clearText) { if (clearText == null) { return(""); } byte[] clearTextBytes = Encoding.UTF8.GetBytes(clearText); SymmetricAlgorithm rijn = SymmetricAlgorithm.Create(); MemoryStream ms = new MemoryStream(); CryptoStream cs = new CryptoStream(ms, rijn.CreateEncryptor(m_cryptKey, m_initVector), CryptoStreamMode.Write); cs.Write(clearTextBytes, 0, clearTextBytes.Length); cs.Close(); return(Convert.ToBase64String(ms.ToArray())); }
public static string DecryptString(string EncryptedText) { string retval; byte[] encryptedTextBytes = Convert.FromBase64String(EncryptedText); using (MemoryStream ms = new MemoryStream()) { SymmetricAlgorithm rijn = SymmetricAlgorithm.Create(); using (CryptoStream cs = new CryptoStream(ms, rijn.CreateDecryptor(key, rgbIV), CryptoStreamMode.Write)) { cs.Write(encryptedTextBytes, 0, encryptedTextBytes.Length); cs.Close(); } retval = Encoding.UTF8.GetString(ms.ToArray()); } return(retval); }
public CryptoHelper(string algorithmName, string key) { SymmetricAlgorithm provider = SymmetricAlgorithm.Create(algorithmName); byte[] bKeys = new byte[24]; byte[] sssss = Encoding.Unicode.GetBytes(key); for (int lvi = 0; lvi < 24; lvi++) { if (lvi >= sssss.Length) { break; } bKeys[lvi] = sssss[lvi]; } provider.Key = bKeys; provider.IV = new byte[] { 0x23, 0x54, 0xC6, 0x68, 0x90, 0xAB, 0xBD, 0xEF }; encryptor = provider.CreateEncryptor(); decryptor = provider.CreateDecryptor(); }
public static byte[] EncryptData(string data, string keyFile) { byte[] ClearData = Encoding.UTF8.GetBytes(data); SymmetricAlgorithm Algorithm = SymmetricAlgorithm.Create(AlgorithmName); ReadKey(Algorithm, keyFile); MemoryStream Target = new MemoryStream(); Algorithm.GenerateIV(); Target.Write(Algorithm.IV, 0, Algorithm.IV.Length); CryptoStream cs = new CryptoStream(Target, Algorithm.CreateEncryptor(), CryptoStreamMode.Write); cs.Write(ClearData, 0, ClearData.Length); cs.FlushFinalBlock(); return(Target.ToArray()); }
private static string EncryptString(string clearText) { if (!string.IsNullOrWhiteSpace(clearText)) { var clearTextBytes = Encoding.UTF8.GetBytes(clearText); var rijn = SymmetricAlgorithm.Create(); var ms = new MemoryStream(); var rgbIv = Encoding.ASCII.GetBytes("lkjhfuefvbhjoiwq"); var key = Encoding.ASCII.GetBytes("oiturekjhbkjvhguzgweriuzguzrgkac"); var cs = new CryptoStream(ms, rijn.CreateEncryptor(key, rgbIv), CryptoStreamMode.Write); cs.Write(clearTextBytes, 0, clearTextBytes.Length); cs.Close(); return(Convert.ToBase64String(ms.ToArray())); } return(null); }
protected void Page_Load(object sender, EventArgs e) { var token = HttpContext.Current.Request.Form["Token"]; var resCode = int.Parse(HttpContext.Current.Request.Form["ResCode"]); if (resCode == 0) { var dataBytes = Encoding.UTF8.GetBytes(token); var symmetric = SymmetricAlgorithm.Create("TripleDes"); symmetric.Mode = CipherMode.ECB; symmetric.Padding = PaddingMode.PKCS7; var encryptor = symmetric.CreateEncryptor(Convert.FromBase64String("fFnSgtgWppg17ntADfoepx9uL6Dl16Bx"), new byte[8]); var signedData = Convert.ToBase64String(encryptor.TransformFinalBlock(dataBytes, 0, dataBytes.Length)); var data = new { token = token, SignData = signedData }; var ipgUri = "https://sadad.shaparak.ir/api/v0/AdviceEx/Verify"; var res = CallApi <VerifyResultData>(ipgUri, data); if (res != null && res.Result != null) { if (res.Result.ResCode == "0") { var result = res.Result; res.Result.Succeed = true; Message.Text = res.Result.Description; ResCode.Text = res.Result.ResCode; RRN.Text = res.Result.RetrivalRefNo; Trace.Text = res.Result.SystemTraceNo; } } } }
public InsecureEncryptionAlgorithm() { using (var tripleDES = new MyTripleDESCryptoServiceProvider()) //Noncompliant {{Use the recommended AES (Advanced Encryption Standard) instead.}} // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ { //... } using (var des = new DESCryptoServiceProvider()) //Noncompliant { //... } using (TripleDES TripleDESalg = TripleDES.Create()) //Noncompliant // ^^^^^^^^^^^^^^^^^^ { } using (var des = DES.Create("fgdsgsdfgsd")) //Noncompliant { } using (var aes = new AesCryptoServiceProvider()) { //... } using (var rc2 = new RC2CryptoServiceProvider()) // Noncompliant { } using (var rc2 = RC2.Create()) // Noncompliant { } SymmetricAlgorithm des1 = SymmetricAlgorithm.Create("DES"); //Noncompliant des1 = SymmetricAlgorithm.Create("TripleDES"); //Noncompliant des1 = SymmetricAlgorithm.Create("3DES"); //Noncompliant var rc2 = SymmetricAlgorithm.Create("RC2"); // Noncompliant var crypto = CryptoConfig.CreateFromName("DES"); // Noncompliant }
/// <summary> /// Converts a secure string back to the object tree it represents, using /// a custom <see cref="Deserializer"/> and <see cref="SignatureChecker"/>. /// </summary> /// <param name="secureString">the secure string to be converted back to an /// object tree.</param> /// <param name="encryptionKey">the key to use to decrypt the ciphertext</param> /// <param name="validationKey">ignored</param> /// <param name="encryptionAlgorithm">the name of the encryption algorithm to use, null means use default</param> /// <param name="validationAlgorithm">the name of the signing algorithm to use, null means use default</param> /// <param name="deserializer">a <see cref="Deserializer"/> delegate from the /// root object of the object tree that can recreate the object tree from a /// <see cref="Stream"/> of serialized bytes.</param> /// <param name="sigChecker">a <see cref="SignatureChecker"/> delegate that /// compares an actual signature to the expected signature, throwin an exception /// if they don't match.</param> /// <remarks>The encryption key and algorithms must have /// the same values as they did when <see cref="Protect(Serializer, byte[], byte[])"/> was called or /// an exception will occur.</remarks> public static void Unprotect(string secureString, byte[] encryptionKey, byte[] unused, string encryptionAlgorithm, string validationAlgorithm, Deserializer deserializer, SignatureChecker sigChecker) { byte[] secureBytes = Convert.FromBase64String(secureString); MemoryStream secureStream = new MemoryStream(secureBytes); BinaryReader binaryReader = new BinaryReader(secureStream); byte[] actualHash = binaryReader.ReadBytes(binaryReader.ReadByte()); byte[] iv = binaryReader.ReadBytes(binaryReader.ReadByte()); byte[] cipherText = binaryReader.ReadBytes((int)(secureStream.Length - secureStream.Position)); // Verify the hash HashAlgorithm hashAlgorithm = validationAlgorithm != null ? HashAlgorithm.Create(validationAlgorithm) : HashAlgorithm.Create(); byte[] expectedHash = hashAlgorithm.ComputeHash(cipherText); sigChecker(actualHash, expectedHash); // Decrypt the ciphertext MemoryStream cipherTextStream = new MemoryStream(cipherText); SymmetricAlgorithm cipher = encryptionAlgorithm != null ? SymmetricAlgorithm.Create(encryptionAlgorithm) : SymmetricAlgorithm.Create(); cipher.Mode = CipherMode.CBC; cipher.Padding = PaddingMode.PKCS7; cipher.Key = encryptionKey; cipher.IV = iv; CryptoStream cryptoStream = new CryptoStream(cipherTextStream, cipher.CreateDecryptor(), CryptoStreamMode.Read); try { deserializer(cryptoStream); } finally { cryptoStream.Close(); } }
public VerifyResult Refund() { var result = new VerifyResult(); if (Token == null) { result.Description = "توکن امنیتی در سیستم وجود ندارد."; return(result); } var dataBytes = Encoding.UTF8.GetBytes(Token); var symmetric = SymmetricAlgorithm.Create("TripleDes"); symmetric.Mode = CipherMode.ECB; symmetric.Padding = PaddingMode.PKCS7; var encryptor = symmetric.CreateEncryptor(Convert.FromBase64String(TransactionKey), new byte[8]); var signedData = Convert.ToBase64String(encryptor.TransformFinalBlock(dataBytes, 0, dataBytes.Length)); var data = new { Token = Token, SignData = signedData }; var res = CallApi <VerifyResultData>(RestVerifyWebservice, data); if (res.Result != null) { result.Amount = long.Parse(res.Result.Amount); result.Status = res.Result.ResCode; result.OrderId = res.Result.OrderId != null?long.Parse(res.Result.OrderId) : 0; result.RefrenceNumber = res.Result.SystemTraceNo; result.BankReciptNumber = res.Result.RetrivalRefNo; result.Description = GetDescription(1002, int.Parse(result.Status)); } return(result); }
public SymmetricAlgorithm GetCipher(int algorithm, int mode, /*SecretKey key,*/ byte[] key, byte[] vec) { try { string name = null; string chain = null; if (algorithm == EncryptionHeader.ALGORITHM_AES_128 || algorithm == EncryptionHeader.ALGORITHM_AES_192 || algorithm == EncryptionHeader.ALGORITHM_AES_256) { name = "AES"; } if (mode == EncryptionHeader.MODE_CBC) { chain = "CBC"; } else if (mode == EncryptionHeader.MODE_CFB) { chain = "CFB"; } //SymmetricAlgorithm cipher = SymmetricAlgorithm.Create(name + "/" + chain + "/Nopadding"); #if NETSTANDARD2_0 var cipher = Aes.Create(); #else SymmetricAlgorithm cipher = SymmetricAlgorithm.Create(); #endif cipher.Key = key; cipher.IV = vec; cipher.Padding = PaddingMode.None; cipher.Mode = chain == "CBC" ? CipherMode.CBC : CipherMode.CFB; // cipher.Key = ; //cipher.IV = return(cipher); } catch (CryptographicException ex) { throw ex; } }
public EncryptedData Encrypt(XmlElement inputElement, string keyName) { // There are two keys of note here. // 1) KeyAlg: the key-encryption-key is used to wrap a key. The keyName // parameter will give us the KEK. // 2) SymAlg: A 256-bit AES key will be generated to encrypt the contents. // This key will be wrapped using the KEK. SymmetricAlgorithm symAlg = SymmetricAlgorithm.Create("Rijndael"); symAlg.KeySize = 256; symAlg.GenerateKey(); symAlg.GenerateIV(); EncryptedData encryptedData = new EncryptedData(); EncryptedKey encryptedKey = new EncryptedKey(); object keyAlg = keyNameMapping [keyName]; encryptedKey.EncryptionMethod = new EncryptionMethod(GetKeyWrapAlgorithmUri(keyAlg)); if (keyAlg is RSA) { encryptedKey.CipherData = new CipherData(EncryptKey(symAlg.Key, (RSA)keyAlg, false)); } else { encryptedKey.CipherData = new CipherData(EncryptKey(symAlg.Key, (SymmetricAlgorithm)keyAlg)); } encryptedKey.KeyInfo = new KeyInfo(); encryptedKey.KeyInfo.AddClause(new KeyInfoName(keyName)); encryptedData.Type = XmlEncElementUrl; encryptedData.EncryptionMethod = new EncryptionMethod(GetAlgorithmUri(symAlg)); encryptedData.KeyInfo = new KeyInfo(); encryptedData.KeyInfo.AddClause(new KeyInfoEncryptedKey(encryptedKey)); encryptedData.CipherData = new CipherData(EncryptData(inputElement, symAlg, false)); return(encryptedData); }
public static string DecryptString(this string encryptedText) { if (string.IsNullOrWhiteSpace(encryptedText)) { throw new ArgumentNullException("encryptedText"); } byte[] encryptedTextBytes = Convert.FromBase64String(encryptedText); using (var rijn = SymmetricAlgorithm.Create()) using (var memory = new MemoryStream()) { using (var cs = new CryptoStream(memory, rijn.CreateDecryptor(key, rgbIV), CryptoStreamMode.Write)) { cs.Write(encryptedTextBytes, 0, encryptedTextBytes.Length); cs.Close(); } return(Encoding.UTF8.GetString(memory.ToArray())); } }
public static string DecryptString(string EncryptedText) { byte[] encryptedTextBytes = Convert.FromBase64String(EncryptedText); var ms = new MemoryStream(); System.Security.Cryptography.SymmetricAlgorithm rijn = SymmetricAlgorithm.Create(); byte[] rgbIV = Encoding.ASCII.GetBytes("ayojvlzmdalyglrj"); byte[] key = Encoding.ASCII.GetBytes("hlxilkqbbhczfeultgbskdmaunivmfuo"); var cs = new CryptoStream(ms, rijn.CreateDecryptor(key, rgbIV), CryptoStreamMode.Write); cs.Write(encryptedTextBytes, 0, encryptedTextBytes.Length); cs.Close(); return(Encoding.UTF8.GetString(ms.ToArray())); }
//DecryptString //Make sure you use the same keys you used to encrypt the string public string DecryptString(string EncryptedText, string key1, string key2) { byte[] encryptedTextBytes = Convert.FromBase64String(EncryptedText); MemoryStream ms = new MemoryStream(); System.Security.Cryptography.SymmetricAlgorithm rijn = SymmetricAlgorithm.Create(); byte[] rgbIV = Encoding.ASCII.GetBytes(key1); byte[] key = Encoding.ASCII.GetBytes(key2); CryptoStream cs = new CryptoStream(ms, rijn.CreateDecryptor(key, rgbIV), CryptoStreamMode.Write); cs.Write(encryptedTextBytes, 0, encryptedTextBytes.Length); cs.Close(); return(Encoding.UTF8.GetString(ms.ToArray())); }
/// <summary> /// A simply decryption, can be used to store passwords /// </summary> /// <param name="encryptedText">a base64 encoded encrypted string</param> /// <returns>Decrypeted text</returns> private static string Decrypt(string encryptedText) { string returnValue; var encryptedTextBytes = Convert.FromBase64String(encryptedText); using (var symmetricAlgorithm = SymmetricAlgorithm.Create(Algorithm)) { var memoryStream = new MemoryStream(); var rgbIv = Encoding.ASCII.GetBytes(RgbIv); var key = Encoding.ASCII.GetBytes(RgbKey); using (var cryptoStream = new CryptoStream(memoryStream, symmetricAlgorithm.CreateDecryptor(key, rgbIv), CryptoStreamMode.Write)) { cryptoStream.Write(encryptedTextBytes, 0, encryptedTextBytes.Length); cryptoStream.FlushFinalBlock(); returnValue = Encoding.ASCII.GetString(memoryStream.ToArray()); } } return(returnValue); }
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); }
private byte[] EncryptData(int choice, byte[] Key, byte[] IV, byte[] toEncryptData) { try { SymmetricAlgorithm crypt = SymmetricAlgorithm.Create(sma[choice]); ICryptoTransform transform = crypt.CreateEncryptor(Key, IV);//这里不一样 MemoryStream ms = new MemoryStream(); CryptoStream cs = new CryptoStream(ms, transform, CryptoStreamMode.Write); //Convert the data to a byte array. //Write all data to the crypto stream and flush it. cs.Write(toEncryptData, 0, toEncryptData.Length); cs.FlushFinalBlock(); //Get encrypted array of bytes. return(ms.ToArray()); } catch { throw new CryptographicException("加密出现失误,请重新检查输入!"); } }
/// <summary> /// Return the available key sizes for the given algorithim /// </summary> /// <param name="selectedAlgorithim"></param> /// <returns></returns> public ObservableCollection <int> GetKeySizes(int selectedAlgorithim) { var keySizes = new ObservableCollection <int>(); var algortihim = (SymmetricMsdnCipher)selectedAlgorithim; var cipher = SymmetricAlgorithm.Create(algortihim.ToString()); foreach (var legalkeySize in cipher.LegalKeySizes) { int keySize = legalkeySize.MinSize; while (keySize <= legalkeySize.MaxSize) { keySizes.Add(keySize); if (legalkeySize.SkipSize == 0) { break; } keySize += legalkeySize.SkipSize; } } return(keySizes); }
public void Init() { const string encryptionAlgorithm = "AES"; const string hashAlgorithm = "HMACSHA256"; var shellSettings = new ShellSettings { Name = "Foo", DataProvider = "Bar", DataConnectionString = "Quux", EncryptionAlgorithm = encryptionAlgorithm, EncryptionKey = SymmetricAlgorithm.Create(encryptionAlgorithm).Key.ToHexString(), HashAlgorithm = hashAlgorithm, HashKey = HMAC.Create(hashAlgorithm).Key.ToHexString() }; var builder = new ContainerBuilder(); builder.RegisterInstance(shellSettings); builder.RegisterType <DefaultEncryptionService>().As <IEncryptionService>(); _container = builder.Build(); }
public void TestDataEncoding() { var key = SymmetricAlgorithm.Create("Rijndael"); key.GenerateKey(); key.GenerateIV(); var fullkey = new byte[key.Key.Length + key.IV.Length]; Array.Copy(key.Key, fullkey, key.Key.Length); Array.Copy(key.IV, 0, fullkey, key.Key.Length, key.IV.Length); var stringTest = "ewAiAGQAYQB0AGUAIgA6ACIAcwBhAGIAYQB0AG8AIAAyADAAIABmAGUAYgBiAHIAYQBpAG8AIAAyADAAMgAxACIALAAiAHQAZQB4AHQAIgA6ACIAZAAxAGQAYgBmADcAYgBhAC0AMwBhADUAZgAtADQANgBkAGEALQA4AGIAMQA5AC0ANQA5ADQAMgBjADMAMwA0ADEAMwA1ADYAIgAsACIAbQBlAHMAcwBhAGcAZQAiADoAIgBJACAAbABvAHYAZQAgAHkAbwB1ACIALAAiAF8AaABpAHMAdABvAHIAeQAiADoAWwBdAH0A"; var data = UnicodeEncoding.Unicode.GetBytes(stringTest); var service = new CryptoService(); var encoded = service.EncodeData(data, fullkey); var decoded = service.DecodeData(encoded, fullkey); Assert.Equal(decoded, data); }