Beveiligings- & cryptografietools

Genereer sterke wachtwoorden, hashes, HMAC, checksums en SHA-256-vingerafdrukken in je browser. Gratis, privé en nul uploads.

100% Privé • Geen Server Uploads

Waarom Utiliome's gratis Beveiligings- & cryptografietools gebruiken?

Van de grond af opgebouwd voor strikte privacy, directe uitvoering en nul wrijving. Geen registratie nodig.

Web Crypto CSPRNG-engine

Haalt ruwe cryptografische entropie rechtstreeks uit crypto.getRandomValues() van de browser, ondersteund door de CSPRNG van de OS-kernel in plaats van de voorspelbare Math.random()-status.

CSPRNG Diceware-woordselectie

Trekt willekeurige Engelse woordenboekwoorden uniform via Web Crypto crypto.getRandomValues() met zuivere rejection sampling in plaats van voorspelbare menselijke zinsbouw.

Gelijktijdige Digest-Matrix voor Vijf Algoritmen

Berekent in één enkele doorgang 128-bit MD5 (RFC 1321) naast 160-bit SHA-1, 256-bit SHA-256, 384-bit SHA-384 en 512-bit SHA-512 (NIST FIPS 180-4) vanuit één UTF-8-string of binaire bestandsbuffer.

Natieve Web Crypto API

Gebruikt window.crypto.subtle hardwareversnelling om SHA-256 checksums op maximale CPU-snelheid te berekenen.

Utiliome vs. traditionele cloudtools

Vergelijk onze lokale WebAssembly-engine met verouderde cloudtools.

Functie Utiliome (Lokale Browser) Verouderde Cloud Converters
Gegevensprivacy & Beveiliging Nul server-uploads (Verwerking in browser) Uploadt je gevoelige PDF's naar externe cloudservers
Gegevensprivacy & Beveiliging Nul server-uploads (Verwerking in browser) Uploadt je gevoelige PDF's naar externe cloudservers
Max Bestandsgrootte Geen harde limieten (alleen beperkt door RAM) Strikte limieten van 10MB - 50MB
Gegevensprivacy & Beveiliging Nul server-uploads (Verwerking in browser) Uploadt je gevoelige PDF's naar externe cloudservers
Hoe het werkt

Hoe Beveiligings- & cryptografietools te gebruiken in 3 eenvoudige stappen

Geen software-installatie vereist. Alles draait direct in je webbrowser.

1

Stel lengte en tekenklassen in

Selecteer een lengte tussen 4 en 128 tekens en schakel hoofdletters (A-Z), kleine letters (a-z), cijfers (0-9) en afdrukbare ASCII-symbolen in op basis van uw systeemvereisten.

2

Configureer uitsluitingen en bulkaantal

Schakel filtering van dubbelzinnige tekens (0/O, 1/l/I) in voor handmatig overtypen, of verhoog het batchaantal om meerdere onafhankelijke secrets tegelijk te genereren.

3

Controleer entropie-bits en kopieer

Verifieer de live weergave van de combinatorische en Shannon-entropie in bits ten opzichte van uw beveiligingsdrempel (128+ bits voor productie-inloggegevens) en kopieer lokaal.

CSPRNG-wachtwoorden met hoge entropie genereren: configuratie en voorbeelden

Kort antwoord: Stem tekensets en lengte (4 tot 128 tekens) af op hoe het secret wordt opgeslagen en geparseerd. Gebruik 24+ volledige ASCII-tekens voor wachtwoordmanagers, 32+ alfanumerieke tekens voor URI-connectiestrings en .env-bestanden om escaping-fouten met scheidingstekens te voorkomen, en homoglief-gefilterde strings voor handmatige console-invoer.

Verschillende runtime-omgevingen stellen strikte parsing-eisen aan inloggegevens. Door de grootste veilige tekenset N te kiezen en de lengte L te schalen, behaalt u de gewenste bit-entropiemarges zonder onbedoelde shell-interpolatie of fouten in URI-parsers te veroorzaken.

