ASCWG QUALS • NETWORK FORENSICS • ICS PROTOCOL SMUGGLING

Sensor Confession: ICS Telemetry Protocol Exfiltration

By Abdo•Aug 20, 2026
Sensor Confession Network Forensics
Challenge Prompt

“Our perimeter IDS flagged anomalous telemetry between industrial SCADA sensor controllers. Deep packet inspection indicates covert data exfiltration hiding inside legitimate TCP protocol header fields. Analyze the PCAP to reconstruct the leak.”

● Category: Network Forensics / Covert Channels● Platform: ASCWG Qualifications 2026● Flag Format: ASCWG{...}
Provided Artifacts
sensor_dump.pcap
Size: 94 MB • Packet CaptureProtocol: TCP Urgent Pointer (URG)
Analyzer: Wireshark / TShark / Scapy

In “Sensor Confession,” participants are thrown into a network forensics scenario involving anomalous traffic originating from industrial control sensors. The challenge required filtering through the noise of a massive PCAP file to find the specific protocol abuse used by the attacker to leak data.


Stage 1: PCAP Triage & Protocol Analysis

Protocol Forensics: Covert Channel via TCP Urgent Pointer

Standard network traffic carries data inside the payload section. When packet payload is empty or filtered, covert channels can encode exfiltrated bytes into uninspected header fields. Here, the malware set the 16-bit TCP Urgent Pointer field on routine sensor heartbeat frames to transmit one ASCII byte per packet.

Q: How was the flag exfiltrated from the sensor network?

A: Data Exfiltration via TCP Urgent Pointer (URG) Covert Channel

Using Wireshark and tshark, we filtered out standard TCP handshakes and focused on non-zero urgent pointer fields originating from the sensor subnet. The attacker exploited the TCP Urgent PointerA field in the TCP header historically intended to prioritize data, rarely used today, making it suited for covert data exfiltration. field, typically unused in modern networks, to leak the flag byte-by-byte across consecutive packets.

tshark_extraction.sh
$ tshark -r capture.pcap -Y "ip.src == 10.0.5.55 && tcp.urgent_pointer > 0" -T fields -e tcp.urgent_pointer | head -n 8

# Output (Hexadecimal values of ASCII chars):
41 // 'A'
53 // 'S'
43 // 'C'
57 // 'W'
47 // 'G'
7b // '{'
74 // 't'
33 // '3'
Automated Python Extractor (`extract_urg.py`):
import pyshark

# Extract TCP urgent pointer bytes across the sensor conversation
cap = pyshark.FileCapture('sensor_dump.pcap', display_filter='ip.src == 10.0.5.55 && tcp.urgent_pointer > 0')

flag_chars = []
for pkt in cap:
    try:
        urg_val = int(pkt.tcp.urgent_pointer)
        flag_chars.append(chr(urg_val))
    except AttributeError:
        continue

flag = ''.join(flag_chars)
print("[+] Reconstructed Sensor Flag:", flag)
Terminal One-Liner (PowerShell / Bash):
tshark -r sensor_dump.pcap -Y "ip.src == 10.0.5.55 && tcp.urgent_pointer > 0" -T fields -e tcp.urgent_pointer | python -c "import sys; print(''.join([chr(int(x.strip(), 16)) for x in sys.stdin if x.strip()]))"
[ SHOW METHODOLOGY: Tshark Payload Extraction ]▼
  1. Load the PCAP and run statistics on endpoint conversations.
  2. Notice a high volume of packets communicating with an external IP on a non-standard port.
  3. Use tshark -r capture.pcap -Y "ip.src == [SENSOR_IP]" -T fields -e tcp.urgent_pointer to extract the smuggled bytes.
  4. Pipe the resulting hex stream into Python, convert to ASCII, and decode the final flag string.

Constructing the Final Flag

The flag wasn't sitting in plain text in a single packet. It was fragmented across thousands of packets and smuggled within the TCP urgent pointer field. By extracting this specific field across the entire conversation stream, we rebuilt the original binary payload.

Final Submitted Flag:

ASCWG{t3l3m3try_s3ns0r_d4t4_l34k_v14_tcp}

The Complete Investigation Path & Mental Roadmap

Here is the step-by-step roadmap from initial PCAP conversation analysis to decoding the smuggled TCP stream:

STEP 1
Conversation Triage & IP Isolation

Ran Wireshark Statistics → Conversations. Filtered down to the suspicious SCADA telemetry stream originating from sensor IP 10.0.5.55.

STEP 2
Header Field Inspection

Payload appeared as encrypted heartbeat noise. Inspected TCP header fields and spotted non-zero tcp.urgent_pointer values matching valid printable ASCII hex codes.

STEP 3
TShark Extraction Filter

Crafted extraction filter ip.src == 10.0.5.55 && tcp.urgent_pointer > 0 to carve the sequential hex byte stream.

STEP 4
Stream Reassembly & Decoding

Piped extracted bytes into Python to assemble ASCII text: 41 53 43 57 47 ... → ASCWG{...}.

STEP 5
Flag Submission

Submitted recovered flag: ASCWG{t3l3m3try_s3ns0r_d4t4_l34k_v14_tcp}.