Générateur de mot de passe

Un boîtier de bois avec un bouton et un écran. On appuie, il affiche douze caractères tirés au hasard : une majuscule, une minuscule, un chiffre, un caractère spécial au minimum. Rien n’est enregistré, rien ne sort de la boîte.

Le besoin de départ

« Choisissez un mot de passe fort. » La consigne est partout, et elle demande précisément ce qu’un cerveau humain ne sait pas faire : produire du hasard. Ce qu’on invente porte toujours une date de naissance, un prénom, une suite de touches voisines ; et ce qu’on trouverait vraiment aléatoire, on ne le retiendrait pas.

La recommandation officielle ne se discute donc pas, elle se délègue. L’ANSSI demande douze caractères mêlant les quatre familles ; c’est un cahier des charges, pas un conseil de prudence.

D’où l’objet : une machine qui applique la règle, posée sur la table, qu’on tient dans la main. Le détour est pédagogique autant que pratique ; fabriquer le générateur oblige à comprendre ce qui fait la force d’un mot de passe, là où l’écouter dire ne l’oblige à rien.

Comment ça marche

Trois éléments : un bouton, un écran, une carte qui fait le tirage.

Le boîtier fermé, tel qu’il sort de l’atelier. Le câble ne sert qu’à l’alimentation : l’objet ne communique avec rien.

On appuie sur le bouton vert. La diode cligne, le temps du tirage, et douze caractères s’affichent sur l’écran. C’est tout : pas de menu, pas de réglage, pas de second écran.

La garantie tient dans l’ordre du tirage. Les quatre premiers caractères sont pris un dans chaque famille (une majuscule, une minuscule, un chiffre, un signe), et les huit suivants dans l’une des quatre au hasard. Le mot de passe ne peut donc pas sortir sans remplir le critère de l’ANSSI : ce n’est pas vérifié après coup, c’est construit ainsi.

Et l’objet ne retient rien. Pas de mémoire, pas de réseau, pas de journal ; le mot de passe existe le temps qu’on le lise et disparaît au tirage suivant. C’est ce qui permet de le poser sur une table partagée sans autre précaution que de tourner l’écran.

Comment c’est fabriqué

Machines

graveuse laser

Matériaux

contreplaqué 3 mm, Arduino Uno, écran LCD 16x2, bouton poussoir, LED

Temps

quatre séances de deux heures

Coût

15 €

« WALL-E » gravé sur la face : le groupe a nommé sa machine avant de la finir.

1. Les bases, sur plaque d’essai. Une LED, un bouton, le premier programme qui les fait dialoguer. Rien du projet final, tout de son vocabulaire : tension, résistance, entrée, sortie.
2. Le programme, sans écran. Le tirage s’écrit et se met au point sur le moniteur série, avant qu’il soit question d’affichage. Un bogue de logique et un bogue de câblage ne se cherchent pas au même endroit : les séparer fait gagner la séance suivante.
3. Le boîtier. Pas de dessin à la main : Boxes.py produit le plan à partir de trois dimensions et de l’épaisseur de la matière (ici 150 x 100 x 50 mm en contreplaqué de 3 mm). Les encoches tiennent seules, sans vis ni colle. Restent à ajouter au fichier la fenêtre de l’écran, le trou du bouton et la gravure de la face, puis à découper. Montage à blanc pour vérifier les jeux avant l’assemblage définitif.
4. L’assemblage. L’écran et le bouton passent de la plaque d’essai au boîtier, le programme repasse un test complet, et chacun repart avec le sien.

Fabriqué avec un groupe de l’École de la 2e Chance de Dordogne, à l’Atelier Partagé (La Traverse, Bergerac), en juin 2025.

Fichiers et plans

Le montage de prototypage, écran en liaison parallèle. Le boîtier final passe en I2C : quatre fils au lieu de douze.

• Le programme, une centaine de lignes : tirage des douze caractères, affichage sur l’écran, clignotement de la diode. Il demande la bibliothèque LiquidCrystal_I2C, qui ne fait pas partie de celles installées d’origine avec l’IDE.
• Le schéma de câblage ci-dessus, pour la version de prototypage.
• Boxes.py, le générateur dont sort le boîtier. Le projet est libre, et une instance publique le fait tourner dans le navigateur, sans rien installer.

Le dessin du boîtier n’est donc pas archivé, et il n’a pas à l’être : il ne se dessine pas, il se génère. Trois dimensions, une épaisseur, et le plan sort en deux minutes ; refaire le fichier coûte moins que le retrouver.

Le réglage qui décide de tout est la compensation du trait de coupe, le burn de Boxes.py : c’est elle, et non les cotes, qui rend les encoches serrées, justes ou flottantes. Elle dépend de la machine et de la matière, ce qui est une raison de plus de regénérer le fichier sur place plutôt que d’en trimballer un. Seules les ouvertures de l’écran et du bouton demandent une reprise, et elles dépendent des modèles qu’on a sous la main.

