예제 #1
0
 protected override void Dispose(Boolean disposing)
 {
     if (disposing)
     {
         Aes.Dispose();
     }
 }
예제 #2
0
 protected override void OnDispose(bool disposing)
 {
     if (disposing)
     {
         _key.Dispose();
     }
 }
예제 #3
0
 /// <summary>Instantly dispose of all resources.</summary>
 public void Dispose()
 {
     Disposed = true;
     Aes.Dispose();
     Allocator.ReturnKey(ref Key);
     Allocator.ReturnIV(ref IV);
 }
예제 #4
0
        /// <summary>
        /// AES加密
        /// </summary>
        /// <param name="value">待加密字段</param>
        /// <param name="keyVal">密钥值(最短:16位长度,过长也只取16位)</param>
        /// <param name="ivVal">加密辅助向量(最短:16位长度,过长也只取16位)</param>
        /// <returns></returns>
        public static string AesStr(this string value, string keyVal, string ivVal)
        {
            if (value == null)
            {
                throw new ArgumentNullException("未将对象引用设置到对象的实例。");
            }

            var encoding = Encoding.UTF8;

            byte[] btKey     = keyVal.FormatByte(encoding);
            byte[] btIv      = ivVal.FormatByte(encoding);
            byte[] byteArray = encoding.GetBytes(value);
            string encrypt;
            Aes    aes = Aes.Create();

            //Rijndael aes = Rijndael.Create();
            using (MemoryStream mStream = new MemoryStream())
            {
                using (CryptoStream cStream = new CryptoStream(mStream, aes.CreateEncryptor(btKey, btIv), CryptoStreamMode.Write))
                {
                    cStream.Write(byteArray, 0, byteArray.Length);
                    cStream.FlushFinalBlock();
                    encrypt = Convert.ToBase64String(mStream.ToArray());
                }
            }
            aes.Dispose();
            return(encrypt);
        }
예제 #5
0
 protected override void Dispose(bool disposing)
 {
     if (disposing)
     {
         _impl.Dispose();
     }
 }
예제 #6
0
        private bool disposedValue = false; // To detect redundant calls

        protected override void Dispose(bool disposing)
        {
            if (!disposedValue)
            {
                if (disposing)
                {
                    try
                    {
                        topStream.Dispose(); // This call will flush and dispose all chained streams.
                    }
                    catch (CryptographicException)
                    {
                        topStream.Dispose();
                        throw;
                    }
                    finally
                    {
                        transform.Dispose();
                        csp.Dispose();
                        sha.Dispose();
                    }
                }

                disposedValue = true;
            }
        }
예제 #7
0
        /// <summary>
        ///   Close the stream.
        /// </summary>
        public override void Close()
        {
            TraceOutput("Close {0:X8}", this.GetHashCode());

            // In the degenerate case, no bytes have been written to the
            // stream at all.  Need to check here, and NOT emit the
            // final block if Write has not been called.
            if (_pendingCount > 0)
            {
                WriteTransformFinalBlock();
                _s.Write(_PendingWriteBlock, 0, _pendingCount);
                _totalBytesXferred += _pendingCount;
                _pendingCount       = 0;
            }
            _s.Close();

            _xform.Dispose();
            _aesCipher.Dispose();

#if WANT_TRACE
            untransformed.Close();
            transformed.Close();
            Console.WriteLine("\nuntransformed bytestream is in  {0}", traceFileUntransformed);
            Console.WriteLine("\ntransformed bytestream is in  {0}", traceFileTransformed);
#endif
            TraceOutput("-------------------------------------------------------");
        }
예제 #8
0
 public void Dispose()
 {
     m_Disposed = true;
     m_Encryptor.Dispose();
     m_Decryptor.Dispose();
     m_Aes.Dispose();
     m_EncryptHMAC.Dispose();
 }
