# S06_Format_String.pptx：逐页可提取文字

> [原课件](../../../S06_Format_String.pptx)；共36页。以下是文字提取，**未经逐句纠错**；图中文字、截图代码、公式对象及动画关系可能无法完整提取。阅读主题笔记后，可按页码回原文件查看。

## 第 1 页

````text
格式化字符串漏洞
````

## 第 2 页

````text
内容
格式字符串 
访问可选参数 
printf（）工作原理 
格式字符串攻击 
利用漏洞 
对策
````

## 第 3 页

````text
格式字符串
printf() - 根据格式打印字符串。
int printf(const char *format, …);
printf 的参数列表:
必须包含的格式化字符串
零个或多个可选参数
因此，如果在调用期间传递给 printf（） 的参数不够，编译器不会报警
````

## 第 4 页

````text
%s
%x
%n, printf(“test %n”, &x);
%hn: printf(“test %hn”, &x);
<number>$: 直接参数访问
printf(“test %2$s”, “12”,”34”);
结果： test34
````

## 第 5 页

````text
C语言的可变参数函数（Variadic Functions）
通过一组宏和类型实现，定义在 <stdarg.h> 头文件中
va_list，类型定义，它用于存储可变参数列表的信息
va_start(va_list ap, last_fixed_arg)初始化 va_list 变量 ap。它必须在任何访问可变参数之前调用。第二个参数 last_fixed_arg 是函数最后一个已命名的（即固定参数）参数的名称
va_arg(va_list ap, type)检索可变参数列表中的下一个参数，并将其转换为指定的 type 类型。每次调用都会将 ap 推进到下一个参数
va_end(va_list ap)完成可变参数的访问后，用于清理 va_list 变量 ap。它必须在函数返回之前调用
````

## 第 6 页

````text
访问可选参数
myprint显示了 printf 的原理
考虑在第 7 行中调用 myprintf（） 
va_list指针（第 1 行）访问可选参数
va_start（） 宏（第 2 行）根据第二个参数 Narg（可选参数开始之前的最后一个参数）计算va_list的初始位置
````

### 备注区文字

````text
Usually, arguments are represented using variable names. But as optional arguments in printf() do not have names, they are accessed using stdarg macros in stdarg.h header file.
````

## 第 7 页

````text
访问可选参数
va_start 宏获取 Narg 的起始地址，根据数据类型查找大小并设置va_list指针的值
va_list指针使用 va_arg 宏前进
va_arg（ap， int） ：将 ap 指针 （va_list） 向上移动 4 个字节
当访问所有可选参数时，调用 va_end
````

## 第 8 页

````text
printf 如何访问可选参数
这里，printf 有三个可选参数。以“%”开头的元素称为格式说明符。
printf 扫描格式字符串并打印出每个字符，直到遇到“%”。
printf调用 va_arg，它返回 va_list 指向的可选参数并将其推进到下一个参数。
````

## 第 9 页

````text
printf（） 如何访问可选参数
当调用 printf（） 时，将参数顺序推送到堆栈上。
当它扫描并打印格式字符串时，printf（） 将 %d 替换为第一个可选参数中的值并打印出该值。
然后va_list移动到位置 2。
````

## 第 10 页

````text
如果可变参数未提供
va_arg 宏不知道它是否到达了可选参数列表的末尾
它继续从堆栈中获取数据并前进va_list指针
````

## 第 11 页

````text
Format String Vulnerability
如果user_input包含格式说明符会发生什么？
在这三个示例中，用户的输入 （user_input） 成为格式字符串的一部分
````

### 备注区文字

````text
Using format string vulnerability, attackers can overwrite program’s memory and run malicious code. If the vulnerable program is root privileged, the exploit will give root access to the attacker.
````

## 第 12 页

````text
易受攻击的代码
````

### 备注区文字

````text
printf(input) is vulnerable to format string vulnerability as input can contain format specifiers.
````

## 第 13 页

````text
易受攻击的栈
在 printf（） 中，可选参数（va_list指针）的起点是格式字符串参数正上方的位置。
对应printf第一个参数的地址（如果存在）
````

## 第 14 页

