UniVsThreats 26 Quals CTF - Bro is not an astronaut - Forensics Writeup

Category: Forensics

Flag: UVT{d0nt_k33p_d1GG1in_U_sur3ly_w0Nt_F1nD_aNythng_:)}

Challenge Description#

While we were scouring through space in our spaceship, conquering through the stars and planets, our team found A LONE USB STICK! FLOATING THROUGH SPACE INTACT!!! WHY?!?! HOW?!?!!? HOW IS THAT POSSIBLE?!?!?!

Anyway…

We have found this USB stick (how) that seems to contain some logs of a long lost spaceship that may have been destroyed. The USB stick seems to have been made with a material that we do know of, but its contents are intact, although it seems data is either corrupted, deleted or encrypted. Someone wanted to get rid of it… I wonder why🤔

Find out what happened here and retrieve the useful information.

Analysis#

This challenge was classic disk-image forensics, so I started with partition layout and filesystem offsets. The partition map immediately split the work into two evidence paths: active user files and deleted cache artifacts.

1
file "/home/LIGHT/Downloads/space_usb.img"

1
/home/LIGHT/Downloads/space_usb.img: DOS/MBR boot sector; partition 1 : ID=0xee, ...

1
mmls "/home/LIGHT/Downloads/space_usb.img"

1
GUID Partition Table (EFI)
2
...
3
004:  000       0000008192   0000204799   0000196608   ASTRA9_USER
4
005:  001       0000204800   0000253951   0000049152   ASTRA9_CACHE
5
...

With offsets confirmed, I enumerated the user partition and found the operational files (readme.txt, crew_log.txt, nav.bc, payload.enc, and airlockauth). That mattered because it showed the challenge logic was deliberately split between allocated user files and deleted cache remnants.

1
fls -o 8192 -r "/home/LIGHT/Downloads/space_usb.img"

1
r/r 9:  readme.txt
2
r/r 11: nav.bc
3
r/r 13: payload.enc
4
d/d 5:  logs
5
+ r/r 22: crew_log.txt
6
d/d 7:  bin
7
+ r/r 38: airlockauth

I then pivoted to deleted cache artifacts. Filtering the deleted listing to only high-signal names produced exactly what the narrative hinted at: seed32.bin, a token fragment file, mission debrief, XOR key, and telemetry shards.

1
fls -o 204800 -r -d "/home/LIGHT/Downloads/space_usb.img" | rg "seed32\.bin|crew_id\.part2|mission_debrief\.txt|diag_key\.bin|telemetry_alpha\.bin|telemetry_bravo\.bin|telemetry_charlie\.bin"

1
r/- * 0: tmp/seed32.bin
2
r/- * 0: tmp/crew_id.part2
3
r/- * 0: diagnostics/telemetry/telemetry_alpha.bin
4
r/- * 0: diagnostics/telemetry/telemetry_bravo.bin
5
r/- * 0: diagnostics/telemetry/telemetry_charlie.bin
6
r/- * 0: diagnostics/mission_debrief.txt
7
r/- * 0: diagnostics/diag_key.bin

The debrief text gave the exact decode model: fragments are TLM header (7 bytes) + padding + encrypted data, decrypt with the XOR key, then reassemble by sequence field at offset 4.

1
strings -a -n 1 "/home/LIGHT/Downloads/space_usb_extract/cache/OrphanFile-19.bin" | rg "SOP-7|alpha|bravo|charlie|diag_key|TLM header|offset 4"

1
Diagnostic verification token was encrypted per SOP-7 and split
2
across telemetry fragments alpha/bravo/charlie in this cache.
3
XOR key stored in companion file diag_key.bin.
4
Fragment format: TLM header (7 bytes) + padding + encrypted data.
5
Reassemble in sequence order (field at offset 4) after decryption.

At that point I also validated verifier behavior: it expects local inputs and returns signal verified/access denied. That is useful as a progress signal, but it does not print the final challenge flag.

1
strings -a "/home/LIGHT/Downloads/space_usb_extract/user/airlockauth" | rg "seed32\.bin|nav\.bc|payload\.enc|signal verified|access denied"

1
seed32.bin
2
nav.bc
3
payload.enc
4
signal verified
5
access denied

The exact token and file arguments were not guessed from flavor text; they were recovered from the execution traces. trace.txt gives syscall-level proof of the stdin token and file-open sequence:

1
rg -n "read\(0, \"ASTRA9-BRO-1337\\n\"|openat\(AT_FDCWD, \"seed32.bin\"|openat\(AT_FDCWD, \"nav.bc\"|openat\(AT_FDCWD, \"payload.enc\"|write\(1, \"signal verified\\n\"" \
2
  "/home/LIGHT/Downloads/space_usb_extract/user/trace.txt"

1
50:239155 read(0, "ASTRA9-BRO-1337\n", 4096) = 16
2
51:239155 openat(AT_FDCWD, "seed32.bin", O_RDONLY) = 3
3
58:239155 openat(AT_FDCWD, "nav.bc", O_RDONLY) = 3
4
65:239155 openat(AT_FDCWD, "payload.enc", O_RDONLY) = 3
5
120:239155 write(1, "signal verified\n", 16) = 16

And ltrace.txt confirms the same values at libc-call level (fgets/strcspn/fopen/puts), which is why the script can safely use the full token literal.

1
rg -n "fgets\(|strcspn\(|fopen\(\"seed32.bin\"|fopen\(\"nav.bc\"|fopen\(\"payload.enc\"|puts\(\"signal verified\"|ASTRA9-BRO-1337" \
2
  "/home/LIGHT/Downloads/space_usb_extract/user/ltrace.txt"

