Chiffrer en AES vers Base64

Comment chiffrer un texte avec un mot de passe

1. Laissez Chiffrer et le type de clé Mot de passe sélectionnés.
2. Saisissez un Mot de passe. Afficher le mot de passe le rend visible pendant la saisie. Laissez Itérations PBKDF2 à 310 000 sauf raison particulière ; la personne qui déchiffre doit saisir le même nombre.
3. Tapez le message dans Texte en clair et cliquez sur Chiffrer, ou appuyez sur Entrée dans le champ du mot de passe, ou sur Ctrl+Entrée dans le texte.
4. Copiez le Base64 chiffré ou téléchargez-le. Cochez Sortie URL-safe (- _ , sans =) si la chaîne doit aller dans une URL.

Sous la sortie, l’outil affiche un détail : tailles du sel, de l’IV, du texte chiffré et du tag, le total, et la dérivation de clé utilisée. Pour envoyer le résultat, mettez le Base64 dans un message et le mot de passe dans un autre canal, comme un appel téléphonique ou une autre application de messagerie. Le destinataire ouvre Déchiffrement AES et inverse le processus.

À quoi sert cet outil

Cet outil sert à partager un texte de façon sûre quand il n’existe pas de meilleur canal : un mot de passe Wi-Fi pour un invité, un code de récupération envoyé à un collègue, une note collée dans un ticket que trop de monde peut lire. Il remplace « je te l’envoie par chat » par quelque chose qu’une oreille indiscrète ne peut pas lire.

Ce n’est pas un gestionnaire de secrets. Il ne stocke rien, ne contrôle pas qui a accès, ne journalise pas qui a déchiffré quoi, ne fait pas tourner les clés et ne peut pas révoquer un secret une fois envoyé. Les identifiants d’applications, les clés de production et tout ce qui se partage au sein d’une équipe ont leur place dans un vrai gestionnaire de secrets ou un gestionnaire de mots de passe avec partage. Gardez aussi à l’esprit que le texte chiffré reste déchiffrable pour toujours par quiconque apprend plus tard le mot de passe.

Le format exact

En mode mot de passe, la sortie est :

Base64( salt[16] ‖ iv[12] ‖ ciphertext ‖ tag[16] )

• Clé : PBKDF2-HMAC-SHA256 sur le mot de passe en UTF-8, avec le sel de 16 octets et 310 000 itérations, produisant 32 octets.
• Chiffrement : AES-256-GCM avec l’IV de 12 octets, un tag de 128 bits et sans données associées.
• Aléa : un nouveau sel et un nouvel IV à chaque chiffrement, issus de crypto.getRandomValues.

Le texte chiffré a exactement la longueur du message en UTF-8 : le blob a donc 44 octets de surcoût. Un message de 33 octets devient 77 octets, soit 104 caractères Base64. Il n’y a pas d’octet de version, et le nombre d’itérations n’est pas stocké : si vous le modifiez, le destinataire doit saisir la même valeur, sinon le déchiffrement échoue avec la même erreur qu’un mauvais mot de passe.

En mode Clé brute, l’étape PBKDF2 disparaît et la sortie est Base64( iv[12] ‖ ciphertext ‖ tag[16] ), chiffrée avec votre clé de 16, 24 ou 32 octets fournie en Base64 ou en hex. Générer une clé aléatoire en crée une. Chrome et Edge ne prennent pas en charge les clés AES de 192 bits, et l’outil le signale au lieu d’échouer en silence ; utilisez 128 ou 256 bits.

Le déchiffrer en Python ou en Node.js

Le destinataire n’a pas besoin de ce site. Avec Python et le paquet cryptography (pip install cryptography) :

import base64, os
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.primitives import hashes

def _key(password, salt):
    return PBKDF2HMAC(algorithm=hashes.SHA256(), length=32, salt=salt,
                      iterations=310000).derive(password.encode("utf-8"))

def decrypt(b64, password):
    data = base64.b64decode(b64)
    salt, iv, ct = data[:16], data[16:28], data[28:]
    return AESGCM(_key(password, salt)).decrypt(iv, ct, None).decode("utf-8")

def encrypt(text, password):
    salt, iv = os.urandom(16), os.urandom(12)
    ct = AESGCM(_key(password, salt)).encrypt(iv, text.encode("utf-8"), None)
    return base64.b64encode(salt + iv + ct).decode("ascii")

AESGCM.decrypt attend le tag à la fin du texte chiffré, là où ce format le place. En Node.js, le tag doit être séparé et passé à part :

const crypto = require("crypto");

function decrypt(b64, password) {
  const data = Buffer.from(b64, "base64");
  const salt = data.subarray(0, 16), iv = data.subarray(16, 28);
  const tag = data.subarray(data.length - 16), ct = data.subarray(28, data.length - 16);
  const key = crypto.pbkdf2Sync(password, salt, 310000, 32, "sha256");
  const d = crypto.createDecipheriv("aes-256-gcm", key, iv);
  d.setAuthTag(tag);
  return Buffer.concat([d.update(ct), d.final()]).toString("utf8");
}

Les blobs de cette page se déchiffrent avec les deux fonctions, et ceux produits par encrypt() se déchiffrent sur cette page. Si vous avez utilisé la sortie URL-safe, Buffer.from(b64, "base64") de Node la lit telle quelle ; en Python, utilisez base64.urlsafe_b64decode(b64 + "=" * (-len(b64) % 4)). Notez que openssl enc ne peut pas aider ici, car il ne prend pas en charge GCM. Les pages Python et Node.js traitent plus en détail le côté Base64.

FAQ