reverse engineering and exploit development in linux(x64)

Name: reverse engineering and exploit development in linux(x64)
Rating: 4.5 (53 reviews)

computer architecture, file structure, assembly and c programming language, reverse engineering and exploit development

Created bymohamad gharishvandi

Last updated 8/2021

English

English [Auto],

What you'll learn

computer architecture
assembly langauge
c programming language
reverse engineering
exploit development
memory organization
file structure
file structure in linux
elf files
segment and section headers in elf files
the txt, the bmp header files
headers of images
executables in linux
transistors in computer
nmos vs pmos transistor
transistor circuits with dc and ac inputs
creating not gates using nmos and pmos transistors
creating nand gates using nmos and pmos transistors
creating memory bit using nand gates
decoder
creating ram using nand gates from scratch
what are multiplexers and why we need them
the data path in a computer
control unit of a cpu
creating an alu from scratch
turing complete machine
why computers are fast
why computers are strong
system calls in linux
disassembling the .text section
creating programs in assembly language
the comparing of assembly, python and c
jumps and conditional jumps in assembly
jz,jnz,je,jne,jc,jnc in assembly language
functions and procedures in assembly
format specifiers in c
variables in c
pointers in c
stepping through c programs using gdb
compiling c programs into their assembly counterpart
stack layout of programs in c
memory layout of programs in c
pointers in memory and stack
create a function like printf in c
create a function like strcmp in c
comparing strings in c
creating a static library in c
creating a shared library in c
static library vs shared library in c
reverse engineering a malware
arguments passing and function calling

Course content

6 sections • 136 lectures • 16h 22m total length

bits, binary and data5:49
the concept of bit(binary digit) using lamps. what do we mean by data and what is binary language?
what is a computer1:22
a general overview of what a computer is. a computer in general form is said to be maid up of three sections:
cpu, memory, input/output devices
binary,hex and decimal numbering systems9:05
Explore binary numbering system, convert between binary, decimal, and hexadecimal representations, and learn how grouping bits into four yields hexadecimal representations.
what is a transistor2:30
Explore how a transistor uses gate, drain, and source terminals, with a threshold around 2.7 volts, to switch current on and off, forming the building blocks of computers.
transistor circuit with dc input1:55
transistor circuit with digital clock voltage2:33
Analyze how a five-volt voltage source with a one-second cycle, controlling the gate, drives a transistor to blink a lamp in a simulated circuit observed on an oscilloscope.
nmos and pmos transistors2:28
not gates using cmos transistors4:48
Explore a CMOS inverter built from two transistors, where input low yields five-volt high output and input high yields zero. Validate with a clocked test and oscilloscope.
creating a nand gate using mosfet transistors6:29
Design a nand gate with four transistors (two pmos and two nmos), explain input-driven output, and present the nand gate as a universal building block for ram and cpu.
creating a memory bit using nand gates4:51
creating a memory byte3:35
demonstrates building a memory byte by wiring eight circuits together to store eight bits. shows eight boxes forming ram-like memory with addressable memory cells for selective access.
decoder3:03
Explore how nand and not gates, driven by a transistor network, implement a two-to-four decoder (expandable to three-to-eight) and how its one active output addresses memory cells in Aurora.
creating an 8 byte ram2:12
Create an eight-byte ram by arranging eight memory cells and a three-to-eight decoder to address them; write to a selected cell by applying address and data patterns.
flowing of data in computer(datapath)6:54
multiplexers and why we need them6:06
Explore how multiplexers create a controllable data path by selecting register outputs to a shared bus, using two-to-one multiplexers and chip enable signals to avoid wire conflicts.
creating the bus to move data between registers4:33
Explore how to implement a data bus to transfer and copy data between registers using multiplexers, enabling controlled data movement across multiple registers.
creating AND and XOR for the ALU3:19
Learn how to build a simple ALU add circuit using only NAND and NOT gates to realize AND and OR functions, enabling single-bit and two-bit addition with proper truth tables.
creating an 8-bit adder9:23
Explore building an 8-bit adder from basic logic gates, cascade adders, propagate carry, and verify sums and overflow using example inputs.
subtraction and 2s complement9:14
Explore eight-bit two's complement encoding from minus 128 to 127, enabling subtraction by adding negatives; flip bits and add one to get negative values, using the msb as sign.
subtracting using adder and 2s complement4:43
Explore subtracting using two's complement by inverting the value, adding one, and feeding through an adder to produce the negative result, illustrated with 35 minus 19 equals 16.
enabler1:36
An enabler circuit demonstrates and gate behavior, showing how the output becomes one only when both inputs are one and how a control bit can enable or disable the signal.
creating a two operation-alu3:55
Build a two-operation alu that adds or subtracts using a control bit to select between pass-through input and its negation, implemented with xor and not gates.
completing the alu12:19
Complete an ALU by integrating addition, subtraction, and not gates with and, or gates, using a 3-to-8 decoder and a multiplexer to provide a single operation output.
completing our 8-byte ram8:14
Complete an 8-byte ram by wiring the input bus, decoder, enabler, and write enable signals to the address lines and the write and read data paths.
putting together our computer6:21
Put together the computer by wiring RAM, registers, the AC, ALU, and a multiplexer to feed the input and address lines, then clear all registers to zero.
executing instructions using our computer10:22
Execute instructions on old computers by moving from high-level ideas to assembly, illustrating memory addresses, registers, random access memory, and binary translation via the assembler, with loops, comparisons, and increments.
why are computers so fast-part15:36
Explain how a computer executes instructions through a fetch-decode-execute cycle, using the program counter and instruction register, and contrast Harvard architecture versus von Neumann architectures with separate data and instructions.
why are computers so fast-part210:13
why computers are powerful-turing complete7:48
stack and why we need it15:06
what is operating system2:19
Understand how the operating system serves as an interface between software and hardware, manages memory for instructions and data, and coordinates loading, process execution, and resource sharing.
virtual memory(intuitive view)6:14

