Outil de génération et de validation de mots de passe

Outil professionnel de génération et de validation de mots de passe qui crée des mots de passe sécurisés et des phrases de passe mémorables, avec prise en charge de la génération par lots, la garantie d'unicité, l'évaluation de la force et la validation des règles. Dispose d'une source aléatoire cryptographiquement sécurisée, de jeux de caractères configurables, de filtres de caractères similaires, de statistiques de déduplication par lots et d'une fonction de copie en un clic. Comprend des exemples de code multilingues, une base de connaissances sur les mots de passe, des bonnes pratiques de sécurité et des outils de test de règles. Toutes les opérations sont effectuées localement dans votre navigateur, garantissant confidentialité et sécurité.

Testeur de politique de mots 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 (ex. : abc, 123) Interdire les répétitions excessives (ex. : aaaa)

Résultats

Longueur
Minuscules
Majuscules
Chiffres
Symboles
Séquences
Répétitions
Liste bloquée

Tous les contrôles sont effectués localement dans votre navigateur.

Générateur de phrases secrètes

Nombre de mots

Séparateur

Mettre la première lettre en majuscule Ajouter un chiffre

Les mots sont sélectionnés uniformément avec une aléatoire cryptographiquement sécurisée (Web Crypto) dans une liste de 1271 mots non ambigus ; 6 mots procurent environ 62 bits d'entropie — utilisez 8 mots pour une robustesse accrue.

Fiche récapitulative sur le hachage de mots de passe

Argon2id

Utilisez Argon2id avec des paramètres raisonnables à forte consommation mémoire
Temps ≥ 2 passages, mémoire ≥ 64 Mo (ajustez selon votre environnement)
Stockez un sel unique par utilisateur ; vous pouvez optionnellement utiliser un pepper au niveau de l'application

PBKDF2

Choisissez SHA-256 ou SHA-512 avec des itérations ≥ 210 000 (ajustez selon vos besoins)
Utilisez un sel unique pour chaque hash ; prenez en charge la mise à niveau des paramètres
Passez progressivement à des paramètres plus exigeants lors de la prochaine connexion de l'utilisateur

BCrypt

Définissez le coût entre 10 et 14, selon les capacités de votre serveur
Évitez les problèmes de tronçonnage ; hachez l'ensemble du mot de passe
Implémentez la limitation de débit et la surveillance sur les points d'accès à l'authentification

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

Évaluateur de robustesse des mots de passe

La robustesse est approximée par l'entropie : entropie = log2(taille du jeu de caractères) × longueur. Un jeu de caractères plus large et une longueur plus importante améliorent la résistance aux attaques par devinette.

Faible: < 50 bits — Convient uniquement pour des scénarios à usage unique ou de faible valeur
Moyen: 50–80 bits — Acceptable pour des scénarios à faible risque
Fort: 80–110 bits — Cible par défaut recommandée
Excellent: > 110 bits — Recommandé pour les comptes administrateur ou critiques

Remarque : Les modèles d'attaques réels peuvent varier ; évitez de réutiliser les mots de passe et activez l'authentification multifactorielle (MFA).

Comment l'utiliser

Sélectionnez la longueur et le jeu de caractères (minuscules/majuscules/chiffres/symboles) ; activez éventuellement Éviter les caractères similaires et Exiger chaque
Pour un contrôle plus précis : excluez des caractères ou groupes de caractères spécifiques, ou choisissez des sous-ensembles de symboles
Choisissez le nombre de mots de passe à générer, puis cliquez sur Générer ; les résultats par lots sont automatiquement dédoublonnés et peuvent être copiés d'un seul coup
Pour valider des mots de passe existants, utilisez le Testeur de règles ; pour des phrases de passe mémorables, utilisez le Générateur de phrases de passe

Fonctionnalités

Source aléatoire cryptographiquement sécurisée (Web Crypto)
Jeux de caractères et groupes de symboles configurables
Filtre de caractères similaires et exclusions personnalisées
Génération par lot de 1 à 100 mots de passe, toujours uniques
Indicateurs de force et d'entropie
Testeur de règles et Générateur de phrases de passe
Exemples de code multilingues
Copie en un clic (unique ou tous)

Exemples de génération de mots de passe

Fort

Longueur 24, inclut des majuscules, des minuscules, des chiffres et des symboles

Mémorable

Longueur 16, inclut des majuscules, des minuscules et des chiffres ; évite les caractères similaires

Base de connaissances sur les mots de passe

1) Force et entropie des mots de passe

Entropie ≈ log2(taille du jeu de caractères) × longueur ; la longueur contribue généralement le plus
Objectifs recommandés : Comptes généraux ≥ 80 bits ; Comptes à privilèges élevés/financiers ≥ 110 bits
Jeu de caractères plus vaste + longueur plus importante → meilleure résistance aux devinettes

2) Longueur vs. complexité

Ajouter aveuglément des symboles est moins efficace qu'augmenter la longueur
Évitez les modèles prévisibles (par ex. : toujours « Première lettre majuscule + chiffre final ! »)
Priorisez une longueur suffisante, puis augmentez modérément la diversité des caractères

3) Erreurs courantes et anti-modèles

Séquences clavier (par ex. : qwerty), blocs répétés, anniversaires/années sont facilement ciblées par les règles
Utiliser « mot de passe racine + suffixe site » crée une réutilisation de variantes, concentrant le risque et rendant les mots de passe plus faciles à deviner
Ne réutilisez jamais le même mot de passe sur plusieurs sites web

4) Recommandations de gestion des mots de passe

