内联循环#

在编程中，“内联”（inline）指的是将函数体的代码直接插入到调用它的地方，而不是通过常规的 call 指令跳转过去。将函数体的循环直接插入，循环次数由运行时决定。这样做的好处是：

·省去了函数调用和返回时的栈操作（压栈、跳转、恢复等），提高执行速度。

·对于小函数尤其有利，比如 strlen、memcpy 等。

1
size_t strlen(const char *s) {
2
    size_t len = 0;
3
    while (*s != '\0') {
4
        len++;
5
        s++;
6
    }
7
    return len;
8
}

如果编译器决定内联这个函数，那么在调用 strlen(str) 的地方，它不会生成 call strlen，而是直接生成一段循环指令来扫描字符串。

使用IDA反汇编时,可能会遇到的两种情况：

·直接调用 strlen：反编译窗口会显示strlen(local_58)，容易识别。

·内联循环：你可能会看到一段像上面那样的指令序列，Ghidra 有时能识别并注释为 strlen，有时则显示为一段自定义的循环。你需要根据指令模式（如 repne scasb）或循环逻辑判断它是在计算长度。

反汇编出来的伪代码类似于:

1
for (i = 0; s[i] != 0; i = i + 1) {
2
}

i 是一个整数变量（通常从 0 开始）。 s 是一个指向字符串的指针（比如 char *s）。 循环条件是 s[i] != 0，也就是当前字符不是字符串结束符 \0。 每次循环，i 增加 1，但循环体是空的（大括号里什么都没有）。 当遇到 \0 时，循环结束，此时 i 的值就是字符串的长度（因为 \0 本身没有被计入）。

内联循环 = 编译器将小函数（如 strlen）的循环体直接嵌入到调用处，避免函数调用开销。

内存单元#

定义：内存中用于存储数据的基本单位，通常指一个字节（8 位）。每个内存单元有一个唯一的地址（从 0 开始编号），CPU 通过地址访问这些单元。

mov al, [0x1234] 表示从内存地址 0x1234 处读取一个字节到 AL 寄存器。

寄存器#

定义：CPU 内部的高速存储单元，用于暂存指令、数据或地址。它们是 CPU 计算的核心。

通用寄存器：EAX、EBX、ECX、EDX 等，用于算术运算、数据暂存。 指针寄存器：ESP（栈指针）、EBP（基址指针），用于管理栈。 指令指针：EIP，存放下一条要执行指令的地址。

add eax, ebx 表示将 EAX 和 EBX 的值相加，结果存回 EAX。

段寄存器#

定义：x86 架构特有的寄存器，用于支持内存分段管理。每个段寄存器（如 CS、DS、SS、ES）存放一个段选择子（在保护模式下）或段基址（在实模式下）。 作用：与偏移地址组合，形成最终的物理地址或线性地址。

常见段寄存器：

CS（代码段）：指向存放指令的段。 DS（数据段）：指向存放数据的段。 SS（栈段）：指向栈所在段。 ES、FS、GS（附加段）：用于其他数据访问。

mov ax, [bx] 隐含使用 DS 段寄存器，即实际访问的是 DS 指向的内存单元。

ASCII 字符#

每个字符占用 1 个字节，如 ‘A’ = 0x41。

Unicode 字符#

地址加法器#

物理地址 = 段地址 * 16 + 偏移地址

1
         实则为数据左移四位（二进制位）

衍生：一个数据的x进制形式左移1位相当于*x

CS,IP#

1
  CS      IP

程序#

栈#

操作原则(lAST In First Out)

提供出入栈指令:

push ax :将寄存器ax中的数据送入栈中；

pop ax :从栈顶取出数据送入ax

1
高地址
2
+-----------------+
3
| 函数参数        |
4
+-----------------+
5
| 返回地址        | ← 函数返回时会跳到这里
6
+-----------------+
7
| 保存的 EBP      |
8
+-----------------+
9
| 局部变量        | ← 例如 char buf[10]
10
+-----------------+
11
低地址

1
void vulnerable() {
2
    char buffer[8];      // 局部缓冲区，只能容纳 7 个字符 + 结尾的 '\0'
3
    gets(buffer);        // 从标准输入读取一行，但不检查缓冲区大小
4
}

1
int authenticated = 0;
2
char password[8];
3
gets(password);
4
if (strcmp(password, "secret") == 0) {
5
    authenticated = 1;
6
}

1
mov ax, 1000H

sub#

1
地址 0x1000: 0x78
2
地址 0x1001: 0x56
3
地址 0x1002: 0x34
4
地址 0x1003: 0x12

1
地址 0x1000: 0x12
2
地址 0x1001: 0x34
3
地址 0x1002: 0x56
4
地址 0x1003: 0x78

mov#

