2 courses in 1

Payment Methods

1. Credit Card: Click the Buy $9.00 button above

2. Paypal: Click this link


You are getting 2 courses in 1. In Udemy these two courses are:

(1) Assembly Language Programming for Reverse Engineering

(2) x64 Assembly Language and Reverse Engineering Practicals

The first course covers x86 (32-bit) assembly whilst the second course covers x64 (64-bit) assembly and goes on further to apply your combined knowledge from both courses to crack applications.. So, this course is a combination of two separate courses merged into 1 single course. The first half covers course 1 whilst the second half covers course 2. 

Description of the 1st course

If you have been using debuggers to reverse engineer programs but wished you had more understanding of Assembly Language, then this course is for you. We will cover enough assembly language to allow you to understand how to modify exe files to insert your own code or, to modify existing exe files to do things which it was not intended to do.


Traditionally, assembly language programming is taught using an assemblers like NASM or FASM. But learning it that way will not give you the skills to understand reverse engineered programs. There is a missing link (knowledge gap) of how to apply your assembly knowledge to modify programs. This course fills that knowledge gap. 


Instead of using an assembler, we will directly use the x64dbg debugger to learn assembly language. That is right, we will write our own assembly code inside the x64dbg debugger itself.  You will learn Assembly Language from the ground up with zero knowledge as a complete beginner.


We will use techniques that allow you to:


  1.  modify existing code
  2. overwrite existing code
  3.  modify memory segments to insert data
  4. create new functions
  5. exploit code caves
  6. add new functionality to existing programs
  7. and more...


This black art is not widely taught and there are no existing courses elsewhere that puts together coherently all the knowledge of assembly and reverse engineering. Mostly what you will find are separate courses on Assembly and Reverse Engineering. Many courses on Reverse Engineering don't cover the background assembly language from a software hacker's perspective. And almost all Assembly Language courses teach you how to write programs from scratch, instead of how to modify existing programs to add new functionality with your own code using a debugger like x64dbg.


The knowledge you gain will be your added advantage either as a security researcher, or, malware analyst, or student of software security. It will also benefit programmers who want to know how programs run internally and how to extend program functionality if you do not have the source code.


Go ahead and enroll now and I will see you inside!

Description of the 2nd course

If you've been using debuggers to reverse-engineer programs and wish you had a better understanding of Assembly Language, or if you're just looking to learn Assembly Language in a fun and exciting way, then this course is for you. Embark on a journey to master the intricacies of x64 assembly language with this specialized course, designed for those aiming to elevate their reverse engineering skills. This is the second course in this series after the first one: Assembly Language Programming for Reverse Engineering. In that earlier course the focus was on x86 basics where we covered 32-bit assembly. In this course, we continue the journey by learning x64 (64-bit assembly).  In the second half of this course, we will apply all the knowledge from the first course, as well as new insights from this course, to hands-on reverse-engineering exercises with executable binaries. Taking the first course is preferable but not mandatory. You could just jump straight into this x64 course and learn the differences with x86 as you go along.


While traditional assembly language courses focus on writing code from scratch using assemblers like NASM or FASM, they often leave a knowledge gap when it comes to applying that expertise to real-world reverse engineering. This course is tailored to fill this gap, providing you with the knowledge to modify and extend the functionality of existing  32-bit and 64-bit applications.


Utilizing the powerful x64dbg debugger, we'll bypass the traditional assemblers to teach you assembly language in the context it's most used in the field: directly within the debugging environment. This is also known as the hacker's perspective to assembly language. This hands-on approach ensures that you learn by doing, which is critical for effectively reverse engineering and manipulating software.


This black art is not widely taught and there are no existing courses elsewhere that put together coherently all the knowledge of assembly and reverse engineering in one place. More often than not, courses on Assembly and Reverse Engineering are offered separately. Many courses on Reverse Engineering don't cover the background assembly language from a software hacker's perspective. Moreover, almost all Assembly Language courses focus on writing programs from scratch rather than modifying existing programs to add new functionality with your own code using a debugger like x64dbg.


In this course, you will learn to:


  1. - Navigate and utilize the x64dbg debugger

  2. - Analyze and alter x64 executable files to inject custom code.

  3. - Harness data, executable and memory segments to expand program capabilities.

  4. - Develop new functions within existing applications for added functionality.

  5. - Understand the x64 Microsoft Calling conventions and Stack Frames.

  6. - Directly manipulate memory data segment

  7. - Bypass string encryption 

  8. - Deep tracing to retrieve data and passwords

  9. - Use Python to patch process memory

  10. - Modify packed programs without unpacking

  11. and more . . .


Features of this course:


  1. This course is oriented towards practical applications

  2. No lengthy, dull theoretical lectures

  3. First half of this course: Learn x64 Assembly Language through the x64dbg debugger

  4. Second half of this course: Practice reversing, tracing, extracting data, memory hacking, and modifying executable binaries


Learning Objectives:

By the end of this course, you will have a thorough understanding of x64 assembly language from a reverse engineer's perspective, a skill set that is rare and highly sought after in fields like cybersecurity, malware analysis, and software development.


Whether you're a security researcher, a malware analyst, a student of software security, or a programmer looking to deepen your understanding of software internals, this course is your stepping stone to becoming proficient in the 'black art' of assembly language and reverse engineering.


Enroll now to gain this competitive edge and take your skills to the next level. Let's unravel the complexities of x64 together. I look forward to guiding you through every step of this exciting journey! See you inside!

Course curriculum

    1. Intro to the course

      FREE PREVIEW
    2. How To Get Help

    3. Installing the tools

    4. Binary and hexademical number systems

      FREE PREVIEW
    5. Password to unzip files

    1. Addition

    2. Addition of partial registers

    3. Subtraction

    1. INC and DEC instructions

    2. MUL instructions

    3. DIV Instructions

    4. DIV Exercises

    1. Register to memory and memory to register

    2. MOV to memory and direct memory patching

    3. Memory Exercise

About this course

  • $9.00
  • 208 lessons
  • 28 hours of video content

Instructor

Senior Lecturer Paul Chin

Retired college lecturer (PhD in Computer Science) with more than 25 years experience in teaching computing and IT.

Learn Assembly Language for software cracking today