Générateur de mots de passe

Qu'est-ce qu'un générateur de mots de passe ?

Un générateur de mots de passe crée des chaînes de caractères aléatoires utilisées comme mots de passe pour les comptes utilisateurs, les clés API, les identifiants de bases de données et les secrets de chiffrement. Contrairement aux mots de passe choisis par les humains, les mots de passe générés exploitent l'espace complet des combinaisons de caractères possibles, les rendant résistants aux attaques par dictionnaire et aux devinettes basées sur des schémas. Cet outil génère des mots de passe aléatoires et robustes en ligne en utilisant le générateur de nombres aléatoires cryptographique intégré à ton navigateur.

La robustesse d'un mot de passe dépend de deux facteurs : la longueur et la diversité des caractères. Un mot de passe de 20 caractères utilisant des majuscules, des minuscules, des chiffres et des symboles possède environ 131 bits d'entropie. À ce niveau, une attaque par force brute testant mille milliards de tentatives par seconde nécessiterait plus longtemps que l'âge de l'univers pour essayer toutes les combinaisons. Le calcul est simple : entropie = longueur × log2(taille du jeu de caractères).

Des normes comme NIST SP 800-63B recommandent des mots de passe d'au moins 8 caractères sans limite supérieure imposée par le vérificateur, et déconseillent les règles de composition forcée comme l'exigence d'exactement un symbole, en favorisant plutôt des phrases de passe plus longues. Pour les identifiants machine-à-machine et les comptes de service, 20 caractères aléatoires ou plus tirés d'un jeu de caractères complet constituent la référence acceptée dans la plupart des cadres de sécurité et des régimes de conformité.

Pourquoi utiliser un générateur de mots de passe ?

Les humains sont de mauvais générateurs de nombres aléatoires. Nous réutilisons des mots de passe, choisissons des mots du dictionnaire, substituons des lettres par des schémas prévisibles (@ pour a, 3 pour e) et optons par défaut pour des chaînes courtes. Un générateur de mots de passe élimine les biais humains du processus.

Cas d'usage du générateur de mots de passe

Référence sur l'entropie des mots de passe

L'entropie mesure l'imprévisibilité d'un mot de passe. Elle est calculée comme log2(taille_du_jeu ^ longueur). Une entropie plus élevée signifie davantage de combinaisons possibles à parcourir pour un attaquant. NIST et OWASP recommandent au moins 80 bits d'entropie pour les applications à haute sécurité.

Les temps de craquage supposent 1 000 milliards de tentatives par seconde (attaque hors ligne avec des GPU modernes). Les attaques en ligne avec limitation de débit sont plusieurs ordres de grandeur plus lentes.

CSPRNG vs Math.random() pour la génération de mots de passe

La source d'aléatoire est aussi importante que la longueur du mot de passe. Un mot de passe généré avec un générateur de nombres aléatoires prévisible peut être reconstruit par un attaquant qui connaît l'algorithme et l'état d'initialisation. Cet outil utilise crypto.getRandomValues(), un générateur de nombres pseudo-aléatoires cryptographiquement sûr (CSPRNG) intégré à tous les navigateurs modernes.

Exemples de code

Génère des mots de passe par programmation dans différents langages. Chaque exemple ci-dessous utilise une source aléatoire cryptographiquement sûre, et non Math.random() ou des PRNG faibles équivalents.

// 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"
}

Questions fréquentes