一般有如下形式

1
mov 寄存器,数据
2

3
mov 寄存器,段寄存器
4

5
mov 寄存器,寄存器
6

7
mov 寄存器,内存单元
8

9
mov 内存单元,寄存器
10

11
mov 段寄存器,寄存器

add#

DS和[address]#

执行指令时，8086CPU自动收取DS中的数据为内存单元的地址。

mov从10000H中读取数据：

10000H(1000:0)

将段地址1000H放入ds

用mov al,[0]完成传送([]指的是一个内存单元,这个内存单元的偏移地址是0，它的段地址默认放在ds中)

数据-> 通用寄存器 -> 段寄存器

cmp#

比较

cmp rax, 31

后续通常会紧跟一条条件跳转指令（如 je、jg、jl 等），根据比较结果改变程序执行流。

je（相等时跳转）：若 RAX == 31。 jne（不相等时跳转）：若 RAX != 31。 jg（有符号大于）：若 RAX > 31。 jl（有符号小于）：若 RAX < 31。 ja（无符号大于）：若 RAX > 31（无符号比较）。 jb（无符号小于）：若 RAX < 31（无符号比较）。

range(a,b,c)#

从a开始，到b结束（不包含），长度为c

如果a长度是 34，那么会依次取 0, 2, 4, 6, …, 32。

a[i+x]#

这是字符串切片操作，从a中取出从i开始、长度为x的子串。

异或#

异或（XOR，符号为 ^）是一种按位运算

1
cipher = ord(flag[i]) ^ key
2
result += str(hex(cipher))[2:].zfill(2)

1
  original = cipher ^ key

chr()#

将整数转换成对应字符

chr(65) 返回A

append#

是列表的方法，用于在列表末尾添加一个元素。

”.join(a)#

是字符串的 join 方法，它把列表a中的所有字符串元素（这里是单个字符）连接成一个长字符串，连接符是空字符串 ”（即直接拼接）。

假设解密过程得到 original 依次为：112, 121, 116, 104, 111, 110

chr(112) -> ‘p’

chr(121) -> ‘y’

chr(116) -> ‘t’

chr(104) -> ‘h’ chr(111) -> ‘o’

chr(110) -> ‘n’ 列表 flag_chars 变成 [‘p’,‘y’,‘t’,‘h’,‘o’,‘n’] 然后 ”.join(flag_chars) 得到 “python”。

这样，最终打印出来的就是解密得到的 flag。

%

在数学中，取模运算（Modulo Operation）就是求两个数相除的余数。 对于整数 a 和 b（b ≠ 0），a % b 的结果是 a 除以 b 后得到的余数。

a = b * (a // b) + (a % b)

其中a // b是整数除法（在 Python 中称为地板除，结果向下取整）a % b 就是余数，且0 ≤ 余数 < |b|（当 b > 0 时成立，负数情况见后）。

1
print(7 % 3)   # 输出 1

1
print(-7 % 3)   # 输出 2

1
num = 7
2
if num % 2 == 1:
3
    print("奇数")
4
else:
5
    print("偶数")

1
arr = ['a', 'b', 'c']
2
index = 5
3
print(arr[index % len(arr)])   # 输出 'c'，因为 5 % 3 = 2

1
value = 123
2
# 将 value 限制在 0~9 之间
3
value %= 10   # 123 % 10 = 3

1
num = 12345
2
last_digit = num % 10           # 5
3
second_last = (num // 10) % 10  # 4

1
for i in range(100):
2
    if i % 10 == 0:
3
        print(f"第 {i} 次执行特殊操作")

strlen#

C 语言标准库中的一个函数，用于计算字符串的长度（不包括结尾的空字符 ‘\0’

1
#include <string.h>
2
size_t strlen(const char *s);

参数：s 是指向字符串首字符的指针（必须是 \0 结尾）。 返回值：size_t 类型（通常是无符号整数），表示字符串的字符数，不包括结尾的 \0。 strlen 从 s 指向的地址开始，逐字节读取内存，直到遇到值为 0 的字节（即 \0）为止，然后返回读取的字节数（不包括最后的 \0）。

示例：

1
char str[] = "hello";
2
int len = strlen(str);  // len = 5

当看到 strlen 调用，往往表示程序正在处理字符串，可能是验证输入长度、计算缓冲区大小等。 反汇编中可能直接出现 call strlen，也可能被编译器优化为内联循环（如 repne scasb）。

void#

void 关键字表示“无类型”或“空” 当函数不需要返回任何数据时，返回类型声明为 void

1
int a = 10;
2
void* ptr = &a;                // 可以指向 int
3
// *ptr = 20;                  // 错误！不能解引用 void*
4
int* intPtr = (int*)ptr;       // 需要强制转换后才能使用