Beräkna kontrollsumman för en fil

En checksum (kontrollsumma, ibland stavad chksum) är ett unikt digitalt fingeravtryck beräknat från innehållet i en fil av en hashalgoritm. Detta fingeravtryck, eller fingerprint, representeras vanligtvis av en hexadecimal sträng med fast längd.

En bra hashalgoritms grundläggande egenskap är lavineffekten: varje ändring av källfilen, även med en enda bit, producerar en radikalt annorlunda checksum. Två filer med strikt identiskt innehåll producerar alltid samma checksum, oberoende av filnamn, ändringsdatum eller operativsystem.

Checksum används främst för att verifiera en fils integritet: om det fingeravtryck som räknats om lokalt motsvarar det som annonserats av utgivaren är filen intakt. Annars har den ändrats, blivit korrupt under överföring eller modifierats.

• Verifiera en nedladdnings integritet: en Linux-ISO (Debian, Ubuntu, Fedora, Arch), en Docker-image, en Windows-installerare eller ett open source-arkiv publicerar systematiskt en officiell checksum. Att räkna om den lokalt bekräftar att filen är komplett och oförändrad.
• Upptäcka korruption under överföring: en avbruten nedladdning, en defekt disksektor, ostabilt RAM, en nyckfull nätverkskabel eller en kopia till USB-minne kan korrumpera bytes. Checksumman avslöjar dessa tysta fel omedelbart.
• Signaturavtryck: bekräfta att en fil verkligen kommer från den förväntade upphovsmannen när checksumman sprids via en säker kanal (HTTPS, GPG-signatur). Det är mekanismen som ligger till grund för Linux-paketrepositorier och appbutiker.
• Versionshantering och cachning: Git identifierar varje commit, blob och träd med en SHA-1-hash (under migration till SHA-256). CDN:er och webbpaketerare (Webpack, Vite, esbuild) injicerar en hash i filnamnet (app.4a8f2c.js) för att automatiskt invalidera webbläsarcachen vid ändring.
• Duplikat- och dedupliceringsdetektering: inkrementella säkerhetskopior (Borg, Restic, rsync), filsystem (ZFS) och objektlager identifierar identiska block med sin hash för att bara lagra en kopia.
• Uppladdningsvalidering: en klient skickar den förväntade checksumman, servern räknar om den vid mottagandet. AWS S3 accepterar till exempel en Content-MD5- eller x-amz-checksum-sha256-header för att avvisa en korrupt uppladdning.
• Threat intelligence och antivirus: VirusTotal och antivirusleverantörer indexerar skadliga filer med deras SHA-256-hash, vilket möjliggör detektering utan att överföra hela binären.

• MD5 (128 bitar, 32 hexadecimala tecken): snabb, brett spridd, men kryptografiskt knäckt. MD5-kollisioner kan beräknas på några sekunder på vanlig hårdvara sedan 2004. Att endast använda för icke-skadlig integritetsverifiering (nedladdning mot nätverksavbrott, lokal säkerhetskopia). Förbjudet för alla säkerhets-, signatur- eller autentiseringsfunktioner.
• SHA-1 (160 bitar, 40 hexadecimala tecken): utfasad för kryptografi sedan SHAttered-attacken 2017, som demonstrerade en faktisk kollision mellan två olika PDF:er. Git använder den fortfarande som standard men migrerar till SHA-256. Använd inte längre för att signera eller autentisera.
• SHA-256 (256 bitar, 64 hexadecimala tecken): modern standard, medlem av SHA-2-familjen. Bas för moderna TLS-certifikat, för signaturer av Linux-paket (apt, dnf, pacman), för Bitcoin och för officiella integritetskontroller. Långsammare än MD5 men säker enligt nuvarande kunskap.
• SHA-512 (512 bitar, 128 hexadecimala tecken): 64-bitarsvariant av SHA-2. Hanterar 64-bitarsord nativt, vilket gör den ibland snabbare än SHA-256 på 64-bitars CPU. Längre fingeravtryck, högre säkerhetsmarginal.
• CRC32 (32 bitar, 8 hexadecimala tecken): icke-kryptografisk, ultrasnabb, designad specifikt för att upptäcka överföringsfel. Använd av Ethernet, ZIP, PNG, gzip. Skyddar inte mot illvillighet: en angripare kan trivialt smida en fil med samma CRC32 som en annan. Anpassad för snabba hårdvarukontroller, inte för säkerhet.