````text
我们能实现什么?
攻击 1 ： 崩溃程序
攻击 2 ： 打印堆栈上的数据
攻击 3 ： 更改内存中的程序数据
攻击 4 ： 将程序的数据更改为特定值
攻击 5：  注入恶意代码
````

## 第 15 页

````text
攻击 1 ： 崩溃程序
使用输入：%s%s%s%s%s%s%s%s
printf（） 解析格式字符串。
对于每个 %s，它获取一个值，其中 va_list 指向并前进va_list到下一个位置。
当我们给出 %s 时，printf（） 将该值视为地址并从该地址获取数据。如果该值不是有效地址，则程序崩溃。
````

## 第 16 页

````text
攻击 2 ： 在堆栈上打印出数据
假设堆栈上的一个变量包含一个秘密（常量），我们需要将其打印出来
使用用户输入：%x%x%x%x%x%x%x%x
printf（） 打印出指针指向va_list整数值并将其前进 4 个字节
%x 的数量由va_list指针的起点与变量之间的距离决定。它可以通过反复试验来实现
````

## 第 17 页

````text
攻击 3 ： 更改内存中的程序数据
目标：将 var 变量的值从 0x11223344 更改为其他值
%n：将到目前为止打印出来的字符数写入内存
printf（“hello%n”，&i） ⇒ 当 printf（） 到达 %n 时，它已经打印了 5 个字符，因此它将 5 个字符存储到提供的内存地址中
%n 将va_list指针指向的值视为内存地址并写入该位置
因此，如果我们想将一个值写入内存位置，我们需要在堆栈上有它的地址
````

## 第 18 页

````text
攻击 3 ： 更改内存中的程序数据
var 的地址在输入的开头给出，以便将其存储在堆栈中。
$（command）：命令替换。允许命令的输出替换命令本身。
“\x04”：表示“04”是一个实际数字，而不是两个 ASCII 字符。
假设var的地址为0xbffff304（可以使用gdb获取）
````

### 备注区文字

````text
The input is saved to a file and ask the vulnerable program to get it from the file as we cannot type binary.
````

## 第 19 页

````text
攻击 3 ： 更改内存中的程序数据
var 的地址 （0xbffff304） 在堆栈上。
目标：将va_list指针移动到此位置，然后使用 %n 存储一些值。
%x 用于推进va_list指针。
需要多少 %x？
````

## 第 20 页

````text
攻击 3 ： 更改内存中的程序数据
通过反复试验，我们检查打印0xbffff304需要多少 %x。
这里我们需要 6 个 %x 格式说明符，表示 5 %x 和 1 %n。
攻击发生后，目标地址中的数据被修改为 0x2c（十进制 44）。
因为在 %n 之前已经打印出 44 个字符。
````

## 第 21 页

````text
攻击 4：将程序的数据更改为特定值
目标：将 var 的值从 0x11223344 更改为 0x9896a9
%.8x：精度，控制打印位数。%8x：宽度，不够填空格
printf（） 在 %.10000000x 之前已经打印出 41 个字符，因此，10000000+41 = 10000041 （0x9896a9） 将存储在 0xbffff304 中。
````

### 备注区文字

````text
Precision modifier : Controls the minimum number of digits to print. printf(“%.5d”, 10) prints number 10 with 5 digits: “00010”
Width modifier : printf(“%5d”, 10) prints the number 10 with 3 leading spaces: “- - -10”.
````

## 第 22 页

````text
攻击 4：更快的方法



%n：视参数为4字节
%hn：视参数为2字节
%hhn：视参数为1字节
````

### 备注区文字

````text
%n : Treats argument as a 4-byte integer
%hn : Treats argument as a 2-byte short integer.Overwrites only 2 significant bytes of the argument.
%hhn : Treats argument as a 1-byte char type.Overwrites the least significant byte of the argument.
````

## 第 23 页

````text
攻击 4：更快的方法
目标：将 var 的值更改为 0x66887799
使用 %hn 一次修改两个字节的 var 变量。
将 var 的内存分成两部分，每部分有两个字节。

大多数计算机使用小端架构
2 个最低有效字节 （0x7799） 存储在地址 0xbffff304
2 个有效字节 （0x6688） 存储在 0xbffff306

