Generator Hasha SHA-384

Czym jest haszowanie SHA-384?

SHA-384 to kryptograficzna funkcja skrótu zdefiniowana w NIST FIPS 180-4 jako część rodziny SHA-2. Przyjmuje dane wejściowe o dowolnej długości i produkuje stały 384-bitowy (48-bajtowy) skrót wiadomości, konwencjonalnie przedstawiany jako 96-znakowy ciąg szesnastkowy. SHA-384 jest szeroko stosowany w zestawach szyfrów TLS, podpisach cyfrowych certyfikatów oraz systemach rządowych wymagających większego marginesu odporności na kolizje niż oferuje SHA-256.

Wewnętrznie SHA-384 jest skróconą odmianą SHA-512. Używa tego samego 1024-bitowego rozmiaru bloku, 80 rund kompresji i 64-bitowej arytmetyki słów co SHA-512, ale rozpoczyna z innym zestawem początkowych wartości skrótu (wyprowadzonych z 9. do 16. liczby pierwszej) i zwraca tylko pierwsze 384 bity stanu końcowego. To skrócenie oznacza, że SHA-384 produkuje inny skrót niż SHA-512 dla identycznych danych wejściowych, mimo że oba algorytmy dzielą ten sam rdzeń.

Ponieważ SHA-384 operuje na 64-bitowych słowach, działa szybciej niż SHA-256 na nowoczesnych procesorach 64-bitowych, jednocześnie dostarczając większy skrót. Stanowi praktyczny punkt środkowy: silniejszy niż SHA-256 (192-bitowa odporność na kolizje wobec 128-bitowej) bez narzutu pamięciowego związanego z 128-znakowym wyjściem hex SHA-512. SHA-384 jest domyślnym hashem dla podpisów weryfikacyjnych certyfikatów TLS 1.3 i jest wymagany przez NSA Suite B (obecnie CNSA) do danych TOP SECRET.

Po co używać generatora SHA-384 online?

Generowanie skrótów SHA-384 zazwyczaj wymaga polecenia w terminalu lub napisania kodu. To narzędzie działające w przeglądarce pozwala obliczać skróty SHA-384 natychmiast — bez instalowania czegokolwiek ani przesyłania danych na serwer. Niezależnie od tego, czy potrzebujesz wygenerować hash SRI dla zasobu CDN, zweryfikować sumę kontrolną pliku, czy porównać wynik SHA-384 z SHA-256 dla tych samych danych wejściowych, to narzędzie daje Ci natychmiastowy, bezzależnościowy dostęp do skrótów SHA-384 w każdej nowoczesnej przeglądarce.

Zastosowania generatora SHA-384

Porównanie wariantów rodziny SHA-2

SHA-384 należy do rodziny SHA-2 obok kilku innych wariantów. Poniższa tabela pokazuje, czym różnią się pod względem rozmiaru skrótu, długości wyjścia i typowych zastosowań.

SHA-384 kontra SHA-256 kontra SHA-512 kontra SHA-3-384

Wybór między SHA-384 a innymi algorytmami skrótu zależy od wymagań bezpieczeństwa, ograniczeń platformy i potrzeb wydajnościowych. To porównanie obejmuje najistotniejsze właściwości.

Jak SHA-384 działa wewnętrznie?

SHA-384 przetwarza dane wejściowe przez tę samą konstrukcję Merkle–Damgård co SHA-512. Dane wejściowe są dopełniane do wielokrotności 1024 bitów, dzielone na bloki, a każdy blok jest przetwarzany przez 80 rund mieszania z użyciem funkcji Ch, Maj i dwóch funkcji Sigma z 64-bitową arytmetyką słów. Kluczowa różnica w stosunku do SHA-512 tkwi w początkowych wartościach skrótu: SHA-384 używa wartości wyprowadzonych z części ułamkowych pierwiastków kwadratowych z 9. do 16. liczby pierwszej, podczas gdy SHA-512 używa pierwszych 8 liczb pierwszych. Po przetworzeniu wszystkich bloków SHA-384 skraca 512-bitowy stan wewnętrzny do pierwszych 384 bitów.

Skrócenie i różna inicjalizacja oznaczają, że SHA-384 i SHA-512 zawsze produkują różne skróty dla tych samych danych wejściowych. Sprawia to również, że SHA-384 jest z natury odporny na ataki rozszerzenia długości (length-extension attacks), w odróżnieniu od SHA-256 i SHA-512, gdzie atakujący może dołączyć dane i obliczyć prawidłowy hash bez znajomości oryginalnej wiadomości.

Przykłady kodu SHA-384

SHA-384 jest obsługiwany natywnie we wszystkich głównych językach programowania i środowiskach uruchomieniowych. Poniżej znajdziesz działające przykłady, które możesz skopiować bezpośrednio do swoich projektów.

// 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

Najczęściej zadawane pytania