Iniciando em criptografia - Salt

[Rogerio Almeida Pereira 1]

E aí povo, seguinte: estou começando a estudar criptografia em c# e ASP.Net daí surgiu a dúvida quanto ao salt. Quando devo colocar o salt? Antes de passar pela criptografia sha 512 ou depois?

[xanburzum 169]

Olá amigo... este fórum é apenas para ASP Classic.... porfavor pste no fórum de .Net.

mas o salt é um argumento para melhorar o processo de geração de chave.

 

Olha este exemplo como eu uso:

 

using System;

using System.Collections.Generic;

using System.Text;

using System.Security.Cryptography;

using System.IO;

namespace Criptografia

{

    /// <summary>

    /// Enumerator com os tipos de classes para criptografia.

    /// </summary>

    public enum CryptProvider

    {

        /// <summary>

        /// Representa a classe base para implementações criptografia dos algoritmos simétricos Rijndael.

        /// </summary>

        Rijndael,

        /// <summary>

        /// Representa a classe base para implementações do algoritmo RC2.

        /// </summary>

        RC2,

        /// <summary>

        /// Representa a classe base para criptografia de dados padrões (DES - Data Encryption Standard).

        /// </summary>

        DES,

        /// <summary>

        /// Representa a classe base (TripleDES - Triple Data Encryption Standard).

        /// </summary>

        TripleDES

    }

    public class Criptografia

    {

        #region Variáveis e Métodos Privados

        private string _key = string.Empty;

        private CryptProvider _cryptProvider;

        private SymmetricAlgorithm _algorithm;

        /// <summary>

        /// Inicialização do vetor do algoritmo simétrico

        /// </summary>

        private void SetIV()

        {

            switch (_cryptProvider)

            {

                case CryptProvider.Rijndael:

                    _algorithm.IV = new byte[] { 0xf, 0x6f, 0x13, 0x2e, 0x35, 0xc2, 0xcd, 0xf9, 0x5, 0x46, 0x9c, 0xea, 0xa8, 0x4b, 0x73, 0xcc };

                    break;

                default:

                    _algorithm.IV = new byte[] { 0xf, 0x6f, 0x13, 0x2e, 0x35, 0xc2, 0xcd, 0xf9 };

                    break;

            }

        }

        #endregion

        #region Properties

        /// <summary>

        /// Chave secreta para o algoritmo simétrico de criptografia.

        /// </summary>

        public string Key

        {

            get { return _key; }

            set { _key = value; }

        }

        #endregion

        #region Constructors

        /// <summary>

        /// Contrutor padrão da classe, é setado um tipo de criptografia padrão (Rijndael).

        /// </summary>

        public Criptografia()

        {

            _algorithm = new RijndaelManaged();

            _algorithm.Mode = CipherMode.CBC;

            _cryptProvider = CryptProvider.Rijndael;

        }

        /// <summary>

        /// Construtor com o tipo de criptografia a ser usada Você pode escolher o tipo pelo Enum chamado CryptProvider.

        /// </summary>

        /// <param name="cryptProvider">Tipo de criptografia.</param>

        public Criptografia(CryptProvider cryptProvider)

             {     

                    // Seleciona algoritmo simétrico

                    switch(cryptProvider)

                    {

                           case CryptProvider.Rijndael:

                                  _algorithm = new RijndaelManaged();

                                 _cryptProvider = CryptProvider.Rijndael;

                                  break;

                           case CryptProvider.RC2:

                                  _algorithm = new RC2CryptoServiceProvider();

                                  _cryptProvider = CryptProvider.RC2;

                                  break;

                           case CryptProvider.DES:

                                  _algorithm = new DESCryptoServiceProvider();

                                  _cryptProvider = CryptProvider.DES;

                                  break;

                           case CryptProvider.TripleDES:

                                  _algorithm = new TripleDESCryptoServiceProvider();

                                  _cryptProvider = CryptProvider.TripleDES;

                                  break;

                    }

                    _algorithm.Mode = CipherMode.CBC;

             }

