Outil de déchiffrement AES — compatible OpenSSL et CryptoJS

Comment fonctionne le déchiffrement AES

// AES-256-GCM decrypt with a passphrase (PBKDF2-HMAC-SHA256, 600,000 iterations).
// Identical code runs in the browser and in Node.js 20+ via Web Crypto.
async function aesGcmDecrypt(base64, passphrase) {
  const enc = new TextEncoder();
  const packed = Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
  const salt = packed.slice(0, 16), iv = packed.slice(16, 28); // salt(16) | iv(12)
  const ct = packed.slice(28);                                 // ciphertext + tag
  const baseKey = await crypto.subtle.importKey(
    'raw', enc.encode(passphrase), 'PBKDF2', false, ['deriveKey']);
  const key = await crypto.subtle.deriveKey(
    { name: 'PBKDF2', salt, iterations: 600000, hash: 'SHA-256' },
    baseKey, { name: 'AES-GCM', length: 256 }, false, ['decrypt']);
  const plain = await crypto.subtle.decrypt(
    { name: 'AES-GCM', iv }, key, ct);        // throws if the tag fails
  return new TextDecoder().decode(plain);     // recovered plaintext
}

Fonctionnalités clés

Exemples de déchiffrement AES

sel(16) ‖ iv(12) ‖ texte chiffré ‖ tag(16), Base64 — depuis la page de chiffrement

The quick brown fox jumps over the lazy dog.

U2FsdGVkX18AESIzRFVmd1PBwxIFQpF+VgIhTK0aDHQ=

Attack at dawn!

Comment déchiffrer un texte chiffré AES

1. 1

   Collez le texte chiffré

   Déposez votre texte chiffré en Base64 ou en Hex dans le champ de saisie. S'il commence par U2FsdGVkX1, l'outil le signale comme un format OpenSSL/CryptoJS et propose de basculer vers le bon mode.

2. 2

   Définissez le format et le mode

   Pour une chaîne autonome provenant de cet outil, gardez le mode Phrase secrète et le mode GCM/CBC/CTR correspondant. Pour une sortie OpenSSL/CryptoJS, acceptez le basculement (CBC + phrase secrète). Pour des données en clé brute, choisissez Clé brute et l'encodage, et fournissez l'IV s'il n'est pas préfixé.

