Principles of Software Security IFN657 Lecture 3

QUT Acknowledgement of Traditional Owners

• QUT recognizes the Turrbal and Yugara peoples as the First Nations owners of the land.
• Respect is paid to Elders, customs, lores, and creation spirits.
• The land has always been a place of learning, teaching, and research.
• QUT acknowledges the important role of Aboriginal and Torres Strait Islander people within their community.

Principles of Software Security (IFN657 Lecture 3)

• Key Points from Last Lecture (C and C#):
  • C is efficient but error-prone, closely related to the machine model with flexible memory management.
  • C# is type-safe, with built-in bounds and string checks, and automatic memory management.
  • Computer memory is divided into sections (stack, heap).
  • Stack grows as function calls are made.
  • Heap grows dynamically as memory is allocated.

x86 Architecture - Assembly Basics

• x86 architecture and assembly basics

Machine vs. Assembly vs. C

• Shows the relationship between C code, compiled machine code, and assembly code.
• Demonstrates the translation process from a high-level language (C) to low-level machine code.
• Includes example C code, generated machine code (in hexadecimal format), and assembly instructions.

Levels of Abstraction

• Hardware: Basic electrical circuits implementing logical operations (XOR, AND, OR, NOT).
• Microcode (Firmware): Lower-level instructions.
• Machine code: Opcodes (hexadecimal digits) that tell the processor what to do.
• Low-level languages: Human-readable versions of an architecture's instruction set.
• High-level languages: Transformed into machine code at compilation (e.g., C/C++).
• Interpreted languages: Translated to bytecode, then executed.

Assembly Language

• Assembly is the highest-level language reliably recovered from machine code.
• Vulnerable code or malware is typically stored in binary at the machine code level.
• Disassemblers convert binary to assembly language code.
• Assembly language is a class of languages, with x86 as a specific focus (explained in more detail).

Assemblers and Linkers

• Assemblers and linkers are tools used in software development that manipulate object files and libraries in creating and managing executable code.
• Assembly files are transformed into object files by assemblers.
• Object files are linked into an executable file by a linker that also incorporates libraries.

Assembler vs. Compiler

• Compilers translate high-level languages to machine code in a single step.
• Assemblers translate assembly language to machine code in multiple steps.
• A compiler checks and converts the entire code simultaneously, whereas an assembler typically works in multiple passes.
• Compilers may include a lexical analyzer (scanning), syntax analyzer, semantic analyzer, code optimizer, code generator, and produce mnemonic versions.

AT&T vs. Intel Syntax (NASM)

• Two main assembly language syntax forms.
• NASM format uses a different order, and symbols before registers/literals.
• AT&T format, uses the reverse order, and includes % before registers and $ before literal values.

Fundamental Data Types

• Binary representations of data types (bytes).

Memory

• Memory addresses and their corresponding data.

Data in Memory (Little-Endian Format)

• How data is stored in memory using little-endian format

CPU Registers

• A small amount of data storage directly accessible by the CPU.
• Registers are faster accessible than memory.

x86 Registers

• Categorizes x86 registers into General, Segment, Status, and Instruction Pointer registers.

General Registers

• Storing data or memory addresses and functions like storing data.

x64 Registers

• A further division of x86 registers based on 64-bit architecture

Data Registers

• Functions of EAX, EBX, ECX, EDX registers (explained in more detail).

Index Registers

• Functions of ESI (source) and EDI (destination) registers.

Segment Registers

• Functions of CS (Code Segment), DS (Data Segment), SS (Stack Segment) for referencing code, global data and stack, respectively.
• ES, FS, and GS provide additional segments.
• Memory address are relative to the starting address of the segment.

Status Registers

• Functions of ZF, CF, SF, TF flags (zero, carry, sign, trap).

Instruction Pointer (EIP)

• Points to the next instruction to be executed.
• The complete address consists of a segment selector and offset.

Other Pointer Registers

• ESP (Stack Pointer) and EBP (Base Pointer) are described.
• ESP points to the top of the stack, while EBP points to the current stack frame or local variables in current functions.

Simple Instructions

• Functions and uses of various instructions like MOV, LEA, arithmetic instructions (e.g., ADD, SUB, INC, DEC, MUL, DIV), logic instructions(e.g., XOR, OR, SHR, ROR), and the 'nop' instruction.

Stack Layout

• Visual representation of the stack with multiple stack frames.

Function Calls

• Process of calling and returning from a function explained.

Conditionals

• Functions of test and cmp instructions and how they use flags (ZF, CF).

Branching

• Types of unconditional jumps (JMP) and conditional jumps (e.g., JZ, JNZ, JG, JGE).

Examples of Conditional Jumps

• A variety of conditional jumps.

C Main Method and Offsets

• How C programs organize arguments using the main method (argc, argv array).

A Simple C Program (and compiled form)

• C program demonstrating the usage of file operations.
• Shows assembly code after compilation.

Home Readings

• List of resources for additional learning about NASM Assembly.