Gerador de Hash SHA-256

O que é o SHA-256?

SHA-256 (Secure Hash Algorithm 256-bit) é uma função de hash criptográfico da família SHA-2, publicada pelo NIST em 2001 como parte do FIPS 180-2 (atualizado no FIPS 180-4). Para qualquer entrada — um único caractere, um arquivo de vários gigabytes ou uma string vazia — o SHA-256 produz um resumo fixo de 256 bits (32 bytes), convencionalmente exibido como 64 caracteres hexadecimais. O SHA-256 é a função de hash mais amplamente implantada em sistemas de produção atualmente, sustentando cadeias de certificados TLS, a prova de trabalho do Bitcoin, a Subresource Integrity (SRI) e fluxos de assinatura de código.

O SHA-256 é uma função unidirecional: calcular um hash a partir de uma entrada é rápido (centenas de megabytes por segundo em hardware moderno), mas reverter o processo — encontrar uma entrada que produza um determinado hash — é computacionalmente inviável. Essa propriedade, chamada de resistência a pré-imagem, torna o SHA-256 adequado para hash de senhas (quando combinado com um salt e derivação de chave), assinaturas digitais e verificação de integridade de dados. Ao contrário do MD5 e do SHA-1, nenhum ataque de colisão ou pré-imagem foi demonstrado contra o SHA-256 completo.

A família SHA-2 inclui seis variantes: SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224 e SHA-512/256. O SHA-256 opera com palavras de 32 bits e 64 rodadas por bloco, otimizado para processadores de 32 bits. O SHA-512 usa palavras de 64 bits e 80 rodadas, podendo ser mais rápido em plataformas de 64 bits. Para a maioria das aplicações onde um resumo de 256 bits é suficiente, o SHA-256 permanece a recomendação padrão do NIST, IETF e do CA/Browser Forum.

Por que usar um gerador SHA-256 online?

Gerar um hash SHA-256 normalmente requer um comando de terminal ou algumas linhas de código. Esta ferramenta no navegador permite calcular resumos SHA-256 sem instalar nada, sem trocar de contexto ou escrever um script.

Casos de uso do SHA-256

Comparação das variantes da família SHA-2

O SHA-256 pertence à família SHA-2 definida no FIPS 180-4. Cada variante equilibra tamanho do resumo, características de desempenho e margem de segurança. A tabela abaixo compara todas as variantes SHA-2 que você provavelmente encontrará.

SHA-256 vs SHA-1, MD5 e SHA-3

A escolha do algoritmo de hash correto depende dos seus requisitos de segurança e restrições de compatibilidade. O SHA-256 ocupa o ponto ideal na prática: é seguro, universalmente suportado (incluindo a Web Crypto API) e rápido o suficiente para a maioria das cargas de trabalho. A tabela de comparação abaixo abrange as propriedades mais relevantes na escolha de uma função de hash.

Como o SHA-256 funciona internamente

O SHA-256 processa a entrada em blocos de 512 bits (64 bytes) por meio de uma construção de Merkle–Damgård. O algoritmo inicializa oito palavras de estado de 32 bits (H0–H7) derivadas das partes fracionárias das raízes quadradas dos oito primeiros números primos. Cada bloco passa por 64 rodadas de mistura que utilizam operações bit a bit (AND, XOR, NOT, rotação à direita, deslocamento à direita) e 64 constantes de rodada derivadas das raízes cúbicas dos primeiros 64 números primos.

O efeito avalanche garante que inverter um único bit na entrada altera aproximadamente 50% dos bits da saída. Essa propriedade, combinada com a resistência a colisões de 2^128, é o motivo pelo qual o SHA-256 permanece a recomendação de referência para aplicações sensíveis à segurança em 2026.

Exemplos de código SHA-256

O SHA-256 está disponível nativamente em todas as principais linguagens e runtimes. A Web Crypto API o fornece nos navegadores sem necessidade de biblioteca. Os exemplos abaixo mostram padrões de uso reais, incluindo tratamento de entrada Unicode e hash de arquivos.

// Works in all modern browsers and Node.js 18+
async function sha256(text) {
  const data = new TextEncoder().encode(text)
  const hashBuffer = await crypto.subtle.digest('SHA-256', data)
  const hashArray = Array.from(new Uint8Array(hashBuffer))
  return hashArray.map(b => b.toString(16).padStart(2, '0')).join('')
}

await sha256('hello world')
// → "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"

// Node.js (built-in crypto module)
const crypto = require('crypto')
crypto.createHash('sha256').update('hello world').digest('hex')
// → "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"

import hashlib

# Basic SHA-256 hash
result = hashlib.sha256(b'hello world').hexdigest()
print(result)  # → "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"

# Hash a string (encode to bytes first)
text = 'café ☕'
hashlib.sha256(text.encode('utf-8')).hexdigest()
# → "3eb53e00aa1bb4b1e8aab1ab38e56e6b8fb0b20e1cf7e1d19f36e4fad2537445"

# Hash a file in chunks (memory-efficient)
with open('release.tar.gz', 'rb') as f:
    sha = hashlib.sha256()
    for chunk in iter(lambda: f.read(8192), b''):
        sha.update(chunk)
    print(sha.hexdigest())

package main

import (
    "crypto/sha256"
    "fmt"
)

func main() {
    data := []byte("hello world")
    hash := sha256.Sum256(data)
    fmt.Printf("%x\n", hash)
    // → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
}

# Using sha256sum (Linux) or shasum (macOS)
echo -n "hello world" | sha256sum
# → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9  -

# macOS
echo -n "hello world" | shasum -a 256
# → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9  -

# Verify a file checksum
echo "b94d27b...  myfile.bin" | sha256sum -c
# → myfile.bin: OK

# Using openssl (cross-platform)
echo -n "hello world" | openssl dgst -sha256
# → SHA2-256(stdin)= b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9

Perguntas frequentes