EHAX CTF 2026 - i guess bro - Reverse Engineering Writeup

Category: Reverse Engineering

Flag: EH4X{y0u_gu3ss3d_th4t_r1sc_cr4ckm3}

Challenge Description#

meh yet another crackme challenge

Analysis#

1
file "chall"

1
chall: ELF 64-bit LSB executable, UCB RISC-V, RVC, double-float ABI, version 1 (SYSV), statically linked, ... stripped

1
checksec "chall"

1
Arch:       riscv64-64-little
2
RELRO:      Partial RELRO
3
Stack:      No canary found
4
NX:         NX enabled
5
PIE:        No PIE (0x10000)

The first pass showed a static, stripped RISC-V binary. Since qemu-riscv64 was not present in this environment, I treated it as a static reversing problem and leaned on r2 decompilation plus constant extraction instead of runtime execution.

1
strings -a "chall" | rg -i "I Guess Bro|Wrong length|Correct!|Flag: %s|EH4X\{"

1
'I Guess Bro' - Hard Mode
2
Wrong length! Keep guessing...
3
Correct! You guessed it!
4
Flag: %s
5
EH4X{n0t_th3_r34l_fl4g}
6
EH4X{try_h4rd3r_buddy}

Seeing two ready-made EH4X{...} candidates this early looked suspicious, and the challenge style screamed decoy checks.

1
r2 -e scr.color=0 -A -q -c "s 0x1037e; af; pdg" "chall" | rg "fcn.00010732|Wrong length|Correct!|Flag: %s|== 0x23|Input error"

