2020 CSICTF WriteUp

“csictf team” 是印度 VIT 大学（Vellore Institute of Technology）计算机学会（CSI）学生分部所运营的团队

Misc

Gradient sky（图片隐写）

查看字符串拿到 flag

1
2
3
strings sky.jpg

# csictf{j0ker_w4snt_happy}

unseen（通道隐写 + Steghide 隐写 + Whitespace）

对 nyc.png 做 LSB 位平面分析，红色通道第 0 位平面左上角能看到数字

解 morse.wav 的摩斯电码，得到

1
SEARCH-SOMEWHERE-ELSE

这个提示说明还要继续在音频里找隐藏内容。用图片得到的数字作为 steghide 密码

1
steghide extract -sf morse.wav -p 42845193

提取出 flag.txt。该文件表面上是空白，实际是 Whitespace 语言代码，解码后得到 flag

1
csictf{7h47_15_h0w_y0u_c4n_83c0m3_1nv151813}

Panda（ZIP 爆破）

爆破出密码是 2611，提取出两张图片

逐字节比较两张图拿到 flag

1
2
3
4
5
6
7
from pathlib import Path

panda = Path("panda.jpg").read_bytes()
panda1 = Path("panda1.jpg").read_bytes()

flag = ''.join(chr(b) for a, b in zip(panda, panda1) if a != b)
print(flag)
1
csictf{kung_fu_p4nd4}

In Your Eyes（QuickStego + 盲文）

pasted_1784584339653_nvmjj3.png

使用 QuickStego 工具拿到一段十六进制

pasted_1784584412733_1o8sbg.png

再盲文进行解码，即可得到 flag：csictf{ucbr4ill3}

Archenemy（LSB 隐写）

pasted_1784585550840_h3fq93.png

Steghide 在图像中找到了一个嵌入的 flag.zip 文件

