1
1. Public Key Analysis
2
    Encoding: Base64 (NOT encryption!)
3
    Decoded: 24.07.2025|megacorp@quantum.com
4
    Purpose: Static seed component
5

6
2. Seed Calculation
7
    Components: Email + Date + Timestamp + "PublicSalt"
8
    Weakness: Hardcoded salt, no KDF
9
    Vulnerability: Predictable seed generation
10

11
3. Transformation Pipeline
12
    7 distinct layers before XOR
13
    Ring rotation  Add  Subtract  Cyclic shifts
14
       Quadrant swaps  Bit-pair swap  Variable rotation
15
    All reversible through binary analysis
16

17
4. Successful Decryption
18
    Keystream: (char * 7 + index) & 0xFF
19
    Flag extracted: OS{BENDER}
20
    System: BROKEN

1
def keystream(seed, need):
2
    out = bytearray()
3
    idx = 0
4
    while len(out) < need:
5
        for ch in seed:
6
            out.append((ord(ch) * 7 + idx) & 0xFF)
7
            idx += 1
8
    return bytes(out)

1
#!/usr/bin/env python3
2
from pathlib import Path
3
from collections import deque
4

5
EMAIL = "megacorp@quantum.com"
6
DATE = "24.07.2025"
7
SALT = "PublicSalt"
8
FILE = Path("decrypt_me.txt.enc")
9

10
def rot_right(x, amt):
11
    amt &= 7
12
    return ((x >> amt) | ((x << (8 - amt)) & 0xFF)) & 0xFF
13

14
def bit_flip_pairs(x):
15
    return ((x >> 1) & 0x55) | ((x & 0x55) << 1)
16

17
def keystream(seed, need):
18
    out = bytearray()
19
    idx = 0
20
    while len(out) < need:
21
        for ch in seed:
22
            out.append((ord(ch) * 7 + idx) & 0xFF)
23
            idx += 1
24
            if len(out) >= need:
25
                break
26
    return bytes(out)
27

28
def decode(path):
29
    data = path.read_bytes()
30
    ts_len = int.from_bytes(data[-8:-4], "little")
31
    n = int.from_bytes(data[-4:], "little")
32
    timestamp = data[-8 - ts_len:-8].decode("ascii")
33
    block = data[:n * n]
34

35
    seed = EMAIL + DATE + timestamp + SALT
36
    mask = keystream(seed, len(block))
37
    raw = bytes(b ^ m for b, m in zip(block, mask))
38

39
    grid = [list(raw[i * n:(i + 1) * n]) for i in range(n)]
40
    year, month, day = 2025, 7, 24
41

42
    # Reverse transform 7: Variable rotation
43
    for r in range(n):
44
        for c in range(n):
45
            spin = (year + month + day + r + c) & 7
46
            if spin:
47
                grid[r][c] = rot_right(grid[r][c], spin)
48

49
    # Reverse transform 6: Bit-pair swap
50
    for r in range(n):
51
        for c in range(n):
52
            grid[r][c] = bit_flip_pairs(grid[r][c])
53

54
    # Reverse transform 4: Cyclic shifts
55
    shift = day % n
56
    if shift:
57
        rows = deque(grid)
58
        rows.rotate(-shift)
59
        grid = [list(row) for row in rows]
60
        for r in range(n):
61
            row = deque(grid[r])
62
            row.rotate(-shift)
63
            grid[r] = list(row)
64

65
    # Reverse transforms 3 & 2: Subtract & Add
66
    add_val = year & 0xFF
67
    sub_val = month
68
    for r in range(n):
69
        for c in range(n):
70
            v = grid[r][c]
71
            v = (v + sub_val) & 0xFF
72
            v = (v - add_val) & 0xFF
73
            grid[r][c] = v
74

75
    # Reverse transform 1: Ring rotation (via column reading)
76
    buf = bytearray()
77
    for c in range(n):
78
        for r in range(n - 1, -1, -1):
79
            b = grid[r][c]
80
            if b:
81
                buf.append(b)
82

83
    text = buf.decode("utf-8")
84
    flag = text[text.index("{"):text.index("}") + 1]
85
    return text, flag
86

87
if __name__ == "__main__":
88
    poem, flag = decode(FILE)
89
    print(poem)
90
    print('\nFLAG:', flag)