1
2

2101-10-01T03:17:03+10:00 relay-core[1847]: WARN export request accepted principal=KAI-7 resource=emergency-core
2101-10-01T03:17:04+10:00 relay-core[1847]: INFO resource package completed.

1
2
3
4
5

def derive_emergency_key(
    machine_id: str, session_uuid: str, event_epoch: int
) -> bytes:
  material = f"{machine_id.strip()}|{session_uuid.strip()}|{int(event_epoch)}"
  return hashlib.sha256(material.encode("utf-8")).digest()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

#!/usr/bin/env python3
"""
The False Timeline Solution Script
Purpose: Derive AES-256 key from reconstructed forensic artifacts
and decrypt the .ekey-cache container.
"""

import hashlib
from cryptography.hazmat.primitives.ciphers.aead import AESGCM

# 1. Read binary cache data
cache_file = r"e:\CSSCTF\extracted\var\cache\nexus\.ekey-cache"
with open(cache_file, "rb") as f:
    encrypted_data = f.read()

# 2. Parse NXKEY_V1 container
magic = encrypted_data[:8]         # First 8 bytes: b'NXKEY_V1'
nonce = encrypted_data[8:20]       # Next 12 bytes: Nonce / IV
ciphertext = encrypted_data[20:]   # Remainder: Ciphertext + Auth Tag

print(f"[*] Header format: {magic}")
print(f"[*] Nonce (hex): {nonce.hex()}")
print(f"[*] Ciphertext length: {len(ciphertext)} bytes")

# 3. Parameters from True Timeline
machine_id = "8f3b2a1c9e4d56781234abcd567890ef"  # /etc/machine-id
session_uuid = "aab0c8b2-f8b1-4f11-9a72-6d8123a1005a"  # Actual svc-relay session
event_epoch = 4157543568  # Timestamp from audit.log

# 4. Derive AES-256 key matching exporter.py logic
# Formula: SHA256(machine_id|session_uuid|event_epoch)
key_material = f"{machine_id}|{session_uuid}|{event_epoch}"
aes_key = hashlib.sha256(key_material.encode("utf-8")).digest()

print(f"[*] Derivation string: {key_material}")
print(f"[*] Derived AES-256 key: {aes_key.hex()}")

# 5. Decrypt using AES-GCM
aesgcm = AESGCM(aes_key)
try:
    decrypted_key = aesgcm.decrypt(nonce, ciphertext, None)
    flag = decrypted_key.decode("utf-8")
    print("\n" + "=" * 50)
    print(f"[+] EMERGENCY ACCESS KEY SUCCESSFULLY DECRYPTED:")
    print(f"[+] Flag: {flag}")
    print("=" * 50)
except Exception as e:
    print(f"[-] Decryption failed: {e}")

1

CSSCTF{kai_did_not_do_it}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100

#!/usr/bin/env python3
"""
Signal Fracture Solution Script
Purpose:
1. Carve NXFR fragments from raw disk KBR17_relay.img (spool ring + cache).
2. Extract NXFR fragments from KBR17_uplink.pcap, resolving retry conflicts.
3. Validate SHA-256 against catalog and assemble 8 fragments into a tar.gz archive.
4. Decompress and read flag from final_message.txt.
"""

import gzip
import hashlib
import io
import struct
import tarfile

# Expected SHA-256 hashes from relay.db (Scheduler Catalog)
EXPECTED_HASHES = {
    0: "fdde3a6dc2c9d43e0bbf21b1e90d1214d5776405397ab54426ff7bb6bec8831d",
    1: "82fc22cae997c805035ef22fd98c260c626c67aaaef45301236bc549897e47ae",
    2: "5cd4fd1f9bdc1360dc272362ee421b4f62f2818c7d68332440042c3e46b8f732",
    3: "3258da54f56a49e79a1719d9145a6cd82691a0d2b10a9a1e8782e9cacf507dc6",
    4: "4e86900e878981dcaec4e63b381395496598282d68f2a63e578350bdccfe7daa",
    5: "27ffcedf5e0e4bbec59c36c662aa1397d729c9a8bcd6005131a048856efb3e58",
    6: "fa9dbecb99768ea4d8470546b270845127278e797e09f71073df7e5658bdabae",
    7: "a9d2e70930248e74b776c1db737637d2e2a354308d216921225216288a94b7d0",
}

