CryptoRecovery.io – Servizi di recupero portafogli

Contattaci

Come recuperare il portafoglio MetaMask? Password smarrita, archiviazione nel Vault, crittografia e analisi forense dei dati

Avatar di Peter CryptoRecovery
Peter CryptoRecovery
Come recuperare il portafoglio MetaMask? Password smarrita, archiviazione nel Vault, crittografia e analisi forense dei dati

Come recuperare il portafoglio MetaMask? Password smarrita, archiviazione nel Vault, crittografia e analisi forense dei dati

Se stai leggendo questo articolo, probabilmente hai perso l'accesso al tuo portafoglio MetaMask e non sai più cosa fare. Ho passato anni a recuperare portafogli per le persone: dai trader DeFi che hanno formattato i loro laptop ai nonni che hanno "pulito" le estensioni del browser. Questa guida copre tutto ciò che so su come MetaMask memorizza le tue chiavi, dove si trovano effettivamente quei dati sul disco e come recuperarli quando le cose vanno male. Niente di tutto questo è teorico. Ogni tecnica qui descritta proviene da recuperi reali.

Come MetaMask memorizza effettivamente le tue chiavi

Prima di poter recuperare qualsiasi cosa, devi capire cosa stai recuperando. MetaMask non salva le tue chiavi private in un file chiamato private_keys.txt. Li memorizza all'interno di un blob crittografato denominato cassaforte, che risiede nell'archivio delle estensioni del browser.

Quando crei un portafoglio MetaMask e imposti una password, ecco cosa succede dietro le quinte. MetaMask genera una frase mnemonica BIP-39 (la tua frase di 12 parole Frase di recupero segreta) e lo racchiude – insieme a eventuali chiavi private importate – in un array JSON di oggetti “keyring”. Tale array viene serializzato in una stringa, quindi crittografato utilizzando AES-256-GCM con una chiave derivata dalla tua password tramite PBKDF2-HMAC-SHA256. Il risultato è un blob JSON con tre o quattro campi che viene scritto su chrome.storage.local (nei browser basati su Chromium) o IndexedDB (su Firefox).

Nelle versioni precedenti, il deposito crittografato ha questo aspetto:

{"data":"SGFuZGxlIHRoaXMgZW5jcnlwdGVkIGRhdGE=","iv":"MTIzNDU2Nzg5MDEyMzQ1Ng==","salt":"cmFuZG9tMzJieXRlc2FsdHZhbHVlaGVyZQ=="}

Nelle versioni più recenti (successive alla v11.16.x), è presente un quarto campo:

{"data":"...","iv":"...","keyMetadata":{"algorithm":"PBKDF2","params":{"iterations":600000}},"salt":"..."}

Quello keyMetadata La differenza sta proprio qui: tra un recupero che richiede pochi minuti e uno che richiede settimane. Ne parleremo meglio tra poco.

Il processo di crittografia è semplice, ma è importante comprenderlo con precisione. La tua password in formato UTF-8 viene importata come chiave PBKDF2 non elaborata tramite l'API Web Crypto. A salt casuale di 32 byte (generato da crypto.getRandomValues()) viene utilizzato insieme alla password per generare una chiave AES-GCM a 256 bit. Quindi un IV casuale di 16 byte crittografa i dati serializzati del portachiavi. Il data Il campo contiene sia il testo cifrato che il tag di autenticazione GCM, codificati in base64. Una particolarità degna di nota: MetaMask utilizza un IV di 16 byte per AES-GCM, il che non è conforme agli standard – la specifica NIST SP 800-38D raccomanda infatti 12 byte. Ciò causa problemi di interoperabilità con alcune librerie crittografiche (OpenSSL per Ruby, ad esempio, non funziona con questa configurazione).

