Zo gebruik je het
- Stel de lengte in en kies bij Eenheid of die in bytes aan willekeurige gegevens of in Base64-tekens wordt geteld. Kies voor een sleutel bytes: 32 bytes is een sleutel van 256 bits.
- Stel bij Aantal in hoeveel strings je nodig hebt en kies het scheidingsteken ertussen: nieuwe regel, komma of spatie.
- Kies de variant Standaard of URL-veilig. Met de eenheid bytes kun je ook Opvulling uitzetten als het doelsysteem geen =-tekens verwacht.
- Klik op Genereren voor nieuwe waarden en gebruik daarna Alles kopiëren of Downloaden om de lijst te bewaren.
Bytes, tekens en entropie
De sterkte van een willekeurige string wordt gemeten in bits entropie. Elke willekeurige byte voegt 8 bits toe, dus 16 bytes geven 128 bits en 32 bytes geven 256 bits. Base64 verandert alleen hoe die bytes worden opgeschreven: elk teken bevat 6 bits, en elke 3 bytes worden 4 tekens. De tool toont de entropie van elke string, zodat je die in één oogopslag kunt controleren.
Met de eenheid bytes decodeert de uitvoer naar precies zoveel willekeurige bytes, en dat is wat sleutels en geheimen nodig hebben. Met de eenheid tekens krijg je een exact aantal tekens, die elk uniform worden gekozen uit het alfabet van 64 tekens; gebruik die eenheid als een systeem om een token van vaste lengte vraagt en het als tekst opslaat.
| Bytes | Base64-tekens | Entropie | Typisch gebruik |
|---|---|---|---|
| 12 | 16 | 96 bits | AES-GCM-nonce (IV) |
| 16 | 24 (22 zonder opvulling) | 128 bits | Salts, sessie- en CSRF-tokens, AES-128-sleutels |
| 32 | 44 (43 zonder opvulling) | 256 bits | AES-256- en HMAC-SHA256-sleutels, HS256-geheimen, API-sleutels |
| 64 | 88 (86 zonder opvulling) | 512 bits | HMAC-SHA512-sleutels, HS512-geheimen |
Waar willekeurige Base64-waarden worden gebruikt
- JWT-geheimen. RFC 7518 vereist een HMAC-sleutel die minstens zo lang is als de hashuitvoer: 32 bytes voor HS256, 48 voor HS384 en 64 voor HS512. Sommige bibliotheken gebruiken de geheime string zoals hij is, andere decoderen hem eerst als Base64; controleer dus wat de jouwe verwacht. De JWT-decoder verifieert HS256- tot en met HS512-handtekeningen met beide soorten geheimen, en de HMAC-generator accepteert een sleutel als tekst, hex of Base64.
- Applicatiesleutels. Laravel bewaart bijvoorbeeld een versleutelingssleutel van 32 bytes in zijn
.env-bestand alsAPP_KEY=base64:..., in dezelfde vorm als een string van 32 bytes uit deze tool. - Kubernetes Secrets. Waarden onder
datamoeten standaard Base64 met opvulling zijn. Een string die is gegenereerd met de eenheid bytes, de variant Standaard en opvulling aan, kan daar direct in, en de Pod ontvangt dan de ruwe willekeurige bytes. Verwacht de applicatie de Base64-tekst zelf, zet hem dan onderstringData. - Tokens in URL's. Links om een wachtwoord te herstellen, uitnodigingscodes en andere tokens die via een URL worden doorgegeven, horen de URL-veilige variant te gebruiken, die
+en/vervangt door-en_. Zie Base64URL voor de details.
Waarom crypto.getRandomValues en niet Math.random
Math.random() is een snelle generator voor algemeen gebruik. De uitvoer is niet ontworpen om onvoorspelbaar te zijn, en bij sommige engines kan de interne toestand uit een handvol waarden worden gereconstrueerd. Deze tool gebruikt crypto.getRandomValues(), een cryptografisch veilige generator die zijn seed van het besturingssysteem krijgt: hetzelfde soort bron als achter openssl rand en de module secrets van Python. De waarden worden op je apparaat gemaakt en worden nooit verzonden of opgeslagen.
Willekeurige Base64 genereren in code
# Shell: 32 willekeurige bytes als Base64 (44 tekens)
openssl rand -base64 32
head -c 32 /dev/urandom | base64
# Python
import base64, secrets
base64.b64encode(secrets.token_bytes(32)).decode()
secrets.token_urlsafe(32) # URL-veilig, zonder opvulling, 43 tekens
// Node.js
const crypto = require('crypto');
crypto.randomBytes(32).toString('base64');
crypto.randomBytes(32).toString('base64url'); // URL-veilig, zonder opvulling
// Browser
const bytes = crypto.getRandomValues(new Uint8Array(32));
btoa(String.fromCharCode(...bytes));
Veelgestelde vragen
Hoe lang moet een willekeurige sleutel of een geheim zijn?
16 bytes (128 bits) is genoeg voor waarden die alleen uniek en onmogelijk te raden hoeven te zijn, zoals sessie-ID's, CSRF-tokens en salts. Gebruik 32 bytes (256 bits) voor AES-256-sleutels, HMAC-SHA256-sleutels en HS256-geheimen, en 64 bytes voor HMAC-SHA512 en HS512.
Is dit hetzelfde als openssl rand -base64 32?
= en decodeert het naar 32 willekeurige bytes. De waarden zelf zijn uiteraard elke keer anders.Moet ik de eenheid bytes of tekens gebruiken?
Gebruik bytes als de string wordt gedecodeerd, zoals bij versleutelingssleutels en Kubernetes Secrets. Gebruik tekens als een systeem een token van een exacte lengte nodig heeft en de tekst gebruikt zoals hij is. Een string uit de eenheid tekens decodeert alleen gegarandeerd foutloos als de lengte een veelvoud van 4 is.
Wanneer heb ik de URL-veilige variant nodig?
/ URL-paden en verandert + in een spatie in form-gecodeerde querystrings. URL-veilige Base64 gebruikt in plaats daarvan - en _ en wordt meestal zonder opvulling geschreven.Worden de gegenereerde waarden ergens opgeslagen of naartoe gestuurd?
Nee. Ze worden door JavaScript in je browser gegenereerd, nooit verzonden en zijn weg zodra je de pagina verlaat. Gebruik je er een als echt geheim, bewaar het dan in een wachtwoordmanager of een beheersysteem voor geheimen, en niet in chatberichten of tickets.