T
security hash sha2 sha3 cryptography

O Guia Completo das Famílias de Hash SHA-2 e SHA-3

Uma análise técnica detalhada e comparação das variantes de hash SHA-2 e SHA-3, incluindo SHAKE e BLAKE2.

2026-04-11 Usar esta ferramenta

Introdução ao Hashing na Era Moderna

As funções de hash criptográficas são os heróis anônimos da segurança digital. Desde a proteção de senhas até a verificação da integridade de distribuições de software de vários gigabytes, elas fornecem uma "impressão digital" para os dados. À medida que o poder computacional cresce e as técnicas de criptoanálise evoluem, a indústria mudou de algoritmos legados como MD5 e SHA-1 para padrões mais robustos: SHA-2 e o mais recente SHA-3.

Neste guia, exploraremos as complexidades das famílias SHA-2 e SHA-3, compararemos suas arquiteturas subjacentes e analisaremos alternativas modernas como BLAKE2.

A Família SHA-2: O Cavalo de Batalha da Internet

Desenvolvida pela NSA e publicada pelo NIST em 2001, a família SHA-2 (Secure Hash Algorithm 2) substituiu o vulnerável SHA-1. O SHA-2 é baseado na construção Merkle-Damgård, um método para construir funções de hash resistentes a colisões a partir de funções de compressão unidirecionais.

Variantes do SHA-2

A família SHA-2 consiste em seis funções de hash com diferentes tamanhos de resumo:

  1. SHA-256: A variante mais amplamente utilizada. Produz um hash de 256 bits (32 bytes). É a espinha dorsal do Bitcoin e de muitos certificados SSL/TLS.
  2. SHA-512: Projetado para processadores de 64 bits, produz um hash de 512 bits (64 bytes). Geralmente é mais rápido que o SHA-256 em hardware de 64 bits.
  3. SHA-224: Uma versão truncada do SHA-256.
  4. SHA-384: Uma versão truncada do SHA-512.
  5. SHA-512/224 e SHA-512/256: São versões truncadas do SHA-512 que são mais seguras contra "ataques de extensão de comprimento" do que o SHA-256, mantendo alto desempenho em sistemas de 64 bits.

A Estrutura Merkle-Damgård

A construção Merkle-Damgård funciona:

  1. Preenchendo a mensagem para que seu comprimento seja um múltiplo de um tamanho de bloco fixo.
  2. Dividindo a mensagem em blocos.
  3. Processando cada bloco sequencialmente com uma função de compressão que recebe a saída do bloco anterior como entrada.

Nota sobre vulnerabilidade: Uma fraqueza inerente desta estrutura é o Ataque de Extensão de Comprimento, onde um atacante pode calcular Hash(Mensagem || Extensão) se souber o Hash(Mensagem) e o comprimento da Mensagem, sem conhecer a mensagem original.

A Família SHA-3: Uma Mudança de Paradigma

Embora o SHA-2 continue seguro, o NIST lançou uma competição em 2007 para encontrar um algoritmo fundamentalmente diferente para servir como backup. O vencedor foi o Keccak, que se tornou o padrão SHA-3 em 2015.

A Construção de Esponja (Sponge Construction)

Ao contrário do SHA-2, o SHA-3 usa a Construção de Esponja. Esta arquitetura envolve duas fases:

  1. Absorção (Absorbing): Os blocos da mensagem são combinados via XOR em um subconjunto do estado interno.
  2. Espremer (Squeezing): O estado é transformado e os bits de saída são lidos (espremidos) dele.

Como o estado interno é muito maior do que o hash de saída, o SHA-3 é naturalmente resistente a ataques de extensão de comprimento, eliminando uma grande falha de design encontrada no SHA-2.

Variantes do SHA-3

O SHA-3 reflete os tamanhos de saída do SHA-2 para maior compatibilidade:

  • SHA-3-224
  • SHA-3-256
  • SHA-3-384
  • SHA-3-512

SHAKE: Funções de Saída Estensível (XOF)

Uma das características mais inovadoras do padrão SHA-3 é a introdução do SHAKE (Secure Hash Algorithm and Keccak). Ao contrário das funções de hash tradicionais que produzem uma saída de comprimento fixo, o SHAKE128 e o SHAKE256 permitem especificar qualquer comprimento de saída.

  • SHAKE128: Fornece 128 bits de segurança contra todos os ataques, desde que a saída seja longa o suficiente.
  • SHAKE256: Fornece 256 bits de segurança.