예제 #9
0
 public void Dispose()
 {
     if (_aes != null)
     {
         _aes.Dispose();
         _aes = null;
     }
 }
예제 #10
0
 public void Dispose()
 {
     if (aes != null)
     {
         aes.Dispose();
         aes = null;
     }
 }
예제 #11
0
        /// <summary>
        /// Decrypt the given string.  Assumes the string was encrypted using
        /// EncryptStringAES(), using an identical sharedSecret.
        /// </summary>
        /// <param name="cipherText">The text to decrypt.</param>
        /// <param name="sharedSecret">A password used to generate a key for decryption.</param>
        public static string DecryptStringAES(string cipherText, string sharedSecret)
        {
            if (_salt == null)
            {
                throw new ArgumentNullException(nameof(_salt));
            }
            if (string.IsNullOrEmpty(cipherText))
            {
                throw new ArgumentNullException(nameof(cipherText));
            }
            if (string.IsNullOrEmpty(sharedSecret))
            {
                throw new ArgumentNullException(nameof(sharedSecret));
            }

            // Declare the RijndaelManaged object
            // used to decrypt the data.
            Aes aesAlg = Aes.Create();

            // Declare the string used to hold
            // the decrypted text.
            string plaintext = null;

            try
            {
                // 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 msDecrypt = new MemoryStream(bytes))
                {
                    // Create a RijndaelManaged object
                    // with the specified key and IV.

                    aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8);
                    // Get the initialization vector from the encrypted stream
                    aesAlg.IV = ReadByteArray(msDecrypt);
                    // Create a decrytor to perform the stream transform.
                    ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
                    using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                    {
                        using (StreamReader srDecrypt = new StreamReader(csDecrypt))

                            // Read the decrypted bytes from the decrypting stream
                            // and place them in a string.
                            plaintext = srDecrypt.ReadToEnd();
                    }
                }
            }
            finally
            {
                // Clear the RijndaelManaged object.
                aesAlg?.Dispose();
            }

            return(plaintext);
        }
예제 #12
0
        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);

            if (disposing)
            {
                _aesContext.Dispose();
            }
        }
예제 #13
0
        public static string DecryptString(string cipherText, byte[] salt, string sharedSecret)
        {
            if (string.IsNullOrEmpty(cipherText))
            {
                throw new ArgumentNullException("cipherText");
            }
            if (string.IsNullOrEmpty(sharedSecret))
            {
                throw new ArgumentNullException("sharedSecret");
            }

            // Declare the RijndaelManaged object
            // used to decrypt the data.
            Aes aes = null;

            // Declare the string used to hold
            // the decrypted text.
            string plaintext = null;

            try
            {
                // generate the key from the shared secret and the salt
                var key = new Rfc2898DeriveBytes(sharedSecret, salt);

                // Create a RijndaelManaged object
                // with the specified key and IV.
                aes     = Aes.Create();
                aes.Key = key.GetBytes(aes.KeySize / 8);
                aes.IV  = key.GetBytes(aes.BlockSize / 8);

                // Create a decrytor to perform the stream transform.
                var decryptor = aes.CreateDecryptor(aes.Key, aes.IV);
                // Create the streams used for decryption.
                byte[] bytes = Convert.FromBase64String(cipherText);
                using (var msDecrypt = new MemoryStream(bytes))
                {
                    using (var csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                    {
                        using (var srDecrypt = new StreamReader(csDecrypt))

                            // Read the decrypted bytes from the decrypting stream
                            // and place them in a string.
                            plaintext = srDecrypt.ReadToEnd();
                    }
                }
            }
            finally
            {
                // Clear the RijndaelManaged object.
                if (aes != null)
                {
                    aes.Dispose();
                }
            }

            return(plaintext);
        }
예제 #14
0
        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                _aes?.Dispose();

                _diffieHellman?.Dispose();
            }
        }
예제 #15
0
 public void Dispose()
 {
     if (disposed)
     {
         return;
     }
     aes.Dispose();
     disposed = true;
 }
