public static string encriptar(string texto, string key) { AesCryptoServiceProvider aes = new AesCryptoServiceProvider(); MD5 md5Hash = MD5.Create(); string chave = GetMd5Hash(md5Hash, key); aes.Key = System.Text.Encoding.UTF8.GetBytes(chave); aes.BlockSize = 128; aes.IV = System.Text.Encoding.UTF8.GetBytes("6abraswa+hep&#Ac"); ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV); byte[] encrypted; // 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(texto); } encrypted = msEncrypt.ToArray(); } } return Convert.ToBase64String(encrypted); }
/// <summary> /// 解密字节数组 /// </summary> /// <param name="inputData">要解密的字节数据</param> /// <param name="password">密码</param> /// <returns></returns> public static byte[] Decrypt(byte[] inputData, string password) { AesCryptoServiceProvider aes = new AesCryptoServiceProvider { Key = GetKeyArray(password), Mode = cipherMode, Padding = paddingMode }; var transform = aes.CreateDecryptor(); byte[] data = null; try { data = transform.TransformFinalBlock(inputData, 0, inputData.Length); } catch { return null; } aes.Clear(); return data; }
public string decrypt(byte[] msg, byte[] key) { using (var d = new System.Security.Cryptography.AesCryptoServiceProvider()) { var iv = Enumerable.Repeat((byte)0, 16).ToArray(); d.IV = iv; d.Key = key; d.Mode = CipherMode.CBC; d.Padding = PaddingMode.None; var t = d.CreateDecryptor(); using (var ms = new System.IO.MemoryStream(msg)) { using (var cs = new CryptoStream(ms, t, CryptoStreamMode.Read)) { using (var sr = new System.IO.StreamReader(cs)) { var r = sr.ReadToEnd(); return(r); } } } } }
public static void DisableSslCertificateChecks() { // 2019-Feb-21: The TLS connection to Blockchain.Info's WebSocket still fails with a TLS connection, but // that appears to be unrelated to this issue; it fails a check whether TLS checks are enabled or not // // 2018-Dec-01: We're now requiring the freshest Mono repositories to be installed with Swarmops, and this DOES // force a cert repository to be installed (at long effing last). Therefore, we're disabling this entire // function, and basically checking if anything breaks as HTTPS becomes re-enabled across the board. return; // disable "unreachable code" for the rest of this function, as the disabling is deliberate // disable "variable declared but never used" because of the workaround last here // disable "variable is assigned a value that is never used" because of the workaround last here #pragma warning disable 0162, 0168, 0219 // X.509 is SO SO SO broken. The reason we do this, btw, is that mono doesn't come with root certs. At all. // This disables certificate checking completely and accepts ALL certificates. // TODO: Does this install a new handler every time it's been called? How do you verify that this short-circuit is in place? System.Net.ServicePointManager.ServerCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true; // Further, instantiate an AesCryptoServiceProvider to make sure the linker doesn't optimize it away -- apparently // another known bug. The warning disabled here is "b is assigned a value that is never used". //#pragma warning disable 0219 System.Security.Cryptography.AesCryptoServiceProvider b = new System.Security.Cryptography.AesCryptoServiceProvider(); //#pragma warning restore 0219 #pragma warning restore 0162, 0168, 0219 }
public CryptoProvider(string securityKey, ManualResetEvent cancelEvent) { _cancelEvent = cancelEvent; byte[] key = GenerateKey(securityKey); _aes = new AesCryptoServiceProvider {KeySize = key.Length * 8, Key = key}; }
public static SymmetricAlgorithm GetAlgorithmByName(String algorithmName) { SymmetricAlgorithm symmetricAlgorithm = null; String algorithmNameLoverCase = algorithmName.ToLower(); switch (algorithmNameLoverCase) { case "aes": symmetricAlgorithm = new System.Security.Cryptography.AesCryptoServiceProvider(); break; case "des": symmetricAlgorithm = new System.Security.Cryptography.DESCryptoServiceProvider(); break; case "rc2": symmetricAlgorithm = new System.Security.Cryptography.RC2CryptoServiceProvider(); break; case "rijndael": symmetricAlgorithm = new System.Security.Cryptography.RijndaelManaged(); break; } return(symmetricAlgorithm); }
public static string Request(string requestParams, string devKey, string devIV, string devID) { // Create an unencrypted request as an array of bytes byte[] request = UTF8Encoding.UTF8.GetBytes(requestParams); byte[] key = UTF8Encoding.UTF8.GetBytes(devKey); byte[] iv = UTF8Encoding.UTF8.GetBytes(devIV); AesCryptoServiceProvider aes = new AesCryptoServiceProvider(); aes.Key = key; aes.IV = iv; aes.Mode = CipherMode.CBC; aes.Padding = PaddingMode.Zeros; // Get the transformer from the AES Encryptor ICryptoTransform cTransform = aes.CreateEncryptor(); // Use the transformer to encrypt our request byte[] result = cTransform.TransformFinalBlock(request, 0, request.Length); aes.Clear(); // Encode to base64 string encryptedRequest = Convert.ToBase64String(result, 0, result.Length); // Send request to API string requestUri = "http://api.blackoutrugby.com/?d=" + devID + "&er=" + encryptedRequest; string xmlResponse = getWebResponse(requestUri); return XmlToJson(xmlResponse); }
public static byte[] DecryptCbc(byte[] key, byte[] data) { var result = new byte[data.Length]; var c = new AesCryptoServiceProvider(); c.Key = key; c.IV = new byte[16]; c.Mode = CipherMode.CBC; using (Aes aesAlg = Aes.Create()) { aesAlg.BlockSize = 128; aesAlg.KeySize = 128; aesAlg.Key = key; aesAlg.IV = new byte[16]; aesAlg.Padding = PaddingMode.None; ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV); using (MemoryStream msDecrypt = new MemoryStream(data)) { using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)) { csDecrypt.Read(result, 0, result.Length); } } } return result; }
/// <summary> /// AES加密 /// </summary> /// <param name="data"></param> /// <param name="key"></param> /// <returns></returns> public static byte[] AesEncrypt(string data, byte[] key) { if (key.Length != 16) { var ex = new Exception("the length of AES ecrypted key must be 16bit."); throw ex; } byte[] result; using (SymmetricAlgorithm algorithm = new AesCryptoServiceProvider()) { algorithm.Mode = CipherMode.ECB; algorithm.Padding = PaddingMode.PKCS7; using (ICryptoTransform transform = algorithm.CreateEncryptor(key, key)) { using (MemoryStream ms = new MemoryStream()) { using (Stream cs = new CryptoStream(ms, transform, CryptoStreamMode.Write)) { using (StreamWriter writer = new StreamWriter(cs)) { writer.Write(data); } result = ms.ToArray(); } } } } return result; }
public static string EncryptString(string message, string passphrase = null) { if (string.IsNullOrEmpty(message)) { throw new ArgumentException("message is empty!", message); } if (string.IsNullOrEmpty(passphrase)) { passphrase = ConfigurationManager.AppSettings.Get("Common.Cryptography.DefaultPassPhrase"); } // First hash the passphrase to get a 256bit key var sha = new SHA256CryptoServiceProvider(); var passphraseHash = sha.ComputeHash(Encoding.UTF8.GetBytes(passphrase)); var aes = new AesCryptoServiceProvider { KeySize = 256, Key = passphraseHash }; var memoryStream = new MemoryStream(); var cryptoStream = new CryptoStream(memoryStream, aes.CreateEncryptor(), CryptoStreamMode.Write); using (var writer = new StreamWriter(cryptoStream, Encoding.UTF8)) { writer.Write(message); } var results = memoryStream.ToArray(); var finalArray = new byte[aes.IV.Length + results.Length]; Array.Copy(aes.IV, 0, finalArray, 0, aes.IV.Length); Array.Copy(results, 0, finalArray, aes.IV.Length, results.Length); return HttpServerUtility.UrlTokenEncode(finalArray); }
/// <summary> /// Encrypt a message using AES in CBC (cipher-block chaining) mode. /// </summary> /// <param name="plaintext">The message (plaintext) to encrypt</param> /// <param name="key">An AES key</param> /// <param name="iv">The IV to use or null to use a 0 IV</param> /// <param name="addHmac">When set, a SHA256-based HMAC (HMAC256) of 32 bytes using the same key is added to the plaintext /// before it is encrypted.</param> /// <returns>The ciphertext derived by encrypting the orignal message using AES in CBC mode</returns> public static byte[] EncryptAesCbc(byte[] plaintext, byte[] key, byte[] iv = null, bool addHmac = false) { using (AesCryptoServiceProvider aes = new AesCryptoServiceProvider()) { aes.Key = key; if (iv == null) iv = NullIv; aes.Mode = CipherMode.CBC; aes.IV = iv; // Encrypt the message with the key using CBC and InitializationVector=0 byte[] cipherText; using (System.IO.MemoryStream ciphertext = new System.IO.MemoryStream()) { using (CryptoStream cs = new CryptoStream(ciphertext, aes.CreateEncryptor(), CryptoStreamMode.Write)) { cs.Write(plaintext, 0, plaintext.Length); if (addHmac) { byte[] hmac = new HMACSHA256(key).ComputeHash(plaintext); cs.Write(hmac, 0, hmac.Length); } cs.Flush(); } cipherText = ciphertext.ToArray(); } return cipherText; } }
/// <summary> /// Decrypt a message using AES in CBC (cipher-block chaining) mode. /// </summary> /// <param name="ciphertext">The message encrypted with AES in CBC mode</param> /// <param name="key">The key used to encrypt the message</param> /// <param name="iv">The initialization vector provided, if one was provided. If you are absolutely certain /// the key will only be used once, an IV is not necessary and zero will be used.</param> /// <param name="checkAndRemoveHmac">Set if an HMACHSA256 was placed at the end of the plaintext before encrypting. /// The HMAC will be removed before the plaintext is returned. If the HMAC does not match, the method will throw a /// System.Security.Cryptography.CryptographicException.</param> /// <returns>The plaintext resulting from decrypting the ciphertext with the given key.</returns> public static byte[] DecryptAesCbc(byte[] ciphertext, byte[] key, byte[] iv = null, bool checkAndRemoveHmac = false) { using (AesCryptoServiceProvider aes = new AesCryptoServiceProvider()) { aes.Key = key; if (iv == null) iv = NullIv; aes.IV = iv; aes.Mode = CipherMode.CBC; // Decrypt the message using (System.IO.MemoryStream plaintextStream = new System.IO.MemoryStream()) { using (CryptoStream cs = new CryptoStream(plaintextStream, aes.CreateDecryptor(), CryptoStreamMode.Write)) { cs.Write(ciphertext, 0, ciphertext.Length); } byte[] plaintext = plaintextStream.ToArray(); if (checkAndRemoveHmac) { byte[] hmacProvided = plaintext.Skip(plaintext.Length - Sha256HmacLength).ToArray(); plaintext = plaintext.Take(plaintext.Length - Sha256HmacLength).ToArray(); byte[] hmacCalculated = new HMACSHA256(key).ComputeHash(plaintext); if (!hmacProvided.SequenceEqual(hmacCalculated)) throw new CryptographicException("Message authentication code validation failed."); } return plaintext; } } }
public InsecureEncryptionAlgorithm() { using (var tripleDES = new MyTripleDESCryptoServiceProvider()) //Noncompliant { //... } using (var des = new DESCryptoServiceProvider()) //Noncompliant { //... } using (TripleDES TripleDESalg = TripleDES.Create()) //Noncompliant { } using (var des = DES.Create("fgdsgsdfgsd")) //Noncompliant { } using (var aes = new AesCryptoServiceProvider()) { //... } SymmetricAlgorithm des1 = SymmetricAlgorithm.Create("DES"); //Noncompliant des1 = SymmetricAlgorithm.Create("TripleDES"); //Noncompliant des1 = SymmetricAlgorithm.Create("3DES"); //Noncompliant }
public Stream DecryptedStream(Stream streamToDecrypt) { using (AesCryptoServiceProvider aesAlg = new AesCryptoServiceProvider()) using (ICspProxy csp = CspFactory.GetProvider()) { // Get the AES key from the stream // The length will be the size of the RSA key which was used to encrypt // the 256 bit AES key (assuming the RSA key is always larger than 256 bit). byte[] encryptedKey = new byte[AsymmetricKeySize / 8]; byte[] decryptedKey; streamToDecrypt.Read(encryptedKey, 0, encryptedKey.Length); decryptedKey = csp.Decrypt(encryptedKey); // Attempt to read IV from Stream byte[] ivBytes = new byte[aesAlg.BlockSize / 8]; streamToDecrypt.Read(ivBytes, 0, ivBytes.Length); // Set key and initialization vector aesAlg.Key = decryptedKey; aesAlg.IV = ivBytes; // Create a decryptor to perform the stream transform. ICryptoTransform decryptor = aesAlg.CreateDecryptor(); CryptoStream cryptoStream = new CryptoStream(streamToDecrypt, decryptor, CryptoStreamMode.Read); return cryptoStream; } }
public void CTS_NotAllowed () { // this check is normally (e.g. RijndaelManaged) done later using (var aes = new AesCryptoServiceProvider ()) { aes.Mode = CipherMode.CTS; } }
private async static Task<byte[]> AliceSendsData(string message) { Console.WriteLine("Alice send message {0}", message); byte[] rawData = Encoding.UTF8.GetBytes(message); byte[] encryptedData = null; using(var aliceAlgo = new ECDiffieHellmanCng(aliceKey)) { using(CngKey bobPubKey = CngKey.Import(bobPubKeyBlob, CngKeyBlobFormat.GenericPublicBlob)) { byte[] symmKey = aliceAlgo.DeriveKeyMaterial(bobPubKey); Console.WriteLine("Alice create this symm key with Bobs public key information : {0}", Convert.ToBase64String(symmKey)); using(var aes = new AesCryptoServiceProvider()) { aes.Key = symmKey; aes.GenerateIV(); using(ICryptoTransform encryptor = aes.CreateEncryptor()) { using(MemoryStream ms = new MemoryStream()) { var cs = new CryptoStream(ms, encryptor,CryptoStreamMode.Write); await ms.WriteAsync(aes.IV, 0, aes.IV.Length); cs.Write(rawData, 0, rawData.Length); cs.Close(); encryptedData = ms.ToArray(); } } aes.Clear(); } } } Console.WriteLine("Alice message is encrypted : {0}", Convert.ToBase64String(encryptedData)); return encryptedData; }
public static void AESEncryption() { try { string original = "Here is some data to encrypt!"; // Create a new instance of the AesCryptoServiceProvider // class. This generates a new key and initialization vector (IV). using (AesCryptoServiceProvider myAes = new AesCryptoServiceProvider()) { // Encrypt the string to an array of bytes. byte[] encrypted = EncryptStringToBytes_Aes(original, myAes.Key, myAes.IV); // Decrypt the bytes to a string. string roundtrip = DecryptStringFromBytes_Aes(encrypted, myAes.Key, myAes.IV); //Display the original data and the decrypted data. Console.WriteLine("Original: {0}", original); Console.WriteLine("Round Trip: {0}", roundtrip); } } catch (Exception e) { Console.WriteLine("Error: {0}", e.Message); } }
static System.Security.Cryptography.SymmetricAlgorithm CreateCam(string key, string IV, bool rij = true) { System.Security.Cryptography.SymmetricAlgorithm a = null; if (rij) { a = new System.Security.Cryptography.RijndaelManaged(); } else { a = new System.Security.Cryptography.AesCryptoServiceProvider(); } a.Mode = System.Security.Cryptography.CipherMode.CBC; a.Padding = System.Security.Cryptography.PaddingMode.Zeros; a.BlockSize = 128; a.KeySize = 256; if (null != IV) { a.IV = System.Convert.FromBase64String(IV); } else { a.GenerateIV(); } if (null != key) { a.Key = System.Convert.FromBase64String(key); } return(a); }
/// <summary> /// Encrypts the content key to certificate. /// </summary> /// <param name="cert">The cert.</param> /// <param name="contentKey">The content key.</param> /// <returns>The encrypted content key.</returns> public static byte[] EncryptContentKeyToCertificate(X509Certificate2 cert, byte[] contentKey) { byte[] returnValue = null; if (cert == null) { throw new ArgumentNullException("cert"); } if (contentKey == null) { throw new ArgumentNullException("contentKey"); } if (contentKey.Length != EncryptionUtils.KeySizeInBytesForAes128) { throw new ArgumentOutOfRangeException("contentKey", "Common Encryption content keys are 128-bits (16 bytes) in length."); } using (AesCryptoServiceProvider key = new AesCryptoServiceProvider()) { key.Key = contentKey; returnValue = EncryptionUtils.EncryptSymmetricKey(cert, key); } return returnValue; }
public byte[] Unprotect(byte[] protectedData) { byte[] output = null; using (AesCryptoServiceProvider aesAlg = new AesCryptoServiceProvider()) { aesAlg.Key = _key; aesAlg.IV = _IV; ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV); using (MemoryStream msDecrypt = new MemoryStream(protectedData)) { using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)) { byte[] buffer = new byte[8]; using (MemoryStream msOutput = new MemoryStream()) { int read; while ((read = csDecrypt.Read(buffer, 0, buffer.Length)) > 0) { msOutput.Write(buffer, 0, read); } output = msOutput.ToArray(); } } } } return output; }
private static Aes CreateAes(ProgramOptions options, byte[] iv = null) { if (!options.EncryptionEnabled) return null; var salt = Convert.FromBase64String("hkuDTnecxj+oDytliJ69BQ=="); using (var kdf = new Rfc2898DeriveBytes(options.EncryptionPassword, salt)) { var aes = new AesCryptoServiceProvider(); var keyLen = aes.KeySize/8; if (iv != null) { aes.Key = kdf.GetBytes(keyLen); aes.IV = iv; return aes; } var ivLength = aes.BlockSize/8; var bytes = kdf.GetBytes(keyLen + ivLength); aes.Key = bytes.SubArray(0, keyLen); aes.IV = bytes.SubArray(keyLen, ivLength); return aes; } }
public ICryptoTransform CreateEncryptor(byte[] key, byte[] iv) { using (var provider = new AesCryptoServiceProvider {Padding = _paddingMode}) { return provider.CreateEncryptor(key, iv); } }
public static string AESDecryptor(string encryptedString, byte[] Key, byte[] IV) { byte[] data = Convert.FromBase64String(encryptedString); AesCryptoServiceProvider aes = new AesCryptoServiceProvider(); string decryptedString = ASCIIEncoding.ASCII.GetString(aes.CreateDecryptor(Key, IV).TransformFinalBlock(data, 0, data.Length)); return decryptedString; }
public static void EncryptAndUpload(string file, string awsPath, string key) { if (bool.Parse(ConfigurationManager.AppSettings["ManagedEncryption"])) { Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(key, appKey); using (var aes = new AesCryptoServiceProvider()) { aes.Key = deriveBytes.GetBytes(aes.KeySize / 8); aes.IV = deriveBytes.GetBytes(aes.BlockSize / 8); using (var temp = new FileStream(file + "_encrypted", FileMode.Create)) { using (var stream = new CryptoStream(new FileStream(file, FileMode.Open), aes.CreateEncryptor(), CryptoStreamMode.Read)) { stream.CopyTo(temp); } } UploadFile(file + "_encrypted", awsPath); File.Delete(file + "_encrypted"); } } else UploadFile(file, awsPath); }
internal static CipherBlock ServerCipher(BinaryReader rd, PrivateKeyByPublicKeyHash privateKeySelector) { var certificateHash = rd.ReadVarBytes(); var iv = rd.ReadVarBytes(); var encryptedKey = rd.ReadVarBytes(); var privateKey = privateKeySelector(certificateHash); if (privateKey == null) throw new InvalidOperationException("You have to provide a private key"); if (privateKey.PublicOnly) throw new InvalidOperationException($"The {nameof(CipherBlock)} accepts private keys only."); var aes = new AesCryptoServiceProvider { Padding = PaddingMode.Zeros, IV = iv, Key = new RSAOAEPKeyExchangeDeformatter(privateKey).DecryptKeyExchange(encryptedKey) }; return new CipherBlock(aes, certificateHash); }
public static string AESEncryptor(string plainText, byte[] Key, byte[] IV) { byte[] data = ASCIIEncoding.ASCII.GetBytes(plainText); AesCryptoServiceProvider aes = new AesCryptoServiceProvider(); string encryptedString = Convert.ToBase64String(aes.CreateEncryptor(Key, IV).TransformFinalBlock(data, 0, data.Length)); return encryptedString; }
/// <summary> /// Initialize the encryptor /// </summary> public AESEncryptor() { aesProvider = new AesCryptoServiceProvider(); aesProvider.KeySize = AESKeySize; sha384 = SHA384.Create(); }
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; }
public static byte[] EncryptString(string toEncrypt, byte[] encryptionKey) { if (string.IsNullOrEmpty(toEncrypt)) throw new ArgumentException("toEncrypt"); if (encryptionKey == null || encryptionKey.Length == 0) throw new ArgumentException("encryptionKey"); var toEncryptBytes = Encoding.UTF8.GetBytes(toEncrypt); using (var provider = new AesCryptoServiceProvider()) { provider.Key = encryptionKey; provider.Mode = CipherMode.CBC; provider.Padding = PaddingMode.PKCS7; using (var encryptor = provider.CreateEncryptor(provider.Key, provider.IV)) { using (var ms = new MemoryStream()) { ms.Write(provider.IV, 0, 16); using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write)) { cs.Write(toEncryptBytes, 0, toEncryptBytes.Length); cs.FlushFinalBlock(); } return ms.ToArray(); } } } }
public static byte[] Protect(byte[] encryptionKey, byte[] validationKey, byte[] initializationVector, byte[] plainText) { using (var provider = new AesCryptoServiceProvider()) { using (ICryptoTransform transform = provider.CreateEncryptor(encryptionKey, initializationVector)) { using (var ms = new MemoryStream()) { ms.Write(initializationVector, 0, initializationVector.Length); using (var cryptoStream = new CryptoStream(ms, transform, CryptoStreamMode.Write)) { // Encrypted payload cryptoStream.Write(plainText, 0, plainText.Length); cryptoStream.FlushFinalBlock(); // Compute signature using (var sha = new HMACSHA256(validationKey)) { checked { byte[] signature = sha.ComputeHash(ms.GetBuffer(), 0, (int)ms.Length); // Write the signature to the paylod ms.Write(signature, 0, signature.Length); // Final bytes return ms.ToArray(); } } } } } } }
public static string DecryptString(byte[] encryptedString, byte[] encryptionKey) { using (var provider = new AesCryptoServiceProvider()) { provider.Key = encryptionKey; using (var ms = new MemoryStream(encryptedString)) { // Read the first 16 bytes which is the IV. byte[] iv = new byte[16]; ms.Read(iv, 0, 16); provider.IV = iv; using (var decryptor = provider.CreateDecryptor()) { using (var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read)) { using (var sr = new StreamReader(cs)) { return sr.ReadToEnd(); } } } } } }
public static byte[] decrypt(byte[] encrypted, byte[] Key, byte[] IV) { try { byte[] plain; int count; using (MemoryStream mStream = new MemoryStream(encrypted)) { using (AesCryptoServiceProvider aesProvider = new AesCryptoServiceProvider()) { aesProvider.Mode = CipherMode.CBC; using (CryptoStream cryptoStream = new CryptoStream(mStream, aesProvider.CreateDecryptor(Key, IV), CryptoStreamMode.Read)) { plain = new byte[encrypted.Length]; count = cryptoStream.Read(plain, 0, plain.Length); } } } byte[] returnValue = new byte[count]; Array.Copy(plain, returnValue, count); return returnValue; } catch (Exception e) { Logger.log(e.StackTrace); throw e; } }
static OAuthServerHelper() { RSAParameters privateRsaParameters; RSAParameters publicRsaParameters; using (var rsaKeyGen = new RSACryptoServiceProvider(RsaKeySize)) { privateRsaParameters = rsaKeyGen.ExportParameters(true); publicRsaParameters = rsaKeyGen.ExportParameters(false); } Tuple<byte[], byte[]> aesKeyAndIV; using (var aesKeyGen = new AesCryptoServiceProvider()) { aesKeyAndIV = Tuple.Create(aesKeyGen.Key, aesKeyGen.IV); } rsa = new ThreadLocal<RSACryptoServiceProvider>(() => { var result = new RSACryptoServiceProvider(); result.ImportParameters(privateRsaParameters); return result; }); aes = new ThreadLocal<AesCryptoServiceProvider>(() => { var result = new AesCryptoServiceProvider(); result.Key = aesKeyAndIV.Item1; result.IV = aesKeyAndIV.Item2; return result; }); rsaExponent = OAuthHelper.BytesToString(publicRsaParameters.Exponent); rsaModulus = OAuthHelper.BytesToString(publicRsaParameters.Modulus); }
public SshAes192Cbc() : base() { _algorithm = new AesCryptoServiceProvider(); _algorithm.Mode = CipherMode.CBC; _algorithm.KeySize = 192; }
public static byte[] CreateAesKey() { System.Security.Cryptography.AesCryptoServiceProvider crypto = new System.Security.Cryptography.AesCryptoServiceProvider(); crypto.KeySize = 256; crypto.GenerateKey(); byte[] key = crypto.Key; return(key); }
public static byte[] generateKey() { System.Security.Cryptography.AesCryptoServiceProvider crypto = new System.Security.Cryptography.AesCryptoServiceProvider(); crypto.KeySize = 128; crypto.BlockSize = 128; crypto.GenerateKey(); byte[] keyGenerated = crypto.Key; return(keyGenerated); }
public static void DisableSslCertificateChecks() { // X.509 is SO SO SO broken. The reason we do this, btw, is that mono doesn't come with root certs. At all. // This disables certificate checking completely and accepts ALL certificates. // TODO: Does this install a new handler every time it's been called? How do you verify that this short-circuit is in place? System.Net.ServicePointManager.ServerCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true; // Further, instantiate an AesCryptoServiceProvider to make sure the linker doesn't optimize it away -- apparently // another known bug System.Security.Cryptography.AesCryptoServiceProvider b = new System.Security.Cryptography.AesCryptoServiceProvider(); }
public string generateKey() { string Key; try { System.Security.Cryptography.AesCryptoServiceProvider crypto = new System.Security.Cryptography.AesCryptoServiceProvider(); crypto.KeySize = 128; crypto.BlockSize = 128; crypto.GenerateKey(); byte[] keyGenerated = crypto.Key; Key = Convert.ToBase64String(keyGenerated); } catch (Exception ex) { throw ex; } return(Key); }
byte[] Transform(byte[] dataBytes, byte[] passwordBytes, bool encrypt) { /// <summary>Encrypt by using AES-256 algorithm.</summary> // Create an instance of the AES class. var cipher = new System.Security.Cryptography.AesCryptoServiceProvider(); // Calculate salt to make it harder to guess key by using a dictionary attack. var hmac = new System.Security.Cryptography.HMACSHA1(passwordBytes); var salt = hmac.ComputeHash(passwordBytes); // Generate Secret Key from the password and salt. // Note: Set number of iterations to 10 in order for JavaScript example to work faster. var secretKey = new System.Security.Cryptography.Rfc2898DeriveBytes(passwordBytes, salt, 10); // Create a encryptor from the existing SecretKey bytes by using // 32 bytes (256 bits) for the secret key and // 16 bytes (128 bits) for the initialization vector (IV). var key = secretKey.GetBytes(32); var iv = secretKey.GetBytes(16); // Get cryptor as System.Security.Cryptography.ICryptoTransform class. var cryptor = encrypt ? cipher.CreateEncryptor(key, iv) : cipher.CreateDecryptor(key, iv); // Create new Input. var inputBuffer = new byte[dataBytes.Length]; // Copy data bytes to input buffer. System.Buffer.BlockCopy(dataBytes, 0, inputBuffer, 0, inputBuffer.Length); // Create a MemoryStream to hold the output bytes. var stream = new System.IO.MemoryStream(); // Create a CryptoStream through which we are going to be processing our data. var mode = System.Security.Cryptography.CryptoStreamMode.Write; var cryptoStream = new System.Security.Cryptography.CryptoStream(stream, cryptor, mode); // Start the crypting process. cryptoStream.Write(inputBuffer, 0, inputBuffer.Length); // Finish crypting. cryptoStream.FlushFinalBlock(); // Convert data from a memoryStream into a byte array. var outputBuffer = stream.ToArray(); // Close both streams. stream.Close(); cryptoStream.Close(); return(outputBuffer); }
/// <summary> /// 加密 /// </summary> /// <param name="plainBytes">明文字节数组</param> /// <returns>返回密文字节数组</returns> public byte[] Encrypt(byte[] plainBytes) { var aes = new System.Security.Cryptography.AesCryptoServiceProvider(); aes.Mode = this.CipherMode; aes.Padding = this.PaddingMode; aes.Key = GetKeyBytes(); if (aes.Mode == CipherMode.CBC && IV == null) { IV = initIV(keyBytes.Length); } if (IV != null) { aes.IV = IV; } var encryptor = aes.CreateEncryptor(); var bResult = encryptor.TransformFinalBlock(plainBytes, 0, plainBytes.Length); return(bResult); }
private static byte[] _DecryptData(byte[] data, byte[] IV, int bitLength, byte[] passphrase) { var aes = new System.Security.Cryptography.AesCryptoServiceProvider(); var iv = new byte[16]; //always 16 for AES var key = new byte[IV.Length == 7 ? 32 : IV.Length / 8]; //HACK: for "AES-56", convert to AES-256 var ret = new byte[data.Length]; //Pad the IV if necessary Array.Copy(IV, iv, IV.Length); //Derive the key var derived = _DeriveEncryptionKey(bitLength, passphrase); Array.Copy(derived, key, derived.Length); //Decrypt it! aes.CreateDecryptor(key, iv).TransformBlock(data, 0, data.Length, ret, 0); return(ret); }
static public string AesLoginDynamicKey = @"d_&^t"; // 5 /// <summary> /// 문자열을 AES로 암호화 한다 /// </summary> public static string Encrypt(string dynamincKey, string text) { var comleteAesKey = dynamincKey.Substring(0, 5) + AesKey; System.Security.Cryptography.AesCryptoServiceProvider aes = new System.Security.Cryptography.AesCryptoServiceProvider(); aes.BlockSize = 128; aes.KeySize = 128; aes.IV = Encoding.UTF8.GetBytes(AesIV); aes.Key = Encoding.UTF8.GetBytes(comleteAesKey); aes.Mode = CipherMode.CBC; aes.Padding = PaddingMode.PKCS7; // 문자열을 바이트형 배열로 변환 byte[] src = Encoding.Unicode.GetBytes(text); // 암호화 한다 using (ICryptoTransform encrypt = aes.CreateEncryptor()) { byte[] dest = encrypt.TransformFinalBlock(src, 0, src.Length); // 바이트형 배열에서 Base64형식의 문자열로 변환 return(Convert.ToBase64String(dest)); } }
public void Include(AesCryptoServiceProvider a) { System.Security.Cryptography.AesCryptoServiceProvider b = new System.Security.Cryptography.AesCryptoServiceProvider(); }