We may earn an affiliate commission when you visit our partners.
Course image
Paul Chin, PhD

If you had always wanted to learn how use x64dbg to reverse engineer and debug software, then this is the course for you.

Read more

If you had always wanted to learn how use x64dbg to reverse engineer and debug software, then this is the course for you.

x64dbg is one of the most popular modern debugger in use today and has superseded OllyDbg.  It is used for Reverse Engineering, Malware Analysis and Software Debugging. In this course we will learn x64dbg by solving a simple CrackMe challenge.  A CrackMe is a small program designed to test a programmer's reverse engineering skills. This course is an introduction to Reverse Engineering for anyone who wants to get started in this field. It is suitable for software developers who want to learn how software works internally and also for reverse engineers who want to fix bugs where the source code is not available. This course will equip you with the knowledge and skill to use x64dbg in addition to whatever other tools you might already be familiar. It is also suitable for absolute beginners with no knowledge of reversing, as I will take you from zero to hero.

What you will learn:

  • How to disassemble programs into assembly code

  • Dynamic Analysis

  • Setting breakpoints and stepping through code

  • Modify program behaviour

  • Patching programs

Money back guarantee:

This course is backed by a 30-day money back guarantee.  So, go ahead and enroll in this course now and start reverse engineering and debugging programs the fun and easy way.  

Enroll now

What's inside

Learning objectives

  • Debug programs with x64dbg
  • Reverse engineer programs
  • Solve crackme challenges
  • Disassemble programs into assembly code
  • Setting breakpoints and stepping through code
  • Modify program behaviour
  • Patching programs

Syllabus

Introduction

Introduction to the course

How to setup your working environment for cracking software.

How to download and install x64dbg
Read more

How to download x64dbg and Detect It Easy

Where to download CrackMe

How to prepare your pc for reverse engineering CrackMe's.

Assembly Language Basics

How to run, step over and meaning of conditional and un-conditional jumps

How to Step into Calls, Execute till Return and Run to User Code

How to set Breakpoints, remove Breakpoints and Run to Breakpoints

Two ways to look for strings and how to set Breakpoints on them.

How to reverse jumps by toggling the ZF flag

How to patch a program. How to use NOP instructions to override a jump.

How to assemble a jump instruction and patch it.

Congratulatory messages and other courses.

Traffic lights

Read about what's good
what should give you pause
and possible dealbreakers
Provides a practical introduction to reverse engineering using x64dbg, a popular debugger used in malware analysis and software debugging
Uses CrackMe challenges, which are designed to test and improve reverse engineering skills in a hands-on and engaging manner
Covers patching programs, which is a valuable skill for reverse engineers who need to fix bugs when source code is unavailable
Focuses on x64dbg, which has superseded OllyDbg, suggesting that the course teaches a modern and relevant debugging tool
Requires learners to download and install x64dbg and Detect It Easy, which may require learners to have administrator access to their computers
Teaches assembly language basics, which is a foundational skill for reverse engineering, but may require additional study for some learners

Save this course

Create your own learning path. Save this course to your list so you can find it easily later.
Save

Reviews summary

Beginner guide to x64dbg debugging