        #endregion

        #region Public methods

        /// <summary>

        /// Gera a chave de criptografia válida dentro do array.

        /// </summary>

        /// <returns>Chave com array de bytes.</returns>

        public virtual byte[] GetKey()

        {

            string salt = string.Empty;

            // Ajusta o tamanho da chave se necessário e retorna uma chave válida

            if (_algorithm.LegalKeySizes.Length > 0)

            {

                // Tamanho das chaves em bits

                int keySize = _key.Length * 8;

                int minSize = _algorithm.LegalKeySizes[0].MinSize;

                int maxSize = _algorithm.LegalKeySizes[0].MaxSize;

                int skipSize = _algorithm.LegalKeySizes[0].SkipSize;

                if (keySize > maxSize)

                {

                    // Busca o valor máximo da chave

                    _key = _key.Substring(0, maxSize / 8);

                }

                else if (keySize < maxSize)

                {

                    // Seta um tamanho válido

                    int validSize = (keySize <= minSize) ? minSize : (keySize - keySize % skipSize) + skipSize;

                    if (keySize < validSize)

                    {

                        // Preenche a chave com arterisco para corrigir o tamanho

                        _key = _key.PadRight(validSize / 8, "*");

                    }

                }

            }

            PasswordDeriveBytes key = new PasswordDeriveBytes(_key, ASCIIEncoding.ASCII.GetBytes(salt));

            return key.GetBytes(_key.Length);

        }

        /// <summary>

        /// Encripta o dado solicitado.

        /// </summary>

        /// <param name="plainText">Texto a ser criptografado.</param>

        /// <returns>Texto criptografado.</returns>

        public virtual string Encrypt(string texto)

        {

            byte[] plainByte = Encoding.UTF8.GetBytes(texto);

            byte[] keyByte = GetKey();

            // Seta a chave privada

            _algorithm.Key = keyByte;

            SetIV();

            // Interface de criptografia / Cria objeto de criptografia

            ICryptoTransform cryptoTransform = _algorithm.CreateEncryptor();

            MemoryStream _memoryStream = new MemoryStream();

            CryptoStream _cryptoStream = new CryptoStream(_memoryStream, cryptoTransform, CryptoStreamMode.Write);

            // Grava os dados criptografados no MemoryStream

            _cryptoStream.Write(plainByte, 0, plainByte.Length);

            _cryptoStream.FlushFinalBlock();

            // Busca o tamanho dos bytes encriptados

            byte[] cryptoByte = _memoryStream.ToArray();

            // Converte para a base 64 string para uso posterior em um xml

            return Convert.ToBase64String(cryptoByte, 0, cryptoByte.GetLength(0));

        }

        /// <summary>

        /// Desencripta o dado solicitado.

        /// </summary>

        /// <param name="cryptoText">Texto a ser descriptografado.</param>

        /// <returns>Texto descriptografado.</returns>

        public virtual string Decrypt(string textoCriptografado)

        {

            // Converte a base 64 string em num array de bytes

            byte[] cryptoByte = Convert.FromBase64String(textoCriptografado);

            byte[] keyByte = GetKey();

            // Seta a chave privada

            _algorithm.Key = keyByte;

            SetIV();

            // Interface de criptografia / Cria objeto de descriptografia

            ICryptoTransform cryptoTransform = _algorithm.CreateDecryptor();

            try

            {

                MemoryStream _memoryStream = new MemoryStream(cryptoByte, 0, cryptoByte.Length);

                CryptoStream _cryptoStream = new CryptoStream(_memoryStream, cryptoTransform, CryptoStreamMode.Read);

                // Busca resultado do CryptoStream

                StreamReader _streamReader = new StreamReader(_cryptoStream);

                return _streamReader.ReadToEnd();

            }

            catch

            {

                return null;

            }

        }

        #endregion

    }

}