Profiel 1: Kluis-secret voor wachtwoordmanager (Volledig afdrukbaar ASCII)

Wanneer u inloggegevens opslaat in een versleutelde kluis (1Password, Bitwarden, KeePassXC of HashiCorp Vault) voor automatisch aanvullen van formulieren of API-headers, schakelt u alle vier de tekenklassen in (A-Z, a-z, 0-9 en 32 ASCII-leestekens, N = 94) met een lengte van L = 24:

Configuratie  : Lengte = 24 | Hoofdletters + Kleine letters + Cijfers + Symbolen (N = 94) | Dubbelzinnige uitsluiten = Uit
Uitvoer       : v9#Km!2pQ@7xR$4nL^8wZ&5j
Pool-entropie : 24 * log2(94) = 157.31 bits
Zoekruimte    : 94^24 = 2.26e+47 combinaties

Profiel 2: URI-veilig en Shell-veilig service-secret (Alleen alfanumeriek)

Database-DSN's (postgres://user:password@db.internal:5432/app) en Docker .env-bestanden lopen vaak vast wanneer wachtwoorden gereserveerde URI-scheidingstekens volgens RFC 3986 (:, /, ?, #, [, ], @) of shell-expansietokens ($, `, ", ', \) bevatten. Het uitschakelen van symbolen (N = 62) en het verlengen van de lengte naar L = 32 levert een hogere entropie op dan een wachtwoord van 24 tekens met symbolen, zonder enig risico op escaping-problemen:

Configuratie  : Lengte = 32 | Hoofdletters + Kleine letters + Cijfers (N = 62) | Symbolen = Uit
Uitvoer       : 8fKp3mQv9xRt2nLw7zJc4bYh6dGs5aPe
Pool-entropie : 32 * log2(62) = 190.53 bits
Zoekruimte    : 62^32 = 2.27e+57 combinaties

Profiel 3: Bulk break-glass-noodcodes (Dubbelzinnige tekens uitgesloten)

Voor out-of-band IPMI/iLO-consoles of noodherstelformulieren waarbij een engineer tekens van een scherm moet aflezen in een monospace- of proportioneel lettertype, schakelt u het uitsluiten van dubbelzinnige tekens in (0, O, 1, l, I verwijderd uit N = 62, waardoor N = 57 overblijft) en genereert u een batch:

Configuratie  : Lengte = 20 | Hoofdletters + Kleine letters + Cijfers | Dubbelzinnige uitsluiten (0/O, 1/l/I) = Aan (N = 57) | Bulk = 3
Uitvoer       :
  1. 7mKp4xQv9nRw3zJc8bYh
  2. 5dGs2fPe6tMa9kVu4wNx
  3. 3hBz8qJr7cLy2pWt6gKm
Pool-entropie : 20 * log2(57) = 116.66 bits per wachtwoord
Functie ISO 32000 / WebAssembly / Web Crypto Utiliome (Lokale Browser)
Veilige wachtwoordgenerator Web Crypto CSPRNG (getRandomValues) Genereer cryptografisch veilige, complexe willekeurige wachtwoorden.
Makkelijk te onthouden wachtwoorden Cryptographic Diceware Passphrases Maak mathematisch veilige wachtwoorden die makkelijk te onthouden zijn.
Hash Generator SHA-256 / SHA-512 / SHA-1 (FIPS 180-4) Genereer direct veilige cryptografische hashes (SHA-256, SHA-512) uit tekst.
HMAC Generator Keyed-Hash HMAC (RFC 2104 / FIPS 198-1) Genereer en verifieer HMAC-codes (HMAC-SHA256, HMAC-MD5) lokaal in je browser.
Checksum Calculator Multi-Hash Binary File Fingerprinting Bereken SHA-1, SHA-256, SHA-384 en SHA-512 hashes lokaal in je browser.
SHA256 Bestand Local Multi-GB SHA-256 Verification Bereken en verifieer de SHA-256 hash van een bestand lokaal zonder uploads.

