Computer Organization And Assembly Language

Learn assembly language and its role in turning your code into a safe, optimized running application

What you'll learn

Write and understand x86 32bits assembly languge (Core Intel 80386 Instruction Set) and more

Understand at the most fundamental level mechanisms of higher level languages (pointers, variables, memory allocation, function calls, instructions)

Understand the build process behind GCC compiler - preprocessing, compilation, assembly, linking

Manually generate executables from projects containing source files, object files and libraries

Understand what happens at runtime (when application is launched into execution) - loader, shared libraries, process address space

Understand how hardware resources are used by a running process - CPU, registers, RAM, cache

Master debugging a program using extensions of GDB debugger

Reverse-engineer a binary using both static and dynamic analysis tools (objdump, Ghidra, GDB peda)

Exploit or protect against some of the most popular code vulnerabilities: buffer overflow

Understand and use mechanisms of protection against exploits (ASLR, Stack Smashing Protection, Data Execution Prevention)

Requirements

Computer (x86_64 architecture recommended)

Basic C programming knowledge would be helpful, but not mandatory

Being accustomed with the Linux operating system would be helpful, but I will walk you through everything you need - virtual machine, terminal, VSCode

Description

This course presents in a simple manner the assembly language - intel syntax - for the x86 32-bits architecture and places this in the context of a computing system.  We start with a short presentation of the hardware components on which assembly code is highly reliant, how they work and what is their purpose in relation to the software. We continue with some higher level notions - data, variables, pointers, functions - as we understand them in languages such as C/C++ and we show all the steps that lead to the assembly language. By using a lot of demos and animations, we go through all the assembly language notions - registers, static memory, the stack, function calling, instructions - side by side with the more familiar concepts in higher level languages. In this process, we make use of multiple tools, both for static and dynamic analysis of binaries: GDB, objdump, nm. Towards the end, we touch on the security side of assembly. We do a deep dive into one of the most common vulnerabilities, buffer overflow and show how programs can be exploited. While on this topic, we present a binary analysis tool that is the bleeding edge in the domain of security: Ghidra.This course is for people of any level and is the direct result of a desire to explain the concepts that were most useful to my career path in the simplest manner.

Overview

Section 1: Introduction

Lecture 1 Introduction

Lecture 2 The Big Picture

Lecture 3 Setting Up Your Environment

Section 2: CPU and Memory

Lecture 4 CPU and Memory

Section 3: High-Level Programming Notions

Lecture 5 Data and Data Types

Lecture 6 Variables. Pointers. Functions

Section 4: Compilation Steps

Lecture 7 Compilation Steps

Section 5: Process and Program Memory

Lecture 8 Process and Program Memory

Section 6: Registers in Assembly

Lecture 9 Registers in Assembly

Section 7: Static Variables in Assembly

Lecture 10 Static Variables in Assembly

Section 8: GDB Debugging

Lecture 11 GDB Debugging - Demo

Section 9: Basic x86 Assembly Instructions

Lecture 12 Arithmetic and Logical Instructions

Lecture 13 Data Movement Instructions

Lecture 14 Control Transfer Instructions

Lecture 15 Basic Instructions - Demo

Section 10: The Stack

Lecture 16 The Stack

Lecture 17 Function Calling in Assembly

Section 11: Security

Lecture 18 Buffer Overflow

Lecture 19 Binary Analysis. Ghidra

Absolute beginners in programming that want to understand how the whole system works - from a piece of code to bits on the CPU - and how higher-level languages manage to do it all,Anyone interested in security and wants an introduction into reverse-engineering, exploits and protection mechanisms,Anyone with a special interest towards low-level programming - operating systems, embedded systems, drivers,Programmers at any level who just want a deeper understanding of the underlying mechanisms of the language they are using