Tous les articles

Front-end17 min de lecture

Partager un mot de passe en toute sécurité : Yush expliqué

Pourquoi envoyer un mot de passe par chat est risqué, et comment Yush, l'app que j'ai créée, chiffre tout dans le navigateur : clé après le #, AES-GCM, HKDF.

Aussi en Português, English, Español

Chaque équipe connaît ce moment : quelqu'un a besoin du mot de passe de la base de staging, de la clé d'une API ou du token d'un service, et il finit sur Slack, WhatsApp ou Teams. Ça dépanne sur le coup. Et ça reste là pour toujours.

J'ai créé Yush pour ce moment-là. Vous collez le secret, vous obtenez un lien, vous envoyez le lien. La personne qui le reçoit clique, le secret part directement dans le presse-papiers et le lien meurt. Et surtout : le serveur de Yush ne voit jamais le secret, pas même un instant.

Dans cet article, je vous montre l'app en action et j'explique, avec le vrai code, comment c'est possible uniquement avec ce que le navigateur sait déjà faire.

La page d'accueil de Yush, qui tourne sur ma machine

TL;DR#

  • Un mot de passe envoyé par chat se transforme en copies à plusieurs endroits : serveur de l'app, sauvegarde, notification, historique. Et il n'expire pas.
  • Dans Yush, tout est chiffré dans le navigateur avec la Web Crypto API : AES-GCM-256, HKDF-SHA256 et, avec un mot de passe supplémentaire, PBKDF2 avec 600 000 itérations.
  • La clé vit après le # du lien. Le navigateur n'envoie jamais cette partie de l'URL dans une requête HTTP.
  • Le serveur ne stocke que le texte chiffré, des métadonnées et les hashes de deux preuves (linkProof et accessProof).
  • Ouvrir le lien ne consomme pas de vue. Pour en consommer une, il faut un POST, un clic et la preuve de la clé, donc le robot d'aperçu de WhatsApp ne grille pas le secret.
  • Le secret part directement dans le presse-papiers et n'est jamais affiché à l'écran.
  • Ce n'est pas magique : qui a le lien complet a le secret, et un malware sur l'ordinateur du destinataire reste un malware.

Pourquoi envoyer un mot de passe par chat pose problème#

Le problème, ce n'est pas que le chat soit peu sûr. Beaucoup sont chiffrés pendant le transport. Le problème, c'est que le message ne disparaît pas. Un mot de passe envoyé par chat devient plusieurs copies, chacune avec sa propre vie :

Le même mot de passe, envoyé de deux façons. Dans le chat, il reste. Dans Yush, il a une date d'expiration
  • Le serveur de l'app stocke le message. Si le chat n'a pas de chiffrement de bout en bout (Slack et Teams, par exemple), le service lui-même peut le lire et, selon l'offre, les administrateurs de l'espace de travail peuvent l'exporter.
  • La sauvegarde du téléphone ou du cloud emporte la conversation avec elle.
  • La notification affiche le mot de passe sur l'écran verrouillé, pour qui se trouve à côté.
  • L'historique et la recherche retrouvent le mot de passe des mois plus tard. Pour quiconque pirate le compte, aussi.
  • Ceux qui rejoignent le groupe plus tard voient souvent l'historique.
  • Une capture d'écran et le mot de passe devient une image, hors de tout contrôle.

Et presque personne ne revient pour l'effacer. Le mot de passe de la base de staging de 2024 est toujours dans le canal #dev.

L'idée d'un lien à usage unique règle ça : ce qui reste dans le chat, c'est un lien mort. Une fois que la personne a copié le secret, ou une fois le délai passé, il n'y a plus rien à trouver.

Yush en 30 secondes#

Côté expéditeur, c'est un champ de texte et trois choix : combien de temps le secret vit (de 1 heure à 30 jours), combien de fois il peut être copié (1, 5, 10 ou 25) et les options supplémentaires.

Création d'un secret de test : 7 jours, 1 vue et étape de confirmation

