Convert a wallet to a hashcat hash

The short answer

Every wallet format has one extraction script that produces the line hashcat needs, and one mode number that matches it. Three script families cover the formats on this site:

• *2john.py — the extractors in John the Ripper jumbo’s run/ folder. Many of their outputs work in both John and hashcat after formatting cleanup. Ethereum keystores are the clearest case where the conversion is required: ethereum2john.py reads the UTC JSON and produces the $ethereum$p*…/$ethereum$s*… line that both hashcat (modes 15600/15700) and John need — hashcat does not read the raw JSON. Examples: bitcoin2john.py, electrum2john.py, blockchain2john.py, multibit2john.py.
• *2hashcat.py — the extractors in hashcat’s tools/ folder, for formats the 2john family doesn’t cover as cleanly: metamask2hashcat.py, exodus2hashcat.py, bisq2hashcat.py.
• extract-*.py — btcrecover’s scripts in its extract-scripts/ folder. These produce btcrecover’s own bc:-style base64 for --data-extract, not a hashcat line. They are the right tool for the btcrecover path, and the wrong tool for the hashcat path.

The recipes below use the first two families. If the conversion step feels like a project of its own, that is the strongest argument for btcrecover instead — it does the extraction internally and reads these wallets directly. The hashcat path earns its keep when you have a specific mask or wordlist attack in mind.

Why extraction exists

hashcat is a general-purpose cracker, not a wallet parser. Each mode number corresponds to one hash type — 11300 is Bitcoin/Litecoin wallet.dat, 26600/26610/26620/31900 cover the MetaMask vault generations, and so on. The extraction script reduces your wallet to the small piece hashcat actually needs: the salt, the KDF parameters (like the iteration count), and a verification value that a correct password reproduces. An extracted hash is not normally a plaintext private key, but it can contain highly sensitive encrypted wallet material — for some formats, possession of the extracted data together with the recovered password may be sufficient to expose wallet secrets. Treat every extracted hash as sensitive as the original wallet file.

The one-line recipes

Copy the wallet file to a working folder first, then run the extractor and redirect its output into a text file. The commands assume Python 3 and the script in your current folder or PATH:

Then run hashcat against the extracted file, for example: hashcat -m 11300 wallet.hash words.txt -r rules/best66.rule. The full attack setup — masks, wordlists, rules — is on the hashcat walkthrough.

Verify the line before you run

Three quick checks catch nearly every “it doesn’t work” moment:

• The marker matches the mode. The line should start with the right prefix: $bitcoin$… for 11300, $electrum$… for the Electrum modes, $blockchain$… for 12700/15200, $metamask$… for the MetaMask modes. A $bitcoin$ line with -m 26600 will never load.
• Strip the filename prefix. Several 2john scripts print wallet.dat:$bitcoin$64$… — hashcat needs only the part after the colon. The hashcat forum gives this as the most common formatting mistake.
• Compare with the example hashes. hashcat’s example-hashes page shows exactly what a valid line looks like per mode. If your line looks nothing like the example, the mode is wrong or extraction failed.

Common errors — and the real cause

• “No hashes loaded” — the mode number doesn’t match the hash type in the line. Check the marker and the example hashes before changing anything else.
• “Separator unmatched” — a malformed line, almost always a leftover filename prefix or a line that was wrapped when copied. Re-run the extractor with a clean redirect.
• Extractor produces nothing — the wallet may simply not be encrypted. Bitcoin Core, for example, only encrypts wallet.dat after you set a password; an unencrypted wallet has no password hash to extract. That is not a tool failure.

Every one of these has a step-by-step fix on the troubleshooting index.

When you don’t need this page

• Ethereum keystores — btcrecover reads them directly (the simpler route). If you choose the hashcat path, the conversion is one command: ethereum2john.py UTC--*.json > eth.hash — hashcat does not read the raw JSON.
• btcrecover — it parses the wallet internally, so no hash line is ever needed. The walkthrough is the simpler route for most people.
• John the Ripper — it uses the same *2john.py extractors; the JtR walkthrough covers its side of the same lines.

Safety note

Extraction and cracking both run fully offline on your own machine. The extracted line is not normally a plaintext private key, but for some formats it contains sensitive encrypted wallet material — possession of the extract together with the recovered password may be enough to expose wallet secrets. Treat it like the wallet file: keep it local, never paste it into a public checker or unknown website, and delete the working copy when you’re done. Anyone who asks you to upload a “hash” or wallet file to a public checker or unknown website is not running a safe recovery — a legitimate remote route works through a clear written process with the extract line, never through random uploads. The file safety rules apply to hash lines exactly as they do to wallet files.

Frequently asked questions