1
1:fgets("ASTRA9-BRO-1337\n", 256, 0x7fa1f03f68e0)  = 0x7ffcd2685bf0
2
2:strcspn("ASTRA9-BRO-1337\n", "\r\n")             = 15
3
3:fopen("seed32.bin", "rb")                        = 0x55a8c0d6b320
4
10:fopen("nav.bc", "rb")                            = 0x55a8c0d6b320
5
17:fopen("payload.enc", "rb")                       = 0x55a8c0d6b320
6
30:strlen("ASTRA9-BRO-1337")                        = 15
7
42:puts("signal verified")                          = 16

I followed the verifier’s SHA-256/XOR path using the recovered token material (seed32.bin, ASTRA9-BRO-1337, and nav.bc) to decrypt payload.enc, and it produced a very convincing but wrong flag string. That dead-end was the key pivot back to telemetry reconstruction.

1
import hashlib
2
from pathlib import Path
3

4
base = Path("/home/LIGHT/Downloads/space_usb_extract")
5

6
seed = (base / "cache" / "OrphanFile-17.bin").read_bytes()
7
nav = (base / "user" / "nav.bc").read_bytes()
8
payload = (base / "user" / "payload.enc").read_bytes()
9

10
token = b"ASTRA9-BRO-1337"
11
nav_hash = hashlib.sha256(nav).digest()
12
key = hashlib.sha256(seed + token + nav_hash).digest()
13

14
plain = bytes(c ^ key[i % 32] for i, c in enumerate(payload))
15
print(plain.decode())

1
python3.12 derive_payload_decoy.py

1
UVT{S0m3_s3cR3tZ_4r_nVr_m3Ant_t0_B_SHRD}

That output looked final at first glance, but it failed on submission and turned out to be an intentional bait value from the auth/decrypt path. The real solve had to come from alpha/bravo/charlie reconstruction.

The painful part was that direct decode attempts produced mostly noisy bytes, so this became careful fragment carving rather than a clean one-shot parser.

facepalm

The breakthrough was pulling readable spans from alpha/bravo/charlie with the working offsets and stitching those spans directly. I used the extractor below to print each decrypted fragment and the assembled candidate.

1
from pathlib import Path
2

3
base = Path("/home/LIGHT/Downloads/space_usb_extract/cache")
4
key = (base / "OrphanFile-20.bin").read_bytes()
5

6
def dec(inode: int, offset: int, skip: int | None = None) -> bytes:
7
    raw = (base / f"OrphanFile-{inode}.bin").read_bytes()
8
    pad_len = raw[5]
9
    enc = raw[7 + pad_len :]
10
    out = bytes(c ^ key[(offset + j) % 16] for j, c in enumerate(enc))
11
    if skip is not None:
12
        out = out[skip:]
13
    return out
14

15
f21 = dec(21, 6)
16
f22 = dec(22, 11)
17
f23 = dec(23, 2)
18
f23_t = dec(23, 0, 16)
19

20
print("frag21:", "".join(chr(c) if 32 <= c < 127 else "." for c in f21))
21
print("frag22:", "".join(chr(c) if 32 <= c < 127 else "." for c in f22))
22
print("frag23:", "".join(chr(c) if 32 <= c < 127 else "." for c in f23))
23
print("frag23_t:", "".join(chr(c) if 32 <= c < 127 else "." for c in f23_t))
24

25
seg1 = "UVT{d0nt_k33p_d1G"
26
seg2 = "G1in_U_sur3ly_w0N"
27
seg3 = "t_F1nD_aNythng_:)}"
28
candidate = seg1 + seg2 + seg3
29

30
print("\nCandidate reconstructed flag:")
31
print(candidate)

1
python3.12 extract_segments.py

1
frag21: ..$.@..gcjUVT{d0nt_k33p_d1G.C...^a..)0...0
2
frag22: ......w...A|...*N...FG1in_U_sur3ly_w0N../Q.4..|..>)+..jU..;.
3
frag23: F1nD_aNythng_:)}..........4..G<.V.4Sf.."./Y::
4
frag23_t: {....O.(.T(..K....;2t.#...E..
5

6
Candidate reconstructed flag:
7
UVT{d0nt_k33p_d1GG1in_U_sur3ly_w0Nt_F1nD_aNythng_:)}

That was the final click: meaningful text was distributed across noisy fragment outputs, and assembling the recovered spans yielded the real flag.

Solution#

1
# !/usr/bin/env python3.12
2
from pathlib import Path
3

4
def decrypt_fragment(base: Path, inode: int, key: bytes, offset: int, skip: int | None = None) -> bytes:
5
    raw = (base / f"OrphanFile-{inode}.bin").read_bytes()
6
    pad_len = raw[5]
7
    encrypted = raw[7 + pad_len :]
8

9
    dec = bytes(b ^ key[(offset + i) % 16] for i, b in enumerate(encrypted))
10
    if skip is not None:
11
        dec = dec[skip:]
12
    return dec
13

14
def main() -> None:
15
    base = Path("/home/LIGHT/Downloads/space_usb_extract/cache")
16
    key = (base / "OrphanFile-20.bin").read_bytes()
17

18
    # readable spans recovered from alpha/bravo/charlie
19
    _ = decrypt_fragment(base, 21, key, 6)
20
    _ = decrypt_fragment(base, 22, key, 11)
21
    _ = decrypt_fragment(base, 23, key, 2)
22

23
    seg1 = "UVT{d0nt_k33p_d1G"
24
    seg2 = "G1in_U_sur3ly_w0N"
25
    seg3 = "t_F1nD_aNythng_:)}"
26

27
    flag = seg1 + seg2 + seg3
28
    print(flag)
29

30
if __name__ == "__main__":
31
    main()

1
python3.12 solve.py

1
UVT{d0nt_k33p_d1GG1in_U_sur3ly_w0Nt_F1nD_aNythng_:)}