• Verifiera en Linux-ISO: Debian, Ubuntu, Fedora och Arch publicerar SHA-256 och SHA-512 för varje officiell image, ofta motsignerade i GPG.
• Validera en signerad binär: bekräfta att en körbar fil nedladdad från en spegel inte har ersatts med en sabbad version.
• Jämföra två versioner: före och efter en ändring bevisar en identisk checksum bit-för-bit-identitet, utan att behöva sprida filerna.
• Uppladdningsvalidering: klienten skickar en checksum, servern räknar om den vid mottagandet för att bekräfta frånvaron av korruption.
• Fingerprinting: upptäckt av bottar eller kända filer i fingeravtrycksdatabaser (antivirus, threat intelligence, sökning efter dubbletter).

1. Dra och släpp filen i avsedd zon, eller använd valknappen.
2. Välj algoritm: MD5, SHA-1, SHA-256, SHA-512 eller CRC32.
3. Checksumman visas, redo att kopieras.
4. Jämför det erhållna värdet med referensen (publicerad av utgivaren eller lokalt sparad).

Beräkningen görs lokalt i din webbläsare, utan att filen skickas till en fjärrserver. Innehållet förblir konfidentiellt.

Standardproceduren för verifiering är följande:

1. Den officiella webbplatsen publicerar den förväntade checksumman, till exempel d41d8cd98f00b204e9800998ecf8427e för MD5 eller en sträng på 64 tecken för SHA-256.
2. Ladda ner filen.
3. Räkna ut dess checksum, antingen med detta verktyg eller från kommandoraden.
4. Jämför: om de två strängarna är strikt identiska, tecken för tecken, är filen intakt. Om de skiljer sig, även med ett enda tecken, är filen korrupt eller manipulerad: använd den inte, ladda ner igen.

I kommandoraden under Linux:

# Calculer le checksum
md5sum fichier.iso
sha1sum fichier.iso
sha256sum fichier.iso
sha512sum fichier.iso
cksum fichier.iso          # CRC32 + taille

# Vérifier automatiquement depuis un fichier .sha256 publié par l'éditeur
sha256sum -c fichier.iso.sha256
# Affiche : "fichier.iso: OK" si le checksum correspond

Under macOS:

md5 fichier.iso
shasum -a 1 fichier.iso
shasum -a 256 fichier.iso
shasum -a 512 fichier.iso

# Vérification depuis un fichier de référence
shasum -a 256 -c fichier.iso.sha256

Under Windows (PowerShell):

Get-FileHash fichier.iso -Algorithm MD5
Get-FileHash fichier.iso -Algorithm SHA1
Get-FileHash fichier.iso -Algorithm SHA256
Get-FileHash fichier.iso -Algorithm SHA512

# Comparer à une valeur attendue
(Get-FileHash fichier.iso -Algorithm SHA256).Hash -eq "ABC123..."

Algoritm	Storlek	Hastighet	Rekommenderad användning
CRC32	32 bitar	Mycket snabb	Upptäckt av nätverks- eller lagringsfel, icke-kryptografisk
MD5	128 bitar	Snabb	Endast icke-fientlig integritet, undvik inom säkerhet
SHA-1	160 bitar	Snabb	Föråldrad, gammal kompatibilitet (Git, gamla paket)
SHA-256	256 bitar	Medel	Aktuell standard, integritetsverifiering och signaturer
SHA-512	512 bitar	Snabb i 64 bitar	Integritetsverifiering, högre säkerhetsmarginal

MD5 eller SHA-256 för att verifiera min ISO?

SHA-256 som standard. Nästan alla moderna Linux-distributioner publicerar SHA-256 och SHA-512, ibland tillsammans med MD5 för historisk kompatibilitet. Om utgivaren bara publicerar MD5 och du fruktar en kompromettering, kräv SHA-256 eller verifiera GPG-signaturen på checksum-filen. Om du bara fruktar en korruption vid nedladdning räcker MD5 tekniskt sett.

Garanterar checksumman säkerheten för min fil?

Nej, inte ensam. En checksum bevisar integritet, inte äkthet. Om en angripare kontrollerar nedladdningsservern kan de publicera en modifierad fil och dess modifierade checksum. Verklig säkerhet kommer från en digital signatur (GPG, code signing) som knyter checksumman till en känd privat nyckel. Hämta alltid checksumman via HTTPS eller, bättre, via en verifierbar GPG-signatur.

Min checksum stämmer inte, vad gör jag?

Kontrollera först att du jämför rätt algoritm: en SHA-256 kan inte motsvara en SHA-1. Försök sedan ladda ner igen, helst från en annan spegel: den vanligaste orsaken är ett nätverksavbrott. Om avvikelsen kvarstår efter flera försök, misstänk en kompromettering av spegeln: gå tillbaka till den officiella källan och verifiera GPG-signaturen om den finns. Kör eller använd aldrig filen så länge checksumman inte stämmer.

Varför är MD5 utfasad?

MD5 lider av praktiska kollisioner: det är möjligt att konstruera två olika filer som har exakt samma MD5-hash på några sekunder. Den egenskapen bryter mot själva funktionen hos en kryptografisk hash. Konkret kan en angripare skapa en skadlig binär som har samma MD5 som en legitim binär. SHA-1 lider av samma problem sedan 2017 (SHAttered-attacken). Endast SHA-256, SHA-512 och deras varianter anses fortfarande säkra 2026.

Skillnad mellan hash och checksum?

En hash är det generiska resultatet av en hashfunktion. En checksum är en hash som används specifikt för att verifiera en datas integritet. Alla checksums är hashar, men alla hashar är inte checksums: en lösenordshash (bcrypt, argon2) används för autentisering, en hash i en hashtabell används för att indexera snabbt. Termen fingerprint eller fingeravtryck är en vanlig synonym för checksum.

Räcker CRC32 för mina behov?

CRC32 räcker om du bara försöker upptäcka oavsiktlig korruption på en icke-fientlig kanal: intern nätverksöverföring, verifiering av ZIP-arkiv, konsekvenskontroll i minnet. Med endast 32 bitar har två slumpmässiga filer ungefär 1 chans på 4 miljarder att av en slump ha samma CRC32, vilket är tillräckligt för feldetektering. CRC32 är otillräcklig så snart en angripare kan påverka innehållet: det är trivialt att smida en fil med ett målsatt CRC32. För varje verifiering inför illvillig risk, använd SHA-256.

Varför skiljer sig min checksum mellan OS?

Checksumman för samma binära innehåll är identisk överallt. Om du får två olika resultat är det för att filen verkligen skiljer sig: radslut (CRLF Windows mot LF Unix) efter en FTP-överföring i textläge, ändrad textkodning vid öppning, metadata tillagda av systemet (Spotlight-upplösning macOS, utökade attribut), eller tyst omkomprimering av en överföringsklient. Överför alltid i binärt läge.

Checksum eller digital signatur?

En checksum bevisar att en fil inte har ändrats mellan publicering och mottagande, förutsatt att man hämtar checksumman via en säker kanal. En digital signatur (GPG, PGP, Authenticode code signing) bevisar dessutom upphovsmannens identitet tack vare en privat nyckel. Signaturen omsluter och förstärker checksumman: standardpraxis hos Debian, Tor eller Bitcoin Core är att GPG-signera checksum-filen och sedan använda dessa checksums för att verifiera binärerna.