Vous cliquez sur envoyer, le navigateur chiffre tout et renvoie le lien. Le lien est masqué par défaut (encore une fois : pour qu'il ne finisse pas en capture d'écran), et on peut l'afficher avec l'icône en forme d'œil :

Le lien prêt. Tout ce qui suit le # est la clé, et elle n'existe qu'ici

Regardez bien le lien. Il a deux parties, et la différence entre elles est le cœur de l'app :

http://localhost:5173/s/317yFlKeQyqSttkkk45_hoqM#k=Tupf9Ege-5H227VRp0wy72E2MPU_SOv_KjX5wUyTAuA
                        └── id du secret ──────┘ └── clé (32 octets) ───────────────────────┘

Le reste de l'article explique comment ces deux parties travaillent ensemble.

Le serveur ne connaît pas le secret#

La règle numéro un de Yush : le texte et la clé n'existent que dans le navigateur. Le serveur stocke le texte chiffré, des métadonnées qui ne révèlent rien et les hashes de deux preuves.

Ce qui traverse le réseau et ce que le serveur stocke. Ce qui est à gauche ne quitte jamais le navigateur

Voici la requête que le navigateur envoie quand vous créez un secret (j'ai raccourci les valeurs) :

{
  "ciphertext": "7TK66-zY5asPtCEXK--_DvCGJeLLwMdJy8oDL_91zke820rv-5oncBwgtUihGL...",
  "iv": "gH3tupn6kX87cn32",
  "kdf": null,
  "linkProof": "bPi5MXkmB3C6Ql2_YC1mRfmUZRg8-74maec5w-XuacM",
  "accessProof": "ygxSepD_0Ut2_37sww4y...",
  "expiresIn": 604800,
  "maxViews": 1,
  "allowImmediateDeletion": true,
  "requireConfirmation": true
}

Pas de secret, pas de clé. Et en plus, le serveur remplace les preuves par leur SHA-256 avant de les enregistrer. Même la base de données n'a pas les preuves originales.

De l'autre côté, le log du serveur ne garde rien de sensible non plus : seulement la méthode, le modèle de la route, le statut et le temps. Une ligne ressemble à ceci :

{"method":"POST","route":"/api/secrets/:id/consume","statusCode":200,"ms":1,"msg":"request completed"}

La clé vit après le ##

C'est la partie la plus élégante, et c'est du pur standard web : le fragment de l'URL (tout ce qui suit le #) ne part pas dans les requêtes HTTP. La RFC 3986 définit que le fragment est traité uniquement par celui qui a la page ouverte. Le navigateur demande /s/317yFl... au serveur et garde le #k=... pour lui.

L'id voyage jusqu'au serveur. La clé, après le #, reste dans le navigateur

Dans le code, construire le lien tient en une ligne :

src/secret-service/link.ts
// https://host/s/{id}#k={key}: the key lives in the fragment, which browsers never send to servers
export function buildSecretLink(origin: string, id: string, linkKey: Uint8Array): string {
  if (!SECRET_ID_PATTERN.test(id)) throw new RangeError('Invalid secret id');
  return `${origin}/s/${id}#${encodeKeyForURL(linkKey)}`;
}

La clé, ce sont 32 octets aléatoires issus de crypto.getRandomValues, en base64url. L'id, c'est autre chose : 18 octets aléatoires (144 bits), générés par le serveur. Deviner un id est impossible en pratique, et même en tombant juste, ça ne sert à rien, comme vous allez le voir avec les preuves.

Une précaution de plus : quand le lien s'ouvre, Yush efface le #k= de la barre d'adresse avec history.replaceState. Ainsi, la clé ne reste pas visible pour quelqu'un qui passe derrière vous, ni dans la restauration des onglets. Le prix à payer : recharger la page oblige à rouvrir le lien d'origine.

Une clé, trois dérivations#

Avec les 32 octets de la clé en main, Yush ne s'en sert pas directement pour chiffrer. Il dérive trois valeurs différentes avec HKDF-SHA256, en changeant seulement une étiquette (le info) pour chacune :

De la clé du lien sortent la clé de chiffrement et les deux preuves. Le mot de passe supplémentaire entre par PBKDF2
  • encKey : la clé AES-GCM de 256 bits qui chiffre le secret. Elle est créée non extractible : même le JavaScript de la page ne peut pas lire ses octets.
  • linkProof : la preuve que « j'ai le lien ». Elle dérive uniquement de la clé du lien.
  • accessProof : la preuve que « j'ai le lien et le mot de passe supplémentaire » (quand il y en a un).

Voici le passage qui s'en charge :

src/crypto/kdf.ts
export async function deriveSecretKeys(linkKey: Bytes, passphrase: PassphraseInput | null): Promise<SecretKeys> {
  const linkBase = await hkdfBase(linkKey);
  const linkProof = await hkdfBits(linkBase, INFO_LINK_PROOF); // "yush/v1/link-proof"
 
  let ikm: Bytes = linkKey;
  if (passphrase) {
    const stretched = await pbkdf2(passphrase); // PBKDF2-SHA256, 600k iterations
    ikm = new Uint8Array(KEY_BYTES * 2);
    ikm.set(linkKey, 0);
    ikm.set(stretched, KEY_BYTES);
    stretched.fill(0); // wipe the intermediate bytes
  }
 
  const base = passphrase ? await hkdfBase(ikm) : linkBase;
  const encryptionKey = await crypto.subtle.deriveKey(
    { name: 'HKDF', hash: 'SHA-256', salt: HKDF_SALT, info: INFO_ENCRYPTION_KEY },
    base,
    { name: 'AES-GCM', length: 256 },
    false, // non-extractable
    ['encrypt', 'decrypt'],
  );
  const accessProof = await hkdfBits(base, INFO_ACCESS_PROOF);
  return { encryptionKey, linkProof, accessProof };
}

(J'ai raccourci pour que ça tienne : dans le vrai fichier, il y a aussi la vérification de la taille de la clé et un try/finally qui met l'ikm à zéro.)

Le mot de passe supplémentaire#

Le mot de passe supplémentaire est optionnel et sert dans un cas précis : la fuite du lien. Si vous envoyez le lien par e-mail et le mot de passe par téléphone, quelqu'un qui récupère seulement le lien ne copie rien.

Les mots de passe choisis par des humains sont faibles, donc celui-ci passe par PBKDF2-SHA256 avec 600 000 itérations et un sel aléatoire de 16 octets. C'est le chiffre que l'OWASP recommande pour PBKDF2 avec SHA-256. Avant ça, le mot de passe est normalisé en NFC, pour qu'un « é » tapé sur Mac et sur Windows donne les mêmes octets.

Pourquoi deux preuves#

C'est la décision de conception que je préfère. Les preuves bloquent trois attaques d'un coup :

  • Quelqu'un qui ne connaît que l'id (dans un log de proxy, dans un historique tronqué) ne télécharge pas le texte chiffré, ne grille pas le secret et ne le supprime pas : il lui manque le linkProof, qui dépend d'une clé de 256 bits.
  • Un mauvais mot de passe supplémentaire est détecté avant de consommer la vue. L'accessProof ne correspond pas, le serveur répond 403 et compte la tentative. Après 10 erreurs, le secret s'autodétruit.
  • Une base de données qui fuite ne sert à rien : elle ne contient que les hashes des preuves (impossible de recréer les preuves) et pas la clé (impossible d'attaquer le mot de passe hors ligne).

Chiffrer et masquer la taille#

Le chiffrement, c'est AES-GCM, avec un IV aléatoire de 12 octets par secret et une donnée associée fixe (yush/v1). En plus de chiffrer, GCM authentifie : si quelqu'un modifie un octet du texte chiffré, le déchiffrement échoue au lieu de renvoyer n'importe quoi.

Sauf que chiffrer ne masque pas la taille. Un mot de passe de 8 caractères et une clé privée de 3 000 auraient des textes chiffrés de tailles très différentes. C'est pourquoi Yush place le secret dans une trame de taille fixe avant de le chiffrer :

frame = u32be(length) ‖ utf8(plaintext) ‖ zéros jusqu'à la puissance de 2 suivante (min. 256, max. 32 768 octets)

Le secret d'exemple des captures, STRIPE_KEY=sk_test_exemplo_nao_e_real_51Hx9, fait 43 caractères. Son texte chiffré fait 272 octets : la trame minimale de 256 plus les 16 du tag GCM. Un mot de passe de 8 caractères donnerait exactement la même taille.

Ouvrir le lien ne consomme rien#

Voici un problème auquel peu de gens pensent : les robots ouvrent les liens. WhatsApp, Slack, Discord et Telegram visitent le lien pour générer l'aperçu. Les antivirus de messagerie aussi. Si ouvrir le lien consommait la vue, le secret à usage unique mourrait avant d'arriver à la personne.

Alors, dans Yush, ouvrir et consommer sont deux choses séparées :

Seul le clic consomme une vue. Le robot d'aperçu s'arrête au GET
  • La page (GET /s/:id) n'est que le HTML de l'app. Elle ne touche même pas à la base.
  • Le statut (GET /api/secrets/:id/status) ne fait que lire : délai, vues restantes et besoin ou non d'un mot de passe.
  • Consommer (POST /api/secrets/:id/consume) est la seule étape qui consomme, et elle exige les deux preuves dans le corps de la requête. Elle ne s'exécute qu'après un clic.

Il reste un cas : un scanner qui exécute du JavaScript et qui clique. Pour celui-là, il existe l'option étape de confirmation, qui demande un second clic avant de copier :

Avec l'étape de confirmation, copier demande un second clic

Côté serveur, la consommation est atomique : dans SQLite avec BEGIN IMMEDIATE, dans Postgres avec SELECT ... FOR UPDATE. Deux personnes qui cliquent en même temps sur un secret à usage unique ne le reçoivent pas toutes les deux. Je l'ai couvert avec un test de 12 threads sur SQLite et un autre avec un pool de 30 connexions sur Postgres. Et à la dernière vue, la ligne est supprimée dans la même transaction : il ne reste même pas la trace de son existence.

Directement dans le presse-papiers, sans passer par l'écran#

Le secret n'est jamais affiché à l'écran. Ni dans un state React, ni dans un <input> caché, ni via une sélection de texte. Il va directement du résultat du déchiffrement au presse-papiers.

Il y a un détail lié au navigateur ici. Safari n'autorise l'écriture dans le presse-papiers que si l'appel commence à l'intérieur du clic, avant tout await. Mais le secret n'est même pas encore arrivé : il reste à le récupérer et à le déchiffrer. La solution, c'est ClipboardItem, qui accepte une Promise :

src/secret-service/clipboard.ts
export async function writeSecretToClipboard(text: Promise<string>): Promise<void> {
  if (!isClipboardAvailable()) throw new ClipboardUnavailableError();
 
  if (typeof ClipboardItem === 'function' && typeof navigator.clipboard.write === 'function') {
    try {
      const blob = text.then((value) => new Blob([value], { type: 'text/plain' }));
      await navigator.clipboard.write([new ClipboardItem({ 'text/plain': blob })]);
      return;
    } catch {
      await text; // surface the real failure (wrong passphrase, unavailable secret)
    }
  }
  await navigator.clipboard.writeText(await text);
}

(J'ai simplifié : dans l'app, l'environnement du presse-papiers est injecté, pour pouvoir le tester.)

La page appelle cette fonction de façon synchrone au moment du clic, en lui passant la Promise qui récupère et déchiffre. Safari voit le clic, le reste arrive ensuite. Dans les autres navigateurs, writeText fait le travail.

Et il y a deux autres précautions que je trouve très jolies :

  • Le presse-papiers est vérifié avant de consommer. Si le navigateur ne peut pas copier, le secret n'est pas consommé.
  • Si le navigateur refuse la copie après la consommation, l'app garde seulement le texte chiffré en mémoire pendant 2 minutes, pour un nouveau clic, sans consommer une autre vue.
Copié, et le secret n'apparaît toujours pas à l'écran

Pour le garantir, un test observe toutes les modifications du DOM avec un MutationObserver pendant la copie.

Si on rouvre le même lien, voici ce qui s'affiche :

Le lien après utilisation. Le serveur ne dit pas s'il a expiré ou s'il a été copié

Le « nous ne disons jamais pourquoi » est voulu : le serveur répond le même 404 pour un id qui n'existe pas, qui a expiré, qui a été consommé, qui est mal formé ou qui arrive avec la mauvaise preuve. Quelqu'un qui essaie de deviner n'apprend rien de la réponse.

Le serveur se défend aussi#

Même sans voir le secret, le serveur a du travail :

  • Le schéma rejette tout champ en trop. Si la requête de création arrive avec un "plaintext" en plus dans le JSON, la réponse est 400 Invalid request.. Ainsi, un bug qui enverrait le secret par erreur n'arrive à rien enregistrer.
  • Limite de requêtes par IP sur chaque route.
  • En-têtes stricts : CSP avec script-src 'self' et Trusted Types, frame-ancestors 'none', Referrer-Policy: no-referrer et Cache-Control: no-store. Le build ne contient aucun script inline ni tiers. Pas d'analytics.
  • Une base qui nettoie vraiment : dans SQLite, secure_delete remet à zéro les pages supprimées. Les secrets expirés ne sont jamais renvoyés et sont supprimés régulièrement.

Ce que Yush ne résout pas#

Toute app de sécurité devrait dire ce qu'elle ne protège pas. Voici les limites de Yush :

  • Le lien est l'identifiant. Qui a le lien complet copie le secret. Pour une défense supplémentaire, utilisez le mot de passe supplémentaire et envoyez-le par un autre canal.
  • L'appareil du destinataire. Un malware, une extension malveillante ou un gestionnaire de presse-papiers sont hors de portée de toute app web.
  • Un serveur activement malveillant pourrait servir un JavaScript modifié qui envoie la clé ailleurs. C'est la limite de toute app de chiffrement de bout en bout distribuée par le web. On peut la réduire avec un build reproductible et des hashes publiés des fichiers.
  • Les strings JavaScript ne peuvent pas être mises à zéro. Les buffers d'octets sont remis à zéro, mais le texte déchiffré est une string immuable, et c'est le ramasse-miettes qui la retire de la mémoire.

Et quelques compromis que j'ai choisis en connaissance de cause :

  • La limite de requêtes est en mémoire, par instance. Sur Vercel, chaque instance de la fonction a la sienne. Pour une limite globale, il faudrait Redis ou le pare-feu de Vercel. La vraie protection vient de l'entropie de l'id et des preuves.
  • N'importe qui avec le lien peut supprimer le secret (si l'option est activée), y compris le destinataire. Il n'y a pas de comptes, donc pas de « propriétaire ».
  • Le statut indique combien de vues il reste à qui a l'id. Ça ne révèle pas le contenu, mais c'est une information.

Ce que j'ai appris#

Le web a déjà ce qu'il faut. Yush n'utilise aucune bibliothèque de cryptographie : tout passe par crypto.subtle. AES-GCM, HKDF, PBKDF2 et les clés non extractibles sont disponibles dans tous les navigateurs modernes.

Le # est un canal privé gratuit. Savoir que le fragment ne part pas au serveur change toute la conception : on peut livrer la clé avec le lien sans que le serveur la voie.

Pensez aux robots. L'attaque la plus probable contre un lien à usage unique n'est pas un hacker, c'est l'aperçu de WhatsApp. Séparer « ouvrir » de « consommer » est la décision qui a fait fonctionner l'app dans le monde réel.

Ne pas afficher, c'est aussi un choix d'interface. Envoyer directement dans le presse-papiers retire le secret de l'écran, des captures et des extensions qui lisent la page. Et ça a demandé plus de travail qu'il n'y paraît, à cause de Safari.

Écrivez ce que vous ne protégez pas. Écrire la liste des limites m'a obligée à penser à chaque attaque et à décider : je la mitige, ou je l'assume et je préviens.

Références#

  • Front-end
  • securite
  • cryptographie
  • web-crypto
  • react
  • typescript

Écrit par

Ingénieure logiciel et designer. J'écris sur ce que je rencontre en créant des apps, des APIs et des produits.