Gerador de Hash SHA-512

O que é o Hashing SHA-512?

SHA-512 é uma função de hash criptográfico definida no NIST FIPS 180-4 como o maior membro da família SHA-2. Ela aceita uma entrada de comprimento arbitrário e produz um resumo de mensagem fixo de 512 bits (64 bytes), exibido como uma string hexadecimal de 128 caracteres. O SHA-512 é usado em assinaturas digitais (Ed25519 utiliza SHA-512 internamente), construções HMAC, verificação de integridade de arquivos e protocolos criptográficos que se beneficiam de uma ampla margem de segurança.

O SHA-512 opera em blocos de 1024 bits (128 bytes) usando aritmética de palavras de 64 bits e 80 rodadas de compressão. Seus oito valores de hash iniciais são derivados das partes fracionárias das raízes quadradas dos oito primeiros números primos, e suas 80 constantes de rodada vêm das raízes cúbicas dos primeiros 80 primos. Por usar operações nativas de 64 bits, o SHA-512 costuma ser mais rápido que o SHA-256 em processadores modernos de 64 bits, apesar de produzir um resumo maior.

SHA-384, SHA-512/224 e SHA-512/256 são variantes truncadas do SHA-512 que compartilham a mesma estrutura interna, mas usam valores de hash iniciais diferentes e produzem menos bits. Quando você precisa do maior comprimento de resumo que a família SHA-2 oferece, ou quando um protocolo exige especificamente o SHA-512 (como Ed25519 ou certos esquemas de derivação de chave baseados em HMAC), o SHA-512 é a escolha correta. Ele fornece 256 bits de resistência a colisões, equivalente ao SHA-3-512 e muito superior ao limite de 128 bits do SHA-256.

Por que usar um gerador SHA-512 online?

Calcular um hash SHA-512 normalmente requer um comando de terminal ou algumas linhas de código. Esta ferramenta no navegador permite gerar resumos SHA-512 instantaneamente sem instalar nenhum software, abrir um terminal ou escrever scripts descartáveis.

Casos de Uso do Gerador de Hash SHA-512

Comparação das Variantes da Família SHA-2

O SHA-512 pertence à família SHA-2 definida no FIPS 180-4. A tabela abaixo compara as variantes SHA-2 que compartilham a arquitetura interna de 64 bits do SHA-512, junto com o SHA-256 para referência.

SHA-512 vs SHA-256 vs SHA-384 vs SHA-3-512

O algoritmo de hash correto depende dos seus requisitos de segurança, restrições de desempenho e especificações de protocolo. O SHA-512 oferece o maior resumo na família SHA-2 e costuma ser mais rápido que o SHA-256 em hardware de 64 bits. Esta comparação abrange as propriedades mais relevantes na escolha entre eles.

Como o SHA-512 Funciona Internamente

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

O tamanho de palavra de 64 bits é o principal diferencial em relação ao SHA-256. Em CPUs de 64 bits, cada operação processa o dobro de bits por ciclo, o que explica por que o SHA-512 frequentemente supera o SHA-256 em benchmarks apesar de executar 80 rodadas em vez de 64. O efeito avalanche garante que inverter um único bit de entrada altere aproximadamente 50% de todos os 512 bits de saída.

Exemplos de Código SHA-512

O SHA-512 é suportado nativamente em todas as principais linguagens e runtimes. A Web Crypto API o disponibiliza nos navegadores sem nenhuma biblioteca. Os exemplos abaixo cobrem padrões comuns, incluindo tratamento de Unicode e hashing de arquivos.

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

await sha512('hello world')
// → "309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f"

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

import hashlib

# Basic SHA-512 hash
result = hashlib.sha512(b'hello world').hexdigest()
print(result)
# → "309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee..."

# Hash a string with Unicode (encode to bytes first)
text = 'café ☕'
hashlib.sha512(text.encode('utf-8')).hexdigest()
# → 128-character hex string

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

package main

import (
    "crypto/sha512"
    "fmt"
)

func main() {
    data := []byte("hello world")
    hash := sha512.Sum512(data)
    fmt.Printf("%x\n", hash)
    // → 309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f...
}

# Using sha512sum (Linux) or shasum (macOS)
echo -n "hello world" | sha512sum
# → 309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee...  -

# macOS
echo -n "hello world" | shasum -a 512
# → 309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee...  -

# Verify a file checksum
echo "309ecc48...  myfile.bin" | sha512sum -c
# → myfile.bin: OK

# Using openssl (cross-platform)
echo -n "hello world" | openssl dgst -sha512
# → SHA2-512(stdin)= 309ecc489c12d6eb4cc40f50c902f2b4...

Perguntas Frequentes