Understanding Crypto Wallets

Go: open your terminal and move to a folder you can write in, for example cd ~/Desktop (Windows: cd %USERPROFILE%\Desktop).

Do: create a file called make_wallet.py with the seven lines below, then run it with python3 make_wallet.py.

import hashlib
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
from cryptography.hazmat.primitives import serialization

secret_number = hashlib.sha256(b"finkatana practice wallet").digest()
key = Ed25519PrivateKey.from_private_bytes(secret_number)
pub = key.public_key().public_bytes(serialization.Encoding.Raw,
                                    serialization.PublicFormat.Raw)

print("private key (the secret) :", secret_number.hex())
print("public key  (shareable)  :", pub.hex())
print("address     (your name)  :", hashlib.sha256(pub).hexdigest()[:40])

You should see: three lines, exactly these, because the secret was fixed rather than random:

private key (the secret) : ee9a6b35720794e3d837f4a2dabffc1c0687774b88370dd75d9c8e583764531d
public key  (shareable)  : ebaa7effecb663c5cd79bca56e49886a1384b9db54b558f902aca46cc99b712e
address     (your name)  : 195b7b960a55aecbf024587164b5ad587d4ba91c

Look at what you just made: three numbers and nothing else. No balance, no coins, no ledger. The private key is a 256-bit number. The public key was calculated from it. The address is a hash of the public key, shortened. Your wallet app does exactly this, then hides all three behind a friendly screen.

If not: ModuleNotFoundError: No module named 'cryptography' means the library did not install — run pip install cryptography again and read its last line for the real error. python3: command not found on Windows means you should type python instead. If your three lines differ from the ones above, the quoted phrase inside b"..." is not identical — check for a missing space or a capital letter.

Go: same folder, same terminal.

Do: create sign.py and run it with python3 sign.py. This is the one action a private key exists for.

import hashlib
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey

secret_number = hashlib.sha256(b"finkatana practice wallet").digest()
key = Ed25519PrivateKey.from_private_bytes(secret_number)

message = b"Pay 5 coins to Alice"
signature = key.sign(message)
print("message   :", message.decode())
print("signature :", signature.hex())

You should see: your instruction, and a 128-character signature over it:

message   : Pay 5 coins to Alice
signature : 99c8bbd8c58c1fd61d724fbe59980359ddaa0e18555c7d533e49172d8fa357fe814650dd6c0433982f652ea38ec562f93c01e45ef3a754ddc34cba94c0112101

That signature is a transaction, stripped to its essence. When you tap Confirm in a wallet app, this is the step it performs — and it is the only step that needs your secret.

If not: if the signature you get is different, your message line differs by a character; signatures cover the message exactly, including capitals and spaces. If Python reports TypeError: a bytes-like object is required, the b before the opening quote is missing.

Go: same folder. Think of this file as the network: it never sees your secret.

Do: create verify.py, paste it exactly, and run python3 verify.py. Note that the only wallet material in it is the public key from step 1.

from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
from cryptography.exceptions import InvalidSignature

pub = Ed25519PublicKey.from_public_bytes(bytes.fromhex(
    "ebaa7effecb663c5cd79bca56e49886a1384b9db54b558f902aca46cc99b712e"))
sig = bytes.fromhex(
    "99c8bbd8c58c1fd61d724fbe59980359ddaa0e18555c7d533e49172d8fa357fe"
    "814650dd6c0433982f652ea38ec562f93c01e45ef3a754ddc34cba94c0112101")

for message in [b"Pay 5 coins to Alice", b"Pay 5000 coins to Alice"]:
    try:
        pub.verify(sig, message)
        print("ACCEPTED :", message.decode())
    except InvalidSignature:
        print("REJECTED :", message.decode())

You should see: the original accepted, the inflated amount refused:

ACCEPTED : Pay 5 coins to Alice
REJECTED : Pay 5000 coins to Alice

Nobody had to trust you, and nobody needed your secret. That is the whole trick a blockchain runs on: thousands of strangers can check your instruction is genuine while being completely unable to forge one.

If not: ValueError: non-hexadecimal number found means a character was dropped when you copied the long hex strings — they must be exactly 64 and 128 characters. If both lines say REJECTED, the public key and the signature came from different runs; re-copy both from your own step 1 and step 2 output.

Go: same folder. Delete every file you made: rm make_wallet.py sign.py (Windows: del make_wallet.py sign.py). You have just done to yourself what a stolen laptop, a wiped phone or a dead hard drive does.

Do: create restore.py and run it. It reconstructs the wallet from the secret — and then does it again with one extra letter in the phrase.

import hashlib
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
from cryptography.hazmat.primitives import serialization

def address_from(phrase):
    n = hashlib.sha256(phrase).digest()
    pub = Ed25519PrivateKey.from_private_bytes(n).public_key().public_bytes(
        serialization.Encoding.Raw, serialization.PublicFormat.Raw)
    return hashlib.sha256(pub).hexdigest()[:40]

print("same secret again :", address_from(b"finkatana practice wallet"))
print("one letter wrong  :", address_from(b"finkatana practice wallets"))

You should see: the first address identical to step 1, the second a complete stranger:

same secret again : 195b7b960a55aecbf024587164b5ad587d4ba91c
one letter wrong  : 7273e969b46c9917bd3844d01c749fc288cbd3fe

Two lessons in two lines. The wallet software was disposable — the secret rebuilt everything. And a single wrong character did not produce an error message; it produced a different, perfectly valid, completely empty wallet. That silent failure is why a recovery phrase must be copied character by character and then tested.

If not: if the first line does not match step 1, the phrase inside b"..." is not identical — compare it word by word, including the space before practice.

Go: same folder. This step is meant to fail, and the failure is the lesson.

Do: create attack.py with the public key from step 1 and try to sign with it, as a thief who has only seen your address would have to.

from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey

pub = Ed25519PublicKey.from_public_bytes(bytes.fromhex(
    "ebaa7effecb663c5cd79bca56e49886a1384b9db54b558f902aca46cc99b712e"))

print("public key loaded:", type(pub).__name__)
pub.sign(b"Pay 5 coins to Mallory")

You should see: the key loads perfectly, then refuses to sign, because the ability is simply not there:

public key loaded: Ed25519PublicKey
Traceback (most recent call last):
  File "attack.py", line 7, in <module>
    pub.sign(b"Pay 5 coins to Mallory")
    ^^^^^^^^
AttributeError: 'cryptography.hazmat.bindings._rust.openssl.ed25519.Ed25519PublicKey' object has no attribute 'sign'

This is why publishing your receiving address is safe, and why an exchange asking for your address is a normal request while anything asking for your recovery phrase is theft in progress. Your address is the public half. It can be given to the world.

If not: if you see no traceback at all, the last line was not saved — the file must end with the pub.sign(...) call. The long dotted class name in the last line varies between library versions; what matters is the words has no attribute 'sign'.