예제 #16
0
        public void Dispose()
        {
            if (_publicKeyTaskInitialized && _publicKeyTask.IsCompleted)
            {
                _publicKeyTask.Result.Dispose();
            }

            _aes?.Dispose();
        }
예제 #17
0
파일: ArcCSAF.cs 프로젝트: ziyuejun/GARbro
 public void Dispose()
 {
     if (!m_disposed)
     {
         m_aes.Dispose();
         m_md5.Dispose();
         m_disposed = true;
     }
 }
        public void Disconnect()
        {
            if (AesManaged != null)
            {
                AesManaged.Dispose();
            }

            this.Hash = null;
        }
예제 #19
0
        public override void Dispose(bool disposing)
        {
            if (disposing)
            {
                _aes.Dispose();
            }

            base.Dispose(disposing);
        }
예제 #20
0
        /// <summary>
        /// Encrypt the given string using AES.  The string can be decrypted using
        /// DecryptStringAES().  The sharedSecret parameters must match.
        /// </summary>
        /// <param name="plainText">The text to encrypt.</param>
        /// <param name="sharedSecret">A password used to generate a key for encryption.</param>
        public static string EncryptStringAES(string plainText, string sharedSecret)
        {
            if (_salt == null)
            {
                throw new ArgumentNullException(nameof(_salt));
            }
            if (string.IsNullOrEmpty(plainText))
            {
                throw new ArgumentNullException(nameof(plainText));
            }
            if (string.IsNullOrEmpty(sharedSecret))
            {
                throw new ArgumentNullException(nameof(sharedSecret));
            }

            string outStr = null;                     // Encrypted string to return
            Aes    aesAlg = Aes.Create();;            // RijndaelManaged object used to encrypt the data.

            try
            {
                // generate the key from the shared secret and the salt
                Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(sharedSecret, _salt);

                // Create a RijndaelManaged object
                //aesAlg = new RijndaelManaged();
                aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8);

                // Create a decryptor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    // prepend the IV
                    msEncrypt.Write(BitConverter.GetBytes(aesAlg.IV.Length), 0, sizeof(int));
                    msEncrypt.Write(aesAlg.IV, 0, aesAlg.IV.Length);
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            //Write all data to the stream.
                            swEncrypt.Write(plainText);
                        }
                    }
                    outStr = Convert.ToBase64String(msEncrypt.ToArray());
                }
            }
            finally
            {
                // Clear the RijndaelManaged object.
                aesAlg?.Dispose();
            }

            // Return the encrypted bytes from the memory stream.
            return(outStr);
        }
예제 #21
0
        /// <summary>
        /// Criptografa dados com a cifra AES
        /// </summary>
        /// <param name="PlainText">O texto claro a ser criptografado</param>
        /// <param name="Key">A chave secreta responsável pela encriptação</param>
        /// <param name="IV">Vetor de inicialização do AES/CBC mode</param>
        /// <returns></returns>
        public static byte[] Encrypt(string PlainText, byte[] Key, byte[] IV)
        {
            byte[] CipherText;

            //Verifica possíveis erros
            try
            {
                //Inicia a instância do AES
                using (Aes AES256 = Aes.Create())
                {
                    AES256.Key = Key;
                    AES256.IV  = IV;

                    //Inicia a encriptação AES passando a chave e o IV
                    ICryptoTransform crypto = AES256.CreateEncryptor(AES256.Key, AES256.IV);

                    //Armazena espaço na memória para um texto cifrado
                    using (var memory = new MemoryStream())
                    {
                        //Indica a operação criptografica a ser feita e o tipo de fluxo
                        using (var cryptoStream = new CryptoStream(memory, crypto, CryptoStreamMode.Write))
                        {
                            //Responsável por escrever o texto cifrado no buffer
                            using (var writer = new StreamWriter(cryptoStream))
                            {
                                //Escreve o texto cifrado
                                writer.Write(PlainText);

                                writer.Close();
                            }

                            //Envia todos os bytes cifrados ao array de bytes
                            CipherText = memory.ToArray();

                            cryptoStream.Close();
                        }

                        memory.Close();
                    }

                    //Fecha todo o fluxo criptográfico
                    AES256.Dispose();
                }
            }
            catch (CryptographicException ex)
            {
                MessageBox.Show("Erro de criptografia: " + ex.Message,
                                "Erro criptográfico!", MessageBoxButtons.OK,
                                MessageBoxIcon.Error);

                return(null);
            }

            //Retorna o texto cifrado
            return(CipherText);
        }
예제 #22
0
 protected virtual void Dispose(bool disposing)
 {
     if (disposing)
     {
         if (_aes != null)
         {
             _aes.Dispose();
             _aes = null;
         }
     }
 }
예제 #23
0
        public static string EncryptString(string plainText, byte[] salt, string sharedSecret)
        {
            if (string.IsNullOrEmpty(plainText))
            {
                throw new ArgumentNullException("plainText");
            }
            if (string.IsNullOrEmpty(sharedSecret))
            {
                throw new ArgumentNullException("sharedSecret");
            }

            // Encrypted string to return
            string outStr = null;

            // Object used to encrypt data
            Aes aes = null;

            try
            {
                // Generate key from shared secret and salt
                var key = new Rfc2898DeriveBytes(sharedSecret, salt);

                aes     = Aes.Create();
                aes.Key = key.GetBytes(aes.KeySize / 8);
                aes.IV  = key.GetBytes(aes.BlockSize / 8);

                var encryptor = aes.CreateEncryptor(aes.Key, aes.IV);

                // Create the streams used for encryption.
                using (var msEncrypt = new MemoryStream())
                {
                    using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (var swEncrypt = new StreamWriter(csEncrypt))
                        {
                            //Write all data to the stream.
                            swEncrypt.Write(plainText);
                        }
                    }
                    outStr = Convert.ToBase64String(msEncrypt.ToArray());
                }
            }
            finally
            {
                // Clear the RijndaelManaged object.
                if (aes != null)
                {
                    aes.Dispose();
                }
            }

            // Return the encrypted bytes from the memory stream.
            return(outStr);
        }
예제 #24
0
        /// <summary>
        /// Releases unmanaged and - optionally - managed resources.
        /// </summary>
        /// <param name="disposing">
        /// <c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only
        /// unmanaged resources.
        /// </param>
        protected override void DisposeResources(bool disposing)
        {
            if (!disposing)
            {
                return;
            }

            _encryptor?.Dispose();

            _dh?.Dispose();
        }
예제 #25
0
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
#if !OS_WINDOWS
                _impl.Dispose();
#else
                _impl.Clear();
#endif
            }
        }
예제 #26
0
 protected virtual void Dispose(bool disposing)
 {
     if (!disposed)
     {
         if (disposing)
         {
             aes.Dispose();
         }
         DisposeHelper.OnDispose <AESCryptoProvider>(disposing);
         disposed = true;
     }
 }
예제 #27
0
        protected virtual void Dispose(bool disposing)
        {
            if (!_disposedValue)
            {
                if (disposing)
                {
                    _aes.Dispose();
                }

                _disposedValue = true;
            }
        }
