Explore Go Cryptography (John Arundel)（Z-Library）

【One-Line Pitch】 A hands-on, test-driven tour of cryptography in Go that starts with a toy shift cipher and builds toward real block modes, hashing, and key generation. Best for Go programmers who want working intuition for how encryption actually behaves—not a reference for production crypto. 【Book Arc】 - **Opening (~0%–10%)**: Frames cryptography as everyday infrastructure and sets up the book's method—learn by implementing a simple shift cipher in Go, then breaking it. - **Early (~10%–30%)**: Introduces codes vs. ciphers, keys, and the discipline of writing behavior-driven tests before code; establishes the `[]byte`-based API and project setup. - **Middle (~30%–55%)**: Builds enciphering, deciphering, and cracking tools, then moves into block ciphers, the `cipher.BlockMode` interface, padding schemes, and key enumeration/benchmarking. - **Late (~55%–80%)**: Covers entropy, randomness (pseudo-random vs. secure generators, system entropy pools), block modes (ECB weaknesses, CTR, CBC with IVs), and cryptographic hashing (MD5, SHA-1, SHA-256, salting, password storage). - **Ending (~80%–100%)**: Extends into cryptocurrency concepts—distributed ledgers, double-spending, consensus, proof of work vs. proof of stake—tying cryptography to real-world trust systems. 【Key Takeaways】 - **Cryptography is built on a simple core: plaintext + key → ciphertext** (Early): The shift cipher demonstrates this cleanly, and every later scheme is a more sophisticated version of the same idea. - **Tests define behavior, not implementation** (Early): Writing a test like "Encipher transforms HAL to IBM" forces clarity about inputs and outputs and protects against regressions as the cipher evolves. - **Weak keys are the real vulnerability** (Middle): Brute-force cracking, cribs, and key enumeration show why key strength and keyspace size matter more than algorithm obscurity. - **Block modes matter as much as the cipher itself** (Late): ECB leaks patterns; CTR and CBC with proper IVs address block replay, dropping, and modification attacks. - **Padding must be unambiguous** (Middle): The "illegal pixel" problem and Pad/Unpad implementations show how misaligned or ambiguous padding creates exploitable bugs. - **Entropy and randomness are foundational to security** (Late): Pseudo-random generators are predictable; secure systems need environmental noise, system entropy pools, and hardware sources. - **Hashing serves integrity, not secrecy** (Late): Digests detect bit-flipping and block-dropping; password hashing needs salting and slowness to resist rainbow tables. - **Cryptocurrency is a cryptographic trust problem** (Ending): The blockchain, proof of work, and consensus mechanisms are presented as solutions to double-spending and ordering. 【Reading Tips】 - **Deep-read the early testing chapters**: The behavior-driven approach is the book's pedagogical backbone and pays off in every later chapter. - **Skim the cracking/benchmarking sections if you're not interested in attacks**: They're illustrative but not essential for building secure systems. - **Work the challenges**: The book is designed around hands-on exercises with hints and sample solutions; passive reading will leave gaps. - **Don't expect production-ready crypto**: The book explicitly warns against designing your own ciphers; treat it as conceptual grounding, not a recipe for shipping code. - **Pay attention to the "why it's insecure" moments**: The value is in understanding failure modes (ECB patterns, weak keys, predictable RNGs) more than in the toy implementations. 【Coverage Limits】 This guide covers the book's arc from shift ciphers through hashing and cryptocurrency based on the provided excerpts; specific chapter details beyond the table of contents and sampled sections are not fully represented.