According to learners, this course provides a solid and practical introduction to reverse engineering using the x64dbg debugger. Students find it particularly effective for beginners, noting the clear demonstrations and hands-on approach through CrackMe challenges. While the majority sentiment is largely positive, some reviewers mention that the pace can be fast and that having some prior programming or assembly knowledge is beneficial despite the course covering basics. Learners appreciate it as a good starting point, though they note it focuses specifically on the tool and foundational techniques rather than advanced topics, setting appropriate expectations for its "Beginners" title.
Covers basics, not advanced topics.
"It's a solid introduction to the tool, but don't expect coverage of advanced reverse engineering topics."
"The course covers the essentials of x64dbg well but not much more depth beyond that."
"This is a good starting point, but you'll need other resources to dive deeper into RE techniques."
"Suitable for understanding the basics of this debugger only."
Practical learning with the debugger.
"Solving the CrackMe challenges with the instructor was a great way to learn x64dbg usage."
"The practical examples demonstrating breakpoints and patching were excellent."
"I really appreciated the hands-on labs included with the course videos."
"This helped me get comfortable with x64dbg by actively using it."
Ideal starting point for reversing.
"This course was perfect for me, someone just starting out in reverse engineering."
"It really assumes zero prior knowledge and builds everything up clearly."
"As a complete beginner, I found the material easy to follow and digest."
"Great introduction to using the x64dbg debugger if you've never touched it."
May require some prior knowledge.
"I felt it moved a bit fast in places, especially the assembly basics section, for a total beginner."
"Wish there was more detailed explanation on assembly basics before diving into the debugger."
"It's a good course, but I think you might need some prior exposure to programming concepts to keep up."
"Assumes slight familiarity with how programs execute, which might challenge some."

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in Reverse Engineering 1: x64dbg Debugger for Beginners with these activities:
Review Assembly Language Fundamentals
Reinforce your understanding of assembly language, which is crucial for reverse engineering and debugging with x64dbg.
Show steps
  • Review basic assembly instructions (MOV, ADD, SUB, CMP, JMP).
  • Study the x86-64 register set and their common uses.
  • Practice reading and interpreting simple assembly code snippets.
Read 'Reverse Engineering for Beginners'
Build a strong foundation in reverse engineering with this beginner-friendly guide.
View Alter Ego: A Novel on Amazon
Show steps
  • Read the introductory chapters covering basic concepts.
  • Work through the examples and exercises provided in the book.
  • Use x64dbg to experiment with the techniques discussed.
Read 'Practical Reverse Engineering'
Supplement your learning with a comprehensive guide to reverse engineering, covering x86/x64 architectures and reversing tools.
Show steps
  • Read the chapters related to x86/x64 assembly and debugging.
  • Experiment with the reversing tools discussed in the book.
  • Try to apply the techniques to simple CrackMe challenges.
Four other activities
Expand to see all activities and additional details
Show all seven activities
Solve CrackMe Challenges
Sharpen your reverse engineering skills by tackling CrackMe challenges using x64dbg.
Show steps
  • Download CrackMe challenges from online resources.
  • Load the CrackMe into x64dbg and analyze its behavior.
  • Identify the key checks and implement patches to bypass them.
  • Document your findings and the steps you took to solve the challenge.
Write a Blog Post on x64dbg
Solidify your understanding of x64dbg by writing a blog post explaining its features and usage.
Show steps
  • Choose a specific feature or aspect of x64dbg to focus on.
  • Research and gather information about the chosen topic.
  • Write a clear and concise blog post with examples and screenshots.
  • Publish your blog post on a platform like Medium or your own website.
Reverse Engineer a Simple Program
Apply your x64dbg skills to reverse engineer a simple program and understand its functionality.
Show steps
  • Select a simple program (e.g., a basic calculator or a text editor).
  • Load the program into x64dbg and analyze its code flow.
  • Identify key functions and data structures.
  • Document your findings and create a report summarizing your analysis.
Create a x64dbg Plugin
Extend the functionality of x64dbg by developing a custom plugin.
Show steps
  • Identify a useful feature or functionality that is missing in x64dbg.
  • Learn the x64dbg plugin API and development process.
  • Write the code for your plugin using C++ or another supported language.
  • Test and debug your plugin thoroughly.
  • Share your plugin with the x64dbg community.

Career center

Learners who complete Reverse Engineering 1: x64dbg Debugger for Beginners will develop knowledge and skills that may be useful to these careers:
Reverse Engineer
A reverse engineer analyzes software or hardware to understand its design, functionality, and underlying principles. This often involves disassembling code, studying algorithms, and identifying vulnerabilities. This course on x64dbg debugger helps build a foundation for reverse engineering tasks by teaching how to disassemble programs into assembly code, set breakpoints, step through code, and modify program behavior. The course's focus on solving CrackMe challenges reflects the kind of problem solving a reverse engineer faces. Furthermore, learning to patch programs as taught in the course provides practical skills relevant to a reverse engineer's daily work.
Malware Analyst
A malware analyst investigates malicious software to understand its behavior, identify its purpose, and develop methods for detection and removal. They use tools like debuggers and disassemblers to dissect malware code. This course directly helps aspiring malware analysts by teaching them to use x64dbg, a popular debugger used in malware analysis. The course's content on disassembling programs, setting breakpoints, and stepping through code is crucial for understanding how malware functions. Moreover, the course's approach of solving CrackMe challenges mirrors the problem-solving nature of malware analysis, enhancing practical skills.
Software Security Engineer
Software security engineers focus on identifying and mitigating security vulnerabilities in software applications. They perform code reviews, penetration testing, and reverse engineering to ensure software is secure. This course may be useful to a software security engineer, as it directly addresses reverse engineering techniques using x64dbg. The course's curriculum, including disassembling programs and patching, allows engineers to understand how vulnerabilities can be exploited, and how to prevent them. Learning to modify program behavior, taught in the course, also helps in testing security measures.
Vulnerability Researcher
Vulnerability researchers discover and analyze security weaknesses in software and hardware. They use reverse engineering and debugging to identify potential exploits. This course provides a strong foundation for vulnerability research by teaching the use of x64dbg for reverse engineering. The ability to disassemble programs into assembly code and set breakpoints, as taught in the course, is essential for identifying vulnerabilities. The course's focus on patching programs directly translates to the ability to develop and test exploits, a core skill for vulnerability researchers.
Penetration Tester
Penetration testers simulate cyberattacks to identify vulnerabilities in systems and networks. They employ techniques like reverse engineering to understand how systems can be compromised. This course on x64dbg can be very useful for penetration testers. The course teaches how to disassemble programs, set breakpoints, and modify program behavior, which aids in understanding and exploiting software vulnerabilities. By learning to patch programs, as covered in the course, penetration testers can validate their findings and demonstrate the impact of vulnerabilities.
Security Consultant
Security consultants advise organizations on how to improve their security posture. They often need to understand potential vulnerabilities in software and systems, sometimes requiring reverse engineering skills. This course may be helpful to security consultants by providing hands-on experience with x64dbg for reverse engineering. Learning to disassemble programs and analyze code, as taught in the course, may enable consultants to assess the security of software applications more effectively. The course's emphasis on patching programs can also allow consultants to provide practical remediation advice.
Software Developer
Software developers create and maintain software applications. Understanding how software works at a lower level can improve their debugging and optimization skills. This course may be useful to software developers who want to deepen their understanding of software internals. The course covers disassembling programs into assembly code, setting breakpoints, and stepping through code, enhancing debugging capabilities. By learning reverse engineering techniques with x64dbg, developers can gain insight into the runtime behavior of their programs and troubleshoot complex issues.
Game Developer
Game developers create video games. Reverse engineering skills may be useful for understanding game internals, modding, or creating cheat detection systems. This course may be helpful to game developers interested in reverse engineering game software. The course teaches how to use x64dbg to disassemble programs, set breakpoints, and modify program behavior. Skills learned in the course could be applied to analyze game code, create mods, or develop anti-cheat measures. The course’s focus on patching programs also provides practical knowledge in modifying game behavior.
Firmware Engineer
Firmware engineers develop and maintain low-level software that controls hardware devices. They often work with embedded systems and need to understand assembly language and debugging techniques. This course may be useful to firmware engineers, as it teaches assembly language basics and debugging with x64dbg. The ability to disassemble programs and step through code, as taught in the course, is particularly relevant for debugging firmware issues. Learning to patch programs can also be valuable for modifying firmware behavior and fixing bugs.
Quality Assurance Engineer
Quality assurance engineers test software to identify bugs and ensure quality. While not typically a core skill, reverse engineering can help in understanding complex software behavior and identifying edge cases. This course may be useful to quality assurance engineers seeking to enhance their debugging skills. The course's content on disassembling programs and setting breakpoints can help in understanding the underlying behavior of software. The course's focus on modifying program behavior can also aid in testing specific scenarios and uncovering hidden defects.
Security Architect
Security architects design and implement security systems and networks. A security architect requires some familiarity with vulnerabilities, reverse engineering, and exploit techniques. While security architects will require a broader base of knowledge, this course may be useful to them, as it teaches how to use x64dbg to disassemble programs, set breakpoints, and modify program behavior. The course's curriculum teaches how to patch programs, so architects can understand and prevent vulnerabilities.
Data Scientist
Data scientists analyze large datasets to extract insights and solve business problems. While not directly related, reverse engineering skills may be useful for understanding the internal workings of certain software tools or algorithms they use. This course may be useful to a data scientist who wants to understand the software they use at a deeper level. The course's content on disassembling programs and setting breakpoints provides insights into how software functions internally. Learning to modify program behavior can also help in customizing tools for specific data analysis tasks.
Technical Support Engineer
Technical support engineers troubleshoot and resolve technical issues for customers. Understanding software internals and debugging techniques can be helpful. This course may be useful for technical support engineers wanting to improve their debugging skills. The course teaches how to use x64dbg to disassemble programs, set breakpoints, and step through code, which provides insights into software behavior. The ability to analyze and patch programs, as covered in the course, can aid in diagnosing and resolving complex software issues.
System Administrator
System administrators maintain and manage computer systems and networks. Reverse engineering skills may be useful for troubleshooting and securing systems. This course may be useful for system administrators who want to enhance their understanding of software internals. The course's content on disassembling programs and debugging with x64dbg can allow administrators to analyze system software and identify potential security vulnerabilities. The course's focus on patching programs can also provide practical skills in securing systems.
Technical Writer
Technical writers create documentation for software and hardware products. While primarily focused on communication, understanding software internals can enhance the quality and accuracy of their documentation. This course may be useful for technical writers who want to gain a deeper understanding of software behavior. The course's content on disassembling programs and setting breakpoints provides insight into how software works. Technical writers may use the knowledge to create more detailed and informative documentation.

