Hot Wallets vs Cold Wallets

Go: open a terminal in a folder you can write to and make the layout: mkdir -p airgap/cold airgap/hot, then cd airgap/cold.

Do: save this as make_key.py inside airgap/cold and run python3 make_key.py.

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

key = Ed25519PrivateKey.generate()
raw = key.private_bytes(serialization.Encoding.Raw,
                        serialization.PrivateFormat.Raw,
                        serialization.NoEncryption())
pub = key.public_key().public_bytes(serialization.Encoding.Raw,
                                    serialization.PublicFormat.Raw)

open("cold_secret.key", "wb").write(raw)
os.chmod("cold_secret.key", 0o600)
open("public_address.txt", "w").write(pub.hex())

print("secret written to cold_secret.key  (never copy this file anywhere)")
print("address written to public_address.txt")
print("address:", hashlib.sha256(pub).hexdigest()[:40])

You should see: three lines, the last one a 40-character address. Your address will not match the one below — it is made from fresh randomness every time, which is exactly what you want from a real wallet:

secret written to cold_secret.key  (never copy this file anywhere)
address written to public_address.txt
address: c2defea5bb2232f9732bc1cc8ad6dc04069b6368

Check the permissions with ls -l cold_secret.key (Windows: icacls cold_secret.key). On macOS or Linux the mode column should read -rw-------: readable by you and by nobody else on the machine.

If not: ModuleNotFoundError: No module named 'cryptography' means the library is missing — run pip install cryptography. AttributeError: module 'os' has no attribute 'chmod' cannot happen on a normal install; if os.chmod silently does nothing, you are on Windows, where file permissions work differently — use the folder’s Properties → Security tab instead, or simply carry on, since nothing of value is in this practice key.

Go: back up one level: cd .. so you are in airgap and can see both folders.

Do: copy exactly one file, then build an unsigned payment on the hot side.

cp cold/public_address.txt hot/
cd hot

Now save this as make_payment.py in airgap/hot and run python3 make_payment.py:

import json

payment = {"to": "merchant-7fa31c", "amount": "0.25", "nonce": 41}
open("unsigned.json", "w").write(json.dumps(payment, sort_keys=True))
print("unsigned payment written to unsigned.json")
print(open("unsigned.json").read())

You should see: the payment, byte for byte as below — this one is fixed, so yours will match:

unsigned payment written to unsigned.json
{"amount": "0.25", "nonce": 41, "to": "merchant-7fa31c"}

That copy step is the real air gap. In a hardware wallet the same transfer happens over a USB cable or a QR code, and the same asymmetry holds: the public address goes out, the secret never does.

If not: cp: cannot stat 'cold/public_address.txt' means you are not in the airgap folder — run pwd (Windows: cd) and check. On Windows use copy cold\public_address.txt hot\.

Go: cd ../cold. Carry the payment across by hand: cp ../hot/unsigned.json .

Do: save this as sign_offline.py and run it. This is the only moment the secret is used, and it happens on the machine that has no internet.

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

payment = open("unsigned.json", "rb").read()
key = Ed25519PrivateKey.from_private_bytes(open("cold_secret.key", "rb").read())
open("signature.txt", "w").write(key.sign(payment).hex())

print("signed:", payment.decode())
print("signature.txt written -- copy ONLY this file back")

You should see: the exact payment you approved, and one new file:

signed: {"amount": "0.25", "nonce": 41, "to": "merchant-7fa31c"}
signature.txt written -- copy ONLY this file back

Read that first line again, because it is the security control people skip on real hardware. A hardware wallet shows you the amount and destination on its own screen for precisely this reason: the hot machine may be lying about what it asked you to sign. Confirming on the trusted device is not a formality — it is the check.

If not: FileNotFoundError: 'unsigned.json' means the copy step was skipped. ValueError: An Ed25519 private key is 32 bytes long means cold_secret.key was opened in text mode somewhere and mangled — delete it, re-run step 1, and redo this step.

