Security with Go (John Daniel Leon)（Z-Library）

# Security with Go — Reading Guide ## 【One-Line Pitch】 A practical, dual-purpose handbook for security professionals and Go developers who want to write secure software, build offensive security tools, or defend systems using Go's speed, concurrency, and cross-compilation strengths. Ideal for penetration testers, blue-team defenders, and developers who want to apply Go to real security problems. --- ## 【Book Arc】 - **Opening (~0%–10%)**: Introduces Go as a security language, covering its history, design philosophy, and why it beats Python, Java, and C++ for security work. Sets up the development environment, toolchain, and workspace basics. - **Early (~10%–23%)**: Teaches Go fundamentals—data types, structs, scoping rules, control flow, and the language's unique features like goroutines and channels. Establishes the syntax and idioms used throughout the book. - **Early–Middle (~23%–42%)**: Moves into file operations: creating, truncating, reading, writing, buffering, and archiving files. Includes practical security uses like truncating log files to cover tracks and handling ZIP/TAR archives. - **Middle (~42%–48%)**: Introduces forensics techniques—recursively scanning directories, sorting files by size, and computing hashes (MD5, SHA1, SHA256) to identify and analyze files. - **Late (~48%–60%)**: Covers web security topics: building secure HTTP servers, HTTPS, secure cookies, CSRF tokens, middleware, and preventing common web vulnerabilities like LFI/RFI and user enumeration. - **Ending (~60%–100%)**: Explores offensive techniques—web scraping, fingerprinting web applications, extracting data from HTTP responses, and using proxies including SOCKS5 for Tor. The excerpts do not cover the final chapters on brute force, port scanning, packet injection, or post-exploitation in detail. --- ## 【Key Takeaways】 - **Go's design makes it ideal for security tooling** (Early): Single static binaries, fast compilation, easy cross-compilation, and a strong standard library for networked applications make Go practical for both red-team and blue-team tools. Cross-compiling reverse shells from a Raspberry Pi or deploying lightweight honeypot containers are highlighted use cases. - **Concurrency is built-in and simple** (Early): Goroutines let you run functions in parallel with just the `go` keyword, and channels are the preferred way to share data between threads. The `log` package is concurrency-safe, but `fmt` is not—a practical gotcha for concurrent code. - **File manipulation is a core security skill** (Early–Middle): The book covers creating, truncating, reading, and writing files with attention to security implications. Truncating files to zero bytes can erase log evidence, and buffered writers help manage I/O efficiently. - **Reading files has trade-offs** (Middle): `ioutil.ReadFile()` is the quickest way to load a file but reads everything into memory—dangerous for very large files. Understanding when to use buffered readers versus whole-file reads matters for both performance and memory safety. - **Forensics starts with hashing and file analysis** (Middle): Computing MD5, SHA1, and SHA256 hashes of files is foundational for identifying and verifying evidence. Recursively scanning directories and sorting files by size helps locate suspicious or large files. - **Secure web applications require layered defenses** (Late): HTTPS, secure cookies, HTML escaping, CSRF tokens, and secure HTTP headers are all covered as essential building blocks. The book also addresses preventing user enumeration and LFI/RFI abuse. - **Web scraping is a reconnaissance tool** (Late): Techniques include finding strings with regex, extracting email addresses, reading HTTP headers, setting cookies, finding HTML comments, and discovering unlisted files. Fingerprinting web application technology stacks via response headers helps identify targets. --- ## 【Reading Tips】 - **Skim Chapter 1 if you already know Go**: The language history and "why not Python/Java/C++" comparisons are useful context but not essential. Focus on the cross-compilation and security-specific use cases. - **Deep-read the file operations and forensics chapters**: These contain the most directly applicable security code—hashing, file analysis, and directory traversal. The examples are practical and reusable. - **Pay attention to the web security chapter**: It covers both defensive (secure cookies, CSRF, headers) and offensive (scraping, fingerprinting) techniques. This is where the book's dual blue-team/red-team value shines. - **Watch for the concurrency gotchas**: The note about `fmt` not being concurrency-safe is easy to miss but important for writing reliable concurrent tools. The book deliberately avoids mutexes in favor of channels. - **The excerpts don't cover the final offensive chapters**: If you're specifically interested in brute force, port scanning, packet injection, or post-exploitation, you'll need to read the full book—the sample material stops before these topics. --- ## 【Coverage Limits】 This guide is based on excerpts covering roughly the first 60% of the book: Go fundamentals, file operations, forensics, and web security/scraping. The later chapters on brute force, port scanning, packet injection, social engineering, and post-exploitation are not covered in the source material. --- ##