1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
|
#+date: <2025-07-07 Mon 00:00:00>
#+title: Blockchain Series #1: How Blockchain Works Under the Hood: Hashes, Keys, and Signatures Explained
#+description: Dive into blockchain's cryptographic foundations. Explore how hash functions, Merkle trees, and digital signatures secure distributed, tamper-resistant ledgers.
#+slug: how-blockchain-works
#+filetags: :blockchain:encryption:
#+draft: t
/This is Part 1 of a series I'm writing on blockchain. Stay tuned for further
editions./
Blockchain is one of those technologies that seems to generate more marketing
buzz than real understanding. Everywhere you look, people talk about
decentralization, trustless systems, and the next big disruption. But beneath
the hype, blockchain systems rely on well-understood cryptographic building
blocks to do something very specific: maintain a secure, tamper-resistant ledger
without needing a central authority.
If you're serious about understanding blockchain, it's critical to understand
the cryptographic primitives that make it work. Hash functions, digital
signatures, and public-key cryptography aren't just jargon—they're the core
mechanisms that let a distributed network agree on a shared history no one can
easily rewrite.
This post is Part 1 of a multi-part series on blockchain. Here, we'll focus on
these fundamental building blocks—how they work, why they're used, and how they
fit together to provide the security and trust that blockchain promises.
* What is Blockchain?
At its core, a blockchain is a distributed, append-only ledger shared among
participants in a network.
What does this mean? Essentially, we can think of a standard, non-technical
ledger (book of accounts where transactions are recorded against accounts). When
introductin the idea of a blockchain, let's extend the idea of a standard ledger
and make a few connections:
- Each block of transactions is connected cryptographically to the block before
it, via a [[https://en.wikipedia.org/wiki/Cryptographic_hash_function][cryptographic hash]]. This is what forms a =chain= of blocks, or
records.
- Each block consists of:
- A list of validated transactions
- A timestamp
- A cryptographic hash of the previous block (ensuring immutability)
- Each transaction within a block is initiated between addresses, signed with
cryptographic keys, and sent to the blockchain for validation (e.g.,
proof-of-work, proof-of-staking, etc.).
- The blockchain is shared amongst nodes in the network, who agree on the state
of the blockchain through consensus mechanisms.
As we can see, the decentralized nature and cryptographic linking of
transactions and blocks ensures that modifying the history is infeasible.
If you're more of a visual person, here's a very basic diagram of a standard
blockchain structure.
#+begin_example
+------------+ +------------+ +------------+
| Block 1 | -> | Block 2 | -> | Block 3 |
|------------| |------------| |------------|
| Data | | Data | | Data |
| Prev Hash: | | Prev Hash: | | Prev Hash: |
| 00000000 | | <hash1> | | <hash2> |
| Hash: | | Hash: | | Hash: |
| <hash1> | | <hash2> | | <hash3> |
+------------+ +------------+ +------------+
#+end_example
* What Problems is Blockchain Trying to Solve?
I will be diving into the technical details of blockchains later in this post,
but what exactly is the reason blockchain exists?
You may know of cryptocurrencies, such as Bitcoin, but that is only one of many
use cases for blockchains.
As we learned in the section above, a blockchain can be equated to a ledger.
With this in mind, let's dive into a few interesting use cases:
** Immutable record-keeping
If you simply need a ledger that cannot be modified easily and can establish a
decentralized network to support that, blockchain is a great technology.
** Trust without central authority
The use of a decentralized system means that we do not need to rely on a
centralized authority (e.g., Social Security, a bank, etc.) to store and provide
access to information you need to record.
Think of the US Social Security Number (SSN) system. Each time you want to
perform actions that require verifying your identify (e.g., opening bank
accounts, investment accounts, child birth, etc.), you are currently required to
provide your SSN.
However, this is a singular number - which means that if someone learns it, they
can (essentially) now act as you.
Now imagine a scenario where the SSN system is a blockchain where you have both
your private key for providing evidence to people that you are you. For example,
you open a bank account and sign your form with your private key. Now, the bank
can take that and use your public key to decrypt the message and verify that you
are you, without needing to know your private key.
Another scenario is that, during a background check, a company could use your
public key and consult the related blockchain to validate specific pieces of
information. For example, if your identity alone is in one block, you could
provide that information to your employer without providing your full SSN and
all related personal information for as long as they keep your SSN on file.
** Double-spending problem
With the introduction of digital assets, such as cryptocurrencies and
non-fungible tokens, a new risk is introduced: without control, these assets
could be copied and reused at-will.
To solve this problem, digital assets are transacted on a blockchain to ensure
that the decentralized system of nodes provide consensus on validating
transactions, transactions are recorded in a transparent and tamper-resistant
manner, and cryptographic functions are performed to order the transactions
logically on chain.
* The Role of Cryptography in Blockchain
- Why cryptography matters
- Confidentiality vs. integrity/authenticity
- Core goals:
- Tamper-evidence
- Secure identification
- Non-repudiation
* Hash Functions
- What is a cryptographic hash?
- Properties:
- Collision resistance
- Pre-image resistance
- How blockchain uses hashes:
- Chaining blocks together
- Block headers
- Transactions
- Example command:
#+begin_src bash
echo -n "Hello, Blockchain" | sha256sum
#+end_src
- Optional diagram: chain of blocks with hashes
* Merkle Trees
- Summarizing many transactions in a single root hash
- Use case: efficient inclusion proofs
- Example diagram (ASCII art if desired)
- Why Merkle roots are in block headers
* Public Key Cryptography
- Quick refresher
- Public/private keypairs
- Addresses derived from public keys
- Importance of keeping private keys secret
* Digital Signatures
- Purpose: proving authorship without revealing private key
- Mention ECDSA / EdDSA
- How transactions are signed
- Example snippet:
#+begin_example
Alice signs transaction with her private key
→ Anyone can verify with her public key
#+end_example
- Why signatures prevent forgery
* Bringing it All Together: Blockchain Data Structures
- Block structure:
- Block header with previous block's hash
- Merkle root
- Timestamp, nonce
- How the chain ensures immutability
- Example flow:
1. User creates a transaction
2. Signs it
3. Transaction included in block
4. Block hash links to previous block
* Proof of Work (Optional)
- Hash puzzles to add blocks
- Why it's hard to modify history
- Keep this section simple
* Conclusion
- Summarize how these primitives work together
- Tease next post: "Next, we'll explore security threats and how blockchain
networks mitigate them."
- Optional links to further reading:
- Bitcoin whitepaper
- Ethereum docs
- Cryptography references
* Optional Extras
- Glossary box with terms (hash, signature, Merkle tree)
- External references (e.g., NIST docs on hashes)
|
