Guide library PENGER Academy

The 25th Word (Passphrase)

A BIP39 passphrase changes the wallet derived from your words. It does not unlock an account or detect a typo.

What you’ll learnSeparate normalization, derivation cost, guessing resistance and recovery verification.

Before you startRead Seed Anatomy first if mnemonic backups are new to you.

Cryptographic Mechanism

The BIP39 passphrase is integrated into the key derivation process at the PBKDF2 layer. Understanding the exact mechanism reveals why it is so effective:

PBKDF2 Seed Derivation
seed = PBKDF2( PRF: HMAC-SHA512, Password: mnemonic_sentence, // space-joined words, NFKD-normalized Salt: "mnemonic" + passphrase, // literal "mnemonic" prefix + user passphrase Iterations: 2048, dkLen: 64 bytes // 512-bit output )

Key Properties

  • No validation — any passphrase produces a valid seed. There is no checksum or error detection for the passphrase itself. A typo does not produce an error — it produces a different, usually empty wallet.
  • Deterministic — the same mnemonic + passphrase always produces the same seed, on any device, with any compatible software.
  • Salt-based — the passphrase modifies the PBKDF2 salt. Once the mnemonic is known, an attacker can still test likely passphrases offline; the label “salt” does not make a predictable passphrase strong.
  • NFKD normalization — per BIP39, both the mnemonic and the passphrase are Unicode NFKD-normalized before processing. This ensures consistent behavior across platforms for non-ASCII characters.

Check the exact passphrase when testing recovery. The mnemonic has a checksum; the passphrase has no typo check. Entering “MyPassphras” instead of “MyPassphrase” derives a valid but different, usually empty wallet without a warning.

Use the lab to compare case, whitespace and Unicode normalization. Predict whether café and café normalize to the same input, then check the full seed.

[ TRY IT / PASSPHRASE ]

See how a passphrase changes a wallet

Try different passphrases with the same 12 public words.

Same 12 public wordsabandon × 11 + about

Demo text only. Never enter a real secret.

No passphrase

Same seed

The same inputs open the same wallet.

Demo fingerprints, not wallet addresses.

See what changed

0 of 64 bytes changed

Filled squares changed. One square = one seed byte. This shows change, not passphrase strength.

Fixed public mnemonic

abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about

Case and spaces matter. BIP39 applies Unicode NFKD normalization before deriving the seed.

Derived seed · 512 bits

5eb00bbddcf069084889a8ab9155568165f5c453ccb85e70811aaed6f6da5fc19a5ac40b389cd370d086206dec8aa6c43daea6690f20ad3d8d48b2d2ce9e38e4

Empty-passphrase reference

5eb00bbddcf069084889a8ab9155568165f5c453ccb85e70811aaed6f6da5fc19a5ac40b389cd370d086206dec8aa6c43daea6690f20ad3d8d48b2d2ce9e38e4

PBKDF2-HMAC-SHA512 · 2,048 iterations · 64 bytes. BIP39 specification.

Educational fingerprints

1BA5C 5BAA A4B5 105F A6D4
2501E 91E1 9023 6368 6206
35399 01E2 F07C 8196 93D3

First 10 bytes of SHA-256(seed + byte 0, 1 or 2). The wallet symbols show the first sample shortened. These samples are not BIP32 fingerprints, keys or addresses.

Passphrase Entropy Analysis

The security benefit of a passphrase depends on its entropy. A weak passphrase can be brute-forced by an attacker who already has the seed phrase.

Attack Scenario

If an attacker obtains your 24 seed words but not your passphrase, they must brute-force the passphrase to access your funds. The cost of this attack depends on:

  1. The entropy of the passphrase (search space)
  2. The cost of each guess (PBKDF2 with 2,048 iterations of HMAC-SHA512, followed by BIP32 derivation and address checking)

Count choices from a random process

Illustrative uniformly random inputs; not strength ratings
Method Search space Entropy
Four decimal digits 10⁴ possibilities ≈13.3 bits
Three words drawn independently from a 7,776-word list 7,776³ possibilities ≈38.8 bits
Five words drawn independently from the same list 7,776⁵ possibilities ≈64.6 bits
Eight characters drawn independently from 62 symbols 62⁸ possibilities ≈47.6 bits

For N equally likely choices, H = log₂(N). These values do not apply to words or characters chosen by intuition, and do not state an attacker’s speed.

PBKDF2 Brute-Force Cost

The 2,048 PBKDF2 iterations provide only a modest computational barrier. For a uniformly random passphrase with entropy H and an attacker testing R candidates per second, the upper-bound exhaustive time is Texhaust = 2H / R; a randomly placed target is found after about half the space on average: Taverage ≈ 2H-1 / R. The example below assumes an illustrative aggregate rate of 5,000,000 guesses/s (10 GPUs at 500,000 each):

Passphrase entropy Exhaustive upper bound at 5M guesses/s Average search time
20 bits ~0.21 seconds ~0.10 seconds
30 bits ~3.6 minutes ~1.8 minutes
40 bits ~2.5 days ~1.3 days
50 bits ~7.1 years ~3.6 years
60 bits ~7,300 years ~3,650 years
80 bits ~7.7 billion years ~3.8 billion years

These rates are scenario inputs, not a universal benchmark. Hardware, software, address scanning and attacker optimizations can change R substantially; the formula lets you substitute a measured rate.

The entropy estimate depends on how the words were chosen. The Diceware estimate applies to independently random word selections. A sentence you write yourself does not inherit those odds, however long it looks. Preserve the exact passphrase so you can recover it reliably.

Test the implementation you will recover with

BIP39 specifies the derivation; a product also decides how you enter, cache and select a passphrase. Review the exact model, software version and recovery path.

Compatibility checks
Question Why it matters
Where is the text entered? Host entry can expose it to malware or logging; device entry depends on that device’s trusted interface.
What characters and length are supported? A backup that cannot be entered on a replacement device is operationally incomplete.
Is the passphrase cached or attached to a PIN? Convenience changes what a thief or compromised device might obtain.
Can a separate implementation restore the same addresses? Check with a public training mnemonic first, using the same path and script type.
A fingerprint is a cross-check

A BIP32 master fingerprint is a 4-byte identifier derived from a public key hash. A mismatch signals different key material, but a match alone is not proof: 32-bit identifiers can collide. Compare a known address or other complete public data as well. The lab’s SHA-256 samples are neither master fingerprints nor addresses.

Source: BIP32: key identifiers and fingerprints.

Map dependencies before combining controls

Several passphrases on one mnemonic derive different keys, but they still share the mnemonic, generation device and possibly the same recovery locations. More derived wallets do not automatically create independent failure domains.

Two combinations, two recovery requirements
Arrangement What must be preserved
One mnemonic, several passphrases The shared mnemonic, each exact passphrase, and metadata identifying the intended accounts.
Passphrases on multisig cosigners Enough distinct signing keys, the relevant passphrases and the complete multisig policy. Additional secrets can make the quorum harder to restore.
A spare mnemonic cannot replace a lost passphrase

Suppose the mnemonic is at A and C, and the only passphrase copy is at B.

If A is lost: B+C still provide both inputs for recovery.

If B is lost: A+C cannot restore this wallet without another passphrase copy. A functioning signer may still let you move funds.

What this control does and does not cover

Passphrase threat boundaries
Event Effect
Only the mnemonic is copied The attacker must also obtain or guess the passphrase for that derived wallet. Strength and separation matter.
The signer or recovery software is malicious It may capture both inputs or authorize a deceptive spend. A passphrase does not cure a compromised signing path.
The passphrase is captured without the mnemonic It alone is insufficient, but becomes valuable if the mnemonic is later exposed. Reuse creates correlated exposure.
A person is coerced Cryptographic separation does not predict human behavior or guarantee that a decoy will be accepted.
The passphrase backup is lost The mnemonic alone cannot regenerate the intended derived wallet. A still-functioning signer may let you move funds before access is lost.

Changing a passphrase does not move existing funds. It derives different keys. Moving holdings to those keys requires a transaction; keep the old inputs until every intended asset has been moved and verified.

Source: BIP39: from mnemonic to seed.

Questions that remain

Is the 25th word actually a word from the BIP39 list?

No. It is optional freeform text used in BIP39 derivation, not an extra word from the list. The specification normalizes Unicode; individual products can impose entry, length or character limits. Test compatibility with your recovery tools.

What happens if I enter the wrong passphrase?

There is no BIP39 passphrase error response. A different normalized input derives a different seed, often appearing as an empty wallet. A master fingerprint can detect a mismatch, but verify known addresses with the correct account and script settings before relying on the recovery.

Can I change my passphrase later?

You cannot "change" a passphrase in place — that would change all your keys and addresses. Instead, you would create a new wallet with a different passphrase and transfer your funds from the old wallet to the new one. This involves on-chain transactions and associated fees. For this reason, choose your passphrase carefully from the start.

Should I use a passphrase with a 24-word seed?

A longer mnemonic does not solve exposure of that mnemonic. A passphrase changes derivation and can protect a wallet if the mnemonic alone is copied, provided the passphrase is sufficiently unpredictable and remains available to you. It also adds a secret that can be lost. It is not a server-checked second factor.

Can I use the same passphrase with different seed phrases?

Different mnemonic/passphrase inputs derive different seeds. Reusing a passphrase creates a shared secret across those setups: its later disclosure removes that layer of protection wherever the mnemonic is also exposed. Decide with the full recovery and exposure model in mind.

[ CHECK YOURSELF ]

Test Your Knowledge

Take a quick quiz to check your understanding of this guide.

Take the Quiz

5 questions per level · ~2 min