Gerador MD5

MD5 (Message-Digest Algorithm 5) é uma função hash criptográfica amplamente utilizada que produz um valor hash de 128 bits (16 bytes), tipicamente expresso como um número hexadecimal de 32 dígitos. Foi projetado por Ronald Rivest em 1991 para substituir o algoritmo MD4 anterior e foi especificado na RFC 1321 em abril de 1992.

Apesar de suas vulnerabilidades de segurança, o MD5 ainda é comumente usado para aplicações não relacionadas à segurança, como checksums para verificar integridade de dados e detectar corrupção de dados não intencional. Permanece adequado para outros propósitos não criptográficos devido aos seus requisitos computacionais menores em comparação com algoritmos de hash seguro mais recentes.

MD5 foi projetado pelo Professor Ronald Rivest do MIT como uma substituição mais segura para MD4. O algoritmo recebe uma mensagem de entrada de comprimento arbitrário e produz uma "impressão digital" ou "resumo de mensagem" de 128 bits como saída. O algoritmo MD5 é projetado para ser bastante rápido em máquinas de 32 bits e não requer grandes tabelas de substituição, permitindo uma implementação compacta.

O algoritmo processa uma mensagem de comprimento variável em uma saída de comprimento fixo de 128 bits, dividindo a entrada em blocos de 512 bits. Ele opera em um estado de 128 bits dividido em quatro palavras de 32 bits (A, B, C e D) e passa por quatro rodadas de operações, com cada rodada executando 16 operações baseadas em funções não lineares, adição modular e rotação de bits.

// Inicializar variáveis
A = 0x67452301
B = 0xEFCDAB89
C = 0x98BADCFE
D = 0x10325476

// Preparar funções
F(X,Y,Z) = (X AND Y) OR ((NOT X) AND Z)
G(X,Y,Z) = (X AND Z) OR (Y AND (NOT Z))
H(X,Y,Z) = X XOR Y XOR Z
I(X,Y,Z) = Y XOR (X OR (NOT Z))

// Processar mensagem (mensagem deve ser múltiplo de 512 bits)
// Preencher mensagem até que seu comprimento ≡ 448 (mod 512)
// Adicionar representação de 64 bits do comprimento original da mensagem

// Loop principal
para cada bloco de 512 bits da mensagem preenchida:
    // Dividir bloco em dezesseis palavras de 32 bits (M[0..15])
    // Copiar estado do bloco
    AA = A
    BB = B
    CC = C
    DD = D
    
    // Rodada 1
    para i de 0 a 15:
        A = B + ((A + F(B,C,D) + M[i] + T[i]) <<< s[i])
        Rotacionar A, B, C, D
    
    // Rodada 2
    para i de 16 a 31:
        A = B + ((A + G(B,C,D) + M[(5*i + 1) mod 16] + T[i]) <<< s[i])
        Rotacionar A, B, C, D
    
    // Rodada 3
    para i de 32 a 47:
        A = B + ((A + H(B,C,D) + M[(3*i + 5) mod 16] + T[i]) <<< s[i])
        Rotacionar A, B, C, D
    
    // Rodada 4
    para i de 48 a 63:
        A = B + ((A + I(B,C,D) + M[(7*i) mod 16] + T[i]) <<< s[i])
        Rotacionar A, B, C, D
    
    // Adicionar resultado do processamento do bloco
    A = A + AA
    B = B + BB
    C = C + CC
    D = D + DD

// Saída
MD5 = A || B || C || D // Concatenado para resultado de 128 bits

Em 1996, uma falha foi descoberta no design do MD5, embora não tenha sido considerada fatal na época. Até 2004, vulnerabilidades mais sérias foram encontradas, e pesquisadores demonstraram ataques de colisão práticos - métodos para criar pares de entradas diferentes que produzem o mesmo valor hash MD5.

Em 2008, um grupo de pesquisadores usou essas vulnerabilidades para criar um certificado SSL falsificado que parecia legítimo. O malware Flame explorou fraquezas do MD5 para falsificar uma assinatura digital da Microsoft em 2012. Ataques de colisão modernos podem encontrar colisões MD5 em segundos em hardware de computador padrão.