Gerador de Hash SHA-384

O que é o Hashing SHA-384?

SHA-384 é uma função de hash criptográfico definida no NIST FIPS 180-4 como parte da família SHA-2. Ela aceita uma entrada de comprimento arbitrário e produz um resumo de mensagem fixo de 384 bits (48 bytes), normalmente exibido como uma string hexadecimal de 96 caracteres. O SHA-384 é amplamente utilizado em conjuntos de cifras TLS, assinaturas de certificados digitais e sistemas governamentais que exigem uma margem de resistência a colisões maior do que a oferecida pelo SHA-256.

Internamente, o SHA-384 é uma variante truncada do SHA-512. Ele usa o mesmo tamanho de bloco de 1024 bits, 80 rodadas de compressão e aritmética de palavras de 64 bits do SHA-512, mas começa com um conjunto diferente de valores de hash iniciais (derivados do 9º ao 16º números primos) e gera apenas os primeiros 384 bits do estado final. Esse truncamento faz com que o SHA-384 produza um resumo diferente do SHA-512 para entradas idênticas, apesar de compartilharem o mesmo algoritmo central.

Como o SHA-384 opera com palavras de 64 bits, ele é mais rápido que o SHA-256 em processadores modernos de 64 bits, ao mesmo tempo em que entrega um resumo maior. Isso o torna um meio-termo prático: mais forte que o SHA-256 (192 bits de resistência a colisões vs. 128 bits) sem o custo de armazenamento da saída hex de 128 caracteres do SHA-512. O SHA-384 é o hash padrão para assinaturas de verificação de certificados no TLS 1.3 e é exigido pelo NSA Suite B (agora CNSA) para dados TOP SECRET.

Por que usar um gerador SHA-384 online?

Gerar hashes SHA-384 normalmente requer um comando de terminal ou a escrita de código. Esta ferramenta no navegador permite calcular resumos SHA-384 instantaneamente sem instalar nada nem enviar dados a um servidor. Seja para gerar um hash SRI para um recurso de CDN, verificar o checksum de um arquivo ou comparar a saída do SHA-384 com a do SHA-256 para a mesma entrada, esta ferramenta oferece uma forma imediata e sem dependências de trabalhar com resumos SHA-384 em qualquer navegador moderno.

Casos de uso do Gerador de Hash SHA-384

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

O SHA-384 pertence à família SHA-2 junto com diversas outras variantes. A tabela abaixo mostra como elas diferem em tamanho de resumo, comprimento de saída e aplicações típicas.

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

A escolha entre o SHA-384 e outros algoritmos de hash depende dos seus requisitos de segurança, restrições de plataforma e necessidades de desempenho. Esta comparação abrange as propriedades mais relevantes.

Como o SHA-384 Funciona Internamente

O SHA-384 processa a entrada por meio da mesma construção de Merkle–Damgård do SHA-512. A entrada é preenchida até ser um múltiplo de 1024 bits, dividida em blocos, e cada bloco é processado por 80 rodadas de mistura usando as funções Ch, Maj e duas funções Sigma com aritmética de palavras de 64 bits. A principal diferença em relação ao SHA-512 está nos valores de hash iniciais: o SHA-384 usa valores derivados das partes fracionárias das raízes quadradas do 9º ao 16º número primo, enquanto o SHA-512 usa os 8 primeiros primos. Após o processamento de todos os blocos, o SHA-384 trunca o estado interno de 512 bits para seus primeiros 384 bits.

O truncamento e a inicialização diferente fazem com que o SHA-384 e o SHA-512 produzam sempre resumos diferentes para a mesma entrada. Isso também torna o SHA-384 inerentemente resistente a ataques de extensão de comprimento, ao contrário do SHA-256 e do SHA-512, onde um atacante pode acrescentar dados e calcular um hash válido sem conhecer a mensagem original.

Exemplos de Código SHA-384

O SHA-384 é suportado nativamente em todas as principais linguagens e runtimes. Abaixo estão exemplos funcionais que você pode copiar diretamente para seus projetos.

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

await sha384('hello world')
// → "fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd"

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

import hashlib

# Basic SHA-384 hash
result = hashlib.sha384(b'hello world').hexdigest()
print(result)
# → "fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd"

# Hash a string with Unicode characters
text = 'café ☕'
hashlib.sha384(text.encode('utf-8')).hexdigest()
# → 96-character hex string

# Hash a file in chunks (memory-efficient)
with open('release.tar.gz', 'rb') as f:
    sha = hashlib.sha384()
    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")
    // SHA-384 lives in the crypto/sha512 package
    hash := sha512.Sum384(data)
    fmt.Printf("%x\n", hash)
    // → fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd
}

# Using sha384sum (Linux)
echo -n "hello world" | sha384sum
# → fdbd8e75a67f29f701a4e040385e2e23...  -

# macOS
echo -n "hello world" | shasum -a 384
# → fdbd8e75a67f29f701a4e040385e2e23...  -

# Using openssl (cross-platform)
echo -n "hello world" | openssl dgst -sha384
# → SHA2-384(stdin)= fdbd8e75a67f29f701a4e040385e2e23986303ea...

# Verify a file checksum
sha384sum myfile.bin > checksum.txt
sha384sum -c checksum.txt
# → myfile.bin: OK

Perguntas Frequentes