Diceware-wachtwoordzinnen opbouwen: woordenaantal, scheidingstekens en voorbeelden

Kort antwoord: Een wachtwoordzin van 6 woorden die uniform wordt getrokken uit een Diceware-woordenboek van 7.776 woorden levert 77,55 bits aan cryptografische entropie op, terwijl deze eenvoudig te onthouden en blind te typen blijft. Het toevoegen van een willekeurig cijfer en symbool verhoogt de totale sterkte tot boven de 85 bits en doorstaat strenge zakelijke tekenklasse-validatoren.

Het menselijk geheugen heeft moeite met het onthouden van 16 willekeurige ASCII-tekens (v9#Km!2pQ@7xR$4n), maar onthoudt moeiteloos 5 tot 7 concrete woorden als een mentaal beeld. Door een CSPRNG te gebruiken om woorden onafhankelijk te selecteren, behoud je strikte wiskundige veiligheid terwijl je de typergonomie optimaliseert.

Profiel 1: Wachtwoordmanager Master Key en Volledige Schijfversleuteling (LUKS2 / FileVault)

Tijdens pre-boot prompts voor volledige schijfversleuteling (LUKS2, VeraCrypt, FileVault) is plakken vanaf het klembord niet beschikbaar en kunnen niet-Amerikaanse toetsenbordindelingen verschoven leestekens op een andere plek zetten. Zes woorden in kleine letters, gescheiden door koppeltekens uit een standaard Diceware-woordenboek van 7.776 woorden, voorkomen typefouten met de Shift-toets en bieden enorme offline KDF-bestendigheid:

Configuratie  : 6 Woorden | Scheidingsteken = Koppelteken (-) | Schrijfwijze = lowercase | Extra's = Uit
Uitvoer       : lantern-cobalt-harvest-velvet-orbit-spruce
Woordentropie : 6 * log2(7776) = 77.55 bits
Zoekruimte    : 7776^6 = 2.21e+23 combinaties

Profiel 2: Enterprise SSO en Active Directory-beleidsnaleving

Veel zakelijke IAM- en Active Directory-beleidsregels dwingen regex-controles af die hoofdletters, kleine letters, een cijfer [0-9] en een symbool vereisen. Het toepassen van Title Case met underscores of punten als scheidingsteken plus één door CSPRNG getrokken cijfer (+3,32 bits) en één CSPRNG-symbool (bijv. uit een pool van 32 symbolen, +5,00 bits) voldoet probleemloos aan legacy-validatoren:

Configuratie   : 5 Woorden | Scheidingsteken = Punt (.) | Schrijfwijze = Title Case | Cijfer + Symbool toevoegen = Aan
Uitvoer        : Glacier.Badger.Summit.Quartz.Anchor.7#
Totale Entropie: (5 * 12.925) + log2(10) + log2(32) = 72.95 bits

Profiel 3: Air-Gapped GPG Master Key of Root CA Passphrase

Voor langdurige offline cryptografische vertrouwensankers (OpenPGP-certificeringssleutels, age/SSH cold keys of BIP-39 passphrase-uitbreidingen voor hardware wallets) schaal je op naar 7 of 8 door spaties gescheiden woorden:

Configuratie  : 8 Woorden | Scheidingsteken = Spatie ( ) | Schrijfwijze = lowercase | Extra's = Uit
Uitvoer       : canyon timber falcon magnet fossil harbor meadow quartz
Woordentropie : 8 * log2(7776) = 103.40 bits
Zoekruimte    : 7776^8 = 1.34e+31 combinaties

Wat is een SHA-256 Bestand Checksum?

Kort antwoord: Een SHA-256 bestand checksum is een unieke hexadecimalen digest van 64 tekens die de exacte binaire inhoud van een bestand vertegenwoordigt. Het werkt als een digitale vingerafdruk om te garanderen dat bestanden niet beschadigd of aangepast zijn.

SHA-256 (Secure Hash Algorithm 256-bit) maakt deel uit van de SHA-2-familie gedefinieerd door NIST. Het genereert een vaste 256-bit (32-byte) hashwaarde, meestal weergegeven als een hexadecimalen reeks van 64 tekens.

  Vanwege het cryptografische *Lawine-effect* zal het wijzigen van zelfs een enkele byte in een groot bestand een volledig andere SHA-256 veroorzaken. Dit maakt SHA-256 de standaard voor het verifiëren van software-downloads, OS ISO-bestanden en databaseback-ups.

Webhook- & API-HMAC-handtekeningen berekenen en verifiëren: Praktische handleiding

Kort antwoord: Het ondertekenen van het bericht what do ya want for nothing? met het 4-byte geheim Jefe (IETF RFC 4231 Test Case 2) onder HMAC-SHA256 levert 5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843 op in Hex en W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM= in Base64, ongeacht of de sleutel als UTF-8, Hex (4a656665) of Base64 (SmVmZQ==) wordt ingevoerd.

Een Keyed-Hash Message Authentication Code (HMAC) bewijst zowel de data-integriteit (de payload is onderweg niet gewijzigd) als de authenticiteit (de afzender beschikt over de gedeelde geheime sleutel). Om de handtekening van een provider te reproduceren, moeten drie exacte parameters overeenkomen: de onderliggende hash-functie, de ruwe byte-decodering van de geheime sleutel en de exacte byte-reeks van de ondertekende payload.

Voorbeeld 1: IETF RFC 2104 / RFC 2202 / RFC 4231 Test Case 2

Of je de geheime sleutel van 4 bytes nu invoert als UTF-8-tekst Jefe, ruwe hexadecimale waarde 4a656665 of Base64 SmVmZQ==, deze wordt altijd gedecodeerd naar exact dezelfde sleutelbuffer [0x4a, 0x65, 0x66, 0x65]. Het ondertekenen van het 28-byte UTF-8-bericht what do ya want for nothing? geeft het volgende resultaat:

{
  "keyUtf8": "Jefe",
  "keyHex": "4a656665",
  "keyBase64": "SmVmZQ==",
  "message": "what do ya want for nothing?",
  "signatures": {
    "hmac_md5_hex": "750c783e6ab0b503eaa86e310a5db738",
    "hmac_sha1_hex": "effcdf6ae5eb2fa2d27416d5f184df9c259a7c79",
    "hmac_sha256_hex": "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
    "hmac_sha256_base64": "W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM=",
    "hmac_sha256_base64url": "W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM",
    "hmac_sha384_hex": "af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec3736322445e8e2240ca5e69e2c78b3239ecfab21649",
    "hmac_sha512_hex": "164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737"
  }
}

Voorbeeld 2: Base64 vs. Base64URL en canonieke webhook-payloads

Standaard Base64 (RFC 4648 Sectie 4) gebruikt +, / en afsluitende =-padding, terwijl URL-veilige Base64URL (RFC 4648 Sectie 5, gebruikt in JWS/JWT-handtekeningen en ondertekende URL's) + vervangt door -, / door _ en de =-padding weglaat. Het ondertekenen van The quick brown fox jumps over the lazy dog met de UTF-8-sleutel key onder HMAC-SHA256 laat dit coderingsverschil direct zien:

Key (UTF-8):     key
Message (UTF-8): The quick brown fox jumps over the lazy dog

HMAC-SHA256 Hex:       f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8
HMAC-SHA256 Base64:    97yD9DBThCSxMpjmqm+xQ+9NWaFJRhdZl0edvC0aPNg=
HMAC-SHA256 Base64URL: 97yD9DBThCSxMpjmqm-xQ-9NWaFJRhdZl0edvC0aPNg

Bij het verifiëren van echte webhook-headers moet je eerst de exacte pre-signing payload samenstellen zoals gedefinieerd door de betreffende provider, voordat je de header-prefixen verwijdert:

GitHub (X-Hub-Signature-256: sha256=<hex>):
  Signed input = <raw_http_body>

Stripe (Stripe-Signature: t=1730419200,v1=<hex>):
  Signed input = 1730419200.<raw_http_body>

Slack (X-Slack-Signature: v0=<hex>):
  Signed input = v0:1730419200:<raw_http_body>

Shopify (X-Shopify-Hmac-Sha256: <base64>):
  Signed input = <raw_http_body>
Veelgestelde vragen

Beveiligings- & cryptografietools FAQ en Technische Gids

Alles wat je moet weten over het gebruik van Utiliome's gratis online wachtwoord en sha256 hash generator.

Waarom zou ik symbolen uitschakelen voor database-connectiestrings en .env-bestanden?

RFC 3986 reserveert tekens zoals :, /, ?, #, [, ], @ en % als structurele URI-scheidingstekens, terwijl POSIX-shells en .env-laders $, backticks, aanhalingstekens, # en \ interpreteren als variabele-expansies, opmerkingen of escape-tekens. Het genereren van een alfanumeriek wachtwoord van 32 tekens (A-Z, a-z, 0-9, N = 62) levert 190.53 bits aan entropie op — sterker dan een wachtwoord van 24 tekens met symbolen (157.31 bits) — terwijl parsing- en URL-coderingsfouten in Kubernetes Secrets, Terraform en JDBC/libpq-drivers volledig worden voorkomen.

Als de woordenlijst openbaar is, kan een aanvaller mijn passphrase dan niet kraken met een woordenboekaanval?

Zelfs wanneer een aanvaller het exacte woordenboek van 7.776 woorden in combinator-modus in Hashcat laadt, dwingt uniforme CSPRNG-selectie hem om elke W^k-combinatie te doorzoeken. Voor een wachtwoordzin van 6 woorden staat 7.776^6 gelijk aan 2,21 x 10^23 even waarschijnlijke kandidaten (77,55 bits) — exact dezelfde rekenkundige drempel als een ruwe binaire sleutel van 77,5 bits, zonder grammaticale patronen om af te snijden.

Waarom geeft mijn terminalcommando echo "text" | sha256sum een andere hash terug dan wanneer ik text hier plak?

Standaard voegt echo een afsluitend line-feed-teken (<LF>, byte 0x0a) toe aan je string, waardoor echo "abc" in werkelijkheid de 4-byte reeks 61 62 63 0a hasht in plaats van de 3-byte string 61 62 63. Voer printf '%s' 'abc' | sha256sum (of echo -n 'abc' | sha256sum) uit in je shell om de afsluitende newline weg te laten en exact overeenkomende UTF-8-stringdigests te krijgen.

Waarom mislukt mijn webhook HMAC-verificatie, zelfs als mijn geheime sleutel en JSON-velden er identiek uitzien?

Twee problemen veroorzaken meer dan 90% van alle webhook HMAC-fouten. Ten eerste parsen en her-serialiseren middlewares zoals Express express.json() de JSON, waardoor witruimte, Unicode-escaping of de sleutelvolgorde verandert ten opzichte van de ruwe TCP-bytestroom die de afzender heeft ondertekend — onderteken daarom altijd de ruwe, onbewerkte request-buffer en neem tijdstempel-prefixen van de provider mee (zoals Stripe's <timestamp>.<body> of Slack's v0:<timestamp>:<body>). Controleer ten tweede of het geheim van de provider vanuit Base64 of Hex naar ruwe bytes moet worden gedecodeerd in plaats van als UTF-8-string te worden ingelezen.

Wat is een checksum en waarom is het belangrijk?

Een checksum is een unieke alfanumerieke code die wordt gegenereerd via een cryptografisch algoritme. Het werkt als een digitale vingerafdruk om de echtheid te controleren.

Worden mijn bestanden geüpload naar een server?

Nee. Alle berekeningen vinden lokaal plaats in het geheugen van uw browser met de natieve Web Crypto API.