Password Generator

Wat is een Password Generator?

Een wachtwoordgenerator maakt willekeurige tekenreeksen die worden gebruikt als wachtwoorden voor gebruikersaccounts, API-sleutels, databasereferenties en versleutelingsgeheimen. In tegenstelling tot door mensen gekozen wachtwoorden putten gegenereerde wachtwoorden uit de volledige ruimte van mogelijke tekencombinaties, waardoor ze bestand zijn tegen woordenboekaanvallen en patroongebaseerd raden. Dit hulpmiddel genereert sterke willekeurige wachtwoorden online met behulp van de ingebouwde cryptografische willekeurige nummergenerator van je browser.

De sterkte van een wachtwoord hangt af van twee factoren: lengte en tekendiversiteit. Een wachtwoord van 20 tekens met hoofdletters, kleine letters, cijfers en symbolen heeft ongeveer 131 bits entropie. Op dat niveau zou een brute-force-aanval die één biljoen gissingen per seconde test langer duren dan de leeftijd van het universum om elke combinatie te proberen. De berekening is eenvoudig: entropie = lengte × log2(tekensetgrootte).

Standaarden zoals NIST SP 800-63B bevelen wachtwoorden aan van minimaal 8 tekens zonder bovenlimiet die door de verificateur wordt afgedwongen, en ontmoedigen verplichte samenstellingsregels zoals het vereisen van precies één symbool, waarbij langere wachtzinnen de voorkeur krijgen. Voor machine-naar-machine-referenties en serviceaccounts is 20 of meer willekeurige tekens uit een volledige tekenset de geaccepteerde basislijn in de meeste beveiligingsframeworks en complianceregimes.

Waarom een Password Generator gebruiken?

Mensen zijn slechte willekeurige nummergeneratoren. We hergebruiken wachtwoorden, kiezen woordenboekwoorden, vervangen letters door voorspelbare patronen (@ voor a, 3 voor e) en kiezen standaard voor korte tekenreeksen. Een wachtwoordgenerator verwijdert menselijke vooringenomenheid uit het proces.

Toepassingen van de Password Generator

Referentietabel Wachtwoordentropie

Entropie meet hoe onvoorspelbaar een wachtwoord is. Het wordt berekend als log2(tekensetgrootte ^ lengte). Hogere entropie betekent meer mogelijke combinaties die een aanvaller moet doorzoeken. NIST en OWASP bevelen minimaal 80 bits entropie aan voor beveiligingsgevoelige toepassingen.

Kraaktijden gaan uit van 1 biljoen gissingen per seconde (offline aanval met moderne GPU's). Online aanvallen met snelheidsbeperking zijn meerdere ordes van grootte langzamer.

CSPRNG vs Math.random() voor wachtwoordgeneratie

De bron van willekeurigheid is net zo belangrijk als de wachtwoordlengte. Een wachtwoord gegenereerd met een voorspelbare willekeurige nummergenerator kan worden gereconstrueerd door een aanvaller die het algoritme en de seed-toestand kent. Dit hulpmiddel gebruikt crypto.getRandomValues(), een cryptografisch veilige pseudowillekeurige nummergenerator (CSPRNG) die is ingebouwd in elke moderne browser.

Codevoorbeelden

Genereer wachtwoorden programmatisch in verschillende programmeertalen. Elk onderstaand voorbeeld gebruikt een cryptografisch veilige willekeurige bron, niet Math.random() of vergelijkbare zwakke PRNG's.

// Generate a random password in the browser or Node.js 19+
function generatePassword(length = 20) {
  const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*'
  const values = new Uint32Array(length)
  crypto.getRandomValues(values)
  return Array.from(values, v => charset[v % charset.length]).join('')
}

console.log(generatePassword())    // → "kR7!mZp$Xw2&nLq9@Yf3"
console.log(generatePassword(32))  // → "Hd4%tNx!Qw8#mKp2Rv6&Zj0*Ls3Yb7@"

import secrets
import string

def generate_password(length: int = 20) -> str:
    """Generate a cryptographically secure random password."""
    alphabet = string.ascii_letters + string.digits + string.punctuation
    return ''.join(secrets.choice(alphabet) for _ in range(length))

# Single password
print(generate_password())      # → "kR7!mZp$Xw2&nLq9@Yf3"

# Batch of 5 passwords
for _ in range(5):
    print(generate_password(24))

# Ensure at least one char from each category
def generate_strong(length: int = 20) -> str:
    required = [
        secrets.choice(string.ascii_uppercase),
        secrets.choice(string.ascii_lowercase),
        secrets.choice(string.digits),
        secrets.choice(string.punctuation),
    ]
    remaining = length - len(required)
    alphabet = string.ascii_letters + string.digits + string.punctuation
    all_chars = required + [secrets.choice(alphabet) for _ in range(remaining)]
    secrets.SystemRandom().shuffle(all_chars)
    return ''.join(all_chars)

# OpenSSL — generate 32 random bytes, base64-encode
openssl rand -base64 32
# → "x7Kp2mNqR4wZ8vLs1Yb0Hd6tFj3Xc9Ga5eUi+Wo="

# /dev/urandom with tr — alphanumeric + symbols, 20 chars
tr -dc 'A-Za-z0-9!@#$%^&*' < /dev/urandom | head -c 20; echo
# → "kR7!mZp$Xw2&nLq9@Yf3"

# pwgen (install: apt install pwgen / brew install pwgen)
pwgen -sy 20 5
# Generates 5 passwords, 20 chars each, with symbols

package main

import (
    "crypto/rand"
    "fmt"
    "math/big"
)

func generatePassword(length int) (string, error) {
    charset := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()"
    result := make([]byte, length)
    for i := range result {
        idx, err := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
        if err != nil {
            return "", err
        }
        result[i] = charset[idx.Int64()]
    }
    return string(result), nil
}

func main() {
    pwd, _ := generatePassword(20)
    fmt.Println(pwd) // → "kR7!mZp$Xw2&nLq9@Yf3"
}

Veelgestelde vragen