예제 #28
0
        /// <summary>
        /// Decrypt some encrypted text with a key and salt
        /// </summary>
        /// <param name="encryptionKey">Encryption Key</param>
        /// <param name="encryptionSalt">Encryption Salt</param>
        /// <param name="encryptedText">Encrypted string</param>
        /// <returns>Decrypted string</returns>
        private string Decrypt(string encryptionKey, string encryptionSalt, string encryptedText)
        {
            string retVal = string.Empty;

            if (!string.IsNullOrEmpty(encryptedText))
            {
                // Declare the RijndaelManaged object
                // used to encrypt the data.
                // Create a RijndaelManaged object
                // with the specified key and IV.
                using (Aes aesAlg = Aes.Create())
                {
                    try
                    {
                        byte[] encryptedTextBytes = Convert.FromBase64String(encryptedText);
                        byte[] passwordSaltBytes  = Encoding.UTF8.GetBytes(encryptionSalt);

                        Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(encryptionKey, passwordSaltBytes, this.KeyGenerationIterationCount);
                        aesAlg.Key = pdb.GetBytes(AlgorithmKeyBytes);
                        aesAlg.IV  = pdb.GetBytes(AlgorithmInitializationVectorBytes);

                        // Create a decrytor to perform the stream transform.
                        ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);

                        // Create the streams used for encryption.
                        MemoryStream memoryStreamDecrypt = new MemoryStream(encryptedTextBytes);

                        // CA2202: Nested usings can have Dispose() called twice http://msdn.microsoft.com/en-us/library/ms182334.aspx
                        using (StreamReader streamReaderDecrypt = new StreamReader(new CryptoStream(memoryStreamDecrypt, decryptor, CryptoStreamMode.Read)))
                        {
                            // Read the decrypted bytes from the decrypting stream
                            // and place them in a string.
                            retVal = streamReaderDecrypt.ReadToEnd();
                        }
                    }
                    catch (Exception e)
                    {
                        LogManager.CreateLogger <AESManager>().LogError(e, e.Message);
                    }
                    finally
                    {
                        // Clear the RijndaelManaged object.
                        if (aesAlg != null)
                        {
                            aesAlg.Dispose();
                        }
                    }
                }
            }

            return(retVal);
        }
예제 #29
0
        public void Dispose()
        {
            if (!disposed)
            {
                aes.Dispose();
                encryptor.Dispose();

                Array.Clear(counter, 0, BlockSize);
                Array.Clear(keyStream.Array, 0, KeyStreamBufferSize);

                disposed = true;
            }
        }
예제 #30
0
        /// <summary>
        /// Realiza a encriptação simétrica com a cifra AES (Padrão de Encriptação Avançado).
        /// </summary>
        /// <param name="text">O texto claro a ser criptografado</param>
        /// <param name="AES_KEY">A chave criptográfica</param>
        /// <param name="AES_IV">O vetor de inicialização (IV) das cifras simétricas</param>
        /// <param name="AES_KEY_SIZE">O tamanho da chave criptográfica (Em bits)></param>
        /// <returns></returns>
        public static byte[] Encrypt(string text, byte[] AES_KEY, byte[] AES_IV, int AES_KEY_SIZE)
        {
            try
            {
                if (!String.IsNullOrEmpty(text) && !String.IsNullOrWhiteSpace(text))
                {
                    byte[] Encrypted;

                    using (Aes AES = Aes.Create())
                    {
                        AES.KeySize = AES_KEY_SIZE;
                        AES.Key     = AES_KEY;
                        AES.IV      = AES_IV;

                        ICryptoTransform TransfAES = AES.CreateEncryptor(AES.Key, AES.IV);
                        MyKey = AES_KEY;

                        using (var Memory = new MemoryStream())
                        {
                            using (var Cryp = new CryptoStream(Memory, TransfAES, CryptoStreamMode.Write))
                            {
                                using (var Stream = new StreamWriter(Cryp))
                                {
                                    Stream.Write(text);

                                    Stream.Close();
                                }

                                Encrypted = Memory.ToArray();

                                Cryp.Close();
                            }

                            AES.Dispose();
                        }

                        return(Encrypted);
                    }
                }
            }
            catch (CryptographicException ex)
            {
                Console.WriteLine("Erro na criptografia AES!\nMotivo: " + ex.Message);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Erro na criptografia AES!\nMotivo: " + ex.Message);
            }

            return(null);
        }