Sensor Confession: ICS Telemetry Protocol Exfiltration

“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.”
ASCWG{...}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 -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'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)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 ]▼
- Load the PCAP and run statistics on endpoint conversations.
- Notice a high volume of packets communicating with an external IP on a non-standard port.
- Use
tshark -r capture.pcap -Y "ip.src == [SENSOR_IP]" -T fields -e tcp.urgent_pointerto extract the smuggled bytes. - 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:
Ran Wireshark Statistics → Conversations. Filtered down to the suspicious SCADA telemetry stream originating from sensor IP 10.0.5.55.
Payload appeared as encrypted heartbeat noise. Inspected TCP header fields and spotted non-zero tcp.urgent_pointer values matching valid printable ASCII hex codes.
Crafted extraction filter ip.src == 10.0.5.55 && tcp.urgent_pointer > 0 to carve the sequential hex byte stream.
Piped extracted bytes into Python to assemble ASCII text: 41 53 43 57 47 ... → ASCWG{...}.
Submitted recovered flag: ASCWG{t3l3m3try_s3ns0r_d4t4_l34k_v14_tcp}.