1
fcn.000151c4("Input error!");
2
if (iVar1 == 0x23) {
3
    iVar1 = fcn.00010732(auStack_90);
4
        fcn.000151c4("\n🎉 Correct! You guessed it!\n");
5
        fcn.000110d4("Flag: %s\n",auStack_90);
6
    fcn.000151c4("Wrong length! Keep guessing...");

1
r2 -e scr.color=0 -A -q -c "s 0x10732; af; pdg" "chall" | rg "n0t_th3_r34l_fl4g|try_h4rd3r_buddy|Debugger detected|0xc351|fcn.000105cc|fcn.00010622|fcn.00010574|0x1fb53791|0xcab|-0x7e30f90b5f734a11"

1
iVar1 = fcn.0001eaf0(param_1,"EH4X{n0t_th3_r34l_fl4g}");
2
iVar1 = fcn.0001eaf0(param_1,"EH4X{try_h4rd3r_buddy}");
3
if (iVar2 - iVar1 < 0xc351) {
4
    iVar1 = fcn.000105cc(param_1);
5
    if ((iVar1 != 0) && (iVar1 = fcn.00010622(param_1), iVar1 != 0)) {
6
        iVar1 = fcn.00010574(param_1,0x23);
7
        return iVar1 == -0x7e30f90b5f734a11;
8
    }
9
    fcn.000151c4("Debugger detected! Exiting...");

That decompilation confirmed the trick: both visible flags are explicitly rejected first, then real validation happens through three helper checks. So the shortest path was to reverse those helpers and recover the expected 35-byte input directly.

1
r2 -e scr.color=0 -A -q -c "s 0x105cc; af; pdg" "chall" | rg "0x57bc8|0x57beb|\^ 0xa5|uVar4 = uVar4 \+ 7"

1
puVar5 = 0x57bc8;
2
*puVar3 = uVar1 ^ uVar4 ^ 0xa5;
3
uVar4 = uVar4 + 7;
4
} while (puVar5 != 0x57beb);

1
r2 -q -c "pxj 35 @ 0x57bc8" "chall"

1
[224,234,159,232,194,255,191,225,194,253,150,219,130,141,244,168,138,166,179,20,93,105,77,53,126,105,76,123,19,90,20,23,40,113,54]

1
data = [
2
    224,234,159,232,194,255,191,225,194,253,150,219,130,141,244,168,138,
3
    166,179,20,93,105,77,53,126,105,76,123,19,90,20,23,40,113,54
4
]
5

6
out = []
7
k = 0
8
for b in data:
9
    out.append((b ^ k ^ 0xA5) & 0xFF)
10
    k = (k + 7) & 0xFF
11

12
print(bytes(out).decode())

1
data=[224,234,159,232,194,255,191,225,194,253,150,219,130,141,244,168,138,166,179,20,93,105,77,53,126,105,76,123,19,90,20,23,40,113,54]
2
out=[]
3
k=0
4
for b in data:
5
    out.append((b^k^0xa5)&0xff)
6
    k=(k+7)&0xff
7
print(bytes(out).decode())

1
EH4X{y0u_gu3ss3d_th4t_r1sc_cr4ckm3}

The decoded string looked right, but I still verified it against every remaining constraint from fcn.00010622 and fcn.00010574 so it was not just a plausible-looking decode.

1
r2 -e scr.color=0 -A -q -c "s 0x10622; af; pdg" "chall" | rg "param_1\[0x22\] == 0x7d|iVar3 == 0xcab|0x3b9aca07|0x1fb53791|aiStack_18\[0\] = 5|aiStack_18\[5\] = 0x1e"

1
((param_1[4] == 0x7b && (param_1[0x22] == 0x7d)))) {
2
if (iVar3 == 0xcab) {
3
aiStack_18[0] = 5;
4
aiStack_18[5] = 0x1e;
5
uVar5 = (param_1[iVar3] * uVar5) % 0x3b9aca07;
6
return uVar5 == 0x1fb53791;

1
flag = b"EH4X{y0u_gu3ss3d_th4t_r1sc_cr4ckm3}"
2

3
print("len", len(flag))
4
print("prefix", flag[:5] == b"EH4X{" and flag[0x22] == 0x7D)
5
print("sum", hex(sum(flag)))
6

7
idx = [5, 10, 15, 20, 25, 30]
8
mod = 0x3B9ACA07
9
prod = 1
10
for i in idx:
11
    prod = (prod * flag[i]) % mod
12
print("prod", hex(prod))
13

14
def mix(x: int, i: int) -> int:
15
    x = ((0x5851F42D4C957F2D >> (i & 0x3F)) ^ x) & 0xFFFFFFFFFFFFFFFF
16
    return (((x >> 0x33) + ((x * 0x2000) & 0xFFFFFFFFFFFFFFFF)) ^ 0xEBFA848108987EB0) & 0xFFFFFFFFFFFFFFFF
17

18
x = 0xDEADBEEF
19
for i, b in enumerate(flag):
20
    x = mix(x ^ ((b << ((i & 7) << 3)) & 0xFFFFFFFFFFFFFFFF), i)
21

22
print("hash", hex(x))
23
print("target", hex((-0x7E30F90B5F734A11) & 0xFFFFFFFFFFFFFFFF))

1
flag=b'EH4X{y0u_gu3ss3d_th4t_r1sc_cr4ckm3}'
2
print('len',len(flag))
3
print('prefix', flag[:5]==b'EH4X{' and flag[0x22]==0x7d)
4
print('sum', hex(sum(flag)))
5
idx=[5,10,15,20,25,30]
6
mod=0x3b9aca07
7
prod=1
8
for i in idx:
9
    prod=(prod*flag[i])%mod
10
print('prod', hex(prod))
11
def mix(x,i):
12
    x=((0x5851f42d4c957f2d >> (i & 0x3f)) ^ x) & 0xffffffffffffffff
13
    return (((x >> 0x33) + ((x * 0x2000)&0xffffffffffffffff)) ^ 0xebfa848108987eb0) & 0xffffffffffffffff
14
x=0xdeadbeef
15
for i,b in enumerate(flag):
16
    x=mix(x ^ ((b << ((i & 7)<<3)) & 0xffffffffffffffff), i)
17
print('hash', hex(x))
18
print('target', hex((-0x7e30f90b5f734a11) & 0xffffffffffffffff))

1
len 35
2
prefix True
3
sum 0xcab
4
prod 0x1fb53791
5
hash 0x81cf06f4a08cb5ef
6
target 0x81cf06f4a08cb5ef

Finally I re-extracted from raw file bytes at the decoded table offset to make sure the recovered flag came straight from the challenge artifact, not from any decompiler artifact.

smug

1
from pathlib import Path
2

3
p = Path("/home/LIGHT/Downloads/chall").read_bytes()
4
enc = p[0x47BC8:0x47BC8 + 35]
5
flag = bytes((b ^ ((i * 7) & 0xFF) ^ 0xA5) & 0xFF for i, b in enumerate(enc))
6
print(flag.decode())

1
from pathlib import Path
2
p=Path('/home/LIGHT/Downloads/chall').read_bytes()
3
enc=p[0x47bc8:0x47bc8+35]
4
flag=bytes((b ^ ((i*7)&0xff) ^ 0xa5) & 0xff for i,b in enumerate(enc))
5
print(flag.decode())

1
EH4X{y0u_gu3ss3d_th4t_r1sc_cr4ckm3}

Solution#

1
from pathlib import Path
2

3
def decode_flag(binary_path: str) -> str:
4
    data = Path(binary_path).read_bytes()
5
    enc = data[0x47BC8:0x47BC8 + 35]
6
    out = bytes((b ^ ((i * 7) & 0xFF) ^ 0xA5) & 0xFF for i, b in enumerate(enc))
7
    return out.decode()
8

9
if __name__ == "__main__":
10
    print(decode_flag("chall"))

1
python3.12 solve.py

1
EH4X{y0u_gu3ss3d_th4t_r1sc_cr4ckm3}