Estes são incrivelmente úteis para gerar grandes quantidades de dados pseudorandômicos ou para esquemas de preenchimento de comprimento variável.

BLAKE2: A Alternativa de Alto Desempenho

Embora não seja um padrão NIST, o BLAKE2 (baseado no algoritmo BLAKE da competição SHA-3) é altamente respeitado na indústria.

  • BLAKE2b: Otimizado para plataformas de 64 bits.
  • BLAKE2s: Otimizado para plataformas de 8 a 32 bits.

Por que usar o BLAKE2? Ele é mais rápido que o SHA-3 e até mesmo que o SHA-2 na maioria das CPUs modernas, ao mesmo tempo em que fornece segurança equivalente. É usado em projetos como Argon2 (hashing de senha) e WireGuard.

Análise de Segurança: Por que mudar para o SHA-3?

Se o SHA-2 não está quebrado, por que se preocupar com o SHA-3?

  1. Diversidade: Se um avanço na criptoanálise quebrar a estrutura Merkle-Damgård, o SHA-2 cai. O SHA-3 (Esponja) fornece uma base matemática completamente diferente.
  2. Resistência à Extensão de Comprimento: O SHA-3 é mais seguro para certas construções de MAC (Código de Autenticação de Mensagem).
  3. Preparação para o Futuro: À medida que a computação quântica se aproxima, estados maiores e estruturas diferentes oferecem uma melhor "defesa em profundidade".

Exemplos de Código

Node.js (usando o módulo crypto)

const crypto = require('crypto');

// SHA-256 (SHA-2)
const sha256 = crypto.createHash('sha256').update('Olá Mundo').digest('hex');
console.log(`SHA-256: ${sha256}`);

// SHA3-256 (SHA-3)
const sha3 = crypto.createHash('sha3-256').update('Olá Mundo').digest('hex');
console.log(`SHA3-256: ${sha3}`);

// SHAKE256 com saída de 64 bytes
const shake = crypto.createHash('shake256', { outputLength: 64 })
                    .update('Olá Mundo')
                    .digest('hex');
console.log(`SHAKE256: ${shake}`);

Python (usando hashlib)

import hashlib

# SHA-256
print(f"SHA-256: {hashlib.sha256(b'Olá Mundo').hexdigest()}")

# SHA3-256
print(f"SHA3-256: {hashlib.sha3_256(b'Olá Mundo').hexdigest()}")

# SHAKE256
s = hashlib.shake_256(b'Olá Mundo')
print(f"SHAKE256 (16 bytes): {s.hexdigest(16)}")

FAQ: Mal-entendidos Comuns

1. O SHA-3 é "mais seguro" que o SHA-2?

Em termos de resistência a ataques conhecidos, ambos são atualmente muito seguros. No entanto, a estrutura do SHA-3 é teoricamente mais robusta contra tipos específicos de ataques (como extensão de comprimento).

2. O SHA-512 é sempre melhor que o SHA-256?

Não necessariamente. Embora tenha um resumo mais longo, pode ser mais lento em sistemas de 32 bits. No entanto, em sistemas de 64 bits, o SHA-512 costuma ser mais rápido devido ao uso de aritmética de 64 bits.

3. Devo usar MD5 ou SHA-1 para tarefas não relacionadas à segurança?

Geralmente, não. Mesmo para tarefas que não envolvem segurança (como IDs de objetos do Git), colisões podem causar bugs. Use pelo menos SHA-256 ou BLAKE2, a menos que você tenha um requisito legado.

4. Qual é a diferença entre SHAKE e SHA-3?

O SHA-3 tem um comprimento de saída fixo. O SHAKE é uma XOF (Função de Saída Estensível) que usa o mesmo motor Keccak, mas permite solicitar qualquer número de bits.

Conclusão

A escolha da função de hash correta depende de suas necessidades específicas. Para uso geral e compatibilidade, o SHA-256 continua sendo o padrão da indústria. Se você está construindo um novo sistema e deseja a maior segurança arquitetônica, o SHA-3 é o caminho a seguir. Para aplicações de alto desempenho, o BLAKE2 é uma escolha formidável.

Voltar ao blog Gerador de Hash →