# Wachtwoorden maken in de terminal: wat werkt en wat zonder waarschuwing faalt

> De terminal is een prima wachtwoordgenerator en je hoeft niets te installeren. Maar we probeerden de commando's uit een heel uitgebreide tutorial op een Mac, en de helft faalde: één gaf een enkele letter terug zonder foutmelding. Wat er gebeurt, waarom, en een versie die hardop faalt.

2026-11-10 · David Carrero · password.es
Original: https://password.es/nl/blog/wachtwoorden-maken-in-de-terminal/

---

In mei verscheen op Medium een tutorial met een titel die je moeilijk kunt
negeren: *Generate Unbreakable Passwords in Your Terminal Using Pure Bash*. Het
idee erachter is goed en we delen het: **de terminal heeft al een uitstekende
wachtwoordgenerator aan boord**, je hoeft niets te installeren en het
wachtwoord verlaat je machine niet. Het is precies wat deze site verdedigt met
[de generator in de
browser](/nl/blog/waarom-we-je-wachtwoord-nergens-naartoe-sturen/), alleen
zonder browser.

Dus we kopieerden de commando's en draaiden ze op een Mac, op 10 november 2026,
met macOS 27.2 en de landinstellingen (locale) van het systeem op Spaans. En op Linux, om te
vergelijken. Wat werkt, werkt heel goed. Wat faalt, faalt in een aantal gevallen
zonder iets te zeggen, en dat is het ergste wat een wachtwoordgenerator kan
overkomen.

## Waar het toeval vandaan komt

De tutorial begint met wat er echt toe doet: `openssl rand -base64 32` geeft je
32 willekeurige bytes in base64, en `/dev/urandom` is de bron waaruit bijna alle
andere commando's putten.

Eén kanttekening, want de tutorial stelt het iets romantischer voor dan het is.
Noch `openssl rand` noch `/dev/urandom` levert je “pure fysieke
willekeur”: allebei zijn ze een cryptografische generator — een CSPRNG — die
het besturingssysteem zaait met echte ruis uit de hardware, en die vanaf dat
moment bytes produceert die niemand kan voorspellen. OpenSSL zegt het zelf in
zijn documentatie: het is een deterministische generator volgens het model van
NIST SP 800-90A die zichzelf vanuit het systeem zaait en herzaait. Linux
gebruikt er een op basis van ChaCha20; macOS, volgens de beveiligingsgids van
Apple, een die van Fortuna is afgeleid.

Dat is geen bezwaar, het is juist waarom het werkt: een goed gezaaide CSPRNG is
precies wat je wilt. Het is dezelfde soort bron als
`crypto.getRandomValues()`, die de [generator van deze site](/nl/) gebruikt.

En er is nog iets dat de tutorial goed doet en waar hij best mee had mogen
pronken: de truc met `tr -dc` — alleen de bytes houden die binnen het alfabet
vallen en de rest weggooien — **introduceert geen vertekening**. Dat is de
juiste aanpak. De naïeve manier, de byte nemen en de rest berekenen na deling
door de grootte van het alfabet, bevoordeelt sommige tekens boven andere;
weggooien doet dat niet.

## Op een Mac geeft het commando één letter terug

Dit is het commando uit de tutorial voor een wachtwoord van letters en cijfers:

`cat /dev/urandom | tr -dc 'a-zA-Z0-9' | head -c 32`

Op de Mac, met de landinstellingen op Spaans, komt er dit uit:

`tr: Illegal byte sequence`

En daaronder een `E`. Eén letter. **De exitcode is 0**: voor de terminal is de
operatie geslaagd.

De oorzaak is dat de `tr` van macOS de invoer leest als tekst in de codering van
je landinstellingen, UTF-8, en willekeurige bytes vormen bijna nooit
geldige UTF-8. Zodra hij de eerste tegenkomt die niet past, stopt hij. Wat hij
tot dat moment had gefilterd — soms niets, soms een paar tekens — is wat bij
`head` aankomt, en `head` kan op geen enkele manier weten dat hij er 32
verwachtte.

