No desenvolvimento de aplicações com C#, a proteção de informações sensíveis é uma prioridade constante. As técnicas de proteção de dados dividem-se geralmente em duas categorias principais: criptografia reversível (onde os dados podem ser recuperados) e hashing irreversível (unidirecional).

• Reversíveis: AES, DES, RSA.
• Irreversíveis (Hashing): MD5, família SHA.

1. Algoritmo de Hashing MD5

O MD5 (Message-Digest Algorithm 5) é uma função de dispersão amplamente utilizada para verificar a integridade de arquivos e armazenar senhas (embora para senhas modernas, algoritmos mais fortes sejam recomendados). Ele gera um valor de 128 bits, normalmente representado como uma string hexadecimal de 32 caracteres.

using System;
using System.Security.Cryptography;
using System.Text;

public static class HashHelper
{
    public static string GerarHashMD5(string texto)
    {
        using (MD5 algoritmo = MD5.Create())
        {
            byte[] entradaBytes = Encoding.UTF8.GetBytes(texto);
            byte[] hashBytes = algoritmo.ComputeHash(entradaBytes);

            StringBuilder sb = new StringBuilder();
            foreach (byte b in hashBytes)
            {
                sb.Append(b.ToString("x2"));
            }
            return sb.ToString().ToUpper();
        }
    }
}

2. Criptografia Simétrica DES

O Data Encryption Standard (DES) é um algoritmo simétrico clássico. Ele utiliza uma chave de 64 bits (sendo 56 bits efetivos) para processar blocos de dados. Por ser um padrão mais antigo, é frequentemente utilizado em sistemas legados.

public static string EncriptarDES(string conteudo, string chaveAcesso, string vetorInicial)
{
    byte[] bytesChave = Encoding.ASCII.GetBytes(chaveAcesso);
    byte[] bytesIv = Encoding.ASCII.GetBytes(vetorInicial);
    byte[] dadosPuros = Encoding.UTF8.GetBytes(conteudo);

    using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
    {
        using (var ms = new System.IO.MemoryStream())
        {
            using (var cs = new CryptoStream(ms, des.CreateEncryptor(bytesChave, bytesIv), CryptoStreamMode.Write))
            {
                cs.Write(dadosPuros, 0, dadosPuros.Length);
                cs.FlushFinalBlock();
                return Convert.ToBase64String(ms.ToArray());
            }
        }
    }
}

public static string DecriptarDES(string conteudoCriptografado, string chaveAcesso, string vetorInicial)
{
    byte[] bytesChave = Encoding.ASCII.GetBytes(chaveAcesso);
    byte[] bytesIv = Encoding.ASCII.GetBytes(vetorInicial);
    byte[] dadosCripto = Convert.FromBase64String(conteudoCriptografado);

    using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
    {
        using (var ms = new System.IO.MemoryStream(dadosCripto))
        {
            using (var cs = new CryptoStream(ms, des.CreateDecryptor(bytesChave, bytesIv), CryptoStreamMode.Read))
            {
                using (var sr = new System.IO.StreamReader(cs))
                {
                    return sr.ReadToEnd();
                }
            }
        }
    }
}

3. Criptografia Assimétrica RSA

Diferente dos algoritmos simétricos, o RSA utiliza um par de chaves: uma pública (para criptografia) e uma privada (para descriptografia). É o padrão ouro para assinaturas digitais e troca segura de chaves.

public static string ProcessarRSA(string dado, bool ehCriptografia, string nomeContainer = "ContainerSeguro")
{
    var parametros = new CspParameters { KeyContainerName = nomeContainer };
    using (var rsa = new RSACryptoServiceProvider(parametros))
    {
        if (ehCriptografia)
        {
            byte[] bytesParaCriptografar = Encoding.UTF8.GetBytes(dado);
            byte[] resultado = rsa.Encrypt(bytesParaCriptografar, false);
            return Convert.ToBase64String(resultado);
        }
        else
        {
            byte[] bytesParaDescriptografar = Convert.FromBase64String(dado);
            byte[] resultado = rsa.Decrypt(bytesParaDescriptografar, false);
            return Encoding.UTF8.GetString(resultado);
        }
    }
}

4. Codificação Base64

Embora não seja tecnicamente um algoritmo de criptografia, a codificação Base64 é essencial para converter dados binários resultantes de processos criptográficos em formatos de texto legíveis e transportáveis.

public static string CodificarBase64(string textoSimples)
{
    byte[] bytes = Encoding.UTF8.GetBytes(textoSimples);
    return Convert.ToBase64String(bytes);
}

public static string DecodificarBase64(string textoBase64)
{
    byte[] bytes = Convert.FromBase64String(textoBase64);
    return Encoding.UTF8.GetString(bytes);
}

5. Algoritmos SHA (Secure Hash Algorithm)

Os algoritmos SHA são considerados sucessores mais seguros do MD5. Atualmente, o SHA-256 e versões superiores são recomendados para garantir que uma entrada de dados não foi alterada.

public static string GerarSHA256(string entrada)
{
    using (SHA256 sha256Hash = SHA256.Create())
    {
        byte[] bytes = sha256Hash.ComputeHash(Encoding.UTF8.GetBytes(entrada));
        return Convert.ToBase64String(bytes);
    }
}

6. Criptografia Avançada AES

O Advanced Encryption Standard (AES) é o sucessor do DES e o algoritmo simétrico mais utilizado mundialmente. Ele opera com chaves de 128, 192 ou 256 bits, oferecendo um nível de segurança extremamente elevado para proteção de dados locais e em trânsito.

public static string CriptografarAES(string textoPuro, string chaveSecreta)
{
    using (Aes aesAlg = Aes.Create())
    {
        aesAlg.Key = Encoding.UTF8.GetBytes(chaveSecreta);
        aesAlg.Mode = CipherMode.ECB; // Exemplo simplificado
        aesAlg.Padding = PaddingMode.PKCS7;

        ICryptoTransform encriptador = aesAlg.CreateEncryptor();
        byte[] bufferOriginal = Encoding.UTF8.GetBytes(textoPuro);
        byte[] resultado = encriptador.TransformFinalBlock(bufferOriginal, 0, bufferOriginal.Length);
        
        return Convert.ToBase64String(resultado);
    }
}

public static string DescriptografarAES(string textoCifrado, string chaveSecreta)
{
    using (Aes aesAlg = Aes.Create())
    {
        aesAlg.Key = Encoding.UTF8.GetBytes(chaveSecreta);
        aesAlg.Mode = CipherMode.ECB;
        aesAlg.Padding = PaddingMode.PKCS7;

        ICryptoTransform decriptador = aesAlg.CreateDecryptor();
        byte[] bufferCifrado = Convert.FromBase64String(textoCifrado);
        byte[] resultado = decriptador.TransformFinalBlock(bufferCifrado, 0, bufferCifrado.Length);
        
        return Encoding.UTF8.GetString(resultado);
    }
}