text files6:12
metadata3:39
Demonstrate how metadata acts as headers describing data in files and explain how the file system and operating system mediate between hardware and applications to locate and begin data.
how to create a file and a program to handle it as an image11:20
Create a custom file type and a program that treats data as an image by mapping bits to 16x27 pixels, using a header for image metadata and 24-bit RGB colors.
bitmap image files-part15:27
Explore bitmap image files by constructing and analyzing a 51-by-92 pixel bitmap, noting three color bytes per pixel, a 54-byte header, and row padding to four-byte alignment.
bitmap image files-part214:46
executable file types(elf files)6:28
Explore executable file types on linux x64, focusing on elf files, headers, program headers, section headers, and the roles of linking and loading in creating executables.
elf header- part 110:35
Examine the elf header using readelf and basic commands, identify the magic bytes 7f 45 4c 46, and outline the 64‑bit little‑endian header fields.
elf header-part 26:15
elf header-part36:20
elf header structure in c4:10
Explain the ELF header structure in C, including the common header, program header, and loader and linker roles, and how 2-byte and 8-byte fields are defined through type aliases.
program header-part18:48
program header-part29:15
examine the linux x64 elf program header entries, including p type, offset, virtual and physical addresses, file and memory sizes, flags, alignment, and the nine 56-byte headers parsed by readelf -l.
program header-part39:18
Analyze the second program header segment in Linux x64, detailing its type, the interpreter path, and how addresses, sizes, and alignment shape its memory layout.
program header-part4-segments and sections8:08
Explore the tiered structure of program headers, segments, and sections in linux x64. See how a load segment can contain other sections, guided by addresses and sizes mapping to memory.
section header-part14:48
section header-part211:25
section header-part311:47
why assembly language4:25
Analyze a binary file’s sections and segments to map data layout and understand where machine instructions reside; use objdump to disassemble and prepare for an assembly language crash course.

