SHA-256-hash maken

SHA-256 is sinds 2001 in gebruik en er is in die tijd geen praktische aanval op gevonden — geen botsing, geen terugrekening. Dat is een ongewoon lange staat van dienst voor een cryptografische functie, en het is de reden dat certificaten, softwarehandtekeningen en Subresource Integrity er allemaal op leunen.

De keuze is daarmee in de praktijk gemaakt: waar je vrij bent om te kiezen, kies je deze. MD5 en SHA-1 komen alleen nog voor waar iets anders erom vraagt, en dan is dat een gegeven en geen beslissing. Wie er zelf een verzint of naar iets exotisch grijpt, ruilt een grondig onderzochte functie in voor een die dat niet is.

Het getal in de naam is de lengte van de uitvoer in bits, niet een schaal van betrouwbaarheid. SHA-512 is niet ruim twee keer zo veilig als SHA-256; allebei liggen ze ver buiten wat met bestaande of voorstelbare hardware te doorzoeken is.

Wat het wel beïnvloedt is snelheid en formaat. SHA-512 is op 64-bits processoren doorgaans sneller omdat het met grotere woorden rekent, en de uitvoer is honderdachtentwintig tekens in plaats van vierenzestig. Waar de hash in een veld, een URL of een QR-code moet passen, is dat een echt argument — veiligheid niet.

Het rekenwerk gebeurt met de Web Crypto API, `crypto.subtle.digest`, de implementatie die in de browser zelf zit. Er wordt hier dus geen zelfgeschreven of meegeleverde SHA-256 gebruikt, en dat is precies de bedoeling.

Zelf een hashfunctie implementeren is een van die taken die er eenvoudig uitzien en het niet zijn: een verkeerde afronding of een fout in de laatste blokopvulling levert waarden op die er goed uitzien en nergens mee overeenkomen. De implementatie van de browser is getest tegen de testvectoren van het NIST, en dat is een garantie die een pagina als deze niet zelf kan geven.

Een SHA-256 is 256 bits, geschreven als vierenzestig hexadecimale tekens. De lengte is vast: een enkele letter en een heel boek leveren allebei vierenzestig tekens op.

Dat maakt tellen tot de snelste identificatie van een onbekende waarde. Tweeëndertig tekens is MD5, veertig is SHA-1, vierenzestig is SHA-256 en honderdachtentwintig is SHA-512. Zesendertig met streepjes is geen hash maar een UUID, en vierenveertig tekens die op `=` eindigen is een SHA-256 in Base64 in plaats van in hex.

Komt de waarde hier niet overeen met wat `sha256sum` in een terminal geeft, dan is het bijna altijd één byte: `echo tekst | sha256sum` hasht de tekst mét het regeleinde dat `echo` erachter zet. Met `echo -n` verdwijnt dat en komen de waarden overeen.

Hetzelfde geldt voor een bestand dat met een lege regel aan het eind is bewaard, en voor tekst die tussen Windows en Unix is heen en weer gegaan, waar een regeleinde `0d 0a` of alleen `0a` is. De hash ziet die bytes en maakt geen uitzondering, en daarom is dit de eerste plek om te kijken bij een verschil.

Een hash gaat over bytes, en tekst wordt pas bytes via een codering. Hier is dat altijd UTF-8: `ë` is `c3 ab`, `é` is `c3 a9`, en een emoji is vier bytes. In Latin-1 waren die letters één byte geweest en was de hash een andere.

Daarom is een verschil tussen twee systemen bij zuivere ASCII vrijwel altijd het regeleinde en bij Nederlandse tekst vrijwel altijd de codering. Het loont om bij een koppeling die hashwaarden vergelijkt vast te leggen welke codering geldt, want de specificatie die het niet vermeldt is de specificatie die het probleem veroorzaakt.

Een hash zegt of twee dingen gelijk zijn; hij zegt niet van wie ze komen. Wie de inhoud kan vervangen kan de bijbehorende hash net zo goed vervangen, en dan klopt alles weer. Zonder een tweede kanaal bewijst een gepubliceerde hash daarom weinig.

Een handtekening lost dat op door een sleutel toe te voegen die alleen de afzender heeft: HMAC met een gedeeld geheim, of een digitale handtekening met een privésleutel. De hash is daar een onderdeel van en niet het geheel, en de verwarring tussen die twee zit achter een groot deel van de misplaatste «integriteitscontroles» op internet.

Deze pagina hasht tekst uit een veld. De hash van een bestand haal je gemakkelijker uit het gereedschap dat al op je machine staat: `sha256sum` op Linux, `shasum -a 256` op macOS, `Get-FileHash` in PowerShell op Windows.

De vraag die wél in een browser terechtkomt, is de vraag over een tekst: een waarde nabouwen die een systeem verwacht, een vaste afgeleide sleutel maken, controleren wat een koppeling van een reeks maakt. Daar hoort een tekstveld bij, en dat scheelt bovendien een bestand inlezen dat er niet toe doet.

Een `integrity`-attribuut op een script- of stijlbladverwijzing bevat een SHA-256 van het bestand, geschreven in Base64 en met `sha256-` ervoor. De browser rekent de hash na en weigert het bestand als het niet klopt, wat een CDN dat gecompromitteerd raakt onschadelijk maakt.

De vorm is dus een andere dan de vierenzestig hextekens hier: dezelfde 256 bits, alleen in Base64 geschreven, wat vierenveertig tekens oplevert. Wie de waarde uit deze pagina rechtstreeks in een `integrity`-attribuut plakt, krijgt een bestand dat de browser weigert — het is het juiste getal in de verkeerde notatie.

SHA-512 zit in dezelfde motor en werkt, en er is met opzet geen pagina voor. Het verhaal ervan is een deelverzameling van dat van SHA-256: dezelfde constructie, dezelfde garanties, sneller op 64-bits hardware. Een eigen pagina zou vrijwel dezelfde tekst zijn met een ander getal.

Dat is precies het soort pagina dat op deze site niet wordt geschreven. Twee bijna gelijke pagina’s concurreren met elkaar en geen van beide wordt de beste, terwijl één pagina die het verschil benoemt allebei de vragen beantwoordt. Het gat is er dus, en het staat hier opgeschreven in plaats van stilzwijgend te bestaan.

Wordt er een persoonsgegeven gehasht — een adres, een klantnummer, een burgerservicenummer — dan blijft dat onder de AVG een persoonsgegeven zolang herleiding mogelijk is. Bij een verzameling die klein en voorspelbaar is, is ze dat, en dan is het pseudonimisering en geen anonimisering.

Wat deze pagina verzekert is het praktische deel: de invoer wordt op je eigen machine gehasht en niet aan ons verstrekt. Dat is te controleren in het netwerktabblad, en het is bij dit soort waarden het enige punt waarop een onlinehulpmiddel het verschil kan maken.