SHA-256 e SHA-3 são os dois algoritmos de hash criptográfico mais discutidos em 2026. Um tem 3,4 vezes mais velocidade em servidores modernos. O outro foi criado precisamente para sobreviver a falhas estruturais do rival. Escolher errado em sistemas de produção significa comprometer desempenho ou abrir brechas de segurança que custam dezenas de milhares de euros em auditorias e correções.
Benchmarks publicados por Sylvain Kerkour em 2024 mostram SHA-256 a atingir 2373 MB/s em mensagens de 1 MB num AMD EPYC 4245P (Zen 5), enquanto SHA3-256 fica nos 686 MB/s na mesma máquina. Noutro teste em ARM Graviton 4 da Amazon, a diferença mantém-se: 1744 MB/s contra 510 MB/s. Falamos de uma lacuna de desempenho de 3,4 vezes, relevante em qualquer sistema que processe ficheiros grandes, assine muitos documentos por segundo ou execute pipelines de dados intensivos.
Mas a história não termina nos benchmarks. SHA-3 introduziu uma arquitetura radicalmente diferente, resistência a ataques de extensão de comprimento, e variantes de saída flexível (SHAKE128, SHAKE256) que SHA-256 simplesmente não oferece. Este guia compara os dois algoritmos com dados reais, exemplos de código, casos de uso concretos e uma recomendação clara para cada cenário.
SHA-256 vs SHA-3: Especificações Técnicas Completas
Antes de entrar nos casos de uso, é fundamental perceber as diferenças estruturais entre os dois algoritmos. A tabela abaixo resume as especificações técnicas que determinam desempenho, segurança e compatibilidade.
| Característica | SHA-256 | SHA3-256 |
|---|---|---|
| Standard NIST | FIPS 180-4 | FIPS 202 |
| Ano de Padronização | 2001 | 2015 |
| Construção Interna | Merkle-Damgård | Keccak Sponge |
| Tamanho do Digest | 256 bits (32 bytes) | 256 bits (32 bytes) |
| Estado Interno | 256 bits | 1600 bits |
| Bitrate (SHA3-256) | N/A | 1088 bits |
| Capacidade (SHA3-256) | N/A | 512 bits |
| Número de Rondas | 64 | 24 (Keccak-f[1600]) |
| Velocidade x86-64 (1 MB) | 2373 MB/s | 686 MB/s |
| Velocidade ARM64 (1 MB) | 1744 MB/s | 510 MB/s |
| Resistência Extensão de Comprimento | Não | Sim |
| Aceleração SHA-NI (Intel/AMD) | Sim | Não |
| Variantes XOF Disponíveis | Não | SHAKE128, SHAKE256 |
| Vulnerabilidades Conhecidas (2026) | Nenhuma prática | Nenhuma |
Origens: Por Que o SHA-3 Existe Se o SHA-256 Funciona
SHA-256 foi publicado pela NSA em 2001 e padronizado no FIPS 180-4. Faz parte da família SHA-2 e usa a construção Merkle-Damgård: a mensagem é dividida em blocos de 512 bits, cada bloco é processado sequencialmente e o resultado encadeia no bloco seguinte. É um design sólido, testado por 25 anos, e a razão pela qual Bitcoin, TLS, GPG e o kernel Linux o usam como hash primário.
O problema surgiu em 2004-2005. Investigadores descobriram fraquezas teóricas em MD5 e SHA-1, ambos Merkle-Damgård. SHA-256 continuava seguro, mas a comunidade criptográfica ficou nervosa: toda a família SHA-2 partilha a mesma estrutura matemática de base. Se surgisse um ataque genérico contra Merkle-Damgård suficientemente poderoso, SHA-256 e SHA-512 cairiam juntos.
Em 2007, o NIST lançou uma competição pública para criar um novo padrão de hash radicalmente diferente, sem relação estrutural com SHA-2. Participaram 64 candidatos. Em outubro de 2012, o NIST anunciou o vencedor: Keccak, proposto por Guido Bertoni, Joan Daemen, Michaël Peeters e Gilles Van Assche. Em agosto de 2015, o algoritmo foi padronizado como SHA-3 no FIPS 202.
A ideia central era simples: mesmo que SHA-256 seja comprometido no futuro, SHA-3 usa uma arquitetura diferente e continuaria seguro. Diversidade estrutural como estratégia de defesa.
Merkle-Damgård vs Keccak Sponge: A Diferença Que Importa
Perceber as duas construções explica quase todas as diferenças práticas entre SHA-256 e SHA-3.
Construção Merkle-Damgård (SHA-256)
SHA-256 processa dados em modo de pipeline linear. A mensagem é dividida em blocos de 512 bits. Cada bloco é combinado com o estado atual de 256 bits através de uma função de compressão, produzindo um novo estado de 256 bits. O digest final é o estado após o último bloco. O resultado de cada bloco alimenta diretamente o próximo, criando uma cadeia que não pode ser paralelizada por bloco.
Esta linearidade tem um efeito colateral: ataques de extensão de comprimento. Se um atacante conhece SHA256(segredo || mensagem) e o comprimento de segredo || mensagem, pode calcular SHA256(segredo || mensagem || dados_adicionais) sem conhecer o segredo. Este comportamento deriva diretamente da exposição do estado interno Merkle-Damgård no digest final.
Construção Keccak Sponge (SHA-3)
SHA-3 usa uma construção totalmente diferente: a esponja. O estado interno tem 1600 bits divididos em duas zonas: bitrate (1088 bits para SHA3-256) e capacidade (512 bits). Durante a fase de absorção, os dados de entrada são processados em blocos do tamanho do bitrate, aplicando a permutação Keccak-f[1600] de 24 rondas a cada iteração. Na fase de extração (squeezing), os bits do digest são retirados do estado.
A capacidade permanece completamente isolada da entrada. Um atacante externo nunca vê os 512 bits de capacidade, o que torna os ataques de extensão de comprimento estruturalmente impossíveis. Para SHA3-256, a segurança de colisão é de 128 bits e a segurança de pré-imagem de 256 bits.
A diferença de tamanho do estado (1600 bits vs 256 bits internamente) também explica parte do custo computacional. Cada permutação Keccak-f[1600] opera sobre uma matriz de 5×5×64 bits, com operações XOR, rotações e transposições. É matematicamente mais elegante, mas mais lento em software sem aceleração dedicada.
Benchmarks de Desempenho: 3 Fontes, Dados Reais
Os benchmarks são a razão pela qual a maioria dos programadores ainda escolhe SHA-256 como padrão. Os dados abaixo vêm de medições publicadas em hardware atual.
| Plataforma | Tamanho da Mensagem | SHA-256 (MB/s) | SHA3-256 (MB/s) | Diferença |
|---|---|---|---|---|
| AMD EPYC 4245P (Zen 5) | 64 bytes | 822 | 246 | 3,3x |
| AMD EPYC 4245P (Zen 5) | 1 MB | 2373 | 686 | 3,4x |
| ARM Graviton 4 (AWS) | 64 KB | 1742 | 508 | 3,4x |
| ARM Graviton 4 (AWS) | 10 MB | 1744 | 510 | 3,4x |
| Intel Skylake (AVX2) | Grande | ~1800 MB/s* | ~475 MB/s* | ~3,8x |
*Estimativa baseada em ciclos/byte publicados pela Wikipedia: SHA3-256 AVX2 reporta 7,8 ciclos/byte num Skylake a 3,5 GHz, equivalente a aproximadamente 449 MB/s.
A razão pela qual SHA-256 é consistentemente 3 a 4 vezes mais rápido resume-se a dois fatores. Primeiro, as CPUs Intel e AMD modernas incluem extensões SHA-NI que aceleram SHA-256 em hardware, reduzindo o custo por bloco. Não existe aceleração SHA-NI equivalente para Keccak em CPUs x86-64 convencionais. Segundo, o tamanho do bloco de absorção do SHA3-256 (1088 bits) exige permutações Keccak-f[1600] mais frequentes para o mesmo volume de dados.
ThePrimeagen, criador de conteúdo conhecido pelas suas análises de desempenho em Rust e C, tem destacado que em sistemas que processam streaming de dados em larga escala, a diferença de throughput de 3x não é académica. Um servidor que valida assinaturas de 100 GB por hora processa 30 GB por hora a menos com SHA-3, o que se traduz diretamente em custos de infraestrutura.
Por outro lado, Fireship, que cobre criptografia aplicada para programadores, nota que para a maioria das aplicações web que processam autenticações individuais ou hashes de passwords, a diferença de velocidade entre SHA-256 e SHA3-256 é literalmente imperceptível. O gargalo está na rede, na base de dados ou na lógica de negócio, não no algoritmo de hash.
Segurança: Onde Cada Algoritmo Ganha
Tanto SHA-256 como SHA-3 são considerados seguros em 2026. Não existem ataques práticos conhecidos contra nenhum dos dois. A comparação de segurança centra-se em propriedades de design que afetam casos de uso específicos.
Resistência a Ataques de Extensão de Comprimento
Esta é a vulnerabilidade mais documentada na construção Merkle-Damgård que afeta SHA-256. O ataque funciona assim: se um sistema usa SHA256(chave_secreta || dados) como mecanismo de autenticação (em vez de HMAC), um atacante que conheça o hash resultante e o comprimento total da mensagem consegue calcular SHA256(chave_secreta || dados || dados_falsos) sem saber a chave.
Este padrão afetou APIs de serviços reais. A API original da Amazon S3 e várias APIs de e-commerce dos anos 2000 usavam construções vulneráveis a este ataque. A solução padrão é usar HMAC-SHA256 em vez de SHA256 diretamente, que elimina a vulnerabilidade pela forma como encadeia a chave. SHA3-256 é imune por design.
Força de Colisão e Pré-Imagem
Ambos os algoritmos oferecem 128 bits de resistência a colisões e 256 bits de resistência a pré-imagem quando usados na variante de 256 bits. Em termos práticos, não existe diferença mensurável de segurança para as aplicações actuais. Nenhum computador existente pode quebrar qualquer um dos dois por força bruta.
O que distingue SHA-3 é a independência estrutural de SHA-2. Se for descoberto um ataque matemático específico à construção Merkle-Damgård que afete SHA-256 e SHA-512, SHA-3 permanece seguro. Isto não é uma ameaça imediata, mas é a razão pela qual o NIST criou um segundo padrão independente.
SHAKE128 e SHAKE256: As Variantes XOF do SHA-3
SHA-3 não é apenas SHA3-256 e SHA3-512. O FIPS 202 também define as funções de saída extensível (XOF), que SHA-256 não tem equivalente.
SHAKE128 e SHAKE256 são funções que produzem tantos bytes de saída quantos forem necessários. Em vez de um digest fixo de 256 bits, pode-se pedir 16 bytes, 64 bytes, ou 1 MB de saída pseudo-aleatória determinística derivada da mesma entrada. Esta propriedade é extremamente útil em:
- Derivação de chaves: gerar múltiplas chaves de comprimentos diferentes a partir de um único segredo
- Hashing com saída variável: sistemas onde o tamanho do digest precisa de ser configurável
- Protocolos pós-quânticos: Kyber e Dilithium (os novos padrões NIST de criptografia pós-quântica) usam SHAKE128 e SHAKE256 internamente
- Geração de números pseudo-aleatórios: onde é necessário um PRNG determinístico de alta qualidade
SHA-256 não tem nada equivalente. Para obter saída variável a partir de SHA-256, é necessário encadear construções como HKDF (HMAC-based Key Derivation Function), que adiciona complexidade. SHA-3 integra esta capacidade no próprio algoritmo, sem dependências externas.
A diferença entre SHAKE128 e SHAKE256 está no nível de segurança: SHAKE128 usa bitrate de 1344 bits com capacidade de 256 bits (128 bits de segurança), enquanto SHAKE256 usa bitrate de 1088 bits com capacidade de 512 bits (256 bits de segurança). SHAKE256 é mais lento mas mais seguro para aplicações sensíveis.
5 Exemplos de Uso Real: Quem Usa Cada Um e Porquê
A teoria fica mais clara com casos concretos. Estes cinco exemplos mostram onde cada algoritmo domina em sistemas de produção.
1. Bitcoin: SHA-256 por Necessidade Estrutural
Bitcoin usa SHA-256 em dois locais críticos: o algoritmo de prova de trabalho (Proof of Work) e o identificador de transações. Cada bloco Bitcoin é validado calculando SHA256(SHA256(cabeçalho_do_bloco)) e verificando se o resultado tem um número suficiente de zeros iniciais. Com 500 exahashes por segundo na rede em 2026, SHA-256 é o algoritmo de hash mais executado do mundo em termos absolutos de volume.
Mudar para SHA-3 quebraria a compatibilidade com todos os ASICs de mineração existentes e toda a infraestrutura de carteiras. A migração seria economicamente impossível, independentemente das propriedades técnicas de SHA-3.
2. Ethereum: Keccak-256, Nem SHA-256 Nem SHA-3
Ethereum usa Keccak-256, que parece SHA-3 mas não é. Vitalik Buterin escolheu Keccak antes de o NIST finalizar o padrão em 2015. O NIST alterou ligeiramente os parâmetros de padding na versão final. O resultado é que Keccak256("mensagem") e SHA3-256("mensagem") produzem resultados diferentes para a mesma entrada. Programadores Ethereum que usam bibliotecas Python com hashlib.sha3_256() cometem um erro que produz hashes errados. A biblioteca correta para Ethereum é pysha3 ou equivalente que implemente o Keccak original.
3. TLS 1.3 e HTTPS: SHA-256 como Padrão de Facto
O protocolo TLS 1.3, que protege a maioria do tráfego HTTPS em 2026, usa SHA-256 na transcrição do handshake, na derivação de chaves com HKDF, e em vários MACs internos. SHA-3 é suportado em teoria, mas a suite de cifras padrão de todos os grandes servidores web (Apache, Nginx, Caddy) usa SHA-256. A razão é compatibilidade universal: SHA-256 está nos módulos criptográficos certificados de todos os clientes TLS, de browsers a IoT.
4. CRYSTALS-Kyber e Dilithium: SHA-3 no Núcleo Pós-Quântico
Os algoritmos pós-quânticos standardizados pelo NIST em 2024 usam SHA-3 internamente. Kyber (ML-KEM), o mecanismo de encapsulamento de chaves, usa SHAKE-256 para derivação de chaves e hashing interno. Dilithium (ML-DSA), o algoritmo de assinatura digital, usa SHAKE256 para geração de desafios e expansão de polinómios. Se a sua organização está a migrar para criptografia pós-quântica, já está a usar SHA-3 indiretamente.
5. Git e Linux: SHA-256 em Transição
Git usava SHA-1 para identificar commits e objetos. Após a colisão SHA-1 demonstrada em 2017 (SHAttered), o projeto migrou para SHA-256 no formato de repositório SHA-256 (git 2.29+). O kernel Linux usa SHA-256 extensivamente para verificação de assinaturas de módulos e integridade do sistema de ficheiros. Nenhum dos dois projetos migrou para SHA-3, principalmente por razões de compatibilidade e desempenho em hardware embarcado.
APIs de Programação: Como Usar SHA-256 e SHA-3
A diferença mais imediata para programadores é a API. Abaixo estão exemplos em Python e Node.js, as duas linguagens mais comuns em aplicações web.
# Python 3.6+ — hashlib suporta ambos nativamente
import hashlib
mensagem = b"shattered.io"
# SHA-256: digest fixo de 32 bytes
h_sha256 = hashlib.sha256(mensagem)
print("SHA-256: ", h_sha256.hexdigest())
# SHA3-256: digest fixo de 32 bytes, API idêntica
h_sha3 = hashlib.sha3_256(mensagem)
print("SHA3-256: ", h_sha3.hexdigest())
# SHAKE-256: saída variável — pedir 32 bytes
h_shake = hashlib.shake_256(mensagem)
print("SHAKE-256 (32 bytes):", h_shake.hexdigest(32))
# SHAKE-128: maior throughput, 128-bit security
h_shake128 = hashlib.shake_128(mensagem)
print("SHAKE-128 (16 bytes):", h_shake128.hexdigest(16))
# ATENÇÃO: hashlib.sha3_256() != Keccak-256 do Ethereum
# Para Ethereum, use: pip install pysha3 e import sha3// Node.js — módulo crypto nativo, sem dependências
const crypto = require('crypto');
const mensagem = 'shattered.io';
// SHA-256
const sha256 = crypto.createHash('sha256')
.update(mensagem, 'utf8')
.digest('hex');
console.log('SHA-256: ', sha256);
// SHA3-256 (disponível desde Node.js 12 com OpenSSL 1.1.0+)
const sha3_256 = crypto.createHash('sha3-256')
.update(mensagem, 'utf8')
.digest('hex');
console.log('SHA3-256: ', sha3_256);
// SHAKE-256 com saída de 32 bytes
const shake256 = crypto.createHash('shake256', { outputLength: 32 })
.update(mensagem, 'utf8')
.digest('hex');
console.log('SHAKE-256: ', shake256);
// Verificar suporte SHA3 na versão do Node
console.log('Hashes disponíveis:', crypto.getHashes().filter(h => h.includes('sha3')));A documentação do módulo crypto do Node.js confirma que SHA3-256, SHA3-384, SHA3-512, SHAKE128 e SHAKE256 estão disponíveis em qualquer versão moderna com OpenSSL 1.1.0 ou superior. Em Python, a biblioteca hashlib suporta toda a família SHA-3 desde Python 3.6 sem dependências externas.
Suporte em Linguagens e Bibliotecas
A tabela de suporte por plataforma é relevante para avaliar o custo de adotar SHA-3 em projetos existentes.
| Plataforma / Biblioteca | SHA-256 | SHA3-256 | SHAKE128/256 | Nota |
|---|---|---|---|---|
| OpenSSL 3.x | Nativo | Nativo (v1.1.0+, 2016) | Nativo | Padrão em todas as distribuições Linux |
| Node.js (módulo crypto) | Nativo | Nativo (v12+) | Nativo | Depende do OpenSSL do sistema |
| Python hashlib | Nativo | Nativo (Python 3.6+) | Nativo | Sem dependências externas |
| Java JCA/JCE | Nativo | Java 9+ (2017) | Java 9+ | MessageDigest.getInstance(“SHA3-256”) |
| Go stdlib | crypto/sha256 | golang.org/x/crypto/sha3 | Pacote x/crypto | Pacote extra, não stdlib principal |
| Rust (ring) | Nativo | Não suportado | Não | ring foca em SHA-2 e BLAKE |
| PHP (hash) | hash(‘sha256’) | hash(‘sha3-256’) PHP 7.1+ | PHP 7.1+ | Extensão hash incluída por padrão |
| Intel SHA-NI (hardware) | Acelerado | Não suportado | Não | Instrução nativa desde Skylake (2016) |
O ponto crítico: Rust com a biblioteca ring não suporta SHA-3. Projetos em Rust que precisam de SHA-3 precisam de adicionar o crate sha3 da RustCrypto. Para Go, SHA-3 está fora da biblioteca padrão, em golang.org/x/crypto, o que significa uma dependência externa adicional. Para Python e Node.js, o suporte é nativo e sem fricção.
Conformidade FIPS: O Que Dizem os Reguladores
Para sistemas que requerem conformidade com normas americanas federais (FIPS), o NIST mantém as duas famílias como padrões aprovados. SHA-256 está em FIPS 180-4 e SHA-3 em FIPS 202. Ambos são válidos para aplicações governamentais americanas certificadas.
Em Portugal, o Regulamento eIDAS 2 e as diretrizes da CNCS (Centro Nacional de Cibersegurança) baseiam-se nos padrões ETSI e BSI, que reconhecem ambos os algoritmos. A diretiva NIS2, implementada em Portugal em 2024, não especifica algoritmos de hash mas remete para as recomendações do ENISA (Agência Europeia para a Cibersegurança), que inclui SHA-256 e SHA-3 nas suas listas de algoritmos aprovados.
Para organizações que precisam de certificação FIPS 140-3, o que importa é que o módulo criptográfico (OpenSSL, BoringSSL, etc.) seja certificado para a operação específica. A maioria dos módulos FIPS 140-3 inclui ambas as famílias. Escolher SHA-256 ou SHA-3 não afeta a certificação desde que o módulo suporte ambos.
Resistência Quântica: O Que Muda com Computação Quântica
A pergunta mais frequente em 2026 é: qual dos dois resiste melhor a computadores quânticos?
A resposta curta: nenhum dos dois é pós-quântico, mas ambos requerem computadores quânticos imensos para serem comprometidos, e SHA-3 não oferece vantagem significativa sobre SHA-256 neste contexto específico.
O algoritmo de Grover reduz a segurança de uma função hash de n bits para n/2 bits de segurança efectiva contra ataques de força bruta em computadores quânticos. Para SHA-256 e SHA3-256, ambos com 256 bits, o ataque de Grover requer 2^128 operações quânticas. Para a pré-imagem (encontrar a mensagem original), a complexidade é 2^128 em computadores quânticos, o que ainda é astronomicamente grande.
O NIST estima que computadores quânticos suficientemente poderosos para ameaçar SHA-256 ou SHA3-256 não existirão antes de 2040 na melhor das hipóteses. A prioridade pós-quântica em 2026 está nas assinaturas digitais (RSA, ECDSA) e no estabelecimento de chaves (Diffie-Hellman, ECDH), que são vulneráveis ao algoritmo de Shor muito antes dos hashes serem comprometidos.
Para saída quântica-segura de hashes, a recomendação é usar SHA-512 ou SHA3-512 (512 bits de saída = 256 bits de segurança quântica efetiva via Grover), em vez de trocar de algoritmo. SHA-3 oferece uma vantagem aqui: SHAKE256 pode produzir qualquer número de bytes, permitindo especificar saídas de 512 bits ou maiores sem mudar de algoritmo.
Opiniões de Especialistas: A Comunidade Dividida
A comunidade criptográfica e de desenvolvimento não tem consenso absoluto sobre qual algoritmo preferir para novos projectos.
Joan Daemen, co-designer do Keccak e co-autor do AES (Rijndael), argumentou consistentemente que a diversidade de design entre SHA-2 e SHA-3 é uma propriedade de segurança por si só. Em entrevistas técnicas, Daemen sublinha que um ecossistema criptográfico que depende exclusivamente de uma única construção (Merkle-Damgård) é mais frágil do que um que distribui confiança entre duas arquiteturas independentes.
Bruce Schneier, criptógrafo e autor de “Applied Cryptography”, tem repetidamente recomendado que sistemas novos considerem SHA-3 precisamente porque evita a dependência total em SHA-2. No entanto, Schneier também reconhece que SHA-256 com HMAC é suficiente para a maioria das aplicações actuais e que a pressão de compatibilidade é uma consideração legítima.
Na comunidade de programadores, ThePrimeagen e outros criadores de conteúdo focados em sistemas de alto desempenho tendem a privilegiar SHA-256 quando velocidade é crítica, apontando para os benchmarks de 3,4x como argumento definitivo para sistemas que processam gigabytes por segundo. A posição é pragmática: se o teu sistema é limitado pelo throughput de hash, SHA-256 é a escolha certa.
Fireship, no seu estilo característico de resumos rápidos para programadores, tem posicionado SHA-3 como “o futuro mas não o presente” no contexto web, dado que a maioria dos frameworks e protocolos está construída sobre SHA-256 e a migração requer esforço real sem benefício imediato óbvio para aplicações standard.
O consenso mais equilibrado vem de organizações como o IETF: SHA-256 para compatibilidade e desempenho em sistemas existentes, SHA-3 e SHAKE para novos sistemas onde as propriedades XOF ou a independência estrutural justificam o custo de adoção.
Guia de Migração: De SHA-256 para SHA-3
Se decidir migrar de SHA-256 para SHA-3 num sistema existente, há considerações práticas que determinam o nível de dificuldade.
Cenário 1: Hashing de Conteúdo Sem Estado
Se o sistema usa SHA-256 apenas para gerar checksums de ficheiros ou verificar integridade sem persistência de longo prazo, a migração é trivial. Substituir sha256() por sha3_256() na biblioteca e actualizar os hashes armazenados. O único custo é regenerar todos os hashes existentes.
Passos:
- Adicionar suporte a SHA3-256 na biblioteca criptográfica (geralmente zero custo em Python/Node.js)
- Implementar função que aceita ambos os algoritmos durante o período de transição
- Reger todos os hashes existentes com SHA3-256 num processo batch
- Remover suporte a SHA-256 após confirmação de integridade
Cenário 2: Hashes em Protocolos de Rede
Se SHA-256 está incorporado num protocolo de comunicação (como identificadores de mensagens ou checksums em APIs), a migração requer coordenação entre clientes e servidores. A abordagem recomendada é versionar o protocolo: hash_v2 com SHA3-256 em paralelo com o hash_v1 SHA-256, com período de suporte duplo de pelo menos 6 meses.
Cenário 3: Hashing de Passwords
SHA-256 nunca deveria ser usado directamente para hashing de passwords (sem bcrypt, Argon2 ou PBKDF2). Se o sistema actual usa SHA256(password + salt), o problema não é o algoritmo de hash mas a ausência de função de derivação lenta. A migração correta é para Argon2id ou bcrypt, independentemente do algoritmo de hash subjacente. SHA-3 não resolve o problema de passwords sem derivação lenta.
Compatibilidade com Ethereum
Atenção especial: se migrar de SHA-256 para SHA-3 em contexto blockchain compatível com Ethereum, use Keccak-256 (não SHA3-256 padrão). As bibliotecas corretas são eth-hash em Python e ethereumjs-util em JavaScript. Usar hashlib.sha3_256() em código Ethereum produz resultados errados silenciosamente.
Prós e Contras: Resumo Direto
| SHA-256 | SHA3-256 | |
|---|---|---|
| Velocidade em software | 2373 MB/s (3,4x mais rápido) | 686 MB/s |
| Aceleração hardware | SHA-NI nativo em Intel/AMD | Sem aceleração dedicada |
| Compatibilidade | Universal (TLS, Bitcoin, Git, Linux) | Crescente, não universal |
| Resistência extensão de comprimento | Vulnerável (mitigar com HMAC) | Imune por design |
| Variantes XOF | Não disponível | SHAKE128, SHAKE256 |
| Independência estrutural de SHA-2 | Não (mesma família) | Sim (sponge vs Merkle-Damgård) |
| Suporte em criptografia pós-quântica | Indireto (via HKDF) | Nativo (Kyber, Dilithium) |
| Maturidade e auditorias | 25 anos, extensivamente auditado | 11 anos, menor histórico |
| Suporte em IoT/embarcado | Excelente (mais leve) | Limitado (maior estado interno) |
5 Recomendações por Caso de Uso
Com os dados na mão, aqui estão recomendações claras para os cenários mais comuns.
- Aplicações web e APIs: use SHA-256 com HMAC. É mais rápido, universalmente suportado, e HMAC elimina a vulnerabilidade de extensão de comprimento. SHA3-256 não oferece vantagem prática aqui para a maioria dos casos.
- Sistemas financeiros com conformidade regulatória: avalie SHA3-256 se o regulador exigir FIPS 202 especificamente. Caso contrário, SHA-256 com FIPS 180-4 é suficiente e mais simples de certificar com módulos já aprovados.
- Criptografia pós-quântica: SHA-3 e SHAKE. Kyber e Dilithium já usam SHAKE internamente. Se está a implementar estes algoritmos, está a usar SHA-3 de qualquer forma.
- Derivação de chaves com saída variável: SHAKE256. Mais eficiente do que encadear HMAC-SHA256 em esquemas HKDF complexos, e com output configurável sem dependências externas.
- Sistemas embarcados ou IoT com recursos limitados: SHA-256. O estado interno menor (256 bits vs 1600 bits do Keccak) e a aceleração disponível em muitos microcontroladores modernos tornam SHA-256 a escolha mais eficiente em memória e CPU.
Veredicto: Qual Algoritmo Escolher em 2026
SHA-256 ganha em velocidade (3,4x), compatibilidade universal, e maturidade. SHA-3 ganha em design independente, resistência a extensão de comprimento, e variantes XOF.
A decisão prática para 2026:
Escolha SHA-256 se: o sistema processa grandes volumes de dados e cada MB/s conta; a compatibilidade com sistemas existentes é crítica (TLS, Bitcoin, Git); está a trabalhar em IoT ou sistemas embarcados com memória limitada; ou se está a manter código legado e a migração não tem ROI claro.
Escolha SHA-3 se: está a construir um sistema novo sem restrições de compatibilidade retroativa; precisa de saída de comprimento variável (SHAKE128/SHAKE256); está a implementar criptografia pós-quântica baseada em Kyber ou Dilithium; quer eliminar preocupações de extensão de comprimento por design sem depender de HMAC; ou se o cliente ou regulador exige explicitamente FIPS 202.
Para a maioria dos programadores em Portugal que desenvolvem aplicações web, APIs REST, e sistemas de autenticação, SHA-256 com HMAC continua a ser a escolha certa em 2026. A lacuna de desempenho de 3,4x é real e relevante em escala. SHA-3 é excelente, mas o seu momento de adopção massiva virá com a expansão da criptografia pós-quântica, não hoje.
Cobertura Relacionada
Para aprofundar o tema de funções de hash e criptografia:
- SHA-256 Explicado: Como Funciona e Por Que É Importante
- Funções de Hash Criptográfico: Guia Completo
- A Colisão SHA-1 SHAttered, Explicada
- HMAC-SHA256 em Node.js: 10 Passos, 20 Min [2026]
- Encriptação Simétrica vs Assimétrica: Diferença de 1000x [2026]
- Criptografia Pós-Quântica: 50% da Web Já Protegida [2026]
- Hashing e Criptografia: Guia de Referência
Perguntas Frequentes
SHA-256 é mais seguro do que SHA-3?
Não. Ambos oferecem 128 bits de resistência a colisões e 256 bits de resistência a pré-imagem. Não existem ataques práticos contra nenhum dos dois em 2026. SHA-3 tem vantagem em resistência a extensão de comprimento por design, mas em termos de força bruta são equivalentes.
Posso substituir SHA-256 por SHA-3 diretamente no meu código?
Sim, a nível de API em Python e Node.js a troca é de uma linha. O que muda é o valor do hash produzido: SHA-256 e SHA3-256 produzem hashes completamente diferentes para a mesma entrada. Se tem hashes SHA-256 armazenados numa base de dados, precisa de os regenerar com SHA3-256. Em protocolos de rede, ambas as extremidades têm de concordar no algoritmo.
Keccak-256 do Ethereum é o mesmo que SHA3-256?
Não. Ethereum usa Keccak-256 com o padding original da competição NIST, antes do NIST alterar o padding na versão final padronizada como FIPS 202. Keccak256("abc") e SHA3-256("abc") produzem resultados diferentes. Para código Ethereum, use bibliotecas específicas como pysha3, não hashlib.sha3_256().
SHA-3 é mais rápido que SHA-256 em hardware?
Em hardware dedicado (ASICs e FPGAs), SHA-3 pode ser competitive ou até mais eficiente do que SHA-256, porque a construção Keccak paraleliza bem em circuitos. Em CPUs convencionais, SHA-256 é 3 a 4 vezes mais rápido graças às instruções SHA-NI. Em IoT e microcontroladores sem aceleração dedicada, SHA-256 continua geralmente mais rápido por ter menor estado interno.
Devo usar SHA-3 para hashing de passwords?
Não. Nem SHA-256 nem SHA-3 são adequados para hashing de passwords directamente. Para passwords, use Argon2id (recomendação OWASP 2026), bcrypt, ou scrypt. Estas funções são deliberadamente lentas para dificultar ataques de força bruta, o que SHA-3 não é por design.
SHA-3 vai substituir SHA-256 nos próximos anos?
Provavelmente não por substituição directa, mas por adoção incremental. SHA-256 está demasiado incorporado em protocolos críticos (TLS, Bitcoin, assinaturas digitais de software) para uma migração rápida. SHA-3 vai ganhar quota à medida que a criptografia pós-quântica se expande, já que Kyber e Dilithium dependem de SHAKE. Os dois algoritmos coexistirão por décadas.
Qual é a diferença entre SHA3-256 e SHAKE256?
SHA3-256 produz sempre um digest de exatamente 256 bits. SHAKE256 produz tantos bytes quantos forem pedidos, a qualquer comprimento. Internamente, ambos usam Keccak-f[1600], mas com parâmetros de bitrate/capacidade ligeiramente diferentes. Use SHA3-256 quando precisa de um hash de comprimento fixo (como SHA-256). Use SHAKE256 quando precisa de derivar chaves ou gerar saídas de comprimento variável.
HMAC-SHA256 ainda é seguro em 2026?
Sim. HMAC-SHA256 elimina a vulnerabilidade de extensão de comprimento do SHA-256 e não tem ataques conhecidos. É o padrão em TLS 1.3, JWT (HMAC), e a maioria dos sistemas de autenticação de APIs. Para novos sistemas sem restrições de compatibilidade, HMAC-SHA256 e HMAC-SHA3-256 têm segurança equivalente; SHA-256 continua mais rápido.
