SHA-384 Hash Generator

Vad är SHA-384-hashning?

SHA-384 är en kryptografisk hashfunktion definierad i NIST FIPS 180-4 som en del av SHA-2-familjen. Den tar emot indata av godtycklig längd och producerar ett fast 384-bitars (48-byte) meddelandesammandrag, som vanligtvis visas som en 96-tecken lång hexadecimal sträng. SHA-384 används allmänt i TLS-krypteringssviter, digitala certifikatsignaturer och myndighetsystem som kräver en högre kollisionsresistansmarginal än vad SHA-256 erbjuder.

Internt är SHA-384 en trunkerad variant av SHA-512. Den använder samma 1024-bitars blockstorlek, 80 kompressionsrundor och 64-bitars ordaritmetik som SHA-512, men startar med en annan uppsättning initiala hashvärden (härledda från de 9:e till 16:e primtalen) och returnerar enbart de första 384 bitarna av sluttillståndet. Denna trunkering innebär att SHA-384 producerar ett annat sammandrag än SHA-512 för identiska indata, trots att de delar samma grundläggande algoritm.

Eftersom SHA-384 arbetar med 64-bitars ord körs det snabbare än SHA-256 på moderna 64-bitarsprocessorer och ger samtidigt ett större sammandrag. Det gör det till ett praktiskt mellanalternativ: starkare än SHA-256 (192-bitars kollisionsresistans mot 128-bitars) utan lagringsbelastningen av SHA-512:s 128-tecken långa hex-utdata. SHA-384 är standardhashfunktionen för TLS 1.3:s certifikatverifieringssignaturer och krävs av NSA Suite B (numera CNSA) för HEMLIG data på högsta nivå.

Varför använda en SHA-384-generator online?

Att generera SHA-384-hashvärden kräver normalt ett terminalkommando eller att man skriver kod. Det här webbläsarbaserade verktyget låter dig beräkna SHA-384-sammandrag direkt utan att installera något eller skicka data till en server. Oavsett om du behöver generera ett SRI-hashvärde för en CDN-tillgång, verifiera en filkontrollsumma eller jämföra SHA-384-utdata mot SHA-256 för samma indata, ger det här verktyget dig ett omedelbart, beroendefritt sätt att arbeta med SHA-384-sammandrag i alla moderna webbläsare.

Användningsfall för SHA-384-hashgeneratorn

Jämförelse av SHA-2-familjens varianter

SHA-384 tillhör SHA-2-familjen tillsammans med flera andra varianter. Tabellen nedan visar hur de skiljer sig åt i sammandragens storlek, utdatalängd och typiska användningsområden.

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

Valet mellan SHA-384 och andra hashalgoritmer beror på dina säkerhetskrav, plattformsbegränsningar och prestandabehov. Den här jämförelsen täcker de mest relevanta egenskaperna.

Hur SHA-384 fungerar internt

SHA-384 bearbetar indata via samma Merkle–Damgård-konstruktion som SHA-512. Indatan fylls ut till en multipel av 1024 bitar, delas upp i block och varje block bearbetas genom 80 blandningsrundor med funktionerna Ch, Maj och två Sigma-funktioner med 64-bitars ordaritmetik. Den avgörande skillnaden från SHA-512 är de initiala hashvärdena: SHA-384 använder värden härledda från bråkdelarna av kvadratrötterna av de 9:e till 16:e primtalen, medan SHA-512 använder de första 8 primtalen. När alla block har bearbetats trunkerar SHA-384 det 512-bitars interna tillståndet till de första 384 bitarna.

Trunkering och olika initialisering innebär att SHA-384 och SHA-512 alltid producerar olika sammandrag för samma indata. Det gör också SHA-384 naturligt resistent mot längdutvidgningsattacker, till skillnad från SHA-256 och SHA-512 där en angripare kan lägga till data och beräkna ett giltigt hashvärde utan att känna till det ursprungliga meddelandet.

SHA-384 kodexempel

SHA-384 finns inbyggt i alla större språk och körtidsmiljöer. Nedan finns fungerande exempel som du kan kopiera direkt till dina projekt.

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

Vanliga frågor