Outil de génération et de vérification de mots de passe

Générez des mots de passe forts et des phrases de passe, avec prise en charge de la génération en lot, de la vérification d'unicité, de la force et des politiques, ainsi que des exemples de code multilingues et des connaissances pratiques.

Testeur de stratégie de mot de passe

Mot de passe à tester

Longueur minimale Exiger des lettres minuscules Exiger des lettres majuscules Exiger des chiffres Exiger des symboles Interdire les séquences consécutives (ex. abc, 123) Interdire les répétitions excessives (ex. aaaa)

Résultats

Longueur
Lettres minuscules
Lettres majuscules
Chiffres
Symboles
Séquences consécutives
Répétitions
Liste noire

Toutes les vérifications sont effectuées localement dans votre navigateur.

Générateur de phrases de passe

Nombre de mots

Séparateur

Mettre la première lettre en majuscule Ajouter un chiffre

Les mots sont sélectionnés aléatoirement de manière sécurisée (Web Crypto). La liste de mots utilisée ici est limitée en taille pour des raisons de performance.

Tableau de référence pour le hachage de mots de passe

Argon2id

Utiliser Argon2id avec des paramètres mémoire élevés et adaptés
Au moins 2 itérations et 64 Mo de mémoire (ajuster selon l'environnement)
Utiliser un sel unique par utilisateur ; optionnellement, appliquer un pepper au niveau de l'application

PBKDF2

Choisir SHA-256 ou SHA-512 avec au moins 210 000 itérations (ajuster selon les besoins)
Utiliser un sel unique pour chaque hachage ; prendre en charge la mise à niveau des paramètres
Migrer vers des paramètres plus coûteux lors de la prochaine connexion de l'utilisateur

BCrypt

Coût entre 10 et 14, en fonction des capacités du serveur
Éviter les troncatures ; hacher le mot de passe complet
Appliquer un limitateur et surveiller les points d'authentification

Référence : NIST SP 800-63B, OWASP ASVS. Les paramètres doivent être adaptés aux capacités matérielles et aux SLO.

Évaluation de la force du mot de passe

La force est estimée à partir de l'entropie : entropie = log2(taille du jeu de caractères) × longueur. Un jeu de caractères plus vaste et une longueur plus grande améliorent la résistance aux tentatives de devinette.

Faible: < 50 bits —— Convient uniquement aux scénarios ponctuels ou à faible valeur
Moyen: 50–80 bits —— Acceptable pour les scénarios à faible risque
Fort: 80–110 bits —— Objectif recommandé par défaut
Très fort: > 110 bits —— Recommandé pour les comptes administrateurs ou critiques

Remarque : Les modèles d'attaque réels peuvent varier ; évitez la réutilisation des mots de passe et activez l'authentification à deux facteurs (MFA).

Instructions d'utilisation

Choisissez la longueur et l'ensemble de caractères (minuscules/majuscules/chiffres/symboles) ; activez éventuellement « Éviter les caractères similaires » et « Exiger chaque type »
Pour un contrôle plus fin : excluez des caractères ou groupes de caractères, ou sélectionnez des groupes de symboles spécifiques
Cliquez sur Générer ; pour obtenir plusieurs résultats, activez la génération en lot et copiez tout d'un clic
Pour vérifier un mot de passe existant, utilisez le « Testeur de politique » ; pour créer une phrase de passe facile à retenir, utilisez le « Générateur de phrases de passe »

Fonctionnalités

Source aléatoire cryptographiquement sécurisée (Web Crypto)
Ensembles de caractères et groupes de symboles configurables
Filtrage des caractères similaires et exclusion personnalisée
Génération en lot, garantie d'unicité et statistiques de dédoublonnage
Évaluation de la force et indicateur d'entropie
Testeur de politique et générateur de phrases de passe
Exemples de code dans plusieurs langages （JS、Python、PHP、Go、Java、C#、Rust）
Copie unique (un seul mot de passe / tous les mots de passe)

Exemples de génération de mots de passe

Fort (Strong)

Longueur 24, incluant lettres majuscules/minuscules, chiffres et symboles

Mémorisable (Memorable)

Longueur 16, incluant lettres majuscules/minuscules et chiffres, en évitant les caractères similaires

Base de connaissances sur les mots de passe

1) Force du mot de passe et entropie

Entropie ≈ log2(taille du jeu de caractères) × longueur ; la longueur a généralement un impact plus fort
Objectif recommandé : comptes ordinaires ≥ 80 bits ; comptes à haut privilège / financiers ≥ 110 bits
Un jeu de caractères plus vaste + une longueur plus grande → meilleure résistance aux tentatives de devinette

2) Longueur vs complexité

Ajouter aveuglément des symboles est moins efficace qu'augmenter la longueur
Évitez les modèles prévisibles fixes (ex. : « Majuscule au début + chiffre à la fin ! »)
Priorisez d'abord une longueur suffisante, puis augmentez modérément la diversité des caractères

3) Erreurs courantes et anti-modèles

Suites clavier (qwerty), blocs répétés, dates de naissance/années — facilement ciblés par des règles
« Mot de passe racine + suffixe du site » est une réutilisation variantée, risquée et facile à deviner
N'utilisez jamais le même mot de passe sur plusieurs sites

4) Recommandations pour la gestion des mots de passe

Utilisez un gestionnaire de mots de passe ; utilisez un mot de passe unique par site ; activez l'authentification à deux facteurs (MFA) pour les comptes sensibles
Évitez de transmettre les mots de passe en clair via des canaux publics ; utilisez des phrases passe « faciles à prononcer » si nécessaire
Si une fuite ou une réutilisation est détectée, changez immédiatement le mot de passe et assurez-vous qu'il soit unique

5) Guide des phrases passe (Passphrase)

Une combinaison de 4 à 6 mots est généralement forte et facile à retenir
Mélangez des séparateurs, utilisez des majuscules au début et insérez des chiffres pour renforcer la force et la lisibilité
Évitez les concaténations directes de phrases courantes, de paroles de chansons ou de citations célèbres

Guide des bonnes pratiques de sécurité pour les mots de passe

Bonnes pratiques

Utilisez des mots de passe suffisamment longs : 16+ caractères pour les comptes courants, 24+ pour les comptes critiques
Privilégiez les phrases de passe pour la mémorisation ; utilisez un gestionnaire de mots de passe pour stocker les mots de passe aléatoires à haute intensité
Activez autant que possible l'authentification à plusieurs facteurs (MFA)
N'utilisez jamais le même mot de passe sur plusieurs sites ; chaque compte doit avoir un mot de passe unique

Entropie et force

L'entropie mesure l'imprévisibilité en fonction de la longueur et de la taille de l'ensemble de caractères ; plus le nombre de bits d'entropie est élevé, plus le mot de passe est généralement fort.

Augmentez la longueur pour obtenir le meilleur gain en sécurité
Utilisez autant que possible plusieurs jeux de caractères
Exclure excessivement certains caractères réduit la taille du jeu et affaiblit le mot de passe

Politiques et renouvellement

Privilégiez la longueur et une liste noire de mots de passe courants ou compromis plutôt que des règles de composition complexes
Évitez les renouvellements fréquents obligatoires ; changez uniquement en cas de compromission ou de risque identifié
Utilisez des listes de mots de passe compromis pour bloquer les mots de passe courants ou divulgués

Phrases de passe

Utilisez 4 à 6 mots aléatoires séparés par des symboles, par exemple : lake-CARROT-planet_7
Évitez les citations, chansons ou phrases connues ; la randomité prime sur l'ingéniosité
Pour les comptes critiques, privilégiez un gestionnaire de mots de passe pour stocker des mots de passe aléatoires à très haute entropie

Conseils pour les paramètres de génération

"Require each selected set" garantit qu'au moins un caractère de chaque type sélectionné est présent
"Avoid similar" améliore la lisibilité, mais réduit légèrement la taille du jeu de caractères
Les symboles peuvent être limités au sous-ensemble accepté par le système cible

Stockage côté serveur

Ne jamais stocker les mots de passe en clair ; utilisez un hachage fort (Argon2id / PBKDF2 / BCrypt) avec sel
Configurez correctement les paramètres (mémoire / temps / coût) ; utilisez un pepper si nécessaire
Limitez le taux de tentatives et surveillez les échecs ; en cas d'attaque, ajoutez un CAPTCHA ou une vérification d'appareil

Authentification à plusieurs facteurs et récupération

Privilégiez TOTP ou clés matérielles ; évitez autant que possible SMS
Protégez les processus de récupération : utilisez plusieurs facteurs ou vérification par e-mail avec période de mise en attente
Fournissez des codes de récupération de secours et conseillez aux utilisateurs de les conserver en sécurité

Protection contre les attaques par force brute

Implémentez des délais progressifs ou des blocages basés sur des scores de risque IP/appareil
Configurez un WAF et des limites de débit pour les formulaires de connexion et les API
Surveillez les attaques par re-use de mots de passe et encouragez les utilisateurs à utiliser des mots de passe uniques

Stockage et traitement locaux

Utilisez un gestionnaire de mots de passe fiable pour le stockage et le remplissage automatique
Ne partagez jamais de mots de passe en clair par messagerie ou e-mail ; utilisez des outils de gestion des secrets pour les équipes
Si vous devez les noter physiquement, assurez-vous qu'ils sont conservés en toute sécurité

Avertissement : cet outil génère les mots de passe localement dans le navigateur à l'aide de Web Crypto ; aucune donnée n'est envoyée au serveur.

Comment générer des mots de passe via des langages de programmation

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);
}