SHA-512 Hash Generator

Vad är SHA-512-hashning?

SHA-512 är en kryptografisk hashfunktion definierad i NIST FIPS 180-4 som den största medlemmen i SHA-2-familjen. Den tar emot indata av godtycklig längd och producerar ett fast 512-bitars (64-byte) meddelandesammandrag, som visas som en 128 tecken lång hexadecimal sträng. SHA-512 används i digitala signaturer (Ed25519 förlitar sig internt på SHA-512), HMAC-konstruktioner, verifiering av filintegritet och kryptografiska protokoll som drar nytta av en bred säkerhetsmarginal.

SHA-512 arbetar med 1024-bitars (128-byte) block med hjälp av 64-bitars ordaritmetik och 80 kompressionssteg. Dess åtta initiala hashvärden härleds från bråkdelarna av kvadratrötterna av de första åtta primtalen, och dess 80 rundkonstanter kommer från kubikrötterna av de första 80 primtalen. Eftersom det använder inbyggda 64-bitarsoperationer är SHA-512 ofta snabbare än SHA-256 på moderna 64-bitarsprocessorer, trots att det producerar ett längre sammandrag.

SHA-384, SHA-512/224 och SHA-512/256 är alla trunkerade varianter av SHA-512 som delar samma interna struktur men använder olika initiala hashvärden och returnerar färre bitar. När du behöver den längsta sammandraget SHA-2-familjen erbjuder, eller när ett protokoll specifikt kräver SHA-512 (som Ed25519 eller vissa HMAC-baserade nyckelderivationsscheman), är SHA-512 rätt val. Det ger 256 bitars kollisionsresistans, vilket matchar SHA-3-512 och vida överstiger SHA-256:s 128-bitarsgräns.

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

Att beräkna ett SHA-512-hashvärde kräver normalt ett terminalkommando eller några rader kod. Det här webbläsarbaserade verktyget låter dig generera SHA-512-sammandrag direkt utan att installera programvara, byta till en terminal eller skriva engångsskript.

Användningsområden för SHA-512-hashgeneratorn

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

SHA-512 tillhör SHA-2-familjen definierad i FIPS 180-4. Tabellen nedan jämför de SHA-2-varianter som delar SHA-512:s 64-bitars interna arkitektur, samt SHA-256 som referens.

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

Rätt hashalgoritm beror på dina säkerhetskrav, prestandabegränsningar och protokollspecifikationer. SHA-512 erbjuder det bredaste sammandraget i SHA-2-familjen och är ofta snabbare än SHA-256 på 64-bitars hårdvara. Den här jämförelsen täcker de egenskaper som är viktigast när du väljer mellan dem.

Hur SHA-512 fungerar internt

SHA-512 bearbetar indata via en Merkle–Damgård-konstruktion med 1024-bitars block. Den initialiserar åtta 64-bitars tillståndsord (H0–H7) från bråkdelarna av kvadratrötterna av de första åtta primtalen. Varje block passerar genom 80 blandningssteg som använder bitvisa operationer (AND, XOR, NOT, högerrotering, högerförskjutning) på 64-bitarsord, kombinerade med 80 rundkonstanter från kubikrötterna av de första 80 primtalen.

Den bredare 64-bitars ordstorleken är den viktigaste skillnaden från SHA-256. På 64-bitars processorer bearbetar varje operation dubbelt så många bitar per cykel, vilket förklarar varför SHA-512 ofta presterar bättre än SHA-256 i riktmärken trots att det kör 80 steg i stället för 64. Avalancheffekten säkerställer att en enda ändrad indatabit påverkar ungefär 50 % av alla 512 utdatabitar.

SHA-512 kodexempel

SHA-512 stöds internt i alla större språk och körtidsmiljöer. Web Crypto API tillhandahåller det i webbläsare utan något bibliotek. Exemplen nedan täcker vanliga mönster inklusive hantering av Unicode och filhashning.

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

Vanliga frågor