Malware Analysis Course

Lesson 1 • Legal and Ethical Responsibilities

Outlines responsible disclosure, data handling obligations, and ethical boundaries for analysts. Frames professional conduct expected throughout the course.

Lesson 2 • The Malware Analysis Workflow

Introduces the triage-to-report pipeline analysts follow on every sample. Connects static, dynamic, and code analysis phases into a unified process.

Lesson 3 • Building a Safe Analysis Lab

Teaches isolation techniques using virtual machines and network controls to prevent sample escape. Directly enables hands-on work in all subsequent chapters.

Lesson 1 • Antivirus and Threat Intel Integration

Demonstrates submitting samples to multi-engine scanners and querying threat intelligence platforms. Contextualises static findings within known threat landscapes.

Lesson 2 • Entropy and Packing Detection

Uses entropy measurement to identify packed or encrypted sections within binaries. Prepares analysts to unpack samples before deeper analysis.

Lesson 3 • PE Format Deep Dive

Analyses the Portable Executable structure including headers, sections, and import tables. Understanding PE layout is essential for detecting packing and injection.

Lesson 4 • String Extraction and Analysis

Covers ASCII and Unicode string extraction to surface URLs, registry keys, and embedded commands. Strings often reveal malware intent before any execution.

Lesson 1 • Network Traffic Capture and Analysis

Covers packet capture, protocol dissection, and DNS query logging during malware execution. Network artefacts reveal command-and-control infrastructure and data exfiltration.

Lesson 2 • Process and System Monitoring

Teaches real-time observation of process creation, file writes, and registry changes during execution. Forms the behavioural baseline for every dynamic analysis session.

Lesson 3 • Memory Artifact Collection

Teaches capturing full memory dumps and process memory during live execution for later analysis. Memory artefacts expose injected code and in-memory-only payloads.

Lesson 4 • Automated Sandbox Analysis

Introduces automated sandboxes that generate behavioural reports without manual instrumentation. Analysts learn to interpret sandbox output and identify evasion artefacts.

Lesson 1 • Disassembler Workflow and Navigation

Teaches loading binaries, navigating functions, and annotating code in a professional disassembler. Efficient navigation directly accelerates analysis throughput.

Lesson 2 • Analysing Malicious Algorithms

Focuses on custom encryption, encoding routines, and hashing functions embedded in malware. Decoding these algorithms is critical for extracting configuration data.

Lesson 3 • Control Flow Graph Interpretation

Uses control flow graphs to understand complex branching, exception handling, and obfuscated paths. CFG analysis reveals logic that linear reading obscures.

Lesson 4 • Recognising Common Code Constructs

Identifies loops, conditionals, switch statements, and API call patterns in disassembled code. Pattern recognition reduces time spent on routine code structures.

Lesson 1 • Scripting and Automating Debug Sessions

Teaches writing debugger scripts to automate repetitive tasks such as logging API calls and patching checks. Automation dramatically increases analysis speed on large sample sets.

Lesson 2 • Debugger Fundamentals and Setup

Covers breakpoint types, stepping modes, and register inspection in a user-mode debugger. Establishes the interactive analysis skills built upon in every subsequent section.

Lesson 3 • Kernel-Mode Debugging Basics

Introduces two-machine kernel debugging to analyse drivers, rootkits, and kernel-level payloads. Extends debugging skills from user mode into privileged execution contexts.

Lesson 4 • Bypassing Anti-Debugging Techniques

Identifies and neutralises common anti-debugging checks such as timing attacks and debugger flag tests. Defeating these checks is prerequisite to analysing protected malware.

Lesson 1 • Anti-VM and Anti-Sandbox Evasion

Covers artefact-based and behaviour-based checks malware uses to detect virtual environments. Analysts learn to spoof or remove these artefacts to force full execution.

Lesson 2 • Packer Internals and Custom Loaders

Dissects packer stub logic, self-modifying code, and custom loader routines at the assembly level. Deep packer knowledge enables unpacking without relying on known signatures.

Lesson 3 • Code Obfuscation Techniques

Examines junk code insertion, instruction substitution, and dead code patterns used to hinder analysis. Recognising these patterns prevents wasted time on irrelevant code.

Lesson 4 • Defeating String and API Obfuscation

Targets runtime string decryption and dynamic API resolution techniques that hide malware capabilities. Recovering strings and API names restores analytical visibility.

Lesson 1 • Command-and-Control Protocols

Reverse-engineers HTTP, DNS, and custom binary C2 protocols to understand attacker communication. Protocol analysis enables network detection rule creation.

Lesson 2 • Process Injection and Hollowing

Covers DLL injection, process hollowing, reflective loading, and thread hijacking at the code level. These techniques are central to most advanced malware and APT tooling.

Lesson 3 • Ransomware Internals

Dissects file enumeration, encryption key management, and ransom note delivery in ransomware samples. Understanding internals supports decryption tool development and recovery.

Lesson 4 • Rootkit and Stealth Techniques

Analyses DKOM, hook-based hiding, and filter driver techniques used by kernel-level rootkits. Stealth analysis requires combining kernel debugging with memory forensics.

Lesson 1 • Sigma and Network Detection Rules

Covers Sigma rule authoring for log-based detection and Suricata rules for network traffic alerting. Bridges malware behaviour to SIEM and IDS deployment.

Lesson 2 • Malware Attribution and Clustering

Uses code reuse, infrastructure overlap, and TTP similarity to cluster samples and attribute campaigns. Attribution supports strategic threat intelligence reporting.

Lesson 3 • YARA Rule Development

Teaches writing, testing, and optimising YARA rules targeting unique byte patterns and string clusters. YARA rules are the primary static detection artefact produced by analysts.

Lesson 4 • Indicator Extraction and Enrichment

Systematically extracts network, host, and behavioural indicators and enriches them with threat context. Enriched indicators form the foundation of all detection and hunting work.