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
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
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
creating AND and XOR for the ALU3:19
creating an 8-bit adder9:23
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
completing our 8-byte ram8:14
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
virtual memory(intuitive view)6:14

text files6:12
metadata3:39
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
bitmap image files-part214:46
executable file types(elf files)6:28
elf header- part 110:35
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
program header-part39:18
program header-part4-segments and sections8:08
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
invoking system calls in assembly4:02
printing hello world on the screen using assembly language9:25
breaking the executable into sections11:42
disassembling the text section8:03
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
jnz instruction to control the loop5:52
loops in assembly and python7:22
using gdb to step through the program14:43
methods for different tasks1:43
reading the user input and write it on the screen9:20
hacking our program4:20
if-else in assembly-jp-cmp9:41
implementing our assembly program in python7:21
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
creating a login or password checking program in assembly11:33
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

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
pointers in memory and stack using gdb16:08
creating strings as array of characters5:02
dereferencing character array elements3:53
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
reading user input as string1:39
reading user input as elements of an array5:52
login and password checking program using c6:52
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
disassembling .text section of executable in static and shared libraries3:48

hacking a website using a malware9:59
layout of the malware4:19
program layout: interp-note-abi-tag9:37
program layout: symbol tables21:04
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
reversing the malware: initialization the array-rep stos15:13
reversing the malware: socket call6:42
reversing the malware: htons call11:53
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
reversing the malware: sockaddr_in5:49
reversing the malware: listen system call2:06
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
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
cracking a software17:33

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: