A “Simple” pyc

The challenge is a single compiled prob.pyc. First problem: it was built with a very recent CPython, and most decompilers choke on it. pycdc plus a couple of online tools got most of the source back, and at a glance it looks trivial:

key = [239, 88, 97, 17, ...]
k   = [161, 55, 37, 106, ...]

def chk(ipt):
    # ... a bunch of dead assignments (r0..r5) ...
    res = []
    for i, j in zip(list(ipt), key):
        res.append(i ^ j)
    return bytes(res)

ipt = input().encode()

chk seems to just XOR the input with key, and success requires chk(ipt) == bytes(k). So the “flag” is k[i] ^ key[i], right?

flag = bytes(a ^ b for a, b in zip(k, key))
# b'NoD{No!_Th15_1s_N0t_Fl4G_Y0U_n33d_t0_rev_more!@#}'

NoD{No!_Th15_1s_N0t_Fl4G_Y0U_n33d_t0_rev_more!@#}: a taunt. The visible chk is a decoy.

The Trap: Self-Modifying Bytecode

The real logic is hidden in throw(), which never looks like it matters, but it rewrites chk at runtime using ctypes:

def throw():
    ptr1 = (ctypes.c_char * len(m)).from_address(id(chk.__code__.co_code) + 32)
    res = []
    for i, j in zip(ptr1.raw, m):
        res.append(i ^ j)
    ptr1.raw = bytes(res)              # XOR chk's real bytecode with m, in place
    if chk(ipt) == bytes(k):
        print(chk.__code__.co_consts[8])
    # ... XOR back to restore ...

try:
    if ipt.find('GoN{') != -1 and chk(ipt) == bytes(k):
        print('Good!')
except:
    throw()

The co_code of a code object is a bytes blob of raw bytecode. from_address(id(chk.__code__.co_code) + 32) reaches into that object’s internal buffer and XORs it with the array m. In other words, the chk that actually runs is not the chk we decompiled. Right before the real comparison, its bytecode is patched into a completely different function. The decompiler only ever saw the pre-patch version.

Recovering the Real chk

The plan is to reproduce the patch offline: take the original chk bytecode, XOR it with m, and disassemble the result. The only fiddly part is figuring out where inside co_code the patch actually begins.

Once the offset lines up, XOR-ing the bytecode with m and disassembling gives readable instructions:

m = [0, 0, 16, 0, 255, 1, 254, 0, ...]
bytecode = bytes.fromhex("74 00 64 01 83 01 7D 01 ...")   # original chk co_code
patched  = bytes(b ^ m[i] if i < len(m) else b
                 for i, b in enumerate(bytecode))

Disassembling patched reveals the genuine algorithm: a rolling 32-bit transform over the input, sliding a 4-byte window and applying a rotate and an XOR with 0xDEADBEEF:

def chk(ipt):                     # the REAL check, reconstructed
    for i in range(len(ipt) - 3):
        r0 = int.from_bytes(ipt[i:i+4], 'little')
        rotated = ((r0 >> ((i + 16) % 32)) | (r0 << ((-i + 16) % 32))) & 0xFFFFFFFF
        ipt = ipt[:i] + (rotated ^ 0xDEADBEEF).to_bytes(4, 'little') + ipt[i+4:]
    return ipt

The constants that looked like dead code in the decompiled chk (16, 32, 0xFFFFFFFF, 0xDEADBEEF) were the real transform’s parameters all along.

Inverting the Transform

chk mutates the buffer forward, block by block, so the inverse walks backward from the last window, undoing the XOR and the rotation at each step:

k = [161, 55, 37, 106, 136, 128, 88, 143, ...]

def reverse_chk(output):
    result = bytearray(output)
    for i in range(len(output) - 4, -1, -1):        # reverse order
        cur = int.from_bytes(result[i:i+4], 'little')
        unxored = cur ^ 0xDEADBEEF                   # XOR is its own inverse
        s = (i + 16) % 32
        original = ((unxored << s) | (unxored >> (32 - s))) & 0xFFFFFFFF  # rotate back
        result[i:i+4] = original.to_bytes(4, 'little')
    return result

print(reverse_chk(bytes(k)).decode())

GoN{REDACTED}

Takeaways

The whole challenge is a lesson in not trusting the decompiler’s output. Static analysis showed a plain XOR and even handed over a fake flag to reward a shallow read. The actual check only exists for a few microseconds at runtime, materialized by XOR-patching a code object’s raw bytecode through ctypes.

Two habits beat it: reading every function (the “irrelevant” throw was the entire point), and reconstructing the patched code the same way the program does instead of trusting the source you can see. Once the real chk is out (a rotate + 0xDEADBEEF XOR sliding over the input), inverting it is routine.