Chimera Void

Dintr-un pcap recuperam un upload de G-code catre OctoPrint. Mesajul este ascuns geometric in traseele de printare, vizibil ca void in grila 2D.

Sumar

In captura de retea exista doua fluxuri TCP mari:

  • un flux de tip zgomot pe portul 80 (noise.local), cu multe POST-uri de 1 MB;
  • un flux real pe portul 5000, care contine un upload HTTP multipart catre octoprint.local.

Din al doilea flux se recupereaza fisierul chimera_test.gcode (aprox 47 MB). Mesajul nu este in clar in text, ci este ascuns geometric in traseele de printare din straturile din mijloc (Z=1.0 pana la Z=4.8). Dupa ce traseele sunt convertite in grila 2D si se vizualizeaza void-ul (inversul materialului extrudat), apare flag-ul.

Dovada rezolvarii

Cand deschidem fisierul .pcap in Wireshark putem vedea in statistici ca sunt doar pachete TCP:

Statistici de protocol in Wireshark

Acuma folosind tshark:

Analiza conversatiilor cu tshark

Observatii:

  • Captura este TCP-only.
  • Sunt doua conversatii principale:
    • 192.168.1.99:33333 -> 192.168.1.10:80 (aprox 27 MB)
    • 192.168.1.50:44444 -> 192.168.1.10:5000 (aprox 49 MB)

Concluzie: fluxul de pe 5000 este mai mare si mai suspect. Pe portul 80 apar request-uri de forma POST /noise/data_0 … POST /noise/data_24, fiecare cu Content-Length: 1048576. Acest model repetitiv indica trafic de umplutura (decoy).

Inspectia primului pachet cu date din fluxul pe 5000 arata un upload direct de G-code catre un server de tip OctoPrint:

  • POST /api/files/local HTTP/1.1
  • Host: octoprint.local
  • Content-Type: multipart/form-data
  • Content-Length: 47892095
  • filename="chimera_test.gcode"

Extragem fluxul cu tcpflow:

Extragerea fluxului cu tcpflow

Acuma, ca sa putem vizualiza layerele am facut un script de python care genereaza un fisier .png:

import math
import importlib
import re
import sys

# Fixed challenge defaults.
LAYER = 1.0
EXTENT = 650.0
CELL = 5.0
SCALE = 8

X_RE = re.compile(r"\bX(-?\d+(?:\.\d+)?)")
Y_RE = re.compile(r"\bY(-?\d+(?:\.\d+)?)")


def main() -> None:
    try:
        image_mod = importlib.import_module("PIL.Image")
    except ModuleNotFoundError:
        print("[!] Pillow is required. Install with: pip install pillow")
        sys.exit(1)

    if len(sys.argv) < 2:
        print("Usage: python3 generate_chimera_pngs.py <gcode_or_stream_file> [output_png]")
        sys.exit(1)

    input_file = sys.argv[1]
    output_png = sys.argv[2] if len(sys.argv) > 2 else "layer1_material.png"

    size = int(round(EXTENT / CELL))
    grid = [[0] * size for _ in range(size)]  # 1 = material

    z = None
    cur_x = None
    cur_y = None

    with open(input_file, "r", errors="ignore") as f:
        for line in f:
            line = line.strip()

            if line.startswith("G0 Z"):
                z = float(line.split("Z", 1)[1])
                continue

            if z != LAYER or not line.startswith(("G0 ", "G1 ")):
                continue

            x_match = X_RE.search(line)
            y_match = Y_RE.search(line)
            x = float(x_match.group(1)) if x_match else cur_x
            y = float(y_match.group(1)) if y_match else cur_y

            if (
                line.startswith("G1 ")
                and cur_x is not None
                and x is not None
                and y is not None
                and x != cur_x
            ):
                row = int(y // CELL)
                if 0 <= row < size:
                    x0 = min(cur_x, x)
                    x1 = max(cur_x, x)
                    c0 = max(0, int(x0 // CELL))
                    c1 = min(size - 1, int(math.ceil(x1 / CELL) - 1))
                    for col in range(c0, c1 + 1):
                        grid[row][col] = 1

            cur_x, cur_y = x, y

    img = image_mod.new("L", (size, size), 255)
    for row in range(size):
        for col in range(size):
            if grid[row][col]:
                img.putpixel((col, size - 1 - row), 0)

    img = img.resize((size * SCALE, size * SCALE), image_mod.NEAREST)
    img.save(output_png)
    print(f"[+] Wrote {output_png}")


if __name__ == "__main__":
    main()

Rulam generatorul peste stream-ul reasamblat:

Rularea generatorului de PNG

Void-ul dintre trasee deseneaza flag-ul:

Flag-ul vizibil in void-ul straturilor

Flag: CTF{CONGRATS_WINNERS}