Your memory is the password list. Build it on purpose.

Step 0 — dump everything before you filter anything

Your memory of the password is a reconstruction, and reconstructions need raw material. Work the 68-place search checklist first and write down every candidate password you find — old emails, notebooks, browser autofill, password managers, app backups, notes files. Then walk where old passwords hide and how your memory made the password to surface the patterns you don’t notice yourself using. Only then do you start building the list below.

Step 1 — extract the pieces

Go through your memory and write down, in four buckets:

• Words: names (yours, partner’s, kids’, pets’), nicknames, cities, the wallet’s own name, the exchange you bought through, words from a hobby or job.
• Numbers: years that mattered (birth year, the year you bought the crypto, the current year then), day-month patterns, house numbers, phone fragments.
• Symbols and habits: did every password end in !? Did you use @ for “a”? A 1 for an i? The punctuation habits are the most personal — and the most powerful clues.
• The shape: “capital first, then lowercase, then two digits at the end”. Even if you can’t recall the content, the shape is a hashcat mask.

Also list every old password you’ve used anywhere — most people reuse or transform them. That’s a separate hunt: where old passwords hide.

When you only remember part of it

Most forgotten passwords aren’t a total blank — they’re a handful of fragments with gaps. The gap is the search space, and the trick is to write down exactly what you’re sure of before you try to fill anything in. Four patterns cover almost every partial memory:

• A remembered fragment with an unknown middle: you know it starts with Markus and ends with a year, but the middle could be anything. In btcrecover: Markus%1,6a2019 (one to six lowercase ASCII letters — use %ia if the unknown positions could be lower- or uppercase; tokens on one line are alternatives, so keep the fixed parts inside the same token without spaces). Preview the candidates that are actually generated first: python btcrecover.py --listpass --tokenlist tokens.txt. In hashcat: a mask like Markus?a?a?a?a?a?a?d?d?d?d.
• Fixed length, mixed content: “ten characters, a capital somewhere”. Use a mask with a wildcard for the capital position — or list a few positions: ?u?l?l?l?l?l?l?l?l?d and ?l?l?l?l?u?l?l?l?l?d.
• Numbers you’re sure about: a year or amount you remember is a strong anchor. Put it in a token line of its own (2019), or in a mask position (?d?d?d?d only if you’re sure it was four digits — otherwise give the mask four separate runs).
• A remembered ending: “it ended in !23”. Anchor the end with btcrecover’s $: %1,4a!23$ (no space — a space would make it an alternative, not a fixed suffix), or in hashcat fix the last mask positions: ?a?a?s?d?d. Preview the candidates that are actually generated first: python btcrecover.py --listpass --tokenlist tokens.txt.

The honest limit: every unknown position multiplies the search. Three unknown letters at ~26 options each is ~17,600 candidates (seconds); three unknown symbols at ~30 options each is ~27,000; a whole unknown 10-character segment at ~95 options per character is roughly 10¹⁹ — beyond any list. If more than a few characters are fully unknown, focus on recovering more memory (see how your memory made it) instead of widening the mask.

Put each pattern you remember into its own token line — Step 2 shows the syntax, and the btcrecover walkthrough has the full wildcard reference.

Step 2 — build the btcrecover token file (tokens.txt)

Each line of the file is a group of alternatives; btcrecover assembles one piece from each line into every password guess. The syntax that matters:

The most useful wildcards: %d (one digit), %1,3d (one to three digits), %a (one lowercase letter), %[chars] (one of the listed characters), %y (any one symbol), %0,1y (zero or one symbol). Full details and more wildcards are in the btcrecover walkthrough. Always check your list before a long run:

Step 3 — build the hashcat wordlist and mask

Wordlist: put every word, name and number from step 1 into a plain file, one per line — that’s words.txt. Then let rules do the mangling (append years, digits, symbols, case swaps):

Mask: when you remember the shape instead of the content. Mask characters: ?l lowercase, ?u uppercase, ?d digit, ?s symbol, ?a anything. “Capital, five lowercase, two digits”:

Full details in the hashcat walkthrough. Before spending GPU time, verify what your wordlist + rules actually generate — hashcat prints the candidate stream with --stdout.

Step 4 — the password-manager angle (check this before anything runs)

Wallet passwords are rarely only in your head — most were saved somewhere. If the password manager you used back then is itself locked, recovering the manager recovers the wallet password. These formats are crackable with the same tools:

Same rules apply: a human-chosen master password with clues is recoverable; a randomly generated one is not. And the search-first rule always wins — check old exports and backups of the manager before cracking it. Where stored passwords hide.

Step 5 — run small, then widen

• Start tiny. The most-likely 100 combinations first — many cases end here in minutes.
• Watch the ETA. The tool tells you the timeline. If it says weeks, read how long to crack a password? and decide whether the case even makes sense.
• Iterate. Each “exhausted” run teaches you: a year was wrong, a spelling differs, a symbol sits elsewhere. Widen one dimension at a time — that’s how recoveries actually succeed.
• Know the line. If the math says impossible, no tool changes it. Treat that verdict as final: spend the effort on better clues or a complete backup, not on more GPU time.

Ready to run? The full command-level walkthroughs: btcrecover step by step · hashcat step by step. Both tools are free; if they help you, the developers accept tips.

Sources & references

1. btcrecover — tutorial
2. hashcat — example hashes (wallet formats & modes)