Wachtwoordgenerator en -validator

Genereer sterke wachtwoorden en wachtwoordzinnen, met ondersteuning voor batchgeneratie, uniciteit, sterkte- en beleidscontrole, plus codevoorbeelden in meerdere talen en praktische kennis.

Wachtwoordbeleidstester

Te testen wachtwoord

Minimale lengte Vereist kleine letters Vereist grote letters Vereist cijfers Vereist symbolen Verbied opeenvolgende patronen (zoals abc, 123) Verbied te lange herhalingen (zoals aaaa)

Resultaten

Lengte
Kleine letters
Grote letters
Cijfers
Symbolen
Opeenvolgende reeksen
Herhalingen
Blacklist

Alle controles worden lokaal in je browser uitgevoerd.

Wachtwoordzin-generator

Aantal woorden

Scheidingsteken

Hoofdletter bij het begin Voeg cijfer toe

Woorden worden veilig willekeurig gekozen met Web Crypto. De demo-woordenlijst is beperkt vanwege bestandsgrootte.

Snelgids voor wachtwoordhashing

Argon2id

Gebruik Argon2id met een redelijke geheugenvaste parameter
Tijd ≥ 2 iteraties, geheugen ≥ 64 MB (aanpassen aan omgeving)
Unieke salt per gebruiker; optioneel gebruik van pepper op applicatieniveau

PBKDF2

Kies SHA-256 of SHA-512 met ≥ 210.000 iteraties (aanpassen aan behoeften)
Unieke salt per hash; ondersteunt parametervooruitgang
Migreer naar hogere kostenparameters bij volgende login van de gebruiker

BCrypt

Kostencost tussen 10 en 14, afhankelijk van servercapaciteit
Voorkom truncatieproblemen; hash het volledige wachtwoord
Implementeer rate limiting en monitoring voor authenticatie-eindpunten

Referentie: NIST SP 800-63B, OWASP ASVS. Parameters moeten aangepast zijn aan hardwarecapaciteit en SLO.

Wachtwoordsterkte-evaluatie

De sterke schatting komt uit de entropie: entropy = log2(tekenpoolgrootte) × lengte. Een grotere tekenpool en langere lengte verhogen de weerstand tegen gokken.

Zwak: < 50 bits —— Geschikt alleen voor eenmalige/laagwaardige scenario's
Matig: 50–80 bits —— Aanvaardbaar voor laagrisico scenario's
Sterk: 80–110 bits —— Aanbevolen standaardoogmerk
Uitstekend: > 110 bits —— Geschikt voor beheerders/kritieke accounts

Tip: Echte aanvalsmodellen kunnen verschillen; vermijd wachtwoordhergebruik en activeer multi-factor authenticatie (MFA).

Gebruiksaanwijzing

Kies lengte en tekenset (kleine letters/grote letters/cijfers/symbolen); schakel 'Avoid similar' en 'Require each' in indien nodig
Voor fijnere controle: exclude specifieke tekens of tekengroepen, of kies een symbolengroep
Klik op genereren; voor meerdere resultaten, schakel batchgeneratie in en kopieer alles met één klik
Om bestaande wachtwoorden te valideren, gebruik de 'Beleidstester'; voor gemakkelijk te onthouden wachtwoorden, gebruik de 'Wachtwoordzin-generator'

Functies

Veilige willekeurige bron (Web Crypto)
Configureerbare tekensets en symbolengroepen
Filtering van gelijkende tekens en aangepaste uitsluitingen
Batchgeneratie, uniciteitsgarantie en deduplicatie-statistieken
Sterkte- en entropie-metingen
Beleidstester en wachtwoordzin-generator
Codevoorbeelden in meerdere talen （JS、Python、PHP、Go、Java、C#、Rust）
Eén-klik kopiëren (één of alle wachtwoorden)

Voorbeelden van wachtwoordgeneratie

Sterk (Strong)

Lengte 24, inclusief grote/kleine letters, cijfers en symbolen

Makkelijk te onthouden (Memorable)

Lengte 16, inclusief grote/kleine letters en cijfers, vergelijkbare tekens vermeden

Wachtwoordkennisbank

1) Wachtwoordsterkte en entropie

Entropie ≈ log2(grootte van het tekenset) × lengte; lengte heeft meestal meer invloed
Aanbevolen doel: gewone accounts ≥ 80 bits; hoogrechten/financieel ≥ 110 bits
Grotere tekenset + langere lengte → beter bestand tegen gokken

