Como usar criptografia no C#

Hoje na aula de segurança Digital falamos um pouco da importância de criptografar sistemas de informação corporativos.

Um bom desenvolvedor deve conhecer os princípios básicos da criptografia e saber quando aplicá-la. Neste exemplo vamos fazer um pequeno programa em C# que ira codificar e decodificar um texto qualquer.

 

Classe de Criptografia.

A classe de criptografia usa a referência System.Security.Cryptography do framework .Net. Esta referência permite utilizar 4 tipos diferentes de criptografia sendo elas; Rijndael, RC2, DES e TripleDES.

  1. Inicie um novo projeto no Visual Studio.
  2. Crie uma nova classe com o nome de Criptografia.cs e acrescente o seguinte código:
    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Security.Cryptography;
    using System.IO;
    namespace WindowsFormsApplication1
    {
    /// <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
    }
    }

 

Criando a interface gráfica.

Agora crie a seguinte interface;

O código do botão Codifica ficará assim;

Criptografia criptografia = new Criptografia(CryptProvider.RC2);  // escolhe o tipo de criptografia, neste caso escolhemos o RC2
criptografia.Key = "Etec2017"; // chave
textBox2.Text = criptografia.Encrypt(textBox1.Text);

O código do botão Decofica ficará assim;

Criptografia criptografia = new Criptografia(CryptProvider.RC2);
criptografia.Key = "Etec2017";
textBox3.Text = criptografia.Decrypt(textBox2.Text);

Executando a aplicação, temos o seguinte resultado;

 

Download do projeto de criptografia em C#

clique aqui e bons estudos!
WindowsFormsApplication1

 

Deixe seu comentário