Blocks, Hashes and the Chain That Cannot Be Quietly Edited

What Is Inside a Block?

Think of a blockchain block like a page in a shared notebook that everyone can read. Each page has two parts:

1. The header — a small summary box at the top of the page.
2. The body — the list of transactions recorded on that page.

The block header is the part that matters most for security. It is a compact set of fields:

• Previous block hash — the fingerprint of the block that came before it.
• Merkle root — a single fingerprint summarizing all transactions in the body.
• Timestamp — roughly when the block was created.
• Nonce — a number miners change to try to solve the proof-of-work puzzle.
• Difficulty target — how hard the puzzle is right now.
• Block version — which rules the block follows.

Because the header contains the previous block hash, each block is literally glued to the one before it. That single field is the secret to the whole chain.

A Hash Is a One-Way Digital Fingerprint

A cryptographic hash function takes any input — a word, a file, an entire block — and produces a fixed-length output called a hash (or digest). Bitcoin uses SHA-256, which always produces 256 bits, written as 64 hexadecimal characters.

Three properties matter here:

1. Deterministic. The same input always gives the same hash. No randomness.
2. Fast to compute, impossible to reverse. You can hash a gigabyte in milliseconds, but you cannot go from a hash back to the input.
3. Avalanche effect. Change a single character of the input and roughly half of the output bits flip. There is no "close" hash.

Think of a hash like a fingerprint: it uniquely identifies a person, but you cannot reconstruct the person from the fingerprint. And no two people share one — unless someone tries very hard to fake it, which is what the avalanche effect prevents.

How a Block Seals the One Before It

Here is the trick that makes a blockchain a chain:

1. Block 1 is created. Its header is hashed, producing hash H1.
2. Block 2 is created. Its header includes H1 as the "previous block hash". Its own hash is H2.
3. Block 3 includes H2. Its hash is H3.
4. And so on.

Now imagine an attacker wants to secretly change a transaction inside Block 1. They edit the body. But the Merkle root in Block 1's header changes, so H1 changes. Since Block 2's header stores the old H1, Block 2 no longer matches. Its hash H2 also changes. That breaks Block 3, then Block 4, and so on to the tip of the chain.

To hide the edit, the attacker would have to redo the proof-of-work for every block after the edited one, faster than the honest network adds new blocks. On Bitcoin, that means out-computing thousands of machines — practically impossible. This is what people mean when they say the chain is immutable or tamper-evident.

A Tiny Python Blockchain

The code below builds a small chain of three blocks and then tries to tamper with the first one. Run it and watch the validation fail — this is the exact property we have been describing, in about 40 lines of Python.

import hashlib, json


def sha256(text: str) -> str:
    return hashlib.sha256(text.encode()).hexdigest()


class Block:
    def __init__(self, index, data, prev_hash):
        self.index = index
        self.data = data
        self.prev_hash = prev_hash
        self.hash = self.compute_hash()

    def compute_hash(self):
        payload = f"{self.index}|{self.data}|{self.prev_hash}"
        return sha256(payload)


# Build three linked blocks
b1 = Block(1, "Alice pays Bob 5 coins", "0" * 64)
b2 = Block(2, "Bob pays Carol 2 coins", b1.hash)
b3 = Block(3, "Carol pays Dave 1 coin", b2.hash)
chain = [b1, b2, b3]


def is_valid(chain):
    for i in range(1, len(chain)):
        if chain[i].prev_hash != chain[i - 1].hash:
            return False, f"Block {chain[i].index} does not match previous hash"
        if chain[i].hash != chain[i].compute_hash():
            return False, f"Block {chain[i].index} hash does not match its contents"
    return True, "Chain is valid"


print(is_valid(chain))  # (True, 'Chain is valid')

# Now tamper with block 1
b1.data = "Alice pays Bob 5000 coins"
print(is_valid(chain))  # (False, 'Block 2 does not match previous hash')

One Edit, Many Consequences

The table below shows what happens at each step when someone tries to quietly edit an old block. Notice how the damage cascades.

Frequently Asked Questions

Check Your Understanding

You now understand the core of blockchain security: hashes link blocks, and any edit breaks the link. In the next lesson, we will look at how you interact with this chain — through keys and wallets — and why losing your private key is very different from losing a password.