Op Linux gebeurt dit niet: de `tr` van GNU werkt per byte en kijkt niet naar
de landinstellingen. We probeerden het in een Debian-container en de 32
tekens kwamen eruit. Daarom kan een tutorial die op Linux is geschreven en
getest, voor de schrijver prima kloppen en op de Mac van de lezer stukgaan.

De oplossing is een variabele ervoor: `LC_ALL=C tr -dc …`, die `tr` vertelt de
invoer als bytes te behandelen. Maar het belangrijke is niet de oplossing, het
is de manier waarop het misgaat. De functie `genpass` die de tutorial
voorstelt, in de `.bashrc` van een Mac gezet, print die `E` alsof het een
wachtwoord is. Plak je hem zonder op te letten in een veld zonder minimumlengte,
dan is dat meteen je wachtwoord.

## Het streepje dat geen streepje was

Voor de versie “met symbolen” gebruikt de tutorial dit alfabet:

`tr -dc 'a-zA-Z0-9!@#$%^&*()_+-=[]{}'`

De bedoeling is duidelijk: letters, cijfers en achttien symbolen. Maar voor
`tr` is een streepje tussen twee tekens een bereik, net als in `a-z`. Dus `+-=`
betekent niet “plus, streepje, is-gelijkteken”: het betekent **alles wat er tussen
`+` en `=` in de ASCII-tabel staat**, en dat zijn de komma, de punt, de
schuine streep, de tien cijfers, de dubbele punt, de puntkomma en het
kleiner-dan-teken.

We hebben het gemeten door twee miljoen bytes te genereren en de verschillende
tekens te tellen die eruit kwamen: 86, niet de beoogde 80. Op macOS en op Linux
hetzelfde. Het is geen beveiligingsprobleem — zes tekens meer geven iets meer
entropie, niet minder —, het probleem is dat je niet weet wat je genereert. Als het
systeem waar het wachtwoord heen gaat een `;` of een `<` weigert, faalt het
commando af en toe en is er geen manier om te raden waarom. De regel is: zet het
streepje aan het eind van de set, waar `tr` het als streepje leest.

En dat vertellen we met enige bescheidenheid, want bij het schrijven van de
verbeterde versie hieronder trapten we in een val uit dezelfde familie: we
zetten het alfabet als standaardwaarde van een parameter, `${2:-…{}-}`, en de
eerste sluitende accolade van het alfabet sloot de parameter af. Het resultaat
genereerde een `|` waar niemand om had gevraagd en was het streepje kwijt. We
zagen het alleen omdat we de tekens telden die eruit kwamen.

## 64 tekens die soms 58 zijn

De standaardmodus van de functie doet dit:

`openssl rand -base64 48 | tr -dc 'a-zA-Z0-9' | head -c "$LENGTH"`

48 bytes in base64 zijn 64 tekens. Maar base64 bevat `+` en `/`, en het filter
gooit die weg, dus wat overblijft is iets minder dan 64. Voor de standaardlengte
van 32 is dat ruim genoeg. Voor `genpass 64` niet: we draaiden het 200 keer en
**maar 28 keer kwamen er 64 tekens uit**; de rest zat tussen 58 en 63. Zonder
waarschuwing.

De hexadecimale modus heeft zijn eigen versie van hetzelfde probleem: hij deelt
de lengte door twee om het aantal bytes te berekenen, dus `genpass 15 hex`
geeft er 14.

## De beoordelaar die P@ssw0rd toejuicht

De tutorial sluit af met een script dat wachtwoorden een score geeft: punten
voor de lengte, één voor kleine letters, één voor hoofdletters, één voor cijfers
en twee voor symbolen. We draaiden het met een paar:

- `P@ssw0rd` — **STRONG**
- `Zomer2026!` — **STRONG**
- `correct-horse-battery-staple` — **STRONG**
- 35 keer de letter `a` — MODERATE