SESSION_ID = 0x6E2C17A9
recovered_frags = {}

# ==========================================
# STEP 1: Scan for NXFR fragments in KBR17_relay.img
# ==========================================
print("[*] Scanning NXFR fragments in KBR17_relay.img...")
with open(r"e:\CSSCTF\KBR17_relay.img", "rb") as f:
    img_bytes = f.read()

pos = 0
while True:
    idx = img_bytes.find(b"NXFR", pos)
    if idx == -1:
        break

    hdr = img_bytes[idx : idx + 20]
    if len(hdr) == 20:
        magic, sess, seq, total, plen, pcrc = struct.unpack(">4sIHHII", hdr)
        if sess == SESSION_ID:
            payload = img_bytes[idx + 20 : idx + 20 + plen]
            phash = hashlib.sha256(payload).hexdigest()

            if seq in EXPECTED_HASHES and EXPECTED_HASHES[seq] == phash:
                recovered_frags[seq] = payload
                print(f"  [+] Disk: Successfully recovered Seq {seq} ({plen} bytes)")
    pos = idx + 4

# ==========================================
# STEP 2: Extract fragments from KBR17_uplink.pcap
# ==========================================
print("\n[*] Extracting NXFR fragments from KBR17_uplink.pcap...")
with open(r"e:\CSSCTF\KBR17_uplink.pcap", "rb") as f:
    pcap_bytes = f.read()

pos = 0
while True:
    idx = pcap_bytes.find(b"NXFR", pos)
    if idx == -1:
        break

    hdr = pcap_bytes[idx : idx + 20]
    if len(hdr) == 20:
        magic, sess, seq, total, plen, pcrc = struct.unpack(">4sIHHII", hdr)
        if sess == SESSION_ID:
            payload = pcap_bytes[idx + 20 : idx + 20 + plen]
            phash = hashlib.sha256(payload).hexdigest()

            if seq in EXPECTED_HASHES and EXPECTED_HASHES[seq] == phash:
                recovered_frags[seq] = payload
                print(f"  [+] Network PCAP: Successfully recovered Seq {seq} (SHA-256 Verified)")
    pos = idx + 4

print(f"\n[+] Total fragments assembled: {len(recovered_frags)}/8")

# ==========================================
# STEP 3: Concatenate and Decompress Archive
# ==========================================
if len(recovered_frags) == 8:
    assembled_gz = b"".join(recovered_frags[i] for i in range(8))
    print(f"[+] Successfully concatenated GZIP stream: {len(assembled_gz)} bytes")

    tar_data = gzip.decompress(assembled_gz)

    with tarfile.open(fileobj=io.BytesIO(tar_data)) as tar:
        message_file = tar.extractfile("final_message.txt")
        if message_file:
            message_content = message_file.read().decode("utf-8")
            print("\n" + "=" * 50)
            print("[+] CONTENT OF final_message.txt:")
            print(message_content)
            print("=" * 50)

1

CSSCTF{fragment_t3ll_th3_st0ry}

1
2
3
4
5
6
7
8
9

NXPKT|SESSION=NX-771|TYPE=DATA|SEQ=00|RETRY=0|LEN=1024|WIRECRC=A66FEFC8|DATA=<base64>
NXPKT|SESSION=NX-771|TYPE=DATA|SEQ=03|RETRY=0|LEN=1024|WIRECRC=BB1810C0|DATA=<base64>
NXPKT|SESSION=NX-771|TYPE=PARITY|GROUP=A|LEN=1024|WIRECRC=96ED68C1|DATA=<base64>
NXPKT|SESSION=NX-771|TYPE=DATA|SEQ=01|RETRY=0|LEN=1024|WIRECRC=7C3DCD2A|DATA=<base64>
NXPKT|SESSION=NX-771|TYPE=DATA|SEQ=06|RETRY=1|LEN=1024|WIRECRC=C04CF7F5|DATA=<base64>
NXPKT|SESSION=NX-771|TYPE=DATA|SEQ=04|RETRY=0|LEN=1024|WIRECRC=D6CCE79E|DATA=<base64>
NXPKT|SESSION=NX-771|TYPE=PARITY|GROUP=B|LEN=1024|WIRECRC=456CA33D|DATA=<base64>
NXPKT|SESSION=NX-771|TYPE=DATA|SEQ=07|RETRY=0|LEN=1024|WIRECRC=3D924BBF|DATA=<base64>
NXPKT|SESSION=NX-771|TYPE=DATA|SEQ=06|RETRY=2|LEN=1024|WIRECRC=2A18C562|DATA=<base64>

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

