Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/pardhusreerushivarma20060119/exploit-engineering

Welcome to the definitive record of my journey into x86-64 Assembly Language, System-Level Programming, Reverse Engineering, and Exploit Development.
https://github.com/pardhusreerushivarma20060119/exploit-engineering

assembly-x86 cpp cprogramming exploit-development low-level reverse-engineering system-programming

Last synced: 5 months ago
JSON representation

Welcome to the definitive record of my journey into x86-64 Assembly Language, System-Level Programming, Reverse Engineering, and Exploit Development.

Awesome Lists containing this project

README 

          
# Exploit Engineering With x86-64 Assembly



## šŸ“˜ Introduction



Welcome to the definitive record of my journey into **x86-64 Assembly Language**, **System-Level Programming**, **Reverse Engineering**, and **Exploit Development**. This document isn't merely a learning logā€”it's a reflection of war with abstraction. Here, every bit flipped, every opcode written, every return address overwritten is a deliberate strike toward knowing the machine inside-out.



High-level languages teach you to instruct machines. Assembly teaches you to **become the machine**.



In a world that glorifies abstraction, Iā€™m diving headfirst into raw computation, manual memory control, and binary manipulation. The objective is to acquire absolute mastery over executionā€”from syscall to shellcode. This is about reading the system, bending it, breaking it, and building something superior.



## šŸš€ Motivation



Why Assembly in 2025? Because control is power.



Assembly opens doors that high-level languages keep closed: precise memory handling, manual syscall chaining, stealth, speed, and the ability to forge or dissect executable logic at the lowest layer. From writing minimalistic syscalls to bypassing ASLR using ROP chains, every technique learned here arms me with **surgical precision** over digital systems.



Iā€™m not here to memorize syntax. Iā€™m here to:



* Understand every byte a compiler produces.

* Build working shellcode by hand.

* Reverse engineer malware to its logic core.

* Write exploits that defeat modern mitigations.

* View C code as an abstraction of predictable assembly routines.



## šŸ’” Philosophy



I believe every system engineer, cybersecurity researcher, or reverse engineer should live by these principles:



* If you canā€™t read the assembly, you donā€™t truly understand the machine.

* If you depend on tools, youā€™re one abstraction away from ignorance.

* If you canā€™t break it, you donā€™t fully control it.

* If you fear segfaults, you havenā€™t truly met your CPU.



The system is not magic. Itā€™s logic, and electricityā€”interpreted through machine code. Learn that language, and you speak the truth of computing.



> *you cant control what you dont understand!*



## šŸ’» Platforms



* **Windows x64**: Familiarization with PE format, WinAPI, Structured Exception Handling, x64dbg, and usage of NASM + Microsoft Linker. Exploring syscall stubs, DLL injection, and memory patching.

* **Linux x64**: Hands-on with ELF binaries, GDB (GEF/PEDA), direct syscalls, system call table exploration, segmentation, and shellcode development.



## šŸ§µ Topics Covered (Detailed Overview, maybe i cover more)



### Assembly Core:



* Instruction Set: MOV, CALL, JMP, PUSH, POP, CMP, arithmetic/logical ops

* Registers: RAX, RBX, RCX, RDX, RSI, RDI, RSP, RBP, RIP, FLAGS

* Memory Addressing: Immediate, Register, Displacement, Scaled Indexing

* Control Flow: Loops, branches, conditionals, stack manipulation



### Calling Conventions:



* System V ABI (Linux)

* Microsoft x64 (Windows)

* Stack frames, shadow space, argument passing



### Syscalls:



* Linux: `syscall` instruction, syscall numbers, inline syscall wrappers

* Windows: Direct syscall stubs, `Nt/Zw` functions, bypassing ntdll hooks



### Binary Formats:



* ELF Internals: Sections, segments, PLT/GOT, relocations

* PE Internals: Import Table, Export Table, IAT, Entry Point, SEH



### Reverse Engineering:



* Tools: Ghidra, radare2, IDA Free, Binary Ninja CE, Cutter

* Static Analysis: String/data xrefs, decompilation mapping

* Dynamic Analysis: Stepping through stack frames, tracing control flow

* Signature-less malware analysis techniques



### Exploit Development:



* Stack-based buffer overflows

* Return-to-libc

* ROP Chains

* NX/DEP bypass

* ASLR infoleaks

* Format String attacks

* Custom Shellcode injection

* SEH Exploits (Windows)

* Heap exploitation basics (dlmalloc, fastbins)



### Shellcode Engineering:



* Null-free encoding

* Egg-hunting

* Self-modifying shellcode

* Polymorphic and Metamorphic Shellcode

* Linux Bind and Reverse Shell

* Windows WinExec Shellcode via syscall



## šŸ“š Learning Sources (Used & Referenced)



* *x64 Assembly and C++* - Daniel Kusswurm

* *Practical Reverse Engineering* - Bruce Dang

* *The Art Of 64-Bit Assembly, Volume 1, x86-64 Machine Organisation and Programming* - Randell Hyde

* *The Shellcoder's Handbook* - Chris Anley, John Haesman, Felix "FX" Linder, Gerrardo Richarte

* *x86-64 Assembly Language Programming with Ubuntu* - Ed Jorgenesen, Ph.D

* *The Art of Exploitation* - Jon Erickson

* *Practical Malware Analysis* - Sikorski & Honig

* *IntelĀ® 64 and IA-32 Architectures Software Developer Manuals*

* *[https://cs.lmu.edu/\~ray/notes/nasmtutorial/](https://cs.lmu.edu/~ray/notes/nasmtutorial/)*

* *[https://0x00sec.org/](https://0x00sec.org/) (Advanced RE topics)*

* *Offensive Security Exploit Developer (OSED) Syllabus*

* *Open Security Training 2 - Arch1001 Course* - OST2

* *Hack The Box, Pwnable.kr, OverTheWire*



## āš”ļø Challenges Solved



* Exploit writing in Pwnable.kr challenges

* Reverse engineering Linux crackmes

* Writing custom packers/unpackers

* Defeating stack canaries in vulnerable apps

* Crafting ROP chains to spawn shells

* Writing Windows syscall-only shellcode

* Malware behavior tracing without source

* Debugging obfuscated Windows binaries



## šŸ”’ Cybersecurity Context



This learning is directly applicable to:



* Penetration testing & Red Team operations

* Malware reverse engineering

* Defensive system hardening

* CTFs and wargames

* Forensics and incident response

* OS and firmware development

* Exploit Development



## šŸ§  Mental Models



* Think in terms of control flow graphs

* Stack is your canvas: overwrite, pivot, reroute

* Exploit chains are puzzles: break assumptions one gadget at a time

* Every crash is a message: understand what caused it

* Attack the assumptions of the compiler, not just the binary



## āš™ļø Practical Applications



* Write shellcode for custom C2 implant loaders

* Debug obfuscated binaries step-by-step

* Analyze memory dumps from compromised hosts

* Disassemble malware samples to understand infection vector

* Reconstruct source code logic from stripped binaries

* Inject and hook functions in remote processes

* Patch binaries to bypass license/DRM



## šŸ”„ Dev Environment Philosophy



* Use minimal tools: Vim + NASM + GDB beats bloated IDEs

* Debug every binary from first principles

* Don't trust disassemblyā€”verify with runtime analysis

* Learn to love segmentation faultsā€”they are signposts

* Build muscle memory for hex math, offsets, and instruction timing



## šŸ”­ Future Goals



* Write custom loader with pure Assembly

* Explore UEFI shellcode payloads

* Develop an obfuscation-resistant debugger plugin

* Design polymorphic shellcode engine

* Contribute to open-source RE and pwn tools

* Transition from 64-bit to 32-bit compatibility shellcodes

* Full Windows privilege escalation exploit from scratch