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

Gepubliceerd op door David Carrero

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, 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 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.

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 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.

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, 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 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:

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.

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.

Foto van Luis Gomes · Pexels

← Terug naar de blog