what is assembly language2:51
defining sections in assembly language5:00
Define sections in assembly language to create a first program that prints HelloWallet, using NASM as assembler and a linker to produce an executable from text and data sections.
invoking system calls in assembly4:02
Explore invoking Linux x64 system calls from assembly by loading the syscall number into the correct register, passing arguments via registers, and using write to print to the screen.
printing hello world on the screen using assembly language9:25
breaking the executable into sections11:42
disassembling the text section8:03
Explore how binaries classify data into segments and sections, highlighting the text section as the executable core. Learn to disassemble with objdump in Intel syntax to map bytes to assembly.
what would happen if we remove exit system call4:33
Removing the exit system call causes the program to fetch and execute memory bytes, leading to unpredictable behavior and, after printing a word, a segmentation fault.
creating an infinite loop3:06
Implement an infinite loop in assembly by creating a loop label, and an unconditional jump to repeatedly print a hello world output, then assemble, link, and run the program.
jnz instruction to control the loop5:52
Show how the jnz instruction uses the zero flag to control a loop, decrementing a counter in the ar10 register and repeatedly printing until the counter reaches zero.
loops in assembly and python7:22
using gdb to step through the program14:43
Learn to use gdb to set breakpoints, disassemble the text section, and step through a linux x64 program, inspecting registers, ip, and flags to understand its control flow.
methods for different tasks1:43
reading the user input and write it on the screen9:20
Learn to read user input from standard input using the read system call, store it in memory, and echo it back to the screen on Linux x64.
hacking our program4:20
if-else in assembly-jp-cmp9:41
implementing our assembly program in python7:21
Implement an assembly program in Python by mapping registers to variables, performing subtraction, computing parity via binary representation and counting ones, and illustrating how built-in functions translate to machine code.
jump if greater in assembly and python8:34
jz and je based on eflags register7:15
Explore how jz and je use the eflags register to drive conditional jumps, based on zero and parity flags, as numbers compare and print results.
jc and jb based on carry flag12:28
Explore implementing a loop that compares A and B, uses subtract and logic operations, and uses carry-based jumps jc and jb to control flow and printing.
what are functions or procedures in assembly4:36
Learn how assembly packages instructions into a function, call it from an entry point, and return to the next instruction.
implementing functions in assembly using jumps9:24
Learn to implement functions in assembly on linux x64 by using jumps, saving the instruction pointer, and applying relative addressing to control execution flow.
working with functions using call and ret6:49
working with stack uisng push and pop16:37
Demonstrate stack operations on linux x64 using push and pop to move data, manage registers such as r8, r9, and r11, and diagnose segmentation faults.
creating a login or password checking program in assembly11:33
Develop an assembly-based login program that prompts for a password, compares input with a stored pass, allows three tries before exit, and reports success when correct.
implementing the last password checking program in python6:51
Implement a Python password checking loop that prompts for input up to three attempts, compares it to the predefined password MGE12345, prints success, and maps assembly concepts to Python.
arrays and pointers in assembly9:47
Learn how arrays and pointers are implemented in x64 assembly, define a data array, access elements via base plus offset, and inspect results with gdb.
computer is just mov and add6:11
Explore how assembly language uses move and add to implement operations and control flow, converting compares and jumps into sequences of moves, revealing a turing-complete view of Linux x64 systems.

compiling a c program using gcc compiler5:59
Create and run your C program on Linux by writing a main file, including headers and libraries, and compiling with gcc through preprocessing, compiling, assembling, and linking to an executable.
format specifiers5:23
variables in c3:19
Learn how to declare and initialize integers and characters in c, print their decimal and character representations, and view values as ascii using gcc to compile.
stepping through the last program using gdb4:30
adding numbers in c and looking at the stack changes in gdb16:46
Explore a c program that adds two numbers and prints 30, while using gdb to inspect the stack changes and intel disassembly.
adding two numbers in assembly in 3 ways9:02
stepping through last program with gdb10:58
Step through the last program with gdb, inspect registers and the stack, and observe how pushes and memory addresses modify the top of the stack and the bytes allocated.
compiling assembling linking step by step6:11
arrays in c8:06
Explore how arrays in C represent a collection of integers, how the array name points to the first element, and how size and address concepts reveal memory layout.
looping through array using for loops5:32
Apply a for loop to iterate over a five-element array, printing each element with its index and decimal value. Explanations cover array length, size of elements, and zero-based indexing.
stack layout of last program9:31
Analyze the stack layout of the last program using GDP on OpenNet, with stripped symbols, and map RSP, RBP, and 0x18/0x20 offsets to the stack frame.
setting up the stack5:29
Learn how to set up the stack in Linux x64 using gdb to inspect memory, zero bytes, and align four- and eight-byte writes for correct layout.
how arrays are created in the stack5:02
Explore how arrays are created in the stack on linux x64 by tracing memory addresses, hex values, and mov operations to illustrate stack layout and data placement.
printf from c to assembly4:27
manipulating the program in gdb4:13
pointers in c7:21
Define an int variable and a pointer, print its address and value, then update the value via the pointer and confirm the memory address stays the same.
pointers in memory and stack using gdb16:08
Explore how gdb reveals memory layout and pointers in C by disassembling main, inspecting stack frame registers, and tracing the address of variable a and its pointer.
creating strings as array of characters5:02
dereferencing character array elements3:53
Learn how to dereference character array elements and use pointer arithmetic, including a+1 and a[1], to print strings from memory and inspect ASCII values.
creating strings using pointers4:01
Learn how to create and modify strings using pointers in linux x64, including element-level changes, pointer targets, and printing addresses and contents of null-terminated strings.
comparing strings created with arrays and pointers in memory9:02
Compare strings created with arrays and pointers in memory by building and modifying a stack-based array, then inspecting pointer targets and their addresses using disassembly.
reading user input in c4:02
Learn how to read user input in C using scanf, store the value as a decimal in a variable, and print it with printf, while examining the associated system calls.
reading user input as string1:39
reading user input as elements of an array5:52
login and password checking program using c6:52
Write a C program that prompts for a password, compares input with password using strcmp, and exits on a correct match while looping on failure; later, implement a custom compare.
writing a program which compares two strings11:03
creating a library with a string comparing function9:20
writing a function which calculates the length of a string3:35
Develop a custom string length function inside a library for Linux x64 reverse engineering and exploit development. Test by passing a string and printing its length in decimal.
implementing a function like printf in c3:02
Implement a printf-like function in C that writes to standard output using a descriptor, a string pointer, and its length; compute length with a custom strlen and print the string.
creating a static library in c4:42
creating a shared library6:16
static libraries vs shared libraries9:28
Compare static libraries and shared libraries by building and linking in linux x64 to observe executable size and behavior.
disassembling .text section of executable in static and shared libraries3:48