Go: cd .. then bring back the one file that is safe to move: cp cold/signature.txt hot/ and cd hot.

Do: save this as broadcast.py and run it. It checks the signature, then quietly tries to raise the amount from 0.25 to 9.75 — the exact thing a compromised wallet app would attempt.

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

pub = Ed25519PublicKey.from_public_bytes(
    bytes.fromhex(open("public_address.txt").read().strip()))
payment = open("unsigned.json", "rb").read()
sig = bytes.fromhex(open("signature.txt").read().strip())

try:
    pub.verify(sig, payment)
    print("SIGNATURE VALID -- safe to broadcast:", payment.decode())
except InvalidSignature:
    print("SIGNATURE INVALID -- do not broadcast")

tampered = payment.replace(b'"0.25"', b'"9.75"')
try:
    pub.verify(sig, tampered)
    print("tampered amount ACCEPTED")
except InvalidSignature:
    print("tampered amount REJECTED:", tampered.decode())

You should see: the genuine payment accepted, the altered one refused:

SIGNATURE VALID -- safe to broadcast: {"amount": "0.25", "nonce": 41, "to": "merchant-7fa31c"}
tampered amount REJECTED: {"amount": "9.75", "nonce": 41, "to": "merchant-7fa31c"}

The signature is bound to that payment and no other. Nothing on the hot machine can edit an approved transaction — it can only refuse to send it.

If not: SIGNATURE INVALID on the first line means unsigned.json in hot and the one you signed in cold are not identical — re-copy it and re-sign. ValueError: non-hexadecimal number found means signature.txt picked up a newline; the .strip() should handle it, so check the copy actually completed.

Go: stay in airgap/hot. Assume malware now has full read access to this folder — which is what “your PC was infected” means.

Do: first prove the secret is genuinely not here, then run the theft. Save this as search_secret.py and run it — it reads the real key from the cold folder and hunts for those exact bytes in every file the hot machine has.

import os

secret = open("../cold/cold_secret.key", "rb").read()
found = []
for name in sorted(os.listdir(".")):
    if os.path.isfile(name) and secret in open(name, "rb").read():
        found.append(name)
print("bytes of the cold secret found in:", found or "NOTHING on this machine")

Then run the same file from inside ../cold (change the path in it to "cold_secret.key") so you can see the search is capable of finding something — a search that never finds anything proves nothing.

Now save this as malware.py:

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

print("files this malware can read:", sorted(os.listdir(".")))

pub = Ed25519PublicKey.from_public_bytes(
    bytes.fromhex(open("public_address.txt").read().strip()))
stolen_sig = bytes.fromhex(open("signature.txt").read().strip())

theft = b'{"amount": "9.75", "nonce": 41, "to": "attacker-wallet"}'
try:
    pub.verify(stolen_sig, theft)
    print("THEFT SUCCEEDED")
except InvalidSignature:
    print("THEFT FAILED: the stolen signature does not cover this payment")

You should see: the search coming up empty on the hot machine and finding the key on the cold one, then the attacker reading everything and getting nowhere:

bytes of the cold secret found in: NOTHING on this machine
bytes of the cold secret found in: ['cold_secret.key']
files this malware can read: ['broadcast.py', 'make_payment.py', 'malware.py', 'public_address.txt', 'search_secret.py', 'signature.txt', 'unsigned.json']
THEFT FAILED: the stolen signature does not cover this payment

This is the entire argument for cold storage in one line of output. The attacker has the address, a valid signature, the payment file and the code — total compromise of the hot machine — and cannot move a coin, because a signature proves one specific payment and cannot be re-aimed at another. A hot wallet holding the key would have lost everything at the moment of infection.

If not: if the search prints a filename on the hot machine, you copied something you should not have — delete the whole hot folder and repeat from step 2, moving only the two files named there. If THEFT SUCCEEDED ever prints, the theft line was edited to match the original payment; put it back exactly as written.