爆破密码是 kathmandu，解压得到 flag：csictf{1_h0pe_y0u_don't_s33_m3_here}

Crypto

little RSA（分解 n）

题目给了

1
2
3
c=32949
n=64741
e=42667

分解 n 得到 p，q

1
2
3
4
5
6
7
8
9
10
11
12
13
from Crypto.Util.number import long_to_bytes

c = 32949
n = 64741
e = 42667
p = 101
q = 641

phi = (p - 1) * (q - 1)
d = pow(e, -1, phi)
m = pow(c, d, n)

print("[+] bytes =", long_to_bytes(m))

解出为 18429 解压密码

Rivest Shamir Adleman（分解 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 math import isqrt

n = 408579146706567976063586763758203051093687666875502812646277701560732347095463873824829467529879836457478436098685606552992513164224712398195503564207485938278827523972139196070431397049700119503436522251010430918143933255323117421712000644324381094600257291929523792609421325002527067471808992410166917641057703562860663026873111322556414272297111644069436801401012920448661637616392792337964865050210799542881102709109912849797010633838067759525247734892916438373776477679080154595973530904808231
e = 65537
c = 226582271940094442087193050781730854272200420106419489092394544365159707306164351084355362938310978502945875712496307487367548451311593283589317511213656234433015906518135430048027246548193062845961541375898496150123721180020417232872212026782286711541777491477220762823620612241593367070405349675337889270277102235298455763273194540359004938828819546420083966793260159983751717798236019327334525608143172073795095665271013295322241504491351162010517033995871502259721412160906176911277416194406909

# 已知或爆破得到的小素因子
p = 15485863
q = n // p

assert p * q == n

phi = (p - 1) * (q - 1)

# 求私钥指数 d
d = pow(e, -1, phi)

# RSA 解密
m = pow(c, d, n)

# long -> bytes
msg = m.to_bytes((m.bit_length() + 7) // 8, "big")

print("[+] flag =", msg.decode())

Modern Clueless Child（XOR）

题目给的是

1
52f41f58f51f47f57f49f48f5df46f6ef53f43f57f6cf50f6df53f53f40f58f51f6ef42f56f43f41f5ef5cf4e

按 f 分割得到

1
52 41 58 51 47 57 49 48 5d 46 6e 53 43 57 6c 50 6d 53 53 40 58 51 6e 42 56 43 41 5e 5c 4e

转成 ASCII 得到一段密文

1
RAXQGWIH]FnSCWlPmSS@XQnBVCA^\N

将题目给的 Key 转为 ASCII 字符

1
2
3
'1' = 0x31
'2' = 0x32
'3' = 0x33

然后对密文循环进行 XOR

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
cipher_hex = "52f41f58f51f47f57f49f48f5df46f6ef53f43f57f6cf50f6df53f53f40f58f51f6ef42f56f43f41f5ef5cf4e"
key = "12123"

# 1. 按 f 分隔
parts = cipher_hex.split("f")

# 2. 每一段当成 hex 字节
cipher = bytes(int(x, 16) for x in parts)

# 3. 用 ASCII key 循环 XOR
plain = bytes(
    c ^ ord(key[i % len(key)])
    for i, c in enumerate(cipher)
)

print(plain.decode())

得到 csictf{you_are_a_basic_person}

Quick Math（低指数广播攻击）

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
from math import prod, gcd

# 给定的 RSA 模数与密文（已知 e=3 的广播攻击场景）
n1 = 86812553978993
n2 = 81744303091421
n3 = 83695120256591

c1 = 8875674977048
c2 = 70744354709710
c3 = 29146719498409

ns = [n1, n2, n3]
cs = [c1, c2, c3]

# 检查模数两两互素，确保 CRT 可行
for i in range(len(ns)):
    for j in range(i):
        print(gcd(ns[i], ns[j]))  # 输出应为 1

# ---------- 中国剩余定理 (CRT) ----------
N = prod(ns)  # 所有模数的乘积
x = 0

for c, n in zip(cs, ns):
    Ni = N // n                # 除当前模数外的其他模数乘积
    inv = pow(Ni, -1, n)      # 计算 Ni 在模 n 下的逆元（Python 3.8+ 支持）
    x += c * Ni * inv          # 累加加权值

x %= N  # 得到 x ≡ m^3 (mod N) 的最小非负解，且因为 m^3 < N，整数意义上 x = m^3

# 整数三次方根（二分查找，适用于大整数）
def iroot3(num):
    l, r = 0, num
    while l <= r:
        mid = (l + r) // 2
        v = mid ** 3
        if v == num:
            return mid
        elif v < num:
            l = mid + 1
        else:
            r = mid - 1
    return r  # 若未精确匹配，向下取整（这里必定精确匹配）

m = iroot3(x)  # 恢复出明文

print("m =", m)
print("check:", m ** 3 == x)  # 验证是否成功

Mein Kampf（Enigma M4 参数残缺恢复）

题目给的文件内容核心是

1
2
3
M4 UKW $ Gamma 2 4 $ 5 9 $ 14 3 $ 5 20 fv cd hu ik es op yl wq jm

Ciphertext: zkrtwvvvnrkulxhoywoj

题目描述说：

1
some data was corrupted during transmission

所以里面的 $ 就是传输损坏的字段，需要我们恢复

根据内容基本可以判断是德国 Enigma M4

1
2
3
4
5
6
7
8
M4          -> 四转子 Enigma
UKW $       -> 反射器未知
Gamma       -> 第 4 个薄转子，已知是 Gamma
2 4         -> Gamma 的初始位置 / ring setting
$ 5 9       -> 第 1 个普通转子未知
$ 14 3      -> 第 2 个普通转子未知
$ 5 20      -> 第 3 个普通转子未知
fv cd ...   -> plugboard 插线板

Enigma M4 的薄反射器一般是

1
2
UKW B
UKW C

普通转子可以从 I 到 VIII 里选 3 个，且顺序有影响

1
I II III IV V VI VII VIII

非常小，直接暴力破解即可

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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
from itertools import permutations

ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
A2I = {c: i for i, c in enumerate(ABC)}

# Enigma rotors
ROTORS = {
    "I":    ("EKMFLGDQVZNTOWYHXUSPAIBRCJ", "Q"),
    "II":   ("AJDKSIRUXBLHWTMCQGZNPYFVOE", "E"),
    "III":  ("BDFHJLCPRTXVZNYEIWGAKMUSQO", "V"),
    "IV":   ("ESOVPZJAYQUIRHXLNFTGKDCMWB", "J"),
    "V":    ("VZBRGITYUPSDNHLXAWMJQOFECK", "Z"),
    "VI":   ("JPGVOUMFYQBENHZRDKASXLICTW", "ZM"),
    "VII":  ("NZJHGRCXMYSWBOUFAIVLPEKQDT", "ZM"),
    "VIII": ("FKQHTLXOCBJSPDZRAMEWNIUYGV", "ZM"),

    # M4 thin rotors
    "Beta":  ("LEYJVCNIXWPBQMDRTAKZGFUHOS", ""),
    "Gamma": ("FSOKANUERHMBTIYCWLQPZXVGJD", ""),
}

# M4 thin reflectors
REFLECTORS = {
    "B": "ENKQAUYWJICOPBLMDXZVFTHRGS",
    "C": "RDOBJNTKVEHMLFCWZAXGYIPSUQ",
}

def to_nums(s):
    return [A2I[c] for c in s]

def inverse_wiring(wiring):
    inv = [0] * 26
    for i, c in enumerate(wiring):
        inv[A2I[c]] = i
    return inv

ROTOR_FWD = {name: to_nums(wiring) for name, (wiring, _) in ROTORS.items()}
ROTOR_REV = {name: inverse_wiring(wiring) for name, (wiring, _) in ROTORS.items()}
NOTCHES = {name: {A2I[c] for c in notch} for name, (_, notch) in ROTORS.items()}
REFLECTOR_MAP = {name: to_nums(wiring) for name, wiring in REFLECTORS.items()}

def build_plugboard(pairs):
    plug = list(range(26))
    for pair in pairs:
        a, b = A2I[pair[0]], A2I[pair[1]]
        plug[a], plug[b] = plug[b], plug[a]
    return plug

def step_rotors(names, pos):
    """
    names = [thin, left, middle, right]
    M4 的 thin rotor，也就是 Gamma/Beta，不参与转动。
    """
    left = names[1]
    middle = names[2]
    right = names[3]

    # double stepping
    if pos[2] in NOTCHES[middle]:
        pos[1] = (pos[1] + 1) % 26
        pos[2] = (pos[2] + 1) % 26
    elif pos[3] in NOTCHES[right]:
        pos[2] = (pos[2] + 1) % 26

    pos[3] = (pos[3] + 1) % 26

def pass_rotor_forward(c, rotor_name, ring, pos):
    offset = (pos - ring) % 26
    return (ROTOR_FWD[rotor_name][(c + offset) % 26] - offset) % 26

def pass_rotor_backward(c, rotor_name, ring, pos):
    offset = (pos - ring) % 26
    return (ROTOR_REV[rotor_name][(c + offset) % 26] - offset) % 26

def enigma_decrypt(ciphertext, reflector, rotor_names, rings, positions, plugboard):
    pos = positions[:]
    result = []

    for ch in ciphertext:
        if ch not in ABC:
            continue

        step_rotors(rotor_names, pos)

        c = A2I[ch]

        # plugboard in
        c = plugboard[c]

        # right -> left, including thin rotor
        for i in [3, 2, 1, 0]:
            c = pass_rotor_forward(c, rotor_names[i], rings[i], pos[i])

        # reflector
        c = REFLECTOR_MAP[reflector][c]

        # left -> right
        for i in [0, 1, 2, 3]:
            c = pass_rotor_backward(c, rotor_names[i], rings[i], pos[i])

        # plugboard out
        c = plugboard[c]

        result.append(ABC[c])

    return "".join(result)

ciphertext = "zkrtwvvvnrkulxhoywoj".upper()
plug_pairs = "fv cd hu ik es op yl wq jm".upper().split()
plugboard = build_plugboard(plug_pairs)

# 原题参数：
# M4 UKW $ Gamma 2 4 $ 5 9 $ 14 3 $ 5 20
#
# 这里的数字按 position / ring 理解：
# Gamma position=2 ring=4
# ?     position=5 ring=9
# ?     position=14 ring=3
# ?     position=5 ring=20

positions = [2 - 1, 5 - 1, 14 - 1, 5 - 1]
rings     = [4 - 1, 9 - 1, 3 - 1, 20 - 1]

normal_rotors = ["I", "II", "III", "IV", "V", "VI", "VII", "VIII"]

for reflector in ["B", "C"]:
    for r1, r2, r3 in permutations(normal_rotors, 3):
        rotor_names = ["Gamma", r1, r2, r3]

        plaintext = enigma_decrypt(
            ciphertext,
            reflector,
            rotor_names,
            rings,
            positions,
            plugboard
        )

        if plaintext.startswith("CSICTF"):
            print("[+] Found!")
            print("Reflector:", "UKW", reflector)
            print("Rotors:", rotor_names)
            print("Plaintext:", plaintext)

            msg = plaintext.replace("CSICTF", "")
            flag = "csictf{" + "_".join(
                [msg[:2].lower(), msg[2:6].lower(), msg[6:].lower()]
            ) + "}"

            print("Flag:", flag)

得到 flag：csictf{no_shit_sherlock}

The Climb（希尔密码）

theclimb.java 里核心逻辑是矩阵加密，这是典型的希尔密码

1
2
rmatrix[i] += kmatrix[i][j] * tmatrix[j];
rmatrix[i] %= 26;

源码里给了 key:gybnqkurp

长度是 9，所以是 3×3 矩阵

1
2
3
g y b
n q k
u r p

转换成数字，也就是 a=0, b=1, ..., z=25

1
2
3
4
5
K = [
  [6, 24, 1],
  [13, 16, 10],
  [20, 17, 15]
]

因为源码是加密程序，所以我们要反过来做解密

1
2
C = K × P mod 26
P = K^-1 × C mod 26

求出矩阵 K 在模 26 下的逆矩阵

1
2
3
4
5
K^-1 = [
  [8, 5, 10],
  [21, 8, 21],
  [21, 12, 8]
]

然后把密文每 3 个字符一组解密，解出来是

1
hillshaveeyesxx

最后的 xx 是源码里自动补齐分组长度时加的 padding

得到 flag

1
csictf{hillshaveeyes}

Reverse

Esrever（算法破解）

esrever.py 里有四个加密函数

1
2
3
4
enc1(text)      # 随机 Caesar 偏移
enc2(text,key)  # XOR
enc3(text)      # 字符位置置换
enc4(text)      # 字符位置置换

加密流程是

1
2
Encrypted Key  = enc4(enc4(encryptedKey))
Encrypted Text = enc3(enc3(enc2(enc1(encryptedText), key)))

所以解密时要完全倒过来

1
2
Encrypted Key  -> inv_enc4 -> inv_enc4 -> 爆破 enc1 得到 key
Encrypted Text -> inv_enc3 -> inv_enc3 -> inv_enc2 -> 爆破 enc1 得到 flag
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
from string import ascii_lowercase

encrypted_key = "ieluvnvfgvfahuxhvfphbppnbgrfcrn"

encrypted_text = ''.join(map(chr, [
    187, 183, 173, 170, 187, 163, 181, 177, 172, 165,
    188, 177, 186, 181, 177, 191, 183, 163, 166, 173,
    180, 175, 170, 168, 165, 171, 165, 166, 171, 180,
    184, 166, 161, 184, 162, 178, 167, 164, 166, 166,
    185, 168
]))

mapping3 = [
    28, 33, 6, 17, 7, 41, 27, 29, 31, 30, 39, 21,
    34, 15, 3, 5, 13, 10, 19, 38, 40, 14, 26, 25,
    32, 0, 36, 8, 18, 4, 1, 11, 24, 2, 37, 20,
    23, 35, 22, 12, 16, 9
]

mapping4 = [
    23, 9, 5, 6, 22, 28, 25, 30, 15, 8, 16, 19,
    24, 11, 10, 7, 2, 14, 18, 1, 29, 21, 12, 4,
    20, 0, 26, 13, 17, 3, 27
]

def inv_enc3(text):
    """
    enc3:
        temp[mapping[i]] = text[i]
    所以反过来：
        original[i] = cipher[mapping[i]]
    """
    temp = [""] * len(text)
    for i, m in enumerate(mapping3):
        temp[i] = text[m]
    return ''.join(temp)

def inv_enc4(text):
    """
    enc4:
        temp[i] = text[mapping[i]]
    所以反过来：
        original[mapping[i]] = cipher[i]
    """
    temp = [""] * len(text)
    for i, m in enumerate(mapping4):
        temp[m] = text[i]
    return ''.join(temp)

def inv_enc1(text, r):
    """
    enc1 是：
        ((ord(i) - ord('a') - r) % 26) + ord('a')
    反过来就是 +r。
    """
    return ''.join(chr((ord(c) - 97 + r) % 26 + 97) for c in text)

def inv_enc2(text, key):
    """
    注意源码里这一句：
        chr(ord(text[i]) ^ ord(k[i]) + ord('a'))

    Python 中 + 优先级高于 ^，
    所以实际是：
        ord(text[i]) ^ (ord(k[i]) + ord('a'))

    XOR 自反，所以解密再 XOR 一次即可。
    """
    out = []
    for i, c in enumerate(text):
        k = key[i % len(key)]
        out.append(chr(ord(c) ^ (ord(k) + ord('a'))))
    return ''.join(out)

# 1. 先还原 encryptedKey
key_stage = inv_enc4(inv_enc4(encrypted_key))
print("[+] key after inverse enc4:", key_stage)

# encryptedKey 本质是 enc1(key)，enc1 是 Caesar，爆破 1~25
possible_keys = []
for r in range(1, 26):
    key = inv_enc1(key_stage, r)
    possible_keys.append(key)

# 2. 先还原 encryptedText 的 enc3 两层
text_stage = inv_enc3(inv_enc3(encrypted_text))

# 3. 枚举 key，再反 XOR，再枚举 Caesar
for key in possible_keys:
    mid = inv_enc2(text_stage, key)

    # 反 XOR 后应该全是小写字母
    if not all(c in ascii_lowercase for c in mid):
        continue

    for r in range(26):
        candidate = inv_enc1(mid, r)

        # enc1 会把 { 和 } 也压成小写字母
        # 所以真实 csictf{...} 会变成类似 csictfa...c
        if candidate.startswith("csictfa") and candidate.endswith("c"):
            body = candidate[len("csictfa"):-1]
            flag = "csictf{" + body + "}"

            print("[+] key =", key)
            print("[+] raw candidate =", candidate)
            print("[+] flag =", flag)

因为 enc1 会把 { 和 } 也映射成小写字母

在对应 Caesar 偏移下

1
2
{ -> a
} -> c

所以得到 flag

1
2
3
csictfaesreverisjustreverseinreverserightc

csictf{esreverisjustreverseinreverseright}

pydis2ctf（Python 反汇编）

C1cipher.txt 里面核心反汇编是

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
LOAD_CONST               1 ('')
STORE_FAST               1 (ret_text)

FOR_ITER
STORE_FAST               2 (i)

LOAD_FAST                1 (ret_text)
LOAD_GLOBAL              2 (chr)
LOAD_CONST               2 (2)
LOAD_GLOBAL              3 (ord)
LOAD_FAST                2 (i)
CALL_FUNCTION            1
BINARY_MULTIPLY
LOAD_GLOBAL              4 (len)
LOAD_FAST                0 (text)
CALL_FUNCTION            1
BINARY_SUBTRACT
CALL_FUNCTION            1
INPLACE_ADD
STORE_FAST               1 (ret_text)

翻译成看的 Python 代码就是

1
2
3
4
5
6
def C1(text):
    ret_text = ""
    for i in list(text):
        counter = text.count(i)  # 这个变量其实没用
        ret_text += chr(2 * ord(i) - len(text))
    return ret_text

所以 C1 的加密公式是

1
cipher_char = chr(2 * ord(plain_char) - len(text))

反过来就是

1
plain_char = chr((ord(cipher_char) + len(text)) / 2)

C2cipher.txt 还原出来是

1
2
3
4
5
6
7
8
9
10
11
12
def C2(inpString):
    xorKey = "S"
    length = len(inpString)

    for i in range(length):
        inpString = (
            inpString[:i]
            + chr(ord(inpString[i]) ^ ord(xorKey))
            + inpString[i + 1:]
        )

    return inpString

也就是每个字符和 'S' 异或

但是实际解题时，对 encodedflag.txt 直接反 C1 就能得到 flag；C2 更像是干扰项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import ast

with open("encodedflag.txt", "r", encoding="utf-8") as f:
    data = f.read().strip()

cipher = ast.literal_eval(data)

n = len(cipher)

flag = ""
for c in cipher:
    v = ord(c) + n

    # 正常情况下 v 应该能被 2 整除
    if v % 2 != 0:
        print("[-] Invalid character:", repr(c))

    flag += chr(v // 2)

print(flag)

得到 flag：csictf{T#a+_wA5_g0oD_d155aSe^^bLy}

Scrambled Eggs（算法破解）

pasted_1784649268286_59arwm.png

flag 预处理如下

1
2
3
flag=flag.replace('{','a')
flag=flag.replace('}','a')
flag=flag.replace('_','b')

第一层加密是循环左移，sys.maxsize 是 Python 中一个系统相关的常量，表示当前 Python 解释器所能支持的最大整数索引值

64 位系统上通常等于 2 ^ 63 - 1，再 % 28 就等于 7 了，所以范围是 0~7，可枚举

1
2
3
def enc1(text):
    n=random.randint(0,sys.maxsize%28)
    return text[n:]+text[:n]

源码中

1
2
3
4
5
key1 = 'ashikka_is_mine'
key1 = key1.replace('_','b')

if(len(flag) != 28 or len(key1) != 14):
    exit()

但 ashikka_is_mine 长度是 15，替换 _ 并不会改变长度，所以源码中的 key1 是假的，真正的 key1 要从密文中恢复

key2 完全由 key1 决定

1
key2 = enc2(enc2(key1))

xtfsyhhlizoiyx 有可能是 key1，也有可能是 key2，因为：

1
2
# 从列表 [key1, key2] 中随机抽取 2 个元素，并以随机顺序返回，实际上就是随机打乱 key1 和 key2 的顺序
random.sample([key1,key2],2)

附件中给出了 key2 是 eudlqgluduggdluqmocgyukhbqkx，源码中 key2 是前 14 位随机和后 14 位真实 key2 混合

1
2
3
key2 = k + key2                     # 将随机字符串 k (14位) 拼到 key2 前面
# 然后对 key2 的后14位进行了基于 k 的加法扰乱
key2 = enc2(key2)                   # 最后再用 enc2 做字符映射

enc2 的规则是：map[字母序] → 映射字符

1
2
3
4
5
def enc2(text):
    temp = ''
    for i in text:
        temp += map[ord(i) - ord('a')] # 计算这个字母是字母表里第几个，i='a' -> index = 97-97 = 0
    return temp

逆向得到 xpsotfopspffsoptmihfvpyqjtyw

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
MAP = "vrtpwgncobafmiluhzdqjyxeks"


def dec2(s):
    inv = {}

    # enumerate 用来同时获取列表中的索引和元素
    for i,c in enumerate(MAP):
        inv[c] = chr(ord('a') + i) # 例如 'v'→'a', 'r'→'b'

    # 遍历字符串 s 的每一个字符，查出对应的原始字母，然后连成一串，返回结果
    return ''.join(inv[x] for x in s)

enc_key2 = "eudlqgluduggdluqmocgyukhbqkx"

print(dec2(enc_key2))
1
2
3
4
k：xpsotfopspffso


混合 key2：ptmihfvpyqjtyw

源码中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 生成 14 位随机字符串 k
k = ''.join(random.choice(map) for _ in range(14))

# 将 k 拼接在 key2 前面，此时 key2 长度为 28
key2 = k + key2

# 对后 14 位进行加法扰乱
for i in range(14):
    # k[i] 的字母序号 (0~25) + 原 key2[i] 的 ASCII 码
    a = ord(k[i]) - ord('a') + ord(key2[i+14])
    if a > 122:          # 超出小写字母范围时
        a = a % 122      # 对 122 取模
        a = a + 97       # 回到小写字母区间
    key2[i+14] = chr(a)  # 覆盖原字符

因为 k 只有 14 位，而 key2 原字符也一定在 a~z 范围内，所以我们可以穷举所有可能的原字符：

  • 对每个位置 i：

    • 取已知的 k[i]（通过之前的逆 enc2 拆解得到）

    • 枚举 26 个字母 c ∈ a~z

    • 用加密公式计算出混合后的字符

    • 再次应用 enc2 映射（因为加密最后还有一次 enc2）

    • 检查是否与最终密文 key2 对应位置的字符一致

  • 筛选出所有匹配的候选

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
from itertools import product
import string

# 映射表
MAP = "vrtpwgncobafmiluhzdqjyxeks"

# 题目给出的加密后的 key2（经过 enc2 和 k 混合的结果）
encrypted_key2 = "eudlqgluduggdluqmocgyukhbqkx"


def dec2(s):
    """
    enc2 的逆操作：
    将 MAP 中的字符映射回字母 a~z
    """
    inv = {}
    # 构建逆映射表：MAP 字符 -> 原字母
    for i, c in enumerate(MAP):
        inv[c] = chr(ord('a') + i)

    # 逐字符还原
    return ''.join(inv[x] for x in s)


def mix(k, c):
    """
    模拟加密中的混合操作：
    将密钥字符 k 的字母序号与明文 c 的 ASCII 码相加，
    若结果超出小写字母范围则进行取模回绕。
    对应源码中的：
      a = ord(k)-ord('a') + ord(c)
      if a>122: a = a%122 + 97
      return chr(a)
    """
    a = ord(k) - ord('a') + ord(c)
    if a > 122:
        a = a % 122
        a += 97
    return chr(a)


def recover_key2(enc):
    """
    从加密后的 key2 恢复原始 key2 的候选列表
    """
    # 第一步：逆 enc2，得到 (k + 混合后的 key2) 的原始字母形式
    raw = dec2(enc)
    print("[+] after dec2:")
    print(raw)

    # 前 14 位是随机生成的字符串 k
    k = raw[:14]
    # 后 14 位是经过 mix 扰乱后的 key2
    mixed = raw[14:]

    print("[+] k:")
    print(k)
    print("[+] mixed:")
    print(mixed)

    candidates = []
    # 对后 14 位的每个位置，枚举所有可能的小写字母
    possible = []
    for i in range(14):
        tmp = []
        for c in string.ascii_lowercase:
            # 用当前枚举的字符 c 重新计算混合结果，与 mixed 比对
            if mix(k[i], c) == mixed[i]:
                tmp.append(c)
        possible.append(tmp)

    print("\n[+] each position possible:")
    for i, x in enumerate(possible):
        print(i, x)

    # 笛卡尔积组合所有可能字符，生成完整 key2 候选列表
    for x in product(*possible):
        candidates.append(''.join(x))

    return candidates


# 恢复 key2 的所有可能值
keys = recover_key2(encrypted_key2)

print("\n[+] candidates:")
for k in keys:
    print(k)

运行后得到四组结果

1
2
3
4
5
[+] candidates:
rettnahagbeogi
rettnahzgbeogi
rettnzhagbeogi
rettnzhzgbeogi

我们之前恢复出的 key2 实际上是加密流程中间状态的 key2

在生成最终 key2 前，key1/key2 已经经过了两轮交换

因此，现在得到的是交换后的 key2

核心加密流程如下

1
2
3
4
5
6
7
8
9
10
11
12
13
# 用 key1 和 key2 的字母值作为索引，交叉交换 flag 和密钥的字符位置，打乱顺序
# 示例：若 key1[0]='c'，其序号=2，则 flag[0] 与 flag[2] 交换
for j in range(2):

    # 前 14 个字符：用 key1 打乱 flag，用 key2 打乱 key1
    for i in range(14):
        flag[i], flag[(ord(key1[i])-97)%28] = flag[(ord(key1[i])-97)%28], flag[i]
        key1[i], key1[(ord(key2[i])-97)%14] = key1[(ord(key2[i])-97)%14], key1[i]

    # 后 14 个字符：用 key2 打乱 flag，用 key1 打乱 key2
    for i in range(14,28):
        flag[i], flag[(ord(key2[i-14])-97)%28] = flag[(ord(key2[i-14])-97)%28], flag[i]
        key2[i-14], key2[(ord(key1[i-14])-97)%14] = key2[(ord(key1[i-14])-97)%14], key2[i-14]

编写解密脚本

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
MAP = "vrtpwgncobafmiluhzdqjyxeks"

def enc2(text):
    """正向替换：每个字母变成表中对应字符"""
    return ''.join(MAP[ord(c)-97] for c in text)

def dec2(text):
    """逆向替换：把表中字符变回原字母"""
    # 构造反向表：'v'→'a', 'r'→'b', ...
    inv = {c: chr(97+i) for i,c in enumerate(MAP)}
    return ''.join(inv[c] for c in text)

OUTPUT = "xtfsyhhlizoiyx"

# 从混合步骤恢复出来的 key2 候选（4个）
CANDIDATES = [
    "rettnahagbeogi",
    "rettnahzgbeogi",
    "rettnzhagbeogi",
    "rettnzhzgbeogi"
]

def undo_swaps(k1, k2):
    """
    逆向执行“双重交叉置换”。
    
    源码里对 key1 和 key2 做了两轮相互打乱：
    - 第一轮用 key1[i] 打乱 key1 自身（前半），用 key2[i] 打乱 key2 自身（后半）
    - 第二轮重复一次
    
    因为交换是 "对称操作"（a 和 b 交换，再交换一次就还原），
    逆向时只需把操作顺序完全反过来即可。
    """
    k1, k2 = list(k1), list(k2)
    
    # 总共两轮，原代码正向两轮，我们逆向两轮
    for _ in range(2):
        # ---------- 逆后半交换 ----------
        # 原加密：for i in range(14,28): key2[i-14] 和 key2[(key1[i-14]的字母序)%14] 交换
        # 逆：从后往前做相同的交换
        for i in range(27, 13, -1):
            idx = i - 14               # 0~13
            # 交换位置由 key1[idx] 决定
            pos = (ord(k1[idx]) - 97) % 14
            k2[idx], k2[pos] = k2[pos], k2[idx]
        
        # ---------- 逆前半交换 ----------
        # 原加密：for i in range(14): key1[i] 和 key1[(key2[i]的字母序)%14] 交换
        # 逆：从后往前
        for i in range(13, -1, -1):
            # 交换位置由 key2[i] 决定
            pos = (ord(k2[i]) - 97) % 14
            k1[i], k1[pos] = k1[pos], k1[i]
    
    return ''.join(k1), ''.join(k2)

for cand in CANDIDATES:
    # 两种可能：OUTPUT 是 key1，cand 是 key2；或者反过来
    for try_k1, try_k2 in [(OUTPUT, cand), (cand, OUTPUT)]:
        # 撤销交换得到原始 key1, key2
        orig_k1, orig_k2 = undo_swaps(try_k1, try_k2)
        # 验证原始关系：key2 = enc2(enc2(key1))
        if enc2(enc2(orig_k1)) == orig_k2:
            print(f"Found!\nkey1 = {orig_k1}\nkey2 = {orig_k2}")
            # 成功后就结束
            exit()

pasted_1784656431579_ahj8jj.png

flag 的加密过程是 flag = enc1(enc1(enc1(enc2(flag))))

附件中的 flag 是 lvvrafwgtocdrdzfdqotiwvrcqnd

通过前面的解题脚本恢复为 oaabklefcihsbsrlsticneabhtgs

然后是枚举移位

1
2
3
4
5
6
7
8
9
10
11
def ror(s, n):
    n %= len(s)          # 防止 n 超过长度，0 <= n < len(s)
    return s[-n:] + s[:-n]

flag_stage1 = "oaabklefcihsbsrlsticneabhtgs"

# 原始加密中 flag 经历了三次 enc1（每次随机右移 0~7 位），
# 三次累计最大右移量 = 7+7+7 = 21，所以只需尝试 0~21 共 22 种可能
for n in range(22):
    tmp = ror(flag_stage1, n)   # 尝试右移 n 位进行还原
    print(n, tmp)

第 11 次得到 csictfaallbthebkingsbhorsesa，但它仍然经过了交换处理，继续编写解密脚本

恢复 flag 时必须逆向整个交叉置换过程，同步恢复 key1/key2 的中间状态，而不能直接用最终的 key 去解 flag

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
def undo_all(flag, key1, key2):
    """
    同步逆向双重交叉置换，同时恢复 flag、key1、key2 的原始值
    加密时 flag 的交换与 key1/key2 的交换是交替进行的，
    所以解密时不能分开处理，必须在这里一起还原
    """
    flag = list(flag)
    key1 = list(key1)
    key2 = list(key2)

    # 逆向两轮，每轮内部顺序与加密相反
    for _ in range(2):
        # ---------- 逆后半交换（i=14..27） ----------
        for i in range(27, 13, -1):
            idx = i - 14

            # 先恢复 key2 的交换（原操作：key2[idx] ↔ key2[(key1[idx]的序号)%14]）
            pos = (ord(key1[idx]) - 97) % 14
            key2[idx], key2[pos] = key2[pos], key2[idx]

            # 再恢复 flag 的交换（原操作：flag[i] ↔ flag[(key2[idx]的序号)%28]）
            pos = (ord(key2[idx]) - 97) % 28
            flag[i], flag[pos] = flag[pos], flag[i]

        # ---------- 逆前半交换（i=0..13） ----------
        for i in range(13, -1, -1):
            # 先恢复 key1 的交换（原操作：key1[i] ↔ key1[(key2[i]的序号)%14]）
            pos = (ord(key2[i]) - 97) % 14
            key1[i], key1[pos] = key1[pos], key1[i]

            # 再恢复 flag 的交换（原操作：flag[i] ↔ flag[(key1[i]的序号)%28]）
            pos = (ord(key1[i]) - 97) % 28
            flag[i], flag[pos] = flag[pos], flag[i]

    return ''.join(flag), ''.join(key1), ''.join(key2)


flag, key1, key2 = undo_all(
    "csictfaallbthebkingsbhorsesa",
    "togetherbagain",
    "hfixhtxszyiylo"
)
print(flag)

得到 csictfaallbthebkingsbhorsesa

源码最开始有对 flag 进行预处理

1
2
3
flag.replace('{','a')
flag.replace('}','a')
flag.replace('_','b')

最终 flag 是 csictf{all_the_kings_horses}