courses

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

  1. Timeline from scratch. Given only office-attack.pcap, produce the table at the top of this page: time, stage, evidence. No hints.
  2. 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.
  3. Diff the files. office.pcap and office-attack.pcap share their benign frames exactly. Write something that outputs only the attack frames, then check it against mkattack.py --overlay-only.
  4. 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.
  5. 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.
  6. 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.
  7. Tune for false positives. Run attack.rules against the baseline, then against --seed 7 rebuilds of both files. Which rules are keyed on something stable, and which on an accident of this capture?
  8. 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:

References