Utilisez un gestionnaire de mots de passe ; assurez-vous d'utiliser des mots de passe uniques par site ; activez l'authentification multifacteur (MFA) pour les comptes critiques
Évitez de transmettre des mots de passe en clair sur des canaux publics ; utilisez des phrases de passe « prononçables » si nécessaire
Modifiez immédiatement les mots de passe et rendez-les uniques si une fuite ou une réutilisation est détectée

5) Lignes directrices sur les phrases de passe

Les combinaisons de 4 à 6 mots aléatoires sont généralement solides et mémorables
Mélangez des séparateurs, mettez les premières lettres en majuscules et insérez des chiffres pour améliorer la robustesse et la lisibilité
Évitez de concaténer directement des expressions courantes, des paroles de chansons ou des citations célèbres

Bonnes pratiques de sécurité des mots de passe

Meilleures pratiques

Utilisez une longueur suffisante : 16 caractères minimum pour les comptes courants, 24 caractères minimum pour les comptes critiques
Pour faciliter la mémorisation, privilégiez les phrases de passe ; utilisez un gestionnaire de mots de passe pour stocker des mots de passe aléatoires de haute robustesse
Activez l’authentification multifacteur (MFA) dès que possible
Ne réutilisez jamais de mots de passe sur plusieurs sites : chaque compte doit disposer d’un mot de passe unique

Entropie et robustesse

L’entropie mesure l’imprévisibilité en fonction de la longueur et de la taille du jeu de caractères. Plus le nombre de bits d’entropie est élevé, plus le mot de passe est généralement robuste.

Privilégiez l’augmentation de la longueur pour obtenir le gain de robustesse maximum
Utilisez plusieurs jeux de caractères lorsque c’est possible
Exclure trop de caractères réduit le pool de caractères et affaiblit la robustesse

Politiques et rotation

Privilégiez les exigences de longueur et les listes noires de mots de passe courants/fuités plutôt que les règles de composition complexes
Évitez les rotations obligatoires fréquentes ; ne changez le mot de passe que lors de la détection d’une fuite ou d’un risque
Utilisez des listes de mots de passe compromis pour bloquer les mots de passe courants ou fuités

Phrases de passe

Utilisez 4 à 6 mots aléatoires joints par des séparateurs, par exemple : lac-CARROTE-planet_7
Évitez les citations célèbres, les paroles de chansons ou autres expressions courantes ; l’aléatoire importe plus que l’« ingéniosité »
Pour les comptes critiques, utilisez un gestionnaire de mots de passe pour stocker de véritables mots de passe aléatoires à haute entropie

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

« Exiger chaque jeu sélectionné » garantit qu’au moins un caractère de chaque catégorie choisie est présent
« Éviter les similaires » améliore la lisibilité mais réduit légèrement la taille du pool de caractères
Les symboles peuvent être limités à un sous-ensemble pris en charge par le système cible

Stockage côté serveur

Ne stockez jamais les mots de passe en clair ; utilisez un hachage robuste (Argon2id/PBKDF2/Bcrypt) avec un sel
Configurez les paramètres (mémoire/temps/coût) de manière appropriée ; envisagez d’utiliser un pepper si nécessaire
Limitez le taux de tentatives de connexion et surveillez les échecs ; appliquez des CAPTCHA ou une vérification de l’appareil pendant les attaques

Authentification multifacteur et récupération

Privilégiez TOTP ou des clés matérielles ; évitez autant que possible les SMS
Sécurisez les flux de récupération avec l’authentification multifacteur ou la vérification par e-mail et imposez des délais de refroidissement
Fournissez des codes de récupération de secours et encouragez les utilisateurs à les stocker en sécurité

Protection contre les attaques par force brute

Mettez en œuvre des retards progressifs ou des verrouillages avec une notation de risque par adresse IP/appareil
Appliquez des WAF et des limitations de taux sur les API et les formulaires de connexion
Surveillez le stuffing d’identifiants et encouragez les utilisateurs à adopter des mots de passe uniques

Stockage et manipulation locaux

Utilisez un gestionnaire de mots de passe réputé pour le stockage et la saisie automatique
Ne partagez jamais de mots de passe en clair par chat ou e-mail ; utilisez des outils de gestion de secrets pour les équipes
Si vous notez des mots de passe hors ligne, assurez-vous de leur sécurité physique

Avertissement : Cet outil génère des mots de passe localement dans votre navigateur à l'aide de Web Crypto ; aucune donnée n'est envoyée à un serveur quelconque.

Comment générer des mots de passe avec 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');
  // Rejection sampling removes modulo bias
  const limit = Math.floor(0x100000000 / pool.length) * pool.length;
  const buf = new Uint32Array(1);
  let out = '';
  for (let i = 0; i < length; i++) {
    do { crypto.getRandomValues(buf); } while (buf[0] >= limit);
    out += pool[buf[0] % 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) {
    // GetInt32 draws an unbiased value in [0, pool.Length)
    var chars = new char[length];
    for (int i = 0; i < length; i++) {
      chars[i] = pool[RandomNumberGenerator.GetInt32(pool.Length)];
    }
    return new string(chars);
  }
}

Rust (rand + getrandom)

use rand::rngs::OsRng;
use rand::Rng;

fn random_password(length: usize, pool: &str) -> String {
    // gen_range is uniform, so there is no modulo bias
    let chars: Vec = pool.chars().collect();
    (0..length)
        .map(|_| chars[OsRng.gen_range(0..chars.len())])
        .collect()
}

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