Reading list

We've selected two books that we think will supplement your learning. Use these to develop background knowledge, enrich your coursework, and gain a deeper understanding of the topics covered in Reverse Engineering 1: x64dbg Debugger for Beginners.
Provides a comprehensive guide to reverse engineering, covering x86, x64, and ARM architectures, as well as the Windows kernel. It delves into reversing tools and obfuscation techniques, making it highly relevant for understanding the complexities of software analysis. It serves as an excellent reference for those looking to deepen their knowledge beyond the basics covered in the course.
Great starting point for individuals new to reverse engineering. It covers fundamental concepts and techniques in a clear and accessible manner. It provides a solid foundation for understanding the more advanced topics covered in the course. This book is particularly helpful for those with limited prior experience in reverse engineering.

Share

Help others find this course page by sharing it with your friends and followers:

Similar courses

Similar courses are unavailable at this time. Please try again later.
Our mission

OpenCourser helps millions of learners each year. People visit us to learn workspace skills, ace their exams, and nurture their curiosity.

Our extensive catalog contains over 50,000 courses and twice as many books. Browse by search, by topic, or even by career interests. We'll match you to the right resources quickly.

Find this site helpful? Tell a friend about us.

Affiliate disclosure

We're supported by our community of learners. When you purchase or subscribe to courses and programs or purchase books, we may earn a commission from our partners.

Your purchases help us maintain our catalog and keep our servers humming without ads.

Thank you for supporting OpenCourser.

© 2016 - 2025 OpenCourser