`P@ssw0rd` krijgt hetzelfde cijfer als vier willekeurige woorden. Het is een van
de eerste die elk aanvalswoordenboek probeert. Het script kan dat niet weten,
want het kijkt niet naar wat het wachtwoord *is*, alleen naar uit welke soorten
tekens het bestaat. Het is precies de regel van “een hoofdletter, een cijfer en
een symbool” die NIST in 2017 niet langer aanbeval, en waarover we al schreven
in [het
wachtwoordspel](/nl/blog/het-wachtwoordspel-en-de-regels-die-niets-beschermen/).

Er is nog een tweede, praktischer probleem: het script krijgt het wachtwoord
als argument mee, `./scorepass.sh "P@ssw0rd"`. Daardoor staat het in de
geschiedenis van je shell — in `~/.zsh_history` of `~/.bash_history` — en is het,
zolang het draait, zichtbaar voor elke andere gebruiker van de machine die de
processen opvraagt. Wil je een echt wachtwoord testen, dan kijkt de
[checker](/nl/wachtwoord-checker/) van deze site naar patronen, woordenboeken en
vervangingen zoals `@` voor `a`, en dat doet hij in je browser zonder iets te
versturen.

## Hoeveel is genoeg

De tutorial verkoopt de 256 bits van `openssl rand -base64 32` als “dezelfde
sterkte die banktransacties beschermt”. Het getal klopt en de vergelijking is
overbodig: 256 bits is veel meer dan een wachtwoord nodig heeft. Met het
aanvalsmodel van de rest van de site — 10¹² pogingen per seconde, offline en
met een snelle hash — zit je met 128 bits al op 10¹⁹ jaar. Niets mis met 256,
maar verwar “meer” niet met “nodig”. We leggen het uitgebreid uit in [hoe lang het
duurt om een wachtwoord te
kraken](/nl/blog/hoe-lang-duurt-het-echt-om-je-wachtwoord-te-kraken/).

Twee details over de formaten, die niet over beveiliging gaan maar over
gebruik:

- **base64 is niet URL-veilig**, ook al zegt de tutorial van wel: het bevat
  `+`, `/` en de `=` aan het eind. Die `=` is opvulling, geen toeval; de 256
  bits zitten in de 43 tekens ervoor. Er bestaat een variant, base64url, die
  `+` en `/` vervangt door `-` en `_`, maar `openssl rand -base64` gebruikt die
  niet.
- **Hexadecimaal geeft 4 bits per teken**, de helft van een alfabet met
  letters, cijfers en symbolen. `openssl rand -hex 32` levert 64 tekens en 256
  bits op: perfect voor een API-sleutel. Maar `genpass 16 hex` geeft 16 tekens
  en [64 bits](/nl/blog/wat-zijn-entropie-bits/), en die zijn met datzelfde
  aanvalsmodel gemiddeld in zo'n 107 dagen gekraakt. Het lijkt lang; zo lang is het niet.

## De woorden, en een voorbeeld dat uit geen enkel commando kwam

De modus `words` haalt woorden uit `/usr/share/dict/words` met `shuf`. Op een
Mac bestaat `shuf` niet: het is van GNU en macOS levert het niet mee, dus die
modus werkt gewoon niet. De lijst is er wel, met 235.976 woorden, wat met vier
woorden zo'n 71 bits zou geven. Veel. Het probleem is dat een groot deel woorden
zijn die je nog nooit hebt gezien, en het hele punt van een wachtzin is dat je
hem kunt onthouden.

Het voorbeeld dat de tutorial als uitvoer toont, `correct-horse-battery-staple`,
kwam uit geen enkel commando: het is de zin uit XKCD-strip 936, uit 2011. Die
strip heeft gelijk in wat hij zegt — vier willekeurig gekozen woorden winnen van
één woord met vervangingen —, maar de tutorial vat hem samen als “lengte wint
altijd van complexiteit”, en dat is niet wat hij zegt. Wat wint is **het aantal
opties waaruit willekeurig is gekozen**. Vijfendertig keer een `a` heeft lengte
genoeg en geen enkele entropie. Wil je goede wachtzinnen, dan gebruikt
[Diceware](/nl/blog/diceware-dobbelstenen-beter-wachtwoord/) een lijst van 7.776
woorden die gekozen zijn om te onthouden, met 12,9 bits per woord.

