office-attack.pcap — the same five minutes, with an intrusion in them
office-attack.pcap.gz is
office.pcap plus one compromise, laid over the same timeline
and mirrored at the same point. The benign frames are byte-for-byte the ones
in the baseline file, so anything you find by diffing the two is the
incident and nothing else.
| Property | Value |
|---|---|
| File | office-attack.pcap.gz (10 MB compressed, 15 MB raw) |
| Frames | 25,274 over 303.7 s — the baseline’s 22,089 plus 3,185 |
| Window | Tuesday 2026-11-10, 09:14:00–09:19:04 PST |
| Built by | mkattack.py — same seed in, byte-identical file out |
| Rules | attack.rules — 12 Suricata rules, all of which fire |
| Patient zero | wks-sales-12 10.21.10.61, Windows 11, floor 2 |
Everything hostile comes from that one host, so the whole incident pivots off
one address. Attacker infrastructure sits in the
RFC 5737 documentation ranges
(203.0.113.0/24, 198.51.100.0/24) and the domains all end in .example, so
nothing here resolves to anyone’s real network.
The intrusion, stage by stage
Each row leaves a different kind of evidence, so each one wants a different tool. The times are seconds into the capture.
| Time | Stage | What it looks like on the wire | ATT&CK |
|---|---|---|---|
| 18 | Delivery | TLS to docs-northstar-share.example, a look-alike of the tenant’s SharePoint host |
T1566.002 |
| 24 | Second stage | plain HTTP GET /assets/img/jquery-3.7.1.min.png, served as image/png, body is a PE32+ |
T1105 |
| 31–273 | C2 | nine HTTPS sessions to one host, one every ~30 s, few hundred bytes each way | T1071.001 |
| 37, 158, 277 | C2 fallback | plain HTTP POSTs with a hard-coded MSIE 6.0 User-Agent and no Referer | T1071.001 |
| 42–45 | Discovery | ICMP sweep of 10.21.20.0/24, forty destinations, five answer | T1018 |
| 48–49 | Discovery | half-open SYN scan of dc01 (22 ports) and fs01 (10 ports) | T1046 |
| 45, 164 | Poisoning | LLMNR and NBT-NS answers claiming to be fileserver and wpad |
T1557.001 |
| 45 | Credential access | the victim authenticates to the operator: a real, crackable NTLMv2 response | T1187 |
| 60 | Credential access | three TGS-REQs asking for RC4 service tickets for SPNs | T1558.003 |
| 64 | Credential access | an AS-REQ with no pre-auth, answered with an RC4 AS-REP | T1558.004 |
| 95–134 | Exfil channel | 54 TXT queries, 40-plus base32 characters per label, one domain | T1071.004 |
| 140–157 | MITM | eight ARP replies claiming the VLAN 10 gateway, then the core takes it back | T1557.002 |
| 164–166 | MITM | WPAD answered, a PAC served, and the victim’s traffic through the operator’s proxy | T1557 |
| 190–215 | Lateral movement | workstation-to-workstation SMB: ADMIN$, a service binary written, svcctl opened | T1021.002, T1569.002 |
| 225–242 | Collection | 14 × 64 KB reads off the file server, encrypted SMB3 — volume and direction only | T1039 |
| 243 | Exfiltration | one TLS session, 1.2 MB up against 31 KB down, to a host nothing else talks to | T1041 |
| 270–294 | Exfil backup | 34 ICMP echo requests carrying a kilobyte each | T1095 |
Five minutes is far too fast for this chain in real life; a real operator would take days and the beacon would be slower than the capture is long. The compression is deliberate, so that one file holds the whole story.
The cheapest signal in the file
wks-sales-12 is a Windows 11 host: TTL 128, Windows SYN option ordering,
Schannel ClientHellos for Outlook and Teams. Its beacons are none of those
things. The implant is statically linked Go, and its TLS hello says so.
$ tshark -r office-attack.pcap -Y 'tls.handshake.type==1' \
-T fields -e ip.src -e tls.handshake.ja4 \
-e tls.handshake.extensions_server_name | sort | uniq -c | sort -rn
9 10.21.10.61 t13d171100_57da90880613_40271e0a5736 cdn-telemetry-eu.example
...
1 10.21.10.61 t13d2312h2_f5f6aa22264f_40271e0a5736 outlook.cloud.microsoft
One host, two TLS stacks: t13d2312h2_… everywhere a Microsoft component
speaks, and t13d171100_… to one domain. The 00 in the middle of the JA4
is the giveaway — no ALPN at all, which no browser and no Office component
does. Change the C2 domain and the address and that fingerprint does not
move, which is why it is worth more than either.
Worked examples
The beacon is a clock
$ tshark -r office-attack.pcap -T fields -e frame.time_relative \
-Y 'tcp.flags.syn==1 && tcp.flags.ack==0 && ip.dst==203.0.113.45 && tcp.dstport==443'
30.830000000
62.626906000
93.296317000
122.624553000
153.237968000
183.952769000
213.857077000
244.621844000
273.461443000
Deltas of 31.8, 30.7, 29.3, 30.6, 30.7, 29.9, 30.8, 28.8 seconds. Human traffic does not do that; a sleep timer with a little jitter does. Nothing about the content matters here, only the arrival times — which is the whole point of flow-level analysis.
Carving the second stage
$ mkdir objs && tshark -r office-attack.pcap --export-objects http,objs -q
$ file objs/jquery-3.7.1.min.png
objs/jquery-3.7.1.min.png: PE32+ executable for MS Windows 6.00 (console), x86-64
The URL says .png, the Content-Type says image/png, and the bytes say
PE32+. Wireshark flags that one frame as malformed, because its PNG
dissector is handed something that is not a PNG — that is the finding, not a
defect in the capture. It is the only malformed frame in either file.
Zeek says the same thing in a line of log:
$ zeek -C -r office-attack.pcap
$ zeek-cut id machine subsystem is_exe section_names < pe.log
FlDg6l3bO0XZwf7uWh AMD64 WINDOWS_CUI T .text
FH8kVl1Q4WiXHLmjF9 AMD64 WINDOWS_CUI T .text
Two PEs: the one downloaded over HTTP, and the one written over SMB at t+190. Neither of them runs — the single section is filler — but every offset and length is where the format says it should be, which is what makes them parse.
The scan, and what answered
$ tshark -r office-attack.pcap -T fields -e ip.src \
-Y 'tcp.flags.syn==1 && tcp.flags.ack==0' | sort | uniq -c | sort -rn | head -3
60 10.21.10.61
10 10.21.10.52
6 10.21.10.88
Sixty connection attempts from one host in five minutes, against ten for the busiest normal desk. Then the useful half — which ports answered:
$ tshark -r office-attack.pcap -T fields -e tcp.dstport \
-Y 'tcp.flags.syn==1 && tcp.flags.ack==1 && ip.dst==10.21.10.61 && ip.src==10.21.20.10'
The scan is half-open: the SYN/ACK is answered with a bare RST, with the acknowledgement number left at zero, so the connection never completes and nothing is logged on the target. The ICMP sweep that precedes it is easier still to see — forty destinations, one packet each, 60 ms apart, and the core answers for six of the dead addresses before its ICMP rate limit stops it.
The credential, and cracking it
The poisoning is one packet: an LLMNR response, which the baseline never contains, sent from an endpoint claiming to be the file server.
$ tshark -r office-attack.pcap -Y 'udp.srcport==5355 && dns.flags.response==1' \
-T fields -e ip.src -e dns.qry.name -e dns.a
10.21.10.61 fileserver 10.21.10.61
10.21.10.61 fileserver 10.21.10.61
10.21.10.61 wpad 10.21.10.61
10.21.10.61 wpad 10.21.10.61
(LLMNR has no llmnr.* fields of its own in Wireshark — it is dissected by
the DNS dissector, so you filter on the port and use dns.* for the rest.)
The victim believes it and authenticates. SMB session setup happens once per session — not per file — so the NTLMv2 response sits exactly once at the front of the connection:
$ tshark -r office-attack.pcap -Y 'ntlmssp.messagetype==2' \
-T fields -e tcp.stream -e ntlmssp.ntlmserverchallenge
28 1122334455667788
94 a1b2c3d4e5f60718
$ tshark -r office-attack.pcap -Y 'ntlmssp.messagetype==3' \
-T fields -e tcp.stream -e ntlmssp.auth.domain -e ntlmssp.auth.username \
-e ntlmssp.auth.hostname -e ntlmssp.ntlmv2_response
28 CORP svc-scan SCAN-PC-01 2985ab9a…0101000000000000007c85e0…
94 CORP svc-scan WKS-SALES-12 548f541b…0101000000000000007c85e0…
Assemble those into hashcat’s mode 5600 format —
user::domain:challenge:NTProofStr:blob, where NTProofStr is the first 16
bytes of the NTLMv2 response and the blob is everything after it:
svc-scan::CORP:1122334455667788:2985ab9a7e5edcf6f34079d9679d596c:0101000000000000007c85e0…
and it cracks, because it is a real NTLMv2 response computed from a real password per MS-NLMP section 3.3.2, not random bytes:
$ hashcat -m 5600 hash.txt -a 3 '?u?l?l?l?l?l2026!'
SVC-SCAN::CORP:1122334455667788:2985ab9a…:Summer2026!
mkattack.py --hashes hashes.txt writes both lines out at build time, so
the answer key cannot drift from the capture.
The same credential is reused at t+190, against a different host, with a different server challenge — so the NTProofStr is different and the password is the same. That is what pass-the-hash looks like from the outside.
Kerberos: the etype is the tell
The domain runs AES. These three requests ask for RC4, which is the point: an RC4 service ticket can be cracked offline at speed.
$ tshark -r office-attack.pcap -Y 'kerberos.msg_type==12' \
-T fields -e ip.src -e kerberos.ENCTYPE -e kerberos.SNameString
10.21.10.52 18 krbtgt,CORP.NORTHSTAR.EXAMPLE,cifs,fs01.corp.northstar.example
10.21.10.61 23 krbtgt,CORP.NORTHSTAR.EXAMPLE,MSSQLSvc,sql01.corp.northstar.example:1433
10.21.10.61 23 krbtgt,CORP.NORTHSTAR.EXAMPLE,HTTP,intranet.corp.northstar.example
10.21.10.61 23 krbtgt,CORP.NORTHSTAR.EXAMPLE,MSSQLSvc,reporting.corp.northstar.example:1433
Note kerberos.ENCTYPE is the etype the request body asks for;
kerberos.etype is the etype of each EncryptedData in the message, which
is a different question. Zeek summarises the same thing per connection:
$ zeek-cut request_type client service cipher < kerberos.log
TGS jlin/CORP.NORTHSTAR.EXAMPLE MSSQLSvc/sql01.corp.northstar.example:1433 rc4-hmac
AS svc-legacy/CORP.NORTHSTAR.EXAMPLE krbtgt/CORP.NORTHSTAR.EXAMPLE rc4-hmac
Run the same command against the baseline file and every cipher is
aes256-cts-hmac-sha1-96. The AS-REQ at t+64 is the other Kerberos problem:
it carries no pre-authentication and the KDC answers anyway, which means
that account has “do not require preauth” set and its AS-REP is crackable
without ever touching it.
The DNS tunnel
$ tshark -r office-attack.pcap -T fields -e dns.qry.name \
-Y 'dns.flags.response==0 && dns.qry.type==16' | head -3
cyp2xftgd766c6shgmnvuxivrr7p52vme4zv7csqc7cam3o3eor.000.t.sync-eu.example
h2nmwmoi3mqzhppzx2wqd5a2fawf4lt7wevzg7bqxxrw74.001.t.sync-eu.example
3q6tk6yvsogqjxopdrwoygutunz2axdzylm43s6bgc5.002.t.sync-eu.example
Fifty-four TXT queries to one domain, each with 40 to 52 base32 characters in the first label and a counter in the second. Only the inside leg is here: dc01’s recursion to its forwarder does not cross Po1, which is exactly the view an access-layer SPAN gives you. You can still answer every question that matters — who, how much, how often, to which domain — from this side.
Lateral movement
$ tshark -r office-attack.pcap -Y 'smb2.cmd==3 || smb2.cmd==5' \
-T fields -e ip.src -e ip.dst -e smb2.tree -e smb2.filename
10.21.10.61 10.21.10.64 \\\\10.21.10.64\\ADMIN$
10.21.10.64 10.21.10.61 \\\\10.21.10.64\\ADMIN$ svchost-update.exe
10.21.10.61 10.21.10.64 \\\\10.21.10.64\\IPC$
10.21.10.64 10.21.10.61 \\\\10.21.10.64\\IPC$ svcctl
Write a binary into C:\Windows over the administrative share, open the
service control pipe, start it. Both hosts are workstations in VLAN 10, so
the core bridges the pair and the TTL never changes — the same lesson the
baseline’s Modbus pair teaches, now in the hands of someone moving sideways.
Zeek puts it in three logs:
$ zeek-cut id.orig_h id.resp_h username hostname success < ntlm.log
10.21.10.200 10.21.10.61 svc-scan SCAN-PC-01 -
10.21.10.61 10.21.10.64 svc-scan WKS-SALES-12 T
$ zeek-cut path share_type < smb_mapping.log
\\\\10.21.10.64\\ADMIN$ DISK
\\\\10.21.10.64\\IPC$ PIPE
$ zeek-cut action path name < smb_files.log
SMB::FILE_OPEN \\\\10.21.10.64\\ADMIN$ svchost-update.exe
The first NTLM row has no success value: that logon failed, because the
listener took the hash and refused the authentication, which is what
Responder does by default. The second succeeded.
Exfiltration
$ tshark -r office-attack.pcap -q -z conv,tcp | grep 198.51.100.73
10.21.10.61:51241 <-> 198.51.100.73:443 416 31 kB 818 1,228 kB 1234 1,259 kB
Every other TLS session in the file is shaped the other way round: a little up, a lot down. This one is 1.2 MB up against 31 KB down, to an address with no other history in the capture. The ICMP channel at t+270 is cruder:
$ tshark -r office-attack.pcap -T fields -e ip.dst \
-Y 'icmp.type==8 && data.len>900' | sort | uniq -c
34 203.0.113.45
ping sends 32 bytes on Windows and 56 on Linux. A kilobyte per echo, 34
times, to the same host as the HTTP beacon, is a tunnel.
And the proxy MITM from t+166 shows up in Zeek without any help:
$ zeek-cut id.orig_h id.resp_h id.resp_p tunnel_type action < tunnel.log
10.21.10.200 10.21.10.61 3128 Tunnel::HTTP Tunnel::DISCOVER
The rules
attack.rules holds twelve Suricata rules, one per
observable, with suricata-offline.yaml as a
configuration that needs no root and no interfaces:
$ suricata -c suricata-offline.yaml -S attack.rules \
-r office-attack.pcap -l out --runmode single
$ wc -l out/fast.log
84 out/fast.log
$ head -3 out/fast.log
11/10/2026-09:14:18.151403 [**] [1:9100002:1] NSL ATK look-alike SharePoint domain in SNI [**] ... 10.21.10.61:50741 -> 203.0.113.77:443
11/10/2026-09:14:21.461477 [**] [1:9100002:1] NSL ATK look-alike SharePoint domain in SNI [**] ... 10.21.10.61:50743 -> 203.0.113.77:443
11/10/2026-09:14:24.413200 [**] [1:9100001:1] NSL ATK executable delivered as an image [**] ... 203.0.113.45:80 -> 10.21.10.61:50748
| SID | What it keys on | Alerts |
|---|---|---|
| 9100001 | MZ at the start of a body typed image/… |
1 |
| 9100002 | the look-alike domain in the TLS SNI | 2 |
| 9100003 | MSIE 6.0 User-Agent on a POST, with no Referer | 3 |
| 9100004 | the implant’s JA4 hash | 10 |
| 9100005 | 15 bare SYNs from one source in 20 s | 1 |
| 9100006 | any LLMNR response at all | 4 |
| 9100007 | SMB between two hosts in the endpoint VLAN | 2 |
| 9100008 | a Kerberos ticket encrypted with rc4-hmac |
4 |
| 9100009 | 40-plus base32 characters in a DNS label | 54 |
| 9100010 | a tree connect ending in ADMIN$ |
1 |
| 9100011 | svcctl as UTF-16LE in an SMB2 CREATE |
1 |
| 9100012 | ICMP echo requests over 900 bytes | 1 |
Eighty-four alerts on office-attack.pcap, and zero on office.pcap —
worth checking yourself, because a rule set is only as good as its false
positive rate:
$ suricata -c suricata-offline.yaml -S attack.rules -r office.pcap -l base \
--runmode single && wc -l base/fast.log
0 base/fast.log
They are teaching rules, not production ones. 9100002 keys on a domain and
dies the moment the operator registers another. 9100007 would be noise in an
office that uses peer file shares. 9100005’s threshold is low enough to
catch a 22-port sweep and therefore low enough for a backup agent to trip.
9100011 matches a string in a packet rather than a parsed field, because
Suricata has no smb.filename keyword — which is a useful thing to know
when the keyword you want does not exist.
Exercise ideas
- Timeline from scratch. Given only
office-attack.pcap, produce the table at the top of this page: time, stage, evidence. No hints. - Pivot discipline. Find the compromise starting from a single
indicator — the string
cdn-telemetry-eu— and justify every host and flow you add to the incident. - Diff the files.
office.pcapandoffice-attack.pcapshare their benign frames exactly. Write something that outputs only the attack frames, then check it againstmkattack.py --overlay-only. - Crack the hash. Pull the NTLMv2 response out of the capture by hand and recover the password. Then explain why the second one has a different NTProofStr for the same password.
- Write the missing rules. Three stages in the table have no rule in
attack.rules: the ARP spoofing, the WPAD/PAC MITM, and the asymmetric TLS upload. Two of them Suricata cannot see at all — say which, and why, and what would. - Beacon maths. Compute the interval and jitter from the capture alone, then work out how long a 1-hour-sleep beacon would take to detect with the same method, and what that means for how long you need to keep flow logs.
- Tune for false positives. Run
attack.rulesagainst the baseline, then against--seed 7rebuilds of both files. Which rules are keyed on something stable, and which on an accident of this capture? - What the SPAN cannot see. The operator also touched the servers directly, server to server. Explain why none of that is in the file, and where you would put a second capture point to get it.
What is synthetic, and where it shows
Everything in the baseline page’s list of what is synthetic still applies. On top of it:
- Encrypted payloads are random bytes. The beacons, the exfil upload and the SMB3 reads carry no recoverable content, by construction. Volume, direction and timing are the only things to analyse there — which is also true of the real thing without keys.
- The chain is compressed. Seventeen stages inside five minutes. A real intrusion of this shape is days long, and the dwell time between stages is usually the most useful evidence there is.
- One host does everything. Real operators spread their activity, drop tooling on a second host, and come back from a different address.
- The DCE/RPC is a stub. The endpoint-mapper bind at t+190 is a real
bind PDU; the
ept_mapcall and the svcctl traffic inside the pipe are opaque bytes. Zeek and Suricata both see the bind and the pipe name, which is what the exercises use, but do not expect to decode the service create. - The ICMP tunnel is not a real protocol. It is base64-looking filler of the right size in the right shape, not an encapsulated IP stream.
- No endpoint telemetry. This is a wire capture. Every “the operator then ran…” question has to be answered from frames, which is the constraint worth practising under.
References
- RFC 5737, IPv4 Address Blocks Reserved for Documentation — where the attacker addresses come from
- MS-NLMP, NT LAN Manager (NTLM) Authentication Protocol — NTLMv2 response and NTProofStr computation, section 3.3.2
- MS-SMB2, Server Message Block (SMB) Protocol Versions 2 and 3 — session setup, tree connect, create/write
- RFC 4120, The Kerberos Network Authentication Service (V5) — KDC-REQ-BODY, KDCOptions and APOptions as 32-bit bit strings
- RFC 4178, SPNEGO — the negTokenInit/negTokenResp wrapper the NTLM messages travel in
- RFC 4795, Link-Local Multicast Name Resolution — LLMNR, and why an answer is suspicious
- hashcat mode 5600 (NetNTLMv2) — the hash format used above
- JA4+ network fingerprinting — what the JA4 string’s fields mean
- Suricata 8 rule keywords —
ja4.hash,krb5.ticket_encryption,smb.share,smb.named_pipe - Zeek log reference —
ntlm.log,smb_mapping.log,smb_files.log,kerberos.log,pe.log,tunnel.log - MITRE ATT&CK Enterprise — the technique IDs in the timeline table
- Responder — the tool whose behaviour the poisoning stage imitates, including the fixed challenge and the refused logon