#!/usr/bin/env python3
"""
Ghost Frequency Solution Script
Purpose:
1. Parse KBR17_blackbox.wav and demodulate Bell 202 AFSK (1200/2200 Hz).
2. Frame UART 8N1 bits into ASCII NXPKT packets.
3. Reconstruct missing fragments (SEQ 02 and SEQ 05) via XOR Parity FEC.
4. Concatenate data blocks, decompress Raw DEFLATE, and read flag from TAR archive.
"""

import base64
import io
import tarfile
import wave
import zlib
import numpy as np

# ==========================================
# STEP 1: Load Right Audio Channel from WAV
# ==========================================
wav_path = r"e:\CSSCTF\KBR17_blackbox.wav"
print(f"[*] Loading audio asset {wav_path}...")
with wave.open(wav_path, "rb") as w:
    framerate = w.getframerate()
    nframes = w.getnframes()
    raw_bytes = w.readframes(nframes)

audio = np.frombuffer(raw_bytes, dtype=np.int16)
right_channel = audio[1::2].astype(np.float64)  # Right channel holds AFSK data

# ==========================================
# STEP 2: Demodulate Bell 202 AFSK (1200 baud)
# ==========================================
sps = 40  # 48000 Hz / 1200 baud = 40 samples/bit
num_bits = len(right_channel) // sps

t = np.arange(sps)
sin1200 = np.sin(2 * np.pi * 1200 * t / framerate)
cos1200 = np.cos(2 * np.pi * 1200 * t / framerate)
sin2200 = np.sin(2 * np.pi * 2200 * t / framerate)
cos2200 = np.cos(2 * np.pi * 2200 * t / framerate)

print("[*] Running matched filter correlator (1200 Hz Mark / 2200 Hz Space)...")
raw_bits = []
for i in range(num_bits):
    chunk = right_channel[i * sps : (i + 1) * sps]
    p1200 = np.dot(chunk, sin1200) ** 2 + np.dot(chunk, cos1200) ** 2
    p2200 = np.dot(chunk, sin2200) ** 2 + np.dot(chunk, cos2200) ** 2
    raw_bits.append(1 if p1200 > p2200 else 0)

# ==========================================
# STEP 3: Decode UART 8N1 Framing
# ==========================================
print("[*] Framing UART 8N1 byte stream (LSB first)...")
decoded_bytes = []
i = 0
start_bit, stop_bit = 0, 1

while i < len(raw_bits) - 10:
    if raw_bits[i] == start_bit and raw_bits[i + 9] == stop_bit:
        byte_val = sum(raw_bits[i + 1 + k] << k for k in range(8))
        decoded_bytes.append(byte_val)
        i += 10
        continue
    i += 1

packet_stream = bytes(decoded_bytes).decode("latin-1")

# ==========================================
# STEP 4: Parse NXPKT and Perform Parity FEC
# ==========================================
print("[*] Parsing NXPKT packets for session NX-771...")
lines = [l.strip() for l in packet_stream.split("\n") if l.strip()]

packets = {}
for line in lines:
    if line.startswith("NXPKT|"):
        parts = line.split("|")
        props = dict(p.split("=", 1) for p in parts[1:] if "=" in p)
        if props.get("SESSION") == "NX-771":
            ptype = props.get("TYPE")
            seq = props.get("SEQ", props.get("GROUP"))
            retry = props.get("RETRY", "0")
            data_bytes = base64.b64decode(props["DATA"])
            packets[(ptype, seq, retry)] = data_bytes

def xor_blocks(block_list):
    """Bitwise XOR across a list of bytearrays."""
    res = bytearray(len(block_list[0]))
    for b in block_list:
        for idx in range(len(res)):
            res[idx] ^= b[idx]
    return bytes(res)

