Strumento di Decifratura AES — OpenSSL e CryptoJS

Come Funziona la Decifratura 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
}

Caratteristiche Principali

Esempi di Decifratura AES

sale(16) ‖ iv(12) ‖ testo cifrato ‖ tag(16), Base64 — dalla pagina di cifratura

La veloce volpe marrone salta sopra il cane pigro.

U2FsdGVkX18AESIzRFVmd1PBwxIFQpF+VgIhTK0aDHQ=

Attack at dawn!

Come Decifrare un Testo Cifrato AES

1. 1

   Incolla il testo cifrato

   Rilascia il tuo testo cifrato in Base64 o Hex nel campo di input. Se inizia con U2FsdGVkX1, lo strumento lo segnala come formato OpenSSL/CryptoJS e offre di passare alla modalità corretta.

2. 2

   Imposta il formato e la modalità

   Per una stringa autosufficiente prodotta da questo strumento, mantieni la modalità Passphrase e la GCM/CBC/CTR corrispondente. Per output OpenSSL/CryptoJS, accetta il passaggio (CBC + passphrase). Per dati con chiave grezza, scegli Chiave grezza e la codifica, e fornisci l'IV se non è anteposto.

3. 3

   Scegli la funzione di derivazione della chiave

   In modalità OpenSSL, scegli PBKDF2 (e il suo numero di iterazioni), EVP-SHA256 oppure EVP-MD5 per corrispondere a come è stata derivata la chiave. EVP-MD5 è quella usata da CryptoJS.

4. 4

   Inserisci la passphrase o la chiave

   Digita la passphrase esatta, oppure incolla la chiave grezza esatta in hex o Base64. Il testo in chiaro appare a destra non appena tutto corrisponde.

5. 5

   Leggi la diagnosi in caso di fallimento

   Se la decifratura genera un errore, il pannello indica la causa probabile — IV errato, chiave errata, errore di padding, contaminazione base64 o un KDF non corrispondente — così puoi regolare un'impostazione alla volta invece di procedere per tentativi.

Perché la Decifratura AES Fallisce — e Come Risolverla

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

Cosa Puoi Fare con la Decifratura AES

Decifra l'output di openssl enc

Leggi un blob Salted__ prodotto da openssl enc -aes-256-cbc senza passare da un terminale: incolla il Base64, inserisci la passphrase, scegli la KDF e ottieni il tuo testo in chiaro.

Decifra un testo cifrato CryptoJS

Recupera dati da un'app legacy che usava CryptoJS AES.encrypt(text, passphrase). Seleziona EVP-MD5 per corrispondere alla sua derivazione della chiave MD5 a passaggio singolo — il passo che quasi tutti si perdono.

Fai debug di una decifratura che continua a fallire

Quando il tuo stesso codice non riesce a decifrare qualcosa, incollalo qui per isolare se il problema è la chiave, l'IV, la modalità, la codifica o la KDF, usando il pannello diagnostico.

Verifica un ciclo completo di cifratura

Conferma che il testo cifrato dalla pagina di cifratura AES o dalla tua app si decifra tornando esattamente ai byte originali.

Comprendi un testo cifrato sconosciuto

Identifica un formato dalla sua forma — un prefisso U2FsdGVkX1, o un prefisso a lunghezza fissa che sembra un IV — e capisci come è stato prodotto prima di provare una chiave.

Meccanismi Interni e Formati della Decifratura AES

Decifratura GCM — autenticata

GCM ricalcola il tag a 128 bit sul testo cifrato e lo confronta prima di restituire qualunque testo in chiaro; una mancata corrispondenza genera un errore invece di far trapelare dati corrotti. Usa l'IV a 96 bit che era anteposto. Un fallimento GCM significa che la chiave, la modalità, l'IV o il testo cifrato sono sbagliati — il cifrario non può dirti quale, solo che l'autenticazione è fallita.

Decifratura CBC — osserva il primo blocco e il padding

