Assembly Language Programming for Reverse Engineering (Learn to Modify exe Files)

Discover the tricks of program manipulation and study AS Instruction Set for Reverse Engineering using the most selected course, “Assembly Language Programming for Reverse Engineering.” Suitable for novices and intermediate users of C language, you will be taken through the basics of the assembly language and the abilities required to analyze and change executable files to one’s benefit.

Contrary to most tutorials that include isolated assemblers, such as NASM or FASM, Assembly Language Programming for Reverse Engineering is a unique attempt that submerges you directly into the x64dbg debugger. You will learn assemblies starting from basic concepts, and using numerous practical examples, you will tie the knowledge into a coherent whole.

You will learn advanced practical concepts, including Memory segment Manipulation, Code cave exploitation, & Function creation, from adding small modifications to the existing code to adding new functionality. This combination of assembly language and reverse engineering knowledge is rather scarce, which makes this blog a valuable source of information for young security researchers, Malware analysts, and people interested in computer software security.

Assembly Language Programming for Reverse Engineering Table of Contents:

1. Installing the Tools - 05:43
2. Binary and Hexadecimal Number Systems - 09:50
3. Introduction to xdbg Debugger - 17:47
4. Debugger Stepping Basics - 04:52
5. How to Hollow Out an EXE File - 11:03
6. Introduction to CPU Registers - 09:43
7. The MOV Instruction - 12:50
8. Addition Using Full Registers - 11:40
9. Addition of Partial Registers - 11:59
10. Subtraction - 08:28
11. INC and DEC Instructions - 11:06
12. MUL Instructions - 14:37
13. DIV Instructions - 15:10
14. DIV Exercises - 14:48
15. Register to Memory and Memory to Register - 13:35
16. MOV to Memory and Direct Memory Patching Techniques - 04:51
17. Memory Exercise - 11:43
18. Pushing Register Values to the Stack - 13:45
19. Popping Stack Values to Registers - 10:53
20. How to Push Constants and Strings to the Stack - 06:20
21. Introduction to Function Calls - 09:03
22. Function Call with 2 Parameters - 11:20
23. Exercise: Function Calls with 2 Parameters - 11:38
24. Exercise: Function Calls with 3 Parameters - 08:41
25. Intro to Input Output in Assembly - 12:16
26. How to Read in Numbers and Output It Again - 08:17
27. How to Read in Strings and Output It Back to User - 09:27
28. Introduction to Code Caves - 14:20
29. A Simple Code Cave - 06:43
30. Code Cave Hello - 11:08
31. Exercise: Get Firstname, Lastname - 25:12
32. Project Description - 01:07
33. Designing the Solution - 07:25
34. Coding the Calculator - 24:01
35. Introduction to Functions That Return a Value - 06:20
36. Exercise on strlen() Function - 18:04
37. Intro to the Flags Register and the ZF Flag - 06:16
38. The SF Flag - 06:39
39. The CF Flag - 07:00
40. The OF Flag - 05:47
41. Which Flag to Look: OF or CF? - 02:04
42. Introduction to Jumps and JZ - 07:33
43. JNZ Jump - 03:37
44. JZ Loops - 06:07
45. JNZ Loops - 04:12
46. Other Conditional Jumps - 01:42
47. Introduction to Compare Instructions - 05:52
48. Practical on the CMP Instructions - 06:36
49. Comparing Unsigned and Signed Numbers - 07:18
50. Introduction to Structured Programming and If-Else Statements - 10:44
51. For Loops - 08:22
52. While Loops - 07:35
53. Break out of Loops - 07:51
54. Graph View, Trace Animate, and Principles of Jumps - 09:49
55. NEG Instruction - 03:14
56. Signed and Unsigned Extensions - 05:53
57. Practical on Signed and Unsigned Extensions - 08:54
58. Converting Bytes and Words Using CBW and CWDE - 05:44
59. Converting Bytes and Words Using CWD and CDQ - 04:58
60. IMUL and IDIV - 07:40
61. Example of IDIV - 05:40
62. Introduction to Boolean Algebra - 06:14
63. Bitwise Instructions - 13:32
64. Arithmetic Shifting - 07:01
65. Rotate Instructions - 04:16
66. Exercise on Bitwise Operations - 13:52
67. Introduction to Memory Arrays - 11:43
68. A Practical on Memory Arrays - 08:30
69. Introduction to the LEA Instruction - 11:21
70. A Simple LEA Implementation - 15:10
71. LEA with Counter - 08:57
72. LEA with Loop - 09:31
73. Intro to Data Structures - 05:24
74. Hands-on Practical on Data Structs - 06:53
75. Introduction to String Instructions - 09:24
76. The Direction Flag (DF Flag) - 08:05
77. LODS Instructions - 09:45
78. Exercise: LODS Adder - 06:37
79. The MOVS Instructions - 10:06
80. The REP Instruction - 03:34
81. The SCAS Instructions - 07:39
82. The CMPS Instructions - 05:45
83. Introduction to CALL and RET - 09:59
84. The Importance of Saving Register States - 08:13
85. Nested Function Calls - 07:50
86. Calling Conventions: Using Registers to Pass Params to Functions - 05:49
87. Passing Parameters via the Heap (Global Data) - 04:19
88. Passing Parameters via the Stack - 10:45
89. Cleaning the Stack - 08:19
90. Stack Frames - 07:46
91. Stack Frame Practical - 13:29
92. Introduction to the Call Stack - 13:04
93. Practical on Traversing the Call Stack - 12:30
94. Introduction to WinAPI - 08:41
95. ReadFile and WriteFile - Theory - 09:26
96. ReadFile and WriteFile - Practicals - 10:51
97. Theory on the CreateFile Win32 API - 05:52
98. Practical on the CreateFile Win32 API - 11:47
99. Understanding External Functions - 03:44
100. Practical on External Functions - 05:06
101. Bonus Lecture - 02:39
102. UPDATE: Continue Your Journey with x64 (64-bit) Assembly - 00:14

Who is this course for?

1. Security researchers and students
2. Reverse Engineers
3. Any person who desires to learn Assembly Language for the purpose of being a software hacker or technically a hacker.

Click on the links below to Download Assembly Language Programming for Reverse Engineering!