Le programme complet (C++)

// Bibliothèques nécessaires
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
 
// Initialisation de l'écran LCD (adresse 0x27, 16 colonnes, 2 lignes)
LiquidCrystal_I2C ecran(0x27, 16, 2);
 
// Constantes
const int brocheBouton = 2;      // Bouton poussoir
const int brocheLED = 3;         // LED
 
// Caractères utilisables
const char majuscules[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const char minuscules[] = "abcdefghijklmnopqrstuvwxyz";
const char chiffres[] = "0123456789";
const char speciaux[] = "!@.?";
 
void setup() {
  pinMode(brocheBouton, INPUT_PULLUP);
  pinMode(brocheLED, OUTPUT);
 
  // Initialisation de l'écran
  ecran.begin(16, 2);
  ecran.backlight();
  ecran.setCursor(0, 0);
  ecran.print("Demarrage...");
 
  digitalWrite(brocheLED, HIGH); // LED allumée au démarrage
  delay(1000);
  digitalWrite(brocheLED, LOW);
  ecran.clear();
  ecran.print("Pret.");
}
 
String genererMotDePasse() {
  char motDePasse[13]; // 12 caractères + fin de chaîne
 
  motDePasse[0] = majuscules[random(strlen(majuscules))];
  motDePasse[1] = minuscules[random(strlen(minuscules))];
  motDePasse[2] = chiffres[random(strlen(chiffres))];
  motDePasse[3] = speciaux[random(strlen(speciaux))];
 
  for (int i = 4; i < 12; i++) {
    int ensemble = random(4);
    switch (ensemble) {
      case 0:
        motDePasse[i] = majuscules[random(strlen(majuscules))];
        break;
      case 1:
        motDePasse[i] = minuscules[random(strlen(minuscules))];
        break;
      case 2:
        motDePasse[i] = chiffres[random(strlen(chiffres))];
        break;
      case 3:
        motDePasse[i] = speciaux[random(strlen(speciaux))];
        break;
    }
  }
  motDePasse[12] = '\0';
  return String(motDePasse);
}
 
void loop() {
  if (digitalRead(brocheBouton) == LOW) {
    digitalWrite(brocheLED, HIGH);
    delay(200);
    digitalWrite(brocheLED, LOW);
 
    String mdp = genererMotDePasse();
    ecran.clear();
    ecran.setCursor(0, 0);
    ecran.print("Mot de passe:");
    ecran.setCursor(0, 1);
    ecran.print(mdp);
 
    delay(2000); // Attente avant d'accepter une nouvelle génération
  }
}

Ce qu’on ferait autrement

Il manque une graine au tirage, et c’est le défaut central. Le programme appelle random() sans avoir appelé randomSeed() : sur Arduino, le générateur démarre alors toujours du même état, et rend la même suite de mots de passe à chaque mise sous tension. Un générateur qui se répète ne génère pas.

C’est visible sur les photos de la fiche : trois tirages faits à trois moments différents, et les trois mots de passe commencent par la même lettre. Une ligne suffit à corriger, randomSeed(analogRead(A0)) sur une entrée analogique laissée en l’air, dont le bruit sert d’amorce. Ce n’est pas du hasard cryptographique (pour cela il faudrait une autre source), mais c’est ce qui sépare un objet qui marche d’un objet qui en a l’air.

Les quatre premiers caractères annoncent leur famille. Position 1 une majuscule, position 2 une minuscule, position 3 un chiffre, position 4 un signe : qui connaît la machine connaît le motif, et le tirage perd une partie de ce qu’il vient de garantir. La version de prototypage mélangeait les douze caractères après coup, en six lignes, et cette étape s’est perdue en route. Elle vaut d’être remise.

Le jeu de caractères spéciaux est très court : !@.?, quatre signes là où la version d’essai en proposait vingt-six. Le choix se défend, ces quatre-là passent partout et se retrouvent sur tous les claviers, alors qu’un mot de passe refusé par le site où on veut l’employer ne sert à rien. Mais c’est un arbitrage à énoncer, pas une valeur à laisser par défaut.

Deux montages cohabitent dans les notes : l’écran en liaison parallèle avec son potentiomètre de contraste, et l’écran I2C à quatre fils. Le boîtier fini est en I2C, la liste de matériel décrit l’autre. Pour refaire l’atelier, il faut choisir ; et la liaison parallèle a une vertu pédagogique que l’I2C n’a pas, celle de rendre visible ce qui passe dans les fils.

Ce projet a été soutenu en 2025 par la Fondation Afnic, financée par le .fr, et la Fondation groupe EDF.