## Een versie die hardop faalt

Dit is wat wij voorstellen. We testten hem voor publicatie in bash en zsh op
macOS, en in bash op Linux:

```bash
genpass() {
  local n="${1:-20}" set='A-Za-z0-9!@#%^&*()_+=-' pw
  [ -n "$2" ] && set="$2"
  pw=$(LC_ALL=C tr -dc "$set" < /dev/urandom | head -c "$n")
  [ "${#pw}" -eq "$n" ] || { echo "genpass: mislukt" >&2; return 1; }
  printf '%s\n' "$pw"
}
```

Drie keuzes, elk vanwege een van de fouten hierboven:

- **`LC_ALL=C`** vóór `tr`, zodat hij op een Mac bytes leest en niet stopt.
- **Het streepje aan het eind van het alfabet**, zodat het een streepje is. We
  hebben het geteld: er komen precies de 75 tekens uit die er staan, niet één
  meer.
- **De lengtecontrole.** Komt er om wat voor reden ook een korter wachtwoord
  uit dan gevraagd, dan print de functie het niet, waarschuwt via de
  foutuitvoer en geeft een code anders dan 0 terug. Dat een generator faalt, is
  prima. Dat hij faalt en toch iets aflevert, mag niet gebeuren.

`genpass` geeft 20 tekens uit dat alfabet, zo'n 124 bits. `genpass 32` geeft er
32. `genpass 6 0-9` geeft een pincode. Het alfabet laat bewust `$`, de backtick
en de aanhalingstekens weg: dat zijn de tekens die een shell of een
configuratiebestand interpreteert, en een wachtwoord dat stukgaat als je het in
een `.env` plakt is niet veiliger, alleen lastiger.

## Wat de tutorial aan het eind goed doet

Het laatste deel van de tutorial is het beste: genereren is makkelijk, het
moeilijke is ze niet te hergebruiken. Een wachtwoord van 256 bits dat je op twee
sites gebruikt, is op allebei gecompromitteerd zodra een van de twee een datalek heeft.
Het voorstel — genereren in de terminal en bewaren in een wachtwoordmanager
zoals Bitwarden of KeePass — is precies [de enige regel die het heeft
overleefd](/nl/blog/je-wachtwoordmanager-tegen-je-geheugen/).

Nog één waarschuwing over de andere suggestie, kopiëren naar het klembord met
`pbcopy` of `xclip`. Dat is beter dan het op het scherm printen, maar het
klembord is geen privéplek: klembordbeheerders bewaren een geschiedenis, en op
een Mac met Handoff aan kan wat je kopieert ook op je iPhone verschijnen.
Kopieer, plak en kopieer er daarna iets anders overheen.

---

*Bronnen: de tutorial “Generate Unbreakable Passwords in Your Terminal Using
Pure Bash”, op 12 mei 2026 gepubliceerd op Medium · alle commando's zijn op 10
november 2026 uitgevoerd op macOS 27.2 (bash 3.2, zsh, de `tr` van het systeem,
OpenSSL 4.1) en in een stabiele Debian-container met GNU coreutils 9.7 ·
documentatie van OpenSSL, `RAND(7)`: deterministische generator volgens NIST SP
800-90A Rev. 1, gezaaid vanuit het besturingssysteem · manpagina `random(4)` van
Linux · Apple, Apple Platform Security, generatie van willekeurige getallen ·
XKCD 936, “Password Strength” (2011) · NIST SP 800-63B (2017) over de
samenstellingsregels · het aanvalsmodel, 10¹² pogingen per seconde offline en
met snelle hash, is hetzelfde als op de rest van de site.*
