This bundled training combines two deep-dive modules focused on reversing real-world Rust and Go binaries, two modern languages increasingly used in malware and offensive tooling.
Over the first two days, you’ll focus on Rust reverse engineering: learning how the compiler works, understanding Rust’s type system and control flow, analyzing common data structures (enums, slices, traits), and debugging both clean and obfuscated binaries. You’ll dive into real malware samples, explore process injection techniques, and write custom YARA rules for Rust.
During the final two days, you’ll shift to Go reversing: tackling stripped binaries, runtime analysis, and challenges unique to Go such as goroutines, channels, and reflection. You’ll reverse binaries with advanced concurrency and inspect how attackers leverage Go’s runtime and packaging for malware deployment.
Throughout both modules, you’ll use tools like IDA, Ghidra, LLDB, GDB/GEF, and more to analyze stripped binaries, unpack obfuscated code, and build a strong methodology for reversing modern binaries.
By the end of the course, you’ll be equipped with the skills to:
Confidently reverse engineer Rust and Go binaries
Analyze modern malware samples written in both languages
Use industry-grade tools and debugging environments
Write YARA rules tailored to Rust and Go code patterns
Tackle real-world reverse engineering challenges in modern compiled languages
Trusted by Security Engineers at Leading Companies
Module 1: Introduction to Rust & Reverse Engineering
History, features, and malware use cases
Setting up Ghidra, GDB, LLDB, Radare2
Module 2: Rust Compilation & Runtime
LLVM pipeline, symbol mangling, memory model
Linux & Windows runtime differences
Module 3: Structures & Control Flow in Rust
Reverse engineering enums, slices, traits, structs
Control flow analysis with practical exercises
Module 4: Tools & Techniques
Configuring Ghidra for Rust, debugging with LLDB/GDB
Advanced analysis of stripped binaries
Module 5: Obfuscation & Anti-Analysis
Reversing string obfuscation, anti-debugging, packers
Exercise: Analyze an obfuscated Rust binary
Module 6–7: Malware Techniques & Case Studies
Process hollowing, DLL injection, loader malware
Case study: Luca Stealer
Crafting YARA rules for Rust malware
Module 8: Introduction to Go & Reversing Basics
Why malware authors use Go
Compilation flow (go build/install), memory model
Reverse a simple Go binary
Module 9: Runtime & Binary Layout
Calling conventions, function naming, Go structures
Use of Ghidra, Radare2, IDA, and GDB
Module 10: Control Flow & Interfaces
Understanding interfaces, maps, slices, error handling
Exercise: Analyze Go binary control flow
Module 11: Advanced Features & Obfuscation
Reversing goroutines, channels, mutexes, reflection
Challenges with stripped Go binaries
Module 12: Malware Case Studies
Real Go malware samples
Writing YARA rules for Go binaries
Reverse engineer a packed/malicious Go binary
Module 13: Final Capstone Project
Reverse a complex Go application using full toolchain
Combine Rust & Go reversing techniques
Final review, open Q&A, extra resources
We have a partnership with Hex-rays to get our students IDA Classroom licenses
🔑 Immediate access to all the content
⏱️ Hours of curated and practical knowledge
🎞️ Easy-to-digest, on-demand videos
👨💻 Hands-on exercises & labs
♾️ Lifetime access
📖 Digital and printable slides
📝 Assignments to apply your new skills
💯 Certificate of completion
This course is for anyone looking for a hands-on and pragmatic approach to reverse engineering and analyzing modern binaries written in Rust and Go, including:
✔ Software developers
✔ Security engineers
✔ Vulnerability researchers
✔ Malware analysts
This training was selected and taught at POC & REcon, two of the world’s leading offensive security conferences in the world.
We speak, train, and compete at the world’s most respected security conferences.
Please, contact us here if you have any other question!