3. 3

   Choisissez la fonction de dérivation de clé

   En mode OpenSSL, choisissez PBKDF2 (et son nombre d'itérations), EVP-SHA256, ou EVP-MD5 pour correspondre à la façon dont la clé a été dérivée. EVP-MD5 est celle qu'utilise CryptoJS.

4. 4

   Saisissez la phrase secrète ou la clé

   Tapez la phrase secrète exacte, ou collez la clé brute exacte en hexadécimal ou en Base64. Le texte en clair apparaît à droite dès que tout correspond.

5. 5

   Lisez le diagnostic en cas d'échec

   Si le déchiffrement échoue, le panneau nomme la cause probable — mauvais IV, mauvaise clé, erreur de padding, pollution du Base64, ou incompatibilité de KDF — pour que vous puissiez ajuster un réglage à la fois plutôt que de deviner.

Pourquoi le déchiffrement AES échoue — et comment y remédier

mode: CBC        // but the data was encrypted with GCM
=> Authentication failed

mode: GCM, same passphrase and key size as encryption
=> plaintext

iv: 00000000000000000000000000000000   (wrong IV)
=> first block corrupt, rest readable

iv: (the exact IV used to encrypt)
=> Attack at dawn!

passphrase: hunter3   // one character off
=> padding error

passphrase: hunter2   // exact
=> plaintext

“U2FsdGVkX1...”   (curly quotes and trailing junk copied in)

U2FsdGVkX18AESIzRFVmd1PBwxIFQpF+VgIhTK0aDHQ=   (clean Base64)

OpenSSL compatible: off
input: U2FsdGVkX1...
=> cannot parse

OpenSSL compatible: on, KDF chosen
=> plaintext

KDF: PBKDF2       // CryptoJS ciphertext
=> padding error

KDF: EVP-MD5      // matches CryptoJS
=> plaintext

Ce que vous pouvez faire avec le déchiffrement AES

Déchiffrer une sortie d'openssl enc

Lisez un bloc Salted__ produit par openssl enc -aes-256-cbc sans passer par un terminal : collez le Base64, saisissez la phrase secrète, choisissez le KDF, et obtenez votre texte en clair.

Déchiffrer un texte chiffré CryptoJS

Récupérez des données depuis une ancienne application qui utilisait CryptoJS AES.encrypt(text, passphrase). Sélectionnez EVP-MD5 pour correspondre à sa dérivation de clé MD5 en une seule passe — l'étape que la plupart des gens manquent.

Déboguer un déchiffrement qui échoue sans cesse

Quand votre propre code n'arrive pas à déchiffrer quelque chose, collez-le ici pour isoler si le problème vient de la clé, de l'IV, du mode, de l'encodage, ou du KDF, à l'aide du panneau de diagnostic.

Vérifier un aller-retour de chiffrement

Confirmez qu'un texte chiffré provenant de la page de chiffrement AES ou de votre application se déchiffre exactement en les octets d'origine.

Comprendre un texte chiffré inconnu

Identifiez un format à partir de sa forme — un préfixe U2FsdGVkX1, ou un préfixe de longueur fixe qui ressemble à un IV — et déterminez comment il a été produit avant d'essayer une clé.

Fonctionnement interne et formats du déchiffrement AES

Déchiffrement GCM — authentifié

GCM recalcule le tag de 128 bits sur le texte chiffré et le compare avant de renvoyer le moindre texte en clair ; une non-correspondance déclenche une exception au lieu de divulguer des données corrompues. Il utilise l'IV de 96 bits qui était préfixé. Un échec GCM signifie que la clé, le mode, l'IV ou le texte chiffré est incorrect — le chiffrement ne peut pas vous dire lequel, seulement que l'authentification a échoué.

Déchiffrement CBC — surveillez le premier bloc et le padding

CBC a deux signatures d'échec distinctes. Si seul le premier bloc de 16 octets est brouillé et que le reste semble correct, l'IV était incorrect. Si tous les blocs sont incohérents, la clé est incorrecte. Une erreur de padding PKCS#7 signifie généralement que la clé est incorrecte, ou que le texte chiffré a été corrompu ou tronqué. CBC n'a pas de tag (contrairement à une construction authentifiée comme un HMAC), donc une mauvaise clé peut même se déchiffrer en octets d'apparence plausible.

Déchiffrement CTR — silencieux en cas d'erreur

CTR ne déclenche jamais d'exception : une mauvaise clé produit simplement des données incohérentes, ce qui se manifeste généralement par une erreur « UTF-8 non valide » une fois les octets décodés en texte. Faites correspondre exactement le compteur/IV. Comme il n'y a aucun contrôle d'intégrité, traitez avec suspicion toute sortie CTR que vous n'avez pas authentifiée séparément.

Dispositions de texte chiffré (F1 / F2 / F3)

Le format 1 (phrase secrète) est sel(16) puis IV puis texte chiffré, avec le tag GCM de 16 octets ajouté à la fin en mode GCM. Le format 2 (clé brute) est IV puis texte chiffré, ou texte chiffré nu avec un IV fourni séparément. Le format 3 (OpenSSL) est l'en-tête ASCII Salted__ puis un sel de 8 octets puis le texte chiffré. Savoir quelle disposition vous avez indique à l'outil où se trouvent le sel et l'IV, et une clé brute elle-même devrait provenir d'un CSPRNG — voir le générateur de clé secrète.

Dérivation de clé : faire correspondre ce qui a chiffré les données

Pour un texte chiffré autonome par phrase secrète, cet outil utilise PBKDF2-HMAC-SHA256 à 600 000 itérations. Pour un texte chiffré OpenSSL/CryptoJS, vous devez sélectionner le KDF qui a été utilisé : PBKDF2 (la valeur par défaut d'openssl -pbkdf2 est 10 000 itérations — réglez votre nombre exact), EVP_BytesToKey avec SHA-256 (openssl 1.1+ sans -pbkdf2), ou EVP_BytesToKey avec MD5 et une seule passe (CryptoJS et openssl 1.0.2 et antérieur). Le bug classique du « ça ne se déchiffre pas » est un texte chiffré CryptoJS ou ancien-openssl essayé avec SHA-256 — passez à EVP-MD5 et ça fonctionne.

Bonnes pratiques de déchiffrement AES

Commencez par identifier le format

Avant de toucher aux réglages, regardez le texte chiffré. Un préfixe U2FsdGVkX1 signifie OpenSSL/CryptoJS ; une chaîne autonome provenant de cet outil est au format phrase secrète ; un bloc nu a généralement besoin d'une clé brute et d'un IV séparé.

Faites correspondre exactement la fonction de dérivation de clé

Pour un texte chiffré OpenSSL/CryptoJS, le KDF est aussi important que la phrase secrète. Si PBKDF2 échoue, essayez EVP-MD5 (CryptoJS, ancien openssl) ; le nombre d'itérations doit aussi correspondre, pas seulement l'algorithme.

Collez le texte chiffré proprement

Des retours à la ligne ou des espaces parasites issus de la copie peuvent corrompre le Base64. Cet outil retire les espaces, mais si le décodage échoue toujours, vérifiez la présence de guillemets typographiques, de caractères manquants, ou d'une copie tronquée. Notre outil Base64 peut vous aider à inspecter une chaîne suspecte.

Traitez honnêtement un résultat de mauvaise clé

Avec CTR ou CBC, une mauvaise clé peut produire des octets plutôt qu'une erreur. Si la sortie ressemble à des données incohérentes ou échoue au contrôle UTF-8, la clé ou l'IV est incorrect — ne faites pas confiance à une sortie d'apparence partielle.

N'envoyez jamais de texte chiffré secret ou de clés à un serveur

L'intérêt de déchiffrer dans le navigateur est que rien ne quitte la page. Évitez les outils qui envoient des données ; celui-ci utilise Web Crypto localement, et vous pouvez le vérifier avec l'onglet Réseau ou en passant hors ligne. L'AES-256 est robuste — approuvé CNSA 2.0 pour TOP SECRET — donc si vous n'arrivez pas à déchiffrer, le problème vient des paramètres, pas du chiffrement.

FAQ sur le déchiffrement AES