2) Lengte vs. complexiteit

Blindelings symbolen toevoegen is minder effectief dan de lengte verhogen
Vermijd voorspelbare patronen (zoals steeds 'hoofdletter + eindcijfer!')
Zorg eerst voor voldoende lengte, en verhoog daarna matig de karakterdiversiteit

3) Veelvoorkomende fouten en anti-patterns

Toetsenbordreeksen (qwerty), herhalende blokken, geboortedata/jaren zijn gemakkelijk te raden met regels
'Basiswachtwoord + website-suffix' is een variant van hergebruik, wat risico's concentreert en makkelijk te raden is
Gebruik niet hetzelfde wachtwoord op meerdere websites

4) Aanbevelingen voor wachtwoordbeheer

Gebruik een wachtwoordmanager; uniek wachtwoord per site; activeer MFA voor belangrijke accounts
Verstuur geen wachtwoorden in klare tekst via openbare kanalen; gebruik indien nodig 'uitspreekbare' wachtwoorden
Wijzig onmiddellijk en maak uniek als een lekkage of hergebruik wordt ontdekt

5) Richtlijnen voor wachtwoordzinnen (Passphrase)

Een combinatie van 4–6 woorden is meestal sterk en gemakkelijk te onthouden
Gebruik mengelingen van scheidingstekens, hoofdletters en cijfers om kracht en leesbaarheid te verbeteren
Vermijd directe kopieën van bekende zinnen, songteksten of citaten

Richtlijnen voor wachtwoordveiligheid

Best practices

Gebruik zo lang mogelijk wachtwoorden: 16+ tekens voor gewone accounts, 24+ voor cruciale accounts
Gebruik wachtzinnetjes voor gemakkelijk onthouden; voor willekeurige, sterke wachtwoorden gebruik een wachtwoordbeheerder
Schakel altijd meervoudige authenticatie (MFA) in waar mogelijk
Gebruik geen herhaalde wachtwoorden op verschillende sites; elk account moet een uniek wachtwoord hebben

Entropie en sterkte

Entropie meet de onvoorspelbaarheid op basis van lengte en grootte van het karakterbestand; hogere entropie betekent meestal meer veiligheid.

Verhoog de lengte om het grootste veiligheidsvoordeel te behalen
Gebruik indien mogelijk meerdere character sets
Te veel karakters uitsluiten verkleint het karakterbestand en verlaagt de sterkte

Beleid en wisseling

Kies voor lengte en een blacklist van veelgebruikte/lekkende wachtwoorden boven complexe samenstellingsregels
Vermijd frequente, gedwongen wachtwoordwisselingen; wijzig alleen bij een lek of verhoogd risico
Gebruik lijsten met bekende/lekkende wachtwoorden om deze te blokkeren

Wachtzinnetjes

Gebruik 4–6 willekeurige woorden gescheiden door scheidingstekens, bijvoorbeeld lake-CARROT-planet_7
Vermijd bekende zinnen, citaten of songteksten; willekeurigheid is belangrijker dan 'sluwheid'
Voor cruciale accounts raadt u aan een echte, hoog-entropische willekeurige wachtwoord te bewaren met een wachtwoordbeheerder

Tips voor generatie-instellingen

"Require each selected set" zorgt ervoor dat ten minste één teken uit elke geselecteerde groep wordt gebruikt
"Avoid similar" verhoogt de leesbaarheid, maar verkleint lichtjes het karakterbestand
Symbolen kunnen worden beperkt tot een subset die door het doelsysteem wordt ondersteund

Server-side opslag

Bewaar nooit wachtwoorden in plaintext; gebruik sterke hashing (Argon2id/PBKDF2/BCrypt) met salt
Stel parameters (geheugen/tijd/kosten) passend in; overweeg pepper als extra maatregel
Beperk de rate en monitoreer mislukte pogingen; voeg CAPTCHA of apparaatverificatie toe bij aanvallen

Meervoudige authenticatie en herstel

Kies voor TOTP/hardware-sleutels; vermijd SMS zoveel mogelijk
Bescherm herstelprocedures met meervoudige factoren of e-mailverificatie en voeg een cooling-off periode toe
Bied back-up herstelcodes aan en adviseer gebruikers ze veilig op te slaan

Bescherming tegen brute-force-aanvallen

Gebruik progressieve vertragingen/locks en IP/apparaat-risicoscores
Configureer WAF/limieten voor API’s en inlogformulieren
Monitoreer credential stuffing en moedig gebruikers aan om unieke wachtwoorden te gebruiken

Lokale opslag en verwerking

Gebruik een betrouwbare wachtwoordbeheerder voor opslag en automatisch invullen
Deel wachtwoorden nooit in plaintext via chat of e-mail; gebruik voor teams een geheimenbeheertool
Als u fysieke opslag nodig heeft, zorg dan voor fysieke beveiliging

Disclaimer: Deze tool genereert wachtwoorden lokaal in de browser met Web Crypto; er wordt geen data naar de server verzonden.

Hoe wachtwoorden genereren via programmeertalen

JavaScript（Web Crypto）

function randomPassword(length = 16, sets = {lower:true, upper:true, digits:true, symbols:true}) {
  const pools = {
    lower: 'abcdefghijklmnopqrstuvwxyz',
    upper: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
    digits: '0123456789',
    symbols: '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
  };
  let pool = '';
  for (const k of Object.keys(sets)) if (sets[k]) pool += pools[k];
  if (!pool) throw new Error('No charset');
  const bytes = new Uint32Array(length);
  crypto.getRandomValues(bytes);
  let out = '';
  for (let i = 0; i < length; i++) out += pool[bytes[i] % pool.length];
  return out;
}

Python（secrets）

import secrets

def random_password(length=16, lower=True, upper=True, digits=True, symbols=True):
    pools = {
        'lower': 'abcdefghijklmnopqrstuvwxyz',
        'upper': 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
        'digits': '0123456789',
        'symbols': '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
    }
    pool = ''.join(v for k, v in pools.items() if locals()[k])
    if not pool:
        raise ValueError('No charset')
    return ''.join(secrets.choice(pool) for _ in range(length))

PHP（random_int）

function random_password($length = 16, $sets = ['lower'=>true,'upper'=>true,'digits'=>true,'symbols'=>true]) {
    $pools = [
        'lower' => 'abcdefghijklmnopqrstuvwxyz',
        'upper' => 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
        'digits' => '0123456789',
        'symbols' => '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
    ];
    $pool = '';
    foreach ($sets as $k => $on) if ($on) $pool .= $pools[$k];
    if ($pool === '') throw new Exception('No charset');
    $out = '';
    for ($i = 0; $i < $length; $i++) {
        $out .= $pool[random_int(0, strlen($pool)-1)];
    }
    return $out;
}

Go（crypto/rand）

package main

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

func RandomPassword(length int, pool string) (string, error) {
  out := make([]byte, length)
  for i := 0; i < length; i++ {
    nBig, err := rand.Int(rand.Reader, big.NewInt(int64(len(pool))))
    if err != nil { return "", err }
    out[i] = pool[nBig.Int64()]
  }
  return string(out), nil
}

Java（SecureRandom）

import java.security.SecureRandom;

public class Pw {
  static final String POOL = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*+-=_~`|/?()[]{}<>,.;:'\"";
  static final SecureRandom SR = new SecureRandom();
  static String randomPassword(int length) {
    StringBuilder sb = new StringBuilder(length);
    for (int i = 0; i < length; i++) {
      int idx = SR.nextInt(POOL.length());
      sb.append(POOL.charAt(idx));
    }
    return sb.toString();
  }
}

C#（.NET RandomNumberGenerator）

using System;
using System.Security.Cryptography;

public static class Pw {
  public static string RandomPassword(int length, string pool) {
    using var rng = RandomNumberGenerator.Create();
    var bytes = new byte[length];
    rng.GetBytes(bytes);
    var chars = new char[length];
    for (int i = 0; i < length; i++) {
      chars[i] = pool[bytes[i] % pool.Length];
    }
    return new string(chars);
  }
}

Rust（rand + getrandom）

use rand::rngs::OsRng;
use rand::RngCore;

fn random_password(length: usize, pool: &str) -> String {
    let mut bytes = vec![0u8; length];
    OsRng.fill_bytes(&mut bytes);
    let chars: Vec = pool.chars().collect();
    bytes
        .iter()
        .map(|b| chars[(*b as usize) % chars.len()])
        .collect()
}

fn main() {
    let pool = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*+-=_~`|/?()[]{}<>,.;:'\"";
    let pw = random_password(16, pool);
    println!("{}", pw);
}