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

【One-Line Pitch】 A hands-on, test-driven tour of cryptography for Go programmers, this book builds a cipher system from scratch—then attacks, breaks, and hardens it—while demystifying real-world algorithms like AES, SHA-256, and RSA. Read it if you want to understand *why* crypto works (and fails) through code, not just theory. 【Book Arc】 - **Opening (~0%–12%)**: Introduces the cast (Alice, Bob, Eve, Mallory) and the core problem—secret messages. Starts with the simplest shift cipher, then immediately shifts to test-first Go development: writing failing tests, building an `Encipher` function, and turning it into a command-line tool with flags. - **Early (~12%–28%)**: The attack phase. You learn brute-force cracking, statistical vulnerabilities, and "cribs" (known plaintext) to break weak ciphers. This leads to a deeper look at keys: keyspace size, multi-byte keys, and the modulus operator—culminating in a working cracker tool and a discussion of password security, keyspaces, and passphrases. - **Early–Middle (~28%–36%)**: Moves from toy ciphers to block ciphers. You implement a `cipher.BlockMode` interface, handle block alignment, and add padding schemes. The section ends with key enumeration, endianness, and benchmarking—showing why strong keys are practically uncrackable, even with parallel computing. - **Middle (~36%–48%)**: Shifts to information theory and entropy. You explore Kolmogorov complexity, random number generation (including quantum sources), and then visualize cipher weaknesses by encrypting images. This motivates the move from ECB to more secure modes like CTR and CBC, with a full implementation of CBC. - **Late (~48%–52%)**: Covers hashing for message integrity. You build naive hash functions (LenHash, SumHash), attack them with preimage attacks, and learn the avalanche effect. This leads to real algorithms (MD5, SHA-1, SHA-256) and password hashing with salting and slow hashes. - **Ending (~52%+)**: Applies everything to cryptocurrency. You design "Bobcoin," a toy blockchain, tackling trust, double-spending, and proof-of-work—showing how the cryptographic primitives you've built underpin modern distributed systems. 【Key Takeaways】 - **Test-first development is the pedagogical engine** (Early): Every cipher component—from `Encipher` to `Crack`—is built by writing a failing test first. This isn't just about correctness; it forces you to clarify behavior and edge cases before coding. (Early) - **Keyspace size is the ultimate security metric** (Early): The book quantifies why longer keys are exponentially safer, using the "keyspace the size of the universe" thought experiment. You'll learn to estimate crack times and understand why brute force is futile against strong keys. (Early) - **Cribs and statistical attacks break weak ciphers** (Early): Using known plaintext ("cribs") and frequency analysis, you'll build a working cracker. This demonstrates that security through obscurity is useless—the structure of the cipher itself must be sound. (Early) - **Block modes are where real-world crypto lives** (Middle): ECB mode leaks patterns (shown vividly with image encryption), so you implement CBC with an IV and learn about CTR mode and nonces. This is the difference between a toy cipher and a secure one. (Middle) - **Entropy is a measure of ignorance, not just randomness** (Middle): The book connects information theory to crypto, explaining why compressed or enciphered data has high entropy and how to identify ciphertexts. This is crucial for understanding random number generation. (Middle) - **Hashing is about integrity, not secrecy** (Late): You'll build and break naive hashes, then learn why SHA-256 and salting matter for password storage. The key insight: a good hash has the avalanche effect—a single bit change flips half the output bits. (Late) - **Blockchains are a consensus problem, not a crypto problem** (Ending): The "Bobcoin" chapter shows how hashing and proof-of-work solve double-spending and ordering, not encryption. This ties all the primitives together into a real-world system. (Ending) 【Reading Tips】 - **Skim the "Key points" summaries** at the end of each chapter if you're short on time—they distill the essential concepts without the code walkthroughs. - **Deep-read Chapters 1–4** (Ciphers, Deciphering, Cracking) if you're new to Go testing or crypto basics. The test-first rhythm is established here and carries through the whole book. - **Don't skip the image encryption example in Chapter 14** (Chains)—it's the most intuitive demonstration of why ECB mode is broken. Visualizing the pattern leak makes the theory stick. - **Treat the code as a companion, not a reference**: The GitHub repo has the full examples, but the value is in the step-by-step reasoning. Try to write the tests yourself before peeking at the solutions. - **Watch for the "devil in the details" sections**—they highlight subtle bugs (like endianness or padding edge cases) that are easy to miss but critical in real crypto implementations. 【Coverage Limits】 The excerpts cover roughly the first half of the book (through hashing and the start of cryptocurrency). Later chapters on RSA, Diffie-Hellman, and digital signatures are mentioned in the blurb but not detailed in the provided material.