CBC ha due firme di fallimento distinte. Se solo il primo blocco di 16 byte risulta illeggibile e il resto sembra corretto, l'IV era sbagliato. Se ogni blocco è illeggibile, la chiave è sbagliata. Un errore di padding PKCS#7 di solito significa che la chiave è sbagliata, oppure che il testo cifrato è stato corrotto o troncato. CBC non ha un tag (a differenza di una costruzione autenticata come un HMAC), quindi una chiave sbagliata può persino decifrare in byte dall'aspetto plausibile.

Decifratura CTR — silenziosa in caso di errore

CTR non genera mai un errore: una chiave sbagliata produce semplicemente dati illeggibili, che di solito emergono come errore 'UTF-8 non valido' una volta che i byte vengono decodificati in testo. Fai coincidere esattamente il contatore/IV. Poiché non c'è alcun controllo di integrità, tratta con sospetto qualunque output CTR che non hai autenticato separatamente.

Layout del testo cifrato (F1 / F2 / F3)

Il formato 1 (passphrase) è sale(16) poi IV poi testo cifrato, con il tag GCM di 16 byte accodato in modalità GCM. Il formato 2 (chiave grezza) è IV poi testo cifrato, oppure testo cifrato nudo con un IV fornito separatamente. Il formato 3 (OpenSSL) è l'intestazione ASCII Salted__ poi un sale di 8 byte poi il testo cifrato. Sapere quale layout hai indica allo strumento dove si trovano il sale e l'IV, e una chiave grezza dovrebbe provenire da un CSPRNG — consulta il generatore di chiavi segrete.

Derivazione della chiave: corrispondere a ciò che ha cifrato i dati

Per testo cifrato autosufficiente con passphrase, questo strumento usa PBKDF2-HMAC-SHA256 a 600.000 iterazioni. Per testo cifrato OpenSSL/CryptoJS devi selezionare la KDF usata: PBKDF2 (il valore predefinito di openssl -pbkdf2 è 10.000 iterazioni — imposta il tuo numero esatto), EVP_BytesToKey con SHA-256 (openssl 1.1+ senza -pbkdf2), oppure EVP_BytesToKey con MD5 e un singolo passaggio (CryptoJS e openssl 1.0.2 e versioni precedenti). Il classico bug 'non si decifra' è un testo cifrato CryptoJS o openssl datato provato con SHA-256 — passa a EVP-MD5 e funziona.

Best Practice per la Decifratura AES

Inizia identificando il formato

Prima di toccare le impostazioni, guarda il testo cifrato. Un prefisso U2FsdGVkX1 significa OpenSSL/CryptoJS; una stringa autosufficiente da questo strumento è formato passphrase; un blob nudo di solito richiede una chiave grezza e un IV separato.

Fai corrispondere esattamente la funzione di derivazione della chiave

Per testo cifrato OpenSSL/CryptoJS, la KDF è importante quanto la passphrase. Se PBKDF2 fallisce, prova EVP-MD5 (CryptoJS, openssl datato); anche il numero di iterazioni deve corrispondere, non solo l'algoritmo.

Incolla il testo cifrato senza contaminazioni

A capo o spazi estranei rimasti dalla copia possono corrompere il Base64. Questo strumento rimuove gli spazi bianchi, ma se la decodifica continua a fallire, controlla virgolette tipografiche, caratteri mancanti o una copia troncata. Il nostro strumento Base64 può aiutarti a ispezionare una stringa sospetta.

Tratta onestamente un risultato con chiave sbagliata

Con CTR o CBC, una chiave sbagliata può produrre byte invece di un errore. Se l'output sembra illeggibile o fallisce il controllo UTF-8, la chiave o l'IV sono sbagliati — non fidarti di un output che sembra parzialmente corretto.

Non inviare mai testo cifrato segreto o chiavi a un server

Il senso di decifrare nel browser è che nulla lascia la pagina. Evita strumenti che caricano dati; questo usa Web Crypto localmente, e puoi verificarlo con la scheda Rete o disconnettendoti. AES-256 è robusto — approvato da CNSA 2.0 per TOP SECRET — quindi se non riesci a decifrare, il problema sono i parametri, non il cifrario.

Domande Frequenti sulla Decifratura AES