hacking a website using a malware9:59
layout of the malware4:19
Examine how an operating system loads a program, with assembly and C concepts, differentiating program and process layouts, and detailing headers, program headers, segments, and section headers for malware analysis.
program layout: interp-note-abi-tag9:37
program layout: symbol tables21:04
Explore the ELF module’s program layout, focusing on section headers, symbol tables, dynsym and dynstr, and how the dynamic linker uses the GNU hash for fast symbol resolution.
completing the program and process image8:15
complete the program and process layouts in linux x64 reverse engineering, examining elf headers, symbol tables, version sections, and linking concepts, including dynamic linking and the main text section.
reversing the malware: char array11:31
Reverse engineer a malware char array in Linux x64 using gdb and disassembly. Trace rbp stack offsets and identify the exact array size and null terminator.
reversing the malware: initialization the array-rep stos15:13
reversing the malware: socket call6:42
reversing the malware: htons call11:53
Explore reversing malware on linux x64 by breaking at addresses, disassembling instructions, and tracing htons converting host to network byte order within the process memory map and standard file descriptors.
reversing the malware: inet_addr7:16
reversing the malware: binsh4:20
Explore reversing malware to spawn a shell by mapping memory addresses, disassembling code, and crafting a payload that places binsh on the stack for execution.
reversing the malware: bind system call9:25
Analyze the bind system call in linux x64 malware, constructing the sockaddr with IP and port in C or Python and tracing the register arguments.
reversing the malware: sockaddr_in5:49
Complete the repairs code by forming a three-argument rendezvous point using sockaddr_in, filling ip address and port with sin_family, sin_port, and sin_addr, and verify typecasts with the manual.
reversing the malware: listen system call2:06
Examine how the listen system call uses a file descriptor and backlog to manage the pending connection queue in Linux x64 malware reverse engineering, with hands-on disassembly of arguments.
reversing the malware: accept system call6:26
Examine how the accept system call yields a new circuit by returning a file descriptor for an incoming connection on a listening socket, with pending connections queued.
reversing the malware: send system call4:40
reversing the malware: close and dup23:01
reversing the malware: execve-testing with wireshark7:41
Analyze malware behavior by reversing execve calls and testing argv and environment handling, using Wireshark to monitor traffic during execution.