# Reconstruct Group A (Missing SEQ 02):
d00 = packets[("DATA", "00", "0")]
d01 = packets[("DATA", "01", "0")]
d03 = packets[("DATA", "03", "0")]
parA = packets[("PARITY", "A", "0")]
d02 = xor_blocks([d00, d01, d03, parA])
print("[+] Reconstructed SEQ 02 using Group A Parity.")

# Reconstruct Group B (Missing SEQ 05, using SEQ 06 RETRY 2):
d04 = packets[("DATA", "04", "0")]
d06 = packets[("DATA", "06", "2")]
d07 = packets[("DATA", "07", "0")]
parB = packets[("PARITY", "B", "0")]
d05 = xor_blocks([d04, d06, d07, parB])
print("[+] Reconstructed SEQ 05 using Group B Parity.")

# Concatenate all 8 blocks
full_payload = d00 + d01 + d02 + d03 + d04 + d05 + d06 + d07

# ==========================================
# STEP 5: Decompress Raw DEFLATE and Read Flag
# ==========================================
print("[*] Decompressing Raw DEFLATE stream from offset 10...")
raw_deflate_data = full_payload[10:]
decompressed_tar = zlib.decompress(raw_deflate_data, -zlib.MAX_WBITS)

with tarfile.open(fileobj=io.BytesIO(decompressed_tar)) as tar:
    msg_file = tar.extractfile("NX-771/final_message.txt")
    if msg_file:
        msg_content = msg_file.read().decode("utf-8")
        print("\n" + "=" * 50)
        print("[+] CONTENT OF final_message.txt:")
        print(msg_content)
        print("=" * 50)

1

CSSCTF{th3_gh0st_fr3qu3ncy_w4s_n3v3r_s1l3nt}

1
2
3

cd /home/kali/Downloads/CSSCTF/FORENCIS/
ls -la
file relay_backup.img

1
2
3

relay_backup.img: Linux rev 1.0 ext4 filesystem data,
    UUID=c5502026-0017-4047-8013-210100000004,
    volume name "KUIPER_RELAY" (extents) (large files) (huge files)

1

dumpe2fs -h relay_backup.img

1

debugfs -R "ls -l /" relay_backup.img

1
2
3
4
5
6
7

      2   40755 (2)      0      0    1024 . 
      2   40755 (2)      0      0    1024 ..
     11   40700 (2)      0      0   12288 lost+found
     12   40755 (2)   1000   1000    1024 LOST
     13  100644 (1)   1000   1000     128 README.txt
     14   40755 (2)   1000   1000    1024 logs
     18   40755 (2)   1000   1000    1024 operator

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

/
├── lost+found/
├── LOST/                        <- Suspicious empty decoy
├── README.txt
├── logs/
│   ├── boot.log
│   ├── network.log
│   └── recovery.log
└── operator/
    ├── Documents/shift_report.txt
    ├── Downloads/diagnostics.txt
    └── Pictures/relay_status.png     <- Diagnostic image reference

1
2
3
4
5
6

debugfs -R "cat /README.txt"                     relay_backup.img
debugfs -R "cat /logs/boot.log"                  relay_backup.img
debugfs -R "cat /logs/network.log"               relay_backup.img
debugfs -R "cat /logs/recovery.log"              relay_backup.img
debugfs -R "cat /operator/Documents/shift_report.txt" relay_backup.img
debugfs -R "cat /operator/Downloads/diagnostics.txt"  relay_backup.img

1
2
3
4
5
6
7
8

NEXUS RELAY DIAGNOSTICS
Power subsystem.............OK
Navigation..................OFFLINE
Quantum Link................DEGRADED
Emergency Storage...........ACTIVE

Image integrity warning:
Residual filesystem entries detected.

1

debugfs -R "lsdel" relay_backup.img

1
2
3

 Inode  Owner  Mode    Size      Blocks   Time deleted
    25      0 100644    303      1/     1 Sun Sep 13 17:17:36 2026
1 deleted inodes found.

1

debugfs -R "stat <25>" relay_backup.img

1
2
3
4
5
6
7

Inode: 25   Type: regular    Mode:  0644   Flags: 0x80000
Size: 303
Links: 0                    <- Unlinked
 ctime: ... Sun Sep 13 17:17:36 2026
 dtime: ... Sun Sep 13 17:17:36 2026   <- Non-zero deletion timestamp