如果第一个 %hn 获得值 x，并且在下一个 %hn 之前打印 t 个字符，则第二个 %hn 将获得值 x+t。

先写小值，再写大值
````

## 第 24 页

````text
攻击 4：更快的方法
用0x6688覆盖0xbffff306处的字节
再打印一些字符，这样当我们达到0xbffff304时，字符数将增加到 0x7799
 “%.4368x” 打印 @@@@ 位置的变量
````

## 第 25 页

````text
攻击 4：更快的方法
地址 A ： var 地址的第一部分 （ 4 个字符 ）
地址 B ：var 地址的第二部分（4 个字符）
4 %.8x ： 移动va_list到达地址 1（反复试验，4x8=32）
@@@@ ： 4 个字符
5 _ ： 5 个字符
总计 ： 12+5+32 = 49 个字符
````

## 第 26 页

````text
攻击 4：更快的方法
要打印0x6688 （26248），我们需要 26248 - 49 = 26199 个字符作为 %x 的精度字段
将 @@@@ 放在两个地址之间，以便我们可以再插入一个 %x 并将打印的字符数增加到 0x7799。
 在第一个 %hn 之后，va_list指针指向 @@@@，指针将前进到第二个地址。精度字段设置为 4368 =30617 - 26248 -1，以便在到达第二个 %hn 时打印0x7799 （30617）。
````

## 第 27 页

````text
攻击 5：注入恶意代码
目标：修改易受攻击代码的返回地址，让其指向恶意代码（例如，执行 /bin/sh 的 shellcode）。如果易受攻击的代码是 SET-UID 程序，则获取 root 访问权限。
挑战：
在堆栈中注入恶意代码
查找注入代码的起始地址 （A）
查找易受攻击代码的返回地址 （B）
将值 A 写入 B
````

## 第 28 页

````text
攻击 5：注入恶意代码
使用gdb获取恶意代码的返回地址和起始地址。
假设返回地址为 0xbffff38c
假设恶意代码的起始地址为 0xbfff358
目标 ： 写值0xbffff358以寻址0xbffff38c
步骤：
将0xbffff38c分解为两个连续的 2 字节内存位置：0xbffff38c 和 0xbffff38e
将0xbfff存储到0xbffff38e中，将0xf358存储到0xbffff38c中
````

## 第 29 页

````text
攻击 5：注入恶意代码
在第一个 %hn 之前打印的字符数 =
12 + （4x8） + 5 + 49102 = 49151 （0xbfff）。
在第一个 %hn 之后，打印 13144 + 1 =13145
49151 + 13145 = 62296 （0xbffff358） 打印在0xbffff38c上
````

## 第 30 页

````text
对策：程序员
避免在 printf、sprintf、fprintf、vprintf、scanf、vfscanf 等函数中使用不受信任的用户输入来格式化字符串
````

## 第 31 页

````text
对策：编译器
编译器可以检测潜在的格式字符串漏洞
使用两个编译器编译程序：gcc 和 clang。
我们可以看到格式字符串不匹配
````

## 第 32 页

````text
对策：编译器
在默认设置下，两个编译器都会对第一个 printf（） 发出警告
第二次没有发出警告
````

## 第 33 页

````text
对策：编译器
在给出选项 -wformat=2 时，两个编译器都会对两个 printf 语句发出警告，指出格式字符串不是字符串文字
这些警告只是提醒开发人员存在潜在问题，但仍然会编译程序
````

## 第 34 页

````text
应对方法
地址随机化：使攻击者难以猜测目标内存地址的地址（返回地址、恶意代码的地址）
不可执行堆栈/堆：这将不起作用。攻击者可以使用返回 libc 技术来击败对策
StackGuard：这是行不通的。与缓冲区溢出不同，利用格式字符串漏洞，我们可以确保只修改目标内存;其他内存不受影响
````

## 第 35 页

````text
总结
格式字符串的工作原理
格式字符串漏洞
利用漏洞
利用漏洞注入恶意代码
````

## 第 36 页

````text
利用格式化字符串漏洞，攻击结合returntolibc
````