exploit development-introduction3:44
Learn exploit development and reverse engineering on linux x64, exploring offensive security through two paths: reverse engineering to bypass authentication, and input-driven exploitation to reveal credentials from databases.
argc,argv,memory and stack7:34
Explore how linux x64 programs use argc and argv to pass arguments, inspect memory and the stack with GDB, and understand argv as an array of pointers to strings.
arguments passing and functions calling10:48
Explore how linux x64 passes function arguments, using registers when possible, and pushes the return address on the stack for function calls and stack-frame management.
predicting the flow of execution9:39
Predict the flow of execution in linux x64 by disassembling steps, predicting register and stack behavior, and tracking how arguments and return addresses move through memory.
changing the flow of execution of a program7:46
Explore how a program's flow of execution can be influenced by manipulating function calls, return addresses, and stack arguments, using memory, disassembly, and step-by-step analysis.
changing the behaviour of the program7:39
Explore how to change a Linux x64 program's behavior by manipulating return addresses and function arguments, using disassembly and registers like rdi to alter strings and output.
stopping the software from connecting to its manufacturer through the internet11:16
Explore reverse engineering and exploit development on Linux x64 to bypass authentication. Demonstrates patching binaries and blocking server communication to stop software from connecting to the manufacturer.
cracking a software17:33
Explore practical reverse engineering and exploit development on linux x64 by cracking a software’s registration check, using gdb, disassembly, and input-driven memory corruption to bypass protections.

Requirements

having kali linux(or another linux) installed
knowing basic commands of linux(not completely necessary since we explain about everything).

Description

i always wanted a course, a book or something which starts from scratch and brings me to an expert level. i saw and read a lot of courses which teach you the applications and software about security and hacking, learning those in security industry, is like knowing wordpress to design websites without understanding programming languages. so i started this course from scratch, from nothing. because as einstein put it: "if you can't explain something simply then you don't understand it well enough". in security the difference between experts and amateurs is just in the same statement. those who know the background science are those who DESIGN the metasploit and other softwares, and those who don't are the users of the programs. which one do you want to be?

if the answer is the first group, this the right place for you. we really start from nothing, introduce you the concept of data, that what do we mean by data, bits and bytes? we then introduce the basic element of all the digital devices: TRANSISTOR.

then we use that transistor to create the logic gates, nand and not gates. but we only create them if we need them, so before creating anything, we ask the question of "why do i need this?" . then we start to give a general overview of what a computer is, why we need it and how we are going to create it. that brings us to the concepts that as human we can't remember everything, so we needed something which could remember as long as we want it to, and more importantly we want it to do the computation so much faster that we ever could. those are the only two things that computer has over human brain. so based on that we proceed, a memory for remembering and a cpu for processing. so we start my using our nand gates to create both memory and cpu. and we test it, troubleshoot it, add features to it, until we have our computer. now we save our program as a set of instructions inside the memory, the cpu would fetch those instructions, and execute them and move to the next one, and it does it over and over again. everything in the computer which is not hardware, is a program, a simple FILE.

so in the second chapter we start talking about files. if all the computer could know are 1s and 0s, how could it show us text and images, movies and executables. this is were we talk about file extensions and headers. so that it could be an introduction into getting us to the elf file format, the executables and binary files in linux. because if we want to reverse files and crack and hack them, first we need to know them. all its segment and section headers, but not just an overview, going deep , somehow that we comprehend every byte of it. now its time for us to know how they get executed, or how they get created? using programming languages: ASSEMBLY

in the next chapter we enter the assembly world. why we need it , like always would be the main question, if we could anser it then we enter to HOW we do it. we teach everything you need to know about assembly. and when we write a program we debug it using the gdb, analyze instructions one by one, so that you know the reason for each instruction. and at the same time we compare assembly with other higher level programming languages.

why we need c programming language would trigger the creation of the next chapter. variables, pointers, format specifers, functions, they are all just names without a concept and their comprehension, thats why for every single abstraction there is a separate lecture depicting the memory and stack(we explain what this is in an intuitive manner) organization and how it changes.

when we know all these sciences in such a different manner, then when we get to the reverse engineering and exploit development, the last two chapter, you see that these are just a different look of everything we have learned so far. just looking differently and keep track of memory. and using these we would be able to reverse engineer malwares, hack and crack softwares. which means acquiring the offensive skills without which , you could never be a real hacker.

Who this course is for:

all the beginner and advanced students who want to be real hackers and know the science behind the scenes
penetration testers wanting to get their skills to an independent level
programmers interested in security

reverse engineering and exploit development in linux(x64)

What you'll learn

Explore related topics

Course content

Computer Architecture32 lectures • 3hr 5min

file structures - txt,images and executables18 lectures • 2hr 23min

Assembly language crash course27 lectures • 3hr 29min

C programming language crash course33 lectures • 3hr 40min

Reverse engineering a malware18 lectures • 2hr 29min

Exploit development8 lectures • 1hr 16min

Requirements

Description

Who this course is for: