Udemy
    •  
    •  
    •  
    •  
    •  
    •  
    •  
    •  
Subscribe
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
Reverse Engineering Bootcamp:Ghidra, IDA, Linux, and x86_64
Role Play
Rating: 4.1 out of 5(420 ratings)
63,087 students

What you'll learn

  • The theory behind disassembly and its role in reverse engineering.
  • The four stages of binary analysis: Preprocessing, Compilation, Assembly, and Linking.
  • The compilation process breakdown and the purpose of each phase.
  • Working with symbolic information in stripped and not stripped binaries.
  • How binary executables load and execute.
  • Installation and basics of Ghidra, a tool for reverse engineering.
  • Installing the Java Development Kit (JDK) for Ghidra.
  • Navigating and utilizing Ghidra for project analysis.
  • Real-world malware analysis using Ghidra.
  • Practical reverse engineering skills through hands-on malware analysis.
  • Writing a 64-bit assembly program to display "Hello, world!" using a makefile.
  • Installing and setting up the SASM assembler for assembly programming.
  • Understanding the superiority of NASM (Netwide Assembler) and comparing it with other assemblers.
  • Creating a basic "Hello, world!" program in assembly without using a makefile.
  • Exploring the theory of disassembly and disassemblers in reverse engineering.
  • Analyzing the fundamentals of disassembly and its importance in reverse engineering.
  • Delving into various data types and their representation in assembly language.
  • Understanding CPU architectures, binary files, and their relationship.
  • Converting decimal numbers to binary using basic mathematical operations in assembly.
  • Initiating debugging with gdb (GNU Debugger) and configuring debugging flavors.
  • Debugging techniques for locating and inspecting variables in memory addresses.
  • Expanding knowledge of gdb functionalities for advanced debugging scenarios.
  • Writing a second 64-bit assembly program, creating the source code, and generating a makefile.
  • Analyzing program output using gdb and building a makefile for the assembly code.
  • Exploring binary analysis and comprehending the four stages of compilation.
  • Learning about preprocessing, compilation, assembly, and linking phases of program compilation.
  • Distinguishing between symbols, stripped, and non-stripped binaries.
  • Utilizing READELF to view symbolic information in binaries and object files.
  • Revealing the contents of an object file and attempting to analyze binary executables.
  • Understanding how binary files load and execute in theory.
  • Exploring the Executable and Linkable Format (ELF) used in Linux executables, focusing on the executable header.
  • Learning about ELF fields and ELF program header fields.
  • Understanding the fundamentals of Windows PE (Portable Executable) format used in Windows executables.
  • Mastering bitwise logical operations: OR, XOR, NOT, and AND.
  • Applying OR logic to manipulate data and perform bitwise operations.
  • Implementing NOT logic to invert bits in assembly programming.
  • Exploring XOR logic and its applications in data manipulation.
  • Understanding AND logic and how it's used for masking and bit filtering.
  • Utilizing the Data Display Debugger (DDD) to analyze assembly programs.
  • Developing assembly programs to analyze using DDD and understanding the debugging process.
  • Analyzing RAX register values using DDD and gdb.
  • Mastering control flow with jump and loop instructions in assembly.
  • Learning about common errors in assembly programming and their solutions.
  • Using conditional statements and jumps to control program flow.
  • Implementing jump instructions based on equality conditions.
  • Understanding jump instructions for inequality conditions.
  • Employing jump instructions for comparisons involving greater values.
  • Implementing jump instructions for greater-than-or-equal-to conditions.
  • Using jump instructions for comparisons involving lesser values.
  • Implementing jump instructions for less-than-or-equal-to conditions.
  • Developing an assembly project that utilizes jump and loop instructions effectively.
  • Creating a calculator project using assembly language to perform arithmetic operations.
  • Defining variables and memory allocation in assembly programming.
  • Implementing addition and subtraction operations in assembly language.
  • Adding final touches and decorations to assembly projects.
  • Explaining the practical usage of registers in assembly programming.
  • Completing the assembly projects with a focus on optimization and efficiency.
  • Utilizing memory manipulation techniques to interact with data structures.
  • Exploring a more advanced project called "EXABYTE" involving memory manipulation.
  • Testing and analyzing projects using tools like Readelf and GDB for verification and debugging.

Course content

27 sections • 105 lectures • 17h 46m total length

  • Introduction1:28
  • How Computer Communicates4:32

    Describe the three core computer subsystems—central processing unit, memory, and input/output—and how they exchange data over data, address, and control buses, with hands-on tasks and a simple programming environment.

  • Preparing Dev Env18:16

    See how the cpu fetches instructions from memory using buses to execute programs. Compare Python and C, and prepare a Linux development environment with gcc and Visual Studio Code.

  • What happens when you use computer16:13

Requirements

  • Basic computer skills

Description

Master the Art of seeing what is hidden. Most programmers treat compiled binaries as a "black box"-a mystery they can never solve. This course changes that. In this comprehensive bootcamp, you will learn to peel back the layers of software to understand the working principles of any executable, regardless of whether you have the source code.

The Full Stack of Deconstruction

We don't start with tools; we start with the physics of computing. Before you touch a decompiler, you will understand:

  • Hardware Foundations: From MOSFETs and Logic Gates to how a CPU actually executes an instruction.

  • Low-Level Arithmetic: Mastery of Binary, Hexadecimal, and Boolean Algebra for reverse engineers.

  • The Assembly Layer: Deep-dive into x86-64 Assembly language, focusing on registers, stack frames, and memory addressing.

Tooling and Methodology

You will gain hands-on experience with industry-standard tools and forensic techniques:

  • Static Analysis with Ghidra: Master the NSA’s premier open-source reverse engineering suite. Learn to navigate function graphs, use the decompiler effectively, and perform data type recovery.

  • Dynamic Analysis & Debugging: Use GDB (GNU Debugger) and DDD to monitor program execution in real-time, manipulate memory, and bypass software protections.

  • File Format Anatomy: Gain a surgical understanding of the Linux ELF and Windows PE formats. Learn how headers, sections, and symbols drive the execution process.

Real-World Applications

This isn't a theory-only course. You will apply your skills to:

  • Malware Analysis: Learn the 5 critical steps to identifying and neutralizing malicious software.

  • Vulnerability Research: Understand how to find buffer overflows and logic errors by analyzing raw machine code.

  • Software Hardening: See how stripped binaries work and how to recover symbolic information.

Whether you are looking to enter the world of Exploit Development, Cybersecurity Research, or simply want to become a 1% developer who understands the "atoms" of their code, this course provides the manual you’ve been looking for.

Stop guessing what the code does. Start knowing. Join the bootcamp today.

Who this course is for:

  • For everyone who wants to learn reverse engineering

Report abuse