Quando sblocchi MetaMask con la tua password, il processo si inverte. Il KeyringController recupera la stringa crittografata del vault dalla memoria permanente e la passa a browser-passworder’s decrypt funzione che analizza il JSON, estrae il salt, genera la chiave utilizzando PBKDF2 con gli stessi parametri, decrittografa con AES-GCM e deserializza il risultato in oggetti keyring. I keyring decrittografati risiedono solo nella memoria – sono conservati nel memStore (un ObservableStore (ad esempio) e non vengono mai salvati su disco in chiaro.

Un vault decriptato contiene un array che in genere ha questo aspetto:

[
  {
    "type": "HD Key Tree",
    "data": {
      "mnemonic": "abandon ability able about above absent ...",
      "numberOfAccounts": 3,
      "hdPath": "m/44'/60'/0'/0"
    }
  },
  {
    "type": "Simple Key Pair",
    "data": ["0xabc123..."]
  }
]

Il HD Key Tree Il portachiavi contiene la tua frase mnemonica e il numero di account derivati. Simple Key Pair le voci sono chiavi private importate singolarmente. Se hai collegato dei portafogli hardware, vedrai anche Trezor Hardware e Ledger Hardware tipi di portachiavi – sebbene questi memorizzino solo i percorsi di derivazione e gli indirizzi pubblici, non le chiavi private (che rimangono sul dispositivo hardware).

Con Manifest V3 (l'architettura dei service worker che Chrome ha iniziato a promuovere a partire dal 2023), MetaMask ha aggiunto la possibilità di memorizzare nella cache la chiave di crittografia sotto forma di JWK esportato, in modo da poter decrittografare nuovamente il vault al riavvio del service worker senza richiedere nuovamente la password. Il encryptionKey e encryptionSalt i campi compaiono in memStore quando cacheEncryptionKey è attivata.

Dove MetaMask archivia i tuoi dati su ogni piattaforma

Trovare l'archivio è già metà dell'opera. MetaMask salva i dati in posizioni diverse a seconda del browser e del sistema operativo, e queste differenze sono importanti ai fini del recupero.

Browser basati su Chromium (Chrome, Brave, Edge)

Nei browser basati su Chromium, chrome.storage.local rimane un Database LevelDB sul disco. L'ID dell'estensione determina il nome della cartella.

ID dell'estensione di Chrome è nkbihfbeogaeaoehlefnkodbefgpgknn – impresso nella memoria di ogni specialista del recupero. Coraggioso utilizza lo stesso ID poiché viene installata dal Chrome Web Store. Bordo riceve un proprio ID se installato dall'Edge Add-ons Store: ejbalbakoplchlghecdalmeeeajnimhm. Tuttavia, se un utente ha installato MetaMask su Edge tramite il Chrome Web Store (che Edge supporta), mantiene l'ID di Chrome. Questa distinzione crea spesso confusione.

Ecco i percorsi completi:

Chrome su Windows:
C:\Users\<USER>\AppData\Local\Google\Chrome\User Data\Default\Local Extension Settings\nkbihfbeogaeaoehlefnkodbefgpgknn\

Chrome su macOS:
~/Library/Application Support/Google/Chrome/Default/Local Extension Settings/nkbihfbeogaeaoehlefnkodbefgpgknn/

Chrome su Linux:
~/.config/google-chrome/Default/Local Extension Settings/nkbihfbeogaeaoehlefnkodbefgpgknn/

Brave su Windows:
C:\Users\<USER>\AppData\Local\BraveSoftware\Brave-Browser\User Data\Default\Local Extension Settings\nkbihfbeogaeaoehlefnkodbefgpgknn\

Brave su macOS:
~/Library/Application Support/BraveSoftware/Brave-Browser/Default/Local Extension Settings/nkbihfbeogaeaoehlefnkodbefgpgknn/

Edge su Windows (installazione dallo Store di Edge):
C:\Users\<USER>\AppData\Local\Microsoft\Edge\User Data\Default\Local Extension Settings\ejbalbakoplchlghecdalmeeeajnimhm\

Un dettaglio fondamentale: se l'utente dispone di più profili Chrome, sostituire Default con Profile 1, Profile 2, ecc. Ho visto persone passare ore a cercare nel profilo sbagliato.

Firefox: una cosa completamente diversa

Firefox non utilizza LevelDB. Memorizza i dati delle estensioni in IndexedDB, che Firefox implementa basandosi su SQLite. L'ID dell'estensione è webextension@metamask.io, ma Firefox assegna un UUID interno univoco per ogni installazione – qualcosa del tipo 196319ec-3a5e-4efe-9413-c327a770d874. Lo trovi su about:debugging alla voce «Questo Firefox».

I dati si trovano all'indirizzo:

Windows: %APPDATA%\Mozilla\Firefox\Profiles\<PROFILE>\storage\default\moz-extension+++<UUID>^userContextId=4294967295\idb\

macOS: ~/Library/Application Support/Firefox/Profiles/<PROFILE>/storage/default/moz-extension+++<UUID>^userContextId=4294967295/idb/

Linux: ~/.mozilla/firefox/<PROFILE>/storage/default/moz-extension+++<UUID>^userContextId=4294967295/idb/

All'interno del idb/ cartella, troverai dei file binari con nomi numerici. Si tratta di Compresso con Snappy – non è possibile analizzarli con `grep` come si fa con i file LevelDB. È necessario prima decomprimerli utilizzando uno strumento come snappy-fox prima che i dati del vault diventino estraibili. Questo è l'errore più comune che riscontro durante il ripristino di Firefox: gli utenti aprono il file binario, vedono dati illeggibili mescolati a frammenti di testo riconoscibile e pensano che il vault sia danneggiato. Non è così. È semplicemente compresso.

Prima di Firefox 63, l'archivio delle estensioni utilizzava un semplice file JSON denominato storage.js nella directory dei profili. Se stai ripristinando un'installazione molto vecchia, cerca storage.js oppure storage.js.migrated.

LevelDB e il file 0001.ldb di cui tutti parlano

LevelDB è il motore di archiviazione chiave-valore di Google, e comprenderne la struttura dei file è fondamentale per il ripristino di MetaMask su qualsiasi browser basato su Chromium.

Una directory LevelDB di MetaMask contiene diversi tipi di file. La .ldb file (Le tabelle di stringhe ordinate, o SSTable) sono un sistema di archiviazione permanente e ordinato di coppie chiave-valore. .log file sono il Write-Ahead Log – un buffer temporaneo delle operazioni di scrittura recenti prima che vengano scaricate su .ldb file. C'è un MANIFEST-###### metadati del database di tracciamento dei file, un CURRENT file che punta al manifesto attivo, e un LOCK file che impedisce l'accesso simultaneo.

I dati dell'archivio vengono solitamente salvati in un con numeri bassi .ldb file – 000003.ldb, 000005.ldb, o simili. La documentazione ufficiale di MetaMask precisa che «dovrebbe trattarsi di un valore numerico basso. Se il numero è elevato, non si tratta del vault». Il 0001.ldb file (o 000001.ldb) è uno dei primi SSTable creati al momento della prima inizializzazione di MetaMask. Spesso contiene il vault originale creato durante la creazione del portafoglio.

Estrazione dei dati dell'archivio da .ldb file su Chromium è solitamente semplice. Apri il file in un editor di testo (Sublime Text, VS Code, o anche Notepad++) e cerca la stringa vault. Troverai il blob JSON crittografato incorporato nella struttura del record LevelDB. Copia tutto da {"data":" fino alla chiusura "} – quello è il tuo caveau.

Su Mac o Linux, basta questa riga di comando:

LC_ALL="C" egrep -roa 'vault":"(.*?\\"})' ~/Library/Application\ Support/Google/Chrome/Default/Local\ Extension\ Settings/nkbihfbeogaeaoehlefnkodbefgpgknn/ | sed -E 's/.*({.*}).*/\1/g' | head -1

Una cosa da tenere d'occhio: .ldb i file possono utilizzare Compressione veloce sui blocchi di dati. Se la ricerca nella stringa non va a buon fine e si vedono blocchi di dati binari incomprensibili, il blocco di dati che ti serve potrebbe essere compresso con Snappy. Il .log Il file, al contrario, è sempre non compresso: dati grezzi in formato chiave-valore suddivisi in blocchi da 32 KB. Se il .ldb se l'approccio fallisce, controllare sempre il .log file. La documentazione ufficiale di MetaMask riporta quanto segue: «Se non riesci a ripristinare il tuo vault utilizzando il file .ldb, verifica se è presente un file .log.»

Una caratteristica di LevelDB estremamente utile per il ripristino: è solo aggiunta. Le operazioni di aggiornamento e cancellazione non modificano i record esistenti, ma aggiungono nuove voci con numeri di sequenza più elevati. I vecchi record rimangono fino a quando una compattazione non li elimina. Ciò significa che se qualcuno ha importato un nuovo SRP sovrascrivendo uno vecchio, i vecchi dati del vault potrebbero essere ancora presenti in una versione precedente .ldb file che non è stato ancora compresso. Ho recuperato portafogli "sovrascritti" in questo modo più di una volta.

Per l'estrazione programmatica, il btcrecover il progetto comprende extract-metamask-vaults.py, che legge correttamente il database LevelDB ed estrae tutte le voci del vault, comprese quelle potenzialmente obsolete nascoste nei file non compattati. Il cyclone-github/metamask_extractor Questo strumento svolge la stessa funzione e può generare output direttamente in un formato compatibile con Hashcat.

Quando i file di archiviazione risultano danneggiati

Il danneggiamento del vault è solitamente dovuto a una delle seguenti cause: un arresto anomalo del browser durante un'operazione di scrittura (interruzione di corrente, kernel panic, chiusura forzata), un aggiornamento di MetaMask interrotto che riscrive l'archivio a metà processo, errori effettivi del disco (settori danneggiati, usura dell'SSD) o – caso sempre più comune – la messa in quarantena da parte del software antivirus dei file JavaScript di MetaMask, che può lasciare il database LevelDB in uno stato incoerente anche se i dati del vault sono intatti.

Ti accorgi che il vault è danneggiato quando il file JSON non viene analizzato correttamente: parentesi graffe mancanti, stringhe Base64 troncate, byte nulli inseriti nel mezzo del campo dati. Il MetaMask Vault Decryptor visualizzerà il messaggio "Problema durante la decodifica del vault" oppure semplicemente non funzionerà senza dare alcun avviso.

Il recupero dipende dal tipo e dall'entità del danneggiamento. Se la struttura JSON è danneggiata ma i dati crittografati sono per lo più intatti, spesso è possibile ricostruire manualmente la volta. Il formato è rigido: occorre esattamente il data, iv, e salt campi (più keyMetadata (per i vault più recenti). Eliminare i byte nulli e i caratteri di controllo. Verificare che il data, iv, e salt i valori sono in formato Base64 valido. Se il data se il campo è troncato, però, sei nei guai – AES-GCM richiede il testo cifrato completo oltre al suo tag di autenticazione (gli ultimi 16 byte del data (campo) da decriptare. Basta un solo byte mancante perché l'intera operazione fallisca.

Per i database LevelDB parzialmente danneggiati in cui il .ldb se i file stessi sono danneggiati, prova a leggere il .log Prova invece con il file: si tratta di un formato più semplice (blocchi sequenziali da 32 KB con intestazioni da 7 byte) e potrebbe contenere una copia più recente del vault che è sopravvissuta all'evento di danneggiamento. Se nessuno dei due approcci funziona, a volte è possibile utilizzare le librerie di analisi LevelDB in Python (CCL Solutions Group ha rilasciato implementazioni in Python puro per l'analisi LevelDB, la decompressione Snappy e la deserializzazione V8) per estrarre con precisione i record dai file di database danneggiati, saltando i blocchi corrotti.

In una singola directory LevelDB possono coesistere più SRP. Se un utente ha importato una nuova frase seed, la vecchia voce del vault potrebbe rimanere in una directory separata .ldb file o anche all'interno dello stesso file in una posizione diversa. Cerca sempre tutte le istanze del motivo a volta, non solo il primo.

Il problema dei file sovrascritti e come risolverlo

Questo è lo scenario che causa più dispiacere. Qualcuno disinstalla MetaMask: forse stava cercando di risolvere un problema, forse stava "ripulendo" il browser, forse non si è reso conto di cosa stesse facendo. Sui browser basati su Chromium, la disinstallazione di un'estensione elimina l'intera cartella dei dati dell'estensione, compresi tutti .ldb, .loge i file manifest. Su Firefox, il moz-extension+++<UUID> la cartella viene eliminata e, dato che ogni reinstallazione genera un nuovo UUID, la nuova installazione non toccherà la vecchia posizione (ma la vecchia posizione non c'è più).

La documentazione ufficiale di MetaMask è molto chiara al riguardo: «I dati dell'estensione del browser vengono eliminati quando l'estensione viene disinstallata. In genere, ciò significa che i dati del tuo vault andranno persi».

Quel termine, «generalmente», ha un significato molto ampio. I dati vengono logicamente cancellati – il filesystem contrassegna quei settori come liberi – ma i byte effettivi non vengono immediatamente azzerati. Su un HDD tradizionale, i dati permangono finché quei settori non vengono riutilizzati da nuovi file. Su un SSD, i comandi TRIM possono rendere i dati cancellati irrecuperabili nel giro di pochi minuti, a volte addirittura di pochi secondi.

La prima regola per il recupero di un archivio sovrascritto: smetti immediatamente di usare il computer. Ogni nuovo file salvato sul disco potrebbe sovrascrivere i settori in cui si trovava il tuo archivio. Se possibile, rimuovi il disco e montalo in sola lettura su un altro computer.

Strumenti di ripristino per questo scenario, in ordine di preferenza:

  • Il nostro software personalizzato (multipiattaforma) per il recupero dei file cancellati in modo logico
  • extundelete o ext4magic per i file system ext3/ext4 di Linux
  • Ricerca su disco grezzo come ultima risorsa: grep -rboa "vault" /dev/sdX per eseguire una scansione del dispositivo disco grezzo alla ricerca di stringhe del vault
  • I nostri strumenti su misura per il recupero dei file quando i metadati del filesystem sono andati persi – configurarlo per cercare {"data":" modelli

Sono riuscito a recuperare i vault da dischi rigidi che erano stati disinstallati settimane prima. Sui dischi SSD, invece, la percentuale di successo cala drasticamente già dopo poche ore di utilizzo continuativo. Reinstallare MetaMask è la cosa peggiore che si possa fare, perché crea un nuovo database LevelDB esattamente nella stessa directory, rischiando di sovrascrivere i vecchi settori.

Firefox presenta un vantaggio in questo caso. Poiché a ogni installazione viene assegnato un nuovo UUID, la reinstallazione crea i file in un nuovo percorso di directory. Il vecchio moz-extension+++<OLD-UUID> i dati, anche se la cartella è stata eliminata, non verranno sovrascritti dai file della nuova installazione. Esistono inoltre due impostazioni nascoste di Firefox – extensions.webextensions.keepUuidOnUninstall e extensions.webextensions.keepStorageOnUninstall – che, se impostato su true in about:config Prima della disinstallazione, assicurati che il browser non cancelli i dati memorizzati dall'estensione. Ma nessuno imposta queste opzioni in modo proattivo.

MetaMask su dispositivi mobili è tutta un'altra storia

MetaMask Mobile è sviluppato con React Native e gestisce i dati in modo completamente diverso rispetto all'estensione per browser. Il vault crittografato passa attraverso @react-native-async-storage/async-storage, che utilizza backend specifici per piattaforma.

Su Android, AsyncStorage in genere scrive su un Database SQLite presso /data/data/io.metamask/databases/RKStorage. Questo percorso richiede l'accesso come root per consentire la lettura diretta. La crittografia del vault utilizza lo stesso approccio basato su chiavi derivate da PBKDF2, ma con alcune differenze significative rispetto all'estensione per desktop: l'app mobile, storicamente, utilizza solo 5.000 iterazioni PBKDF2 e crittografa con AES-CBC anziché AES-GCM. Ciò significa che i vault mobili non sono intercambiabili con quelli desktop, anche se la password è la stessa.

Su iOS, i dati risiedono nella sandbox dell'app all'interno di <AppSandbox>/Documents/. Per il ripristino del backup di iCloud, il percorso corretto è Apps → MetaMask → Documents → persistStore → persist-root – Per sfogliare un backup iOS su un Mac, ti servirà uno strumento come iMazing. Il funzionamento di questo metodo dipende dal fatto che l'utente avesse attivato il backup su iCloud mentre MetaMask era attivo; inoltre, a quanto pare, alcune modifiche apportate da Apple hanno reso questo approccio inaffidabile in alcuni casi.

MetaMask per dispositivi mobili include anche una SecureKeychain modulo (basato su react-native-keychain) che memorizza la password del portafoglio dell'utente nel Keychain di iOS o nel Keystore di Android per lo sblocco biometrico. Un controllo di sicurezza ha rivelato che SecureKeychain aggiunge un ulteriore livello di crittografia utilizzando un salt "foxCode" – che si è rivelato essere la stringa hardcoded "encrypt". Il team di MetaMask ha riconosciuto che si trattava di una strategia di difesa a più livelli piuttosto che di un segreto fondamentale per la sicurezza.

La sfida principale nel recupero dei dati dai dispositivi mobili è che non è possibile estrarre manualmente i file dall'archivio equivale a trovare .ldb file sul desktop. Non è possibile collegarsi via SSH al proprio iPhone e cercare le stringhe del vault con grep. A partire da MetaMask per dispositivi mobili v6.3.0, l'app include una funzione di ripristino automatico del vault che si attiva quando viene rilevato un danneggiamento; tuttavia, se l'app viene eliminata, i dati del vault locale andranno persi a meno che non si disponga di un backup del dispositivo. I meccanismi di backup di Android sono particolarmente inaffidabili quando si tratta di salvare tutti i dati interni alle app. La posizione ufficiale di MetaMask è quello di consigliare di trasferire i dati su un nuovo SRP piuttosto che affidarsi al ripristino tramite Android Vault.

La modifica al numero di iterazioni del PBKDF2 che ha reso inutilizzabili tutti gli strumenti di recupero

Per anni, MetaMask ha utilizzato 10.000 iterazioni PBKDF2 – il valore predefinito hardcoded nel browser-passworder libreria. Ogni strumento di recupero, ogni modulo di Hashcat, ogni script di forza bruta era impostato su 10.000 iterazioni. Poi, tra la fine del 2023 e l'inizio del 2024, tutto è cambiato.

Il @metamask/browser-passworder La versione 4.2.0 della libreria (rilasciata il 13 novembre 2023) ha introdotto il supporto per opzioni configurabili di derivazione delle chiavi. Il nuovo valore predefinito della libreria è passato a 900.000 iterazioni, ma l'estensione di MetaMask l'ha configurata per utilizzare 600.000 iterazioni – in linea con la raccomandazione OWASP del 2023 relativa a PBKDF2-HMAC-SHA256. Tramite l'estensione MetaMask v11.16.11 (come confermato in un numero di Hashcat del giugno 2024), venivano creati nuovi vault con 600.000 iterazioni e il nuovo keyMetadata campo.

Si tratta di un aumento di 60 volte del costo computazionale per ogni tentativo di password. Un attacco brute-force che prima richiedeva un giorno con 10.000 iterazioni ora richiede due mesi con 600.000 iterazioni sullo stesso hardware. La comunità di Hashcat ha dovuto sviluppare kernel personalizzati – la modalità 26620, fornita da cyclone – per gestire il nuovo formato. La modalità standard 26600 aveva 10.000 iterazioni hardcoded.

È importante sottolineare che i vecchi archivi NON vengono ricrittografati automaticamente. Se hai creato il tuo portafoglio nel 2021, il tuo vault utilizza ancora 10.000 iterazioni, a meno che MetaMask non abbia attivato esplicitamente una ricrittografia (il updateVault (esiste una funzione a questo scopo, ma non è chiaro con quale frequenza MetaMask la chiami al momento dello sblocco). È possibile capire con quale versione si ha a che fare dalla presenza o dall'assenza del keyMetadata campo. No keyMetadata? Sono 10.000 iterazioni. Ha keyMetadata con "iterations": 600000? È il nuovo formato.

Ecco la cronologia completa delle versioni della libreria di crittografia rilevanti ai fini del ripristino:

  • browser-passworder v1.x–v2.x (prima del 2022): 10.000 iterazioni, valore fisso. Pubblicato senza il @metamask ambito.
  • v3.0.0 (Agosto 2022): Rinominato in @metamask/browser-passworder. Nessuna modifica all'iterazione.
  • v4.2.0 (novembre 2023): Aggiunto keyMetadata supporto. Il numero predefinito di iterazioni per la crittografia è stato modificato a 900.000. keyFromPassword retrocompatibile a 10.000.
  • v4.3.0 (novembre 2023): Aggiunto isVaultUpdated per verificare se il caveau soddisfa i parametri previsti.
  • v5.0.0 (aprile 2024): versione minima di Node.js v16. Nessuna modifica relativa alla crittografia.
  • v6.0.0 (dicembre 2024): Node.js v18.18 come versione minima. Nessuna modifica relativa alla crittografia.

Per gli specialisti del recupero dati: controllate sempre prima il formato del disco. È questo che determina l'intero approccio.

La politica sulle password di MetaMask e cosa comporta per gli attacchi di forza bruta

MetaMask richiede che la password abbia una lunghezza minima di 8 caratteri. Tutto qui. Nessun requisito di maiuscole, numeri o caratteri speciali. L'estensione mostra un indicatore visivo di sicurezza ("Debole" / "Buona") ma non blocca le password deboli che rispettano la lunghezza minima. Non c'è nemmeno una lunghezza massima: i caratteri Unicode sono supportati. Questa politica è in vigore almeno dall'inizio del 2018 (come indicato nell'issue GitHub n. 3515).

Diversi siti di terze parti sostengono erroneamente che MetaMask richieda l'uso di lettere maiuscole, minuscole, numeri e caratteri speciali. Ciò non è vero. L'unico requisito imprescindibile è che la password sia composta da 8 caratteri.

Per il recupero con forza bruta, questo aspetto è di fondamentale importanza. Una password di 8 caratteri composta esclusivamente da lettere minuscole presenta uno spazio delle chiavi di circa 208 miliardi di combinazioni (26^8). Contro un vecchio vault con 10.000 iterazioni, hashcat su una GPU moderna può testare migliaia di hash al secondo, rendendo la password violabile in pochi giorni. Contro un vault da 600.000 iterazioni, il tempo da impiegare si moltiplica per 60. Una password forte di oltre 12 caratteri con maiuscole, minuscole e simboli? Praticamente inviolabile contro entrambi i formati con l'hardware attuale.

Lo strumento pratico di recupero più indicato è btcrecover – La stessa MetaMask lo consiglia agli utenti che hanno un'idea approssimativa della propria password. Supporta la ricerca basata su token e su schemi, consentendo di definire un modello come "my" + [dog|cat|bird] + [2019|2020|2021] + ["!"|"@"|"#"] e testare in modo efficiente tutte le permutazioni. Per gli attacchi accelerati da GPU, la modalità 26600 di Hashcat gestisce i vecchi vault, la modalità 26610 gestisce i vault mobili, mentre la modalità 26620 (o una versione ricompilata della 26600 con iterazioni aggiornate) gestisce il nuovo formato da 600.000 iterazioni.

I percorsi di derivazione e l'epidemia dei «fondi mancanti»

È proprio dal percorso di derivazione che hanno origine la maggior parte dei problemi legati alla "scomparsa dei propri fondi". MetaMask utilizza il percorso standard BIP-44 per Ethereum: m/44'/60'/0'/0. I conti vengono calcolati incrementando l'indice finale: m/44'/60'/0'/0/0 (primo resoconto), m/44'/60'/0'/0/1 (secondo), m/44'/60'/0'/0/2 (terzo), e così via. Questo percorso è valido per tutte le catene compatibili con EVM: lo stesso indirizzo su Ethereum, Polygon, Arbitrum e BSC.

Il problema è che non tutti utilizzano lo stesso percorso. Ledger Live utilizzi m/44'/60'/x'/0/0, aumentando il account campo invece del address_index. L'eredità di Ledger (il vecchio percorso MEW/MyCrypto) utilizza m/44'/60'/0'/x – solo quattro livelli invece di cinque. Il primo indirizzo (m/44'/60'/0'/0/0) è identico su MetaMask, Ledger Live e Trezor. Ma il il secondo account e quelli successivi differiscono completamente, poiché ogni portafoglio incrementa una componente diversa del percorso.

Questo porta a un problema molto specifico: un utente ripristina il proprio seed Ledger in MetaMask, vede il suo primo conto e il relativo saldo, poi aggiunge un secondo conto e vede… zero. I fondi non sono spariti. Si trovano all’indirizzo derivato da m/44'/60'/1'/0/0 (in stile Ledger Live), ma MetaMask sta valutando m/44'/60'/0'/0/1. Chiavi completamente diverse, indirizzi completamente diversi.

Percorso di derivazione predefinito di Ethereum in Trezor corrisponde a quella di MetaMask: m/44'/60'/0'/0/x. Il ripristino da Trezor a MetaMask funziona quindi in genere per tutti gli account. I problemi tra portafogli diversi riguardano principalmente Ledger ↔ MetaMask e Ledger ↔ Trezor.

Per individuare i fondi che si trovano nel percorso di derivazione "errato", le opzioni disponibili sono:

  • Contattaci via e-mail all'indirizzo contact@cryptorecovery.io e faremo del nostro meglio per aiutarti e fornirti assistenza.
  • MyEtherWallet (MEW): Supporta percorsi di derivazione personalizzati tramite "Aggiungi percorso". Inserisci manualmente m/44'/60'/1'/0/0, m/44'/60'/2'/0/0, ecc. per verificare gli indirizzi in stile Ledger Live.
  • MyCrypto: supporto per percorsi di derivazione personalizzati simili.
  • Strumento BIP-39 di Ian Coleman (da eseguire offline): inserisci la frase mnemonica, seleziona ETH, passa da una scheda BIP-44 all'altra e modifica manualmente i componenti del percorso.
  • btcrecover: È in grado di automatizzare i test su diversi schemi di percorsi di derivazione.

Un limite fastidioso: l'integrazione di MetaMask con Trezor non supporta i percorsi di derivazione personalizzati. Un'opzione per i percorsi di derivazione personalizzati è stata implementata per Ledger (PR #9367), ma secondo le ultime informazioni, quella equivalente per Trezor (GitHub issue #11197) rimane ancora in sospeso. Se stai cercando di accedere ad account derivati da Ledger tramite MetaMask + Trezor, dovrai invece utilizzare MEW o MyCrypto.

MetaMask e Trezor: un matrimonio travagliato

L'integrazione tra MetaMask e Trezor funziona tramite Trezor Bridge – un processo in background installato localmente (trezord) che ascolta su http://127.0.0.1:21325/ e colma il divario tra l'ambiente protetto del browser e l'accesso all'hardware USB. Puoi verificare se è in esecuzione premendo http://127.0.0.1:21325/status/.

Il motivo più comune di malfunzionamento è apparentemente semplice: Trezor Suite è aperta. Trezor Suite blocca la connessione USB al dispositivo, impedendo a MetaMask di comunicare. È necessario chiudere completamente Suite: non basta ridurla a icona, ma bisogna chiuderla dalla barra delle applicazioni. Direi che questo rappresenta circa il 40% delle segnalazioni del tipo «MetaMask non riesce a trovare il mio Trezor» che ho ricevuto.

Altri problemi comuni e relative soluzioni:

«Alla ricerca del tuo Trezor…» – il messaggio continua a girare all’infinito – Verificare che Bridge sia installato e trezord è in esecuzione. Prova a utilizzare un cavo USB e una porta diversi. Disattiva la VPN, il firewall e le estensioni del browser (gli ad blocker e le estensioni per la privacy spesso causano interferenze). La modalità di navigazione in incognito elimina i conflitti tra le estensioni.

«Chiamata al dispositivo in corso» – Un'altra applicazione o scheda del browser sta già comunicando con Trezor. Chiudi tutte le altre schede e applicazioni che potrebbero accedere al dispositivo.

Limiti di WebUSB – Firefox non supporta affatto WebUSB, il che significa che la connettività di Trezor su Firefox dipende interamente da Bridge. Chrome, Brave ed Edge funzionano tramite l'implementazione WebUSB/WebHID di Chromium.

Avviso relativo al percorso di derivazione su Trezor Safe 5 – Alcuni utenti segnalano la comparsa del messaggio «Percorso di derivazione errato per l'account selezionato. m/44’/60’/0’/0» sullo schermo del Trezor durante la convalida della transazione. In genere questo avviso può essere tranquillamente ignorato: il portafoglio funziona correttamente nonostante il messaggio. Si tratta di un problema puramente estetico legato al modo in cui il firmware del Trezor convalida i percorsi che non sembrano conformi allo standard.

Nel 2025, Trezor ha iniziato a integrare le funzionalità di Bridge direttamente in Trezor Suite. Questa transizione ha causato una serie di problemi di connettività, poiché alcuni utenti avevano bisogno che Trezor Suite fosse in esecuzione in background per le connessioni a MetaMask, mentre altri dovevano chiuderla completamente. Per la configurazione corretta, vai su Trezor Suite → Impostazioni → Applicazione → Trezor Connect.

Quando MetaMask si collega a un Trezor, gli account risultanti sono sostanzialmente diversi dagli account del portafoglio software di MetaMask. Gli account derivati da Trezor memorizzano nel vault solo le chiavi pubbliche e i percorsi di derivazione; le chiavi private rimangono sul dispositivo hardware. MetaMask può visualizzare i saldi (in sola lettura tramite chiavi pubbliche) senza che Trezor sia collegato, ma non può firmare transazioni senza la presenza del dispositivo fisico. Se è stata utilizzata una passphrase durante la creazione degli account Trezor, è necessario inserire esattamente la stessa passphrase per rigenerare gli stessi indirizzi.

Tecniche di recupero che funzionano davvero nella pratica

Dopo centinaia di interventi di recupero dati, ecco quali sono le situazioni che mi si presentano più spesso e come le gestisco.

Scenario 1: si dispone della password, si è smarrita la frase di seed, l'estensione è ancora installata

Questo è il più semplice. Apri la pagina di MetaMask in background tramite chrome://extensions → Modalità sviluppatore → clicca su «service worker» (MV3) o «pagina in background» (MV2). Nella console:

chrome.storage.local.get('data', result => {
    console.log(result.data.KeyringController.vault);
});

Copia il file JSON del vault e incollalo nel Decrittografo MetaMask Vault (metamask.github.io/vault-decryptor), inserisci la tua password e ti mostrerà la tua frase mnemonica e le eventuali chiavi private importate. Il Vault Decryptor è stato sviluppato da Dan Finlay, cofondatore di MetaMask, e supporta anche .ldb file direttamente tramite caricamento.

Scenario 2: si dispone della password; l'estensione è stata disinstallata, ma i dati potrebbero essere ancora presenti sul disco

Accedi alla directory dei dati dell'estensione. Se la cartella è ancora presente (a volte la disinstallazione non riesce a cancellare tutto, oppure l'utente ha solo disattivato l'estensione invece di rimuoverla), prendi il .ldb e .log file. Estrai il vault utilizzando grep, un editor di testo o btcrecover’s extract-metamask-vaults.py. Decrittografare con il Vault Decryptor.

Se la cartella è andata persa, contattaci all'indirizzo contact@cryptorecovery.io e ti aiuteremo con l'analisi forense del disco.

È inoltre possibile montare l'unità in modalità di sola lettura ed eseguire ricerche dirette sul disco alla ricerca di stringhe corrispondenti a modelli specifici. Su Linux: grep -rboa '{"data":"' /dev/sdX. Il successo dipende in larga misura dall'entità dell'attività del disco verificatasi dopo la cancellazione e dal tipo di unità (SSD o HDD).

Scenario 3: Password dimenticata, si dispone del file del vault

Si tratta di uno scenario di forza bruta. Estrai il vault e convertilo nel formato hashcat utilizzando metamask2hashcat.py oppure cyclone-github/metamask_extractor. Quindi esegui hashcat (modalità 26600 per i vecchi vault, 26620 per quelli nuovi) oppure btcrecover con un file di token che descriva ciò che ricordi della password. Se sai che la tua password era qualcosa del tipo “myDog” più un anno più un simbolo, btcrecover può testare quelle combinazioni in modo efficiente.

Scenario 4: Ripristino di Firefox

Trova l'UUID di MetaMask all'indirizzo about:debugging. Accedere alla directory di archiviazione. Decomprimere i file binari di IndexedDB utilizzando snappy-fox:

./snappy-fox input_file.snappy output.txt

Cerca il file JSON di Vault nell'output decompresso. Quindi procedi con il Vault Decryptor. Il JesseBusman/FirefoxMetamaskWalletSeedRecovery Questo script Python automatizza l'intero processo: esegue una scansione del profilo di Firefox, individua i dati del vault e genera un file JSON formattato pronto per la decrittografia.

Scenario 5: i fondi risultano mancanti dopo l'importazione del seed

Controlla i percorsi di derivazione. Se importi un seed del Ledger in MetaMask, a partire dal secondo account verranno visualizzati indirizzi diversi e saldi pari a zero. Utilizza MEW o MyCrypto con percorsi di derivazione personalizzati per individuare i fondi su Ledger Live (m/44'/60'/x'/0/0) o Ledger Legacy (m/44'/60'/0'/x) percorsi. Se è stata utilizzata una passphrase Trezor, assicurati di inserire esattamente la stessa passphrase: una passphrase diversa genera una serie di indirizzi completamente diversa a partire dallo stesso seed.

Strumenti forensi da avere nel proprio kit

  • Decrittografo MetaMask Vault – versione ufficiale, funziona anche offline, supporta il collegamento diretto .ldb caricamento file
  • btcrecover – recupero della password tramite corrispondenza di sequenze, raccomandato da MetaMask
  • hashcat – Attacco a forza bruta con accelerazione GPU (modalità 26600, 26610, 26620)
  • snappy-fox – Decompressione Snappy per Firefox
  • Strumenti Python di CCL Solutions Group: analisi sintattica di LevelDB in Python puro, decompressione Snappy, deserializzazione V8

Conclusione: cosa distingue i recuperi riusciti da quelli falliti

La differenza tra il recupero di un portafoglio e la sua perdita definitiva dipende quasi sempre da ciò che accade nei primi minuti dopo la scoperta del problema. L'azione più dannosa in assoluto è reinstallare MetaMask sullo stesso profilo del browser: ciò sovrascrive la directory LevelDB con file nuovi. La seconda azione più dannosa è continuare a utilizzare normalmente il computer su un SSD dopo la cancellazione del vault, poiché ciò attiva il TRIM e rende impossibile il recupero a livello di settore.

Se dovessi trarre tre insegnamenti da questa guida: salva la tua frase seed su carta, tieni presente che il tuo vault risiede in una cartella specifica che puoi copiare e conservare, e se qualcosa va storto, smetti immediatamente di usare quel computer prima di tentare qualsiasi operazione di recupero. La crittografia è solida – AES-256-GCM con 600.000 iterazioni PBKDF2 non può essere violata con un attacco di forza bruta a meno che la password non sia debole – ma i dati stessi sono sorprendentemente fragili. Si tratta solo di pochi kilobyte in un database LevelDB, e possono scomparire con un solo clic per la pulizia del browser.

Tutti i portafogli che non sono riuscito a recuperare avevano la stessa causa principale: l'utente ha continuato a utilizzare il dispositivo dopo la perdita dei dati. Tutti i portafogli che sono riuscito a recuperare erano quelli in cui i dati erano ancora presenti sul disco – a volte in posti inaspettati, a volte in più copie grazie all'architettura "append-only" di LevelDB, ma sempre perché qualcuno si è fermato a riflettere prima di agire.

Se hai bisogno di aiuto per recuperare il tuo portafoglio MetaMask, contattaci via e-mail: contact@cryptorecovery.io per una consulenza professionale e gratuita oppure visita la nostra pagina dei contatti