EXTENTS:
(0):2232                    <- Physical block #2232

1
2

dd if=relay_backup.img bs=1024 skip=2232 count=1 of=out/deleted_block.bin
strings -a out/deleted_block.bin

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

NX-17 PERSONAL NOTE

They are wiping the relay.

I couldn't leave the transmission as a normal file.

I attached the recovery package to the diagnostic image before
the node went offline.

If someone finds this:
    archive password = severance2101
Look beyond what the image viewer shows you.

-NX17

1
2
3

mkdir -p out
debugfs -R "dump /operator/Pictures/relay_status.png out/relay_status.png" relay_backup.img
file out/relay_status.png

1

out/relay_status.png: PNG image data, 960 x 540, 8-bit/color RGB, non-interlaced

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import struct
d = open('out/relay_status.png', 'rb').read()
print("signature:", d[:8].hex())
off = 8
while off < len(d):
    ln  = struct.unpack('>I', d[off:off+4])[0]
    typ = d[off+4:off+8].decode('latin1')
    print(f"{typ:>5}  len={ln:<6} offset=0x{off:x}")
    if typ == 'IEND':
        print("IEND ends at offset 0x%x (%d)" % (off+12, off+12))
        print("bytes AFTER IEND:", len(d) - (off+12))
        break
    off += 12 + ln

1
2
3
4
5
6

signature: 89504e470d0a1a0a
 IHDR  len=13     offset=0x8
 IDAT  len=19217  offset=0x21
 IEND  len=0      offset=0x4b3e
IEND ends at offset 0x4b4a (19274)
bytes AFTER IEND: 560

1

python3 -c "d=open('out/relay_status.png','rb').read(); i=d.find(b'PK\x03\x04'); print(hex(i), d[i-4:i+16].hex())"

1

0x4b4a 504b0304 1400 0900 ...

1
2
3

d = open('out/relay_status.png', 'rb').read()
i = d.find(b'PK\x03\x04')
open('out/recovery.zip', 'wb').write(d[i:])

1

zipinfo -v out/recovery.zip

1
2
3
4
5
6
7

Archive: out/recovery.zip
Zip archive file size: 560
central directory contains 2 entries
Entry #1: transmission/manifest.txt
    compression method: deflated
    file security status: encrypted
    file last modified: 2026 Sep 13 20:17:36

1
2

mkdir -p out/recovered
unzip -P severance2101 out/recovery.zip -d out/recovered

1
2

  inflating: out/recovered/transmission/manifest.txt
 extracting: out/recovered/transmission/core_recovery.txt

1
2

cat out/recovered/transmission/manifest.txt
cat out/recovered/transmission/core_recovery.txt

1
2
3

The Nexus remembers what the filesystem forgets.

CSSCTF{d3l3t3d_d03snt_m34n_g0n3}

1

CSSCTF{d3l3t3d_d03snt_m34n_g0n3}

1
2
3
4
5
6
7

ext4 disk image
  -> debugfs lsdel          : Identify deleted Inode 25 (303 bytes, block 2232)
  -> dd block 2232          : Carve operator note -> password + stego target hint
  -> dump relay_status.png  : Extract target image
  -> parse PNG chunks       : Identify 560 trailing bytes after IEND (PNG/ZIP polyglot)
  -> unzip -P severance2101 : Decrypt carved ZIP archive
  -> core_recovery.txt      : Read final Flag

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# 1) Image identification
file target.img
xxd -l 512 target.img

# 2) Filesystem metadata
dumpe2fs -h target.img

# 3) Directory browsing and dumping
debugfs -R "ls -l /" target.img
debugfs -R "cat /path/file" target.img
debugfs -R "dump /path/file out/" target.img

# 4) Deleted inode analysis
debugfs -R "lsdel" target.img
debugfs -R "stat <INODE>" target.img

# 5) Raw block carving
dd if=target.img bs=1024 skip=BLOCK count=1 of=blk.bin
strings -a blk.bin

# 6) Carving trailing ZIP past EOF
python3 -c "d=open('target.png','rb').read(); i=d.find(b'PK\x03\x04'); open('out.zip','wb').write(d[i:])"

# 7) Decrypt encrypted archive
unzip -P <password> out.zip -d out/