Network Attack
Detection
A protocol-depth examination of how network attacks work at the packet level — and what they leave behind for defenders. Ten chapters covering the mechanics beneath the tools, the traffic signatures that expose each attack class, and the detection rules and forensic techniques that find them.
Attacks in the Protocol Stack
The OSI model as an attack surface map, why lower-layer attacks are harder to detect, trust assumptions baked into protocols, and the attacker's view of the stack
Every network attack exploits a trust assumption that a protocol made about the environment it would run in. ARP assumed all hosts on a segment are trustworthy. DNS assumed resolvers would only answer accurately. LLMNR assumed that if a name can't be resolved, any host on the network willing to answer must know the truth. These assumptions were reasonable in the environments the protocols were designed for — isolated LANs, university networks, trusted intranets. They are catastrophically wrong in adversarial environments.
Understanding which layer of the stack an attack operates at is not merely academic. Layer 2 attacks (ARP poisoning) can intercept traffic before any Layer 3 security control sees it. Layer 3/4 attacks can bypass application-layer inspection. The deeper the attack in the stack, the fewer defensive controls are positioned to observe it — most security tooling operates at Layer 7.
Why Layer 2 Is the Blind Spot
Most enterprise security monitoring is built around Layer 3 and above. Firewalls inspect IP packets. IDS/IPS inspect TCP streams and application-layer payloads. SIEM rules correlate authentication events, DNS queries, and HTTP requests. The switch fabric — Layer 2 — is largely invisible to all of these controls.
ARP poisoning, MAC flooding, and VLAN hopping all operate at Layer 2. They generate no IP traffic before achieving their objective. A network with comprehensive Layer 7 logging but no Layer 2 security controls (dynamic ARP inspection, port security, 802.1X) has a significant blind spot that attackers who understand the stack can exploit silently.
Protocol Trust Assumptions — A Taxonomy
| Protocol | Layer | Trust Assumption | Attack That Breaks It |
|---|---|---|---|
| ARP | 2 | Any host can answer an ARP request authoritatively; last answer wins | ARP poisoning / gratuitous ARP flooding |
| DHCP | 3/7 | First DHCP offer received is legitimate; DHCP server is authoritative | Rogue DHCP server; DHCP starvation |
| DNS | 7 | Resolvers answer honestly; transaction IDs are unpredictable; UDP is sufficient | Cache poisoning; DNS tunnelling; Kaminsky attack |
| LLMNR/NBT-NS | 7 | Any host claiming to know a hostname on the local segment can be trusted | Responder poisoning; NTLMv2 capture |
| NTLM | 7 | The server sending the challenge is the intended destination | NTLM relay; pass-the-hash |
| BGP | 3/7 | Peers announcing routes are authorised to originate those prefixes | BGP hijacking; route injection |
| IPv6 SLAAC | 3 | Router Advertisement messages come from legitimate routers | Rogue RA; mitm6 DHCPv6 abuse |
The Attacker's View: Horizontal and Vertical Movement
Network attacks serve two objectives in an engagement. Horizontal movement — using network-level attacks to move laterally between systems at the same privilege level (ARP poisoning for traffic interception, LLMNR poisoning for credential capture). Vertical movement — using captured credentials or relay attacks to escalate privileges (NTLM relay to LDAP, Kerberoasting via the network, DCSync over the replication protocol).
The protocol stack determines both what is possible and what is visible. An attacker who understands where monitoring is deployed can choose the attack layer that produces the least observable signal. A defender who understands the same landscape can position sensors at the layers that are currently blind.
- Every network attack exploits a trust assumption the protocol made about its operating environment — identifying the assumption identifies the fix
- Layer 2 is the most common blind spot in enterprise security monitoring — most detection tooling operates at Layer 3 and above
- The lower the attack in the stack, the fewer security controls are positioned to observe it — depth in the stack translates to detection difficulty
- Protocol trust assumptions were reasonable for isolated LANs; they are exploitable in any environment where an attacker has achieved local network access
ARP Poisoning and Layer 2 Attacks
ARP protocol mechanics, the cache poisoning sequence at the packet level, MITM positioning, VLAN hopping, MAC flooding, and switch-level defences
ARP — the Address Resolution Protocol — is how Layer 2 and Layer 3 are bridged. When a host wants to send an IP packet to another host on the same subnet, it first needs the destination's MAC address. ARP resolves that mapping. The protocol was designed in 1982 for a trusted network environment and has no authentication whatsoever. Any host on the segment can send an ARP reply for any IP address, and the receiving host will update its cache accordingly.
The ARP Protocol in Full
What an Attacker Captures in MITM Position
Once in MITM position, the attacker's NIC is in promiscuous mode, forwarding traffic between the real hosts while capturing everything. What this exposes depends on the protocols in use:
- Unencrypted protocols — HTTP, FTP, SMTP, POP3, Telnet, older SMBv1 — everything is visible in cleartext. Credentials, session cookies, file transfers, emails.
- TLS-encrypted protocols — the attacker sees encrypted blobs but can attempt SSL stripping (downgrading HTTPS to HTTP by intercepting the initial redirect) against targets without HSTS.
- NTLM challenge-response — SMB, HTTP NTLM, and other Windows authentication protocols send a challenge-response that the attacker can capture for offline cracking or relay.
- Kerberos tickets — AS-REQ and TGS-REQ packets transit the network and can be captured for offline cracking (AS-REP Roasting targets) or relay.
Detecting ARP Poisoning
Switch-Level Defences
- Dynamic ARP Inspection (DAI) — switch feature that validates ARP packets against a trusted DHCP snooping binding table. If the MAC/IP pair in an ARP reply doesn't match the binding table, the packet is dropped. Eliminates ARP poisoning when DHCP snooping is also enabled.
- Port security — limits the number of MAC addresses permitted on a switch port. Prevents MAC flooding attacks (which fill the switch's CAM table, causing it to broadcast all frames).
- 802.1X port authentication — requires hosts to authenticate before being granted network access at the switch level. An attacker with physical access but no valid credentials is blocked at Layer 2.
- Private VLANs (PVLANs) — prevent Layer 2 communication between hosts in the same VLAN. Hosts can only communicate via the router, which logs the traffic. Eliminates ARP poisoning between hosts in the same segment.
- ARP has no authentication — any host can send a gratuitous ARP reply claiming any IP, and receiving hosts will update their cache without verification
- ARP poisoning produces two signatures: a single MAC address claiming multiple IPs, and a high rate of unsolicited ARP replies from one source
- Wireshark's
arp.duplicate-address-detectedfilter surfaces poisoning automatically — tshark one-liners can extract the anomaly from large captures - Dynamic ARP Inspection (DAI) on the switch validates ARP against the DHCP binding table and drops spoofed replies before they reach hosts
- MITM position via ARP poisoning exposes all unencrypted traffic and enables SSL stripping against non-HSTS connections
DNS Attacks and Abuse
The Kaminsky cache poisoning attack, DNS tunnelling mechanics and detection, DNS-based C2 beaconing patterns, DGA detection, and DNS rebinding
DNS is the directory service of the internet — and one of the most abused protocols in offensive security. Because DNS traffic is nearly universally permitted through firewalls (port 53 outbound is almost always open), it is the protocol of choice for covert channels, C2 beaconing, and data exfiltration. Understanding both why DNS is vulnerable and what abuse looks like in traffic enables detection that signature-based tools frequently miss.
The Kaminsky Attack — Cache Poisoning Mechanics
DNS cache poisoning injects forged records into a resolver's cache, redirecting queries for a legitimate domain to an attacker-controlled IP. The Kaminsky attack (2008) demonstrated that this was practical at scale by exploiting predictable transaction IDs and the ability to flood the resolver with forged responses.
DNS Tunnelling — Data Encoding in Queries
DNS tunnelling encodes arbitrary data into DNS queries and responses, creating a covert channel through firewalls that permit DNS. Tools like iodine, dnscat2, and DNS2TCP implement full IP-over-DNS or shell-over-DNS. The fundamental technique is the same: data is base32/base64 encoded and embedded in subdomain labels of a query to an attacker-controlled domain.
DNS Rebinding — Bypassing Same-Origin Policy
DNS rebinding is a technique that bypasses the same-origin policy and SSRF server-side filters by exploiting the gap between DNS resolution and subsequent use. The attack works by controlling a domain whose DNS TTL is extremely short, then changing the DNS record between the security check and the actual network request.
- The Kaminsky attack made DNS cache poisoning practical by forcing cache misses via random subdomains and flooding with 65536 forged responses — DNSSEC and source port randomisation are the fixes
- DNS tunnelling detection relies on statistical analysis of query patterns — QNAME length, query rate, unique subdomain count, and entropy — not signatures
- DNS rebinding exploits the gap between DNS resolution and request execution — a 1-second TTL allows the attacker to change the IP between the security check and the actual fetch
- DNS is almost universally permitted outbound — it is therefore the protocol of choice for C2, exfiltration, and covert channels in restricted network environments
- DNSSEC signs DNS responses; RPKI signs BGP route announcements — both address the same root problem (unauthenticated protocol) at different layers
LLMNR, NBT-NS, and mDNS Poisoning
The Windows name resolution fallback chain, the NTLMv2 challenge-response structure, what Responder traffic looks like at the packet level, and disabling the protocols via GPO
The Penetration Testing module shows you how to run Responder and what hashes it captures. This chapter explains why those hashes appear — the complete protocol chain that runs between a Windows host failing DNS resolution and an NTLMv2 response arriving in Responder's output. Understanding this chain is what lets you detect, prevent, and explain the vulnerability to network engineers who have never run a pentest tool.
The Windows Name Resolution Chain
When a Windows machine needs to resolve a hostname, it doesn't immediately broadcast to the network. It follows a prioritised sequence of resolution methods, falling back to less secure options only when earlier ones fail:
The NTLMv2 Challenge-Response — What Gets Captured
When Windows connects to what it believes is FILESERVER01 (actually Responder), it initiates NTLM authentication. The NTLMv2 exchange produces a response that depends on the user's password hash and the server's challenge. The attacker captures this response and can crack it offline.
What This Looks Like in a Packet Capture
Disabling the Protocols — GPO Configuration
- LLMNR and NBT-NS fire only when DNS fails — the attack requires either a DNS failure (typo, missing record) or a direct query for a non-existent hostname
- The NTLMv2 response contains a HMAC-MD5 over the server challenge, client challenge, and timestamp — it can be cracked offline but only succeeds if the password appears in a wordlist
- Relay attacks forward the challenge-response live to a real target — they don't require cracking, making them categorically more powerful than offline hash capture
- Detection: LLMNR responses should be rare to nonexistent in a healthy network — any host sending frequent LLMNR responses on port 5355 warrants investigation
- Disabling LLMNR via GPO and NBT-NS via DHCP or registry eliminates the entire attack class — it is a two-setting configuration change with no meaningful operational impact on modern networks
NTLM, Relay, and Coercion
The NTLM protocol in full, why relay is possible, SMB signing as the fix, coercion techniques (PrinterBug, PetitPotam, DFSCoerce), relay to LDAP, and detection via Event IDs
NTLM relay is arguably the highest-impact network attack class in Active Directory environments. Where passive credential capture (Responder) requires a victim to make an error, coercion-based relay forces authenticated connections from any domain-joined host — including domain controllers — to the attacker's machine. Understanding the cryptographic structure of NTLM explains precisely why relay is possible and exactly what signing prevents.
The NTLM Protocol — Full Cryptographic Structure
Why SMB Signing Breaks Relay
SMB signing cryptographically authenticates every SMB message using a session key derived from the user's NT hash. If an attacker relays a Type 3 message to a server with signing required, that server will demand that subsequent messages are signed — but the attacker doesn't have the session key (which requires knowing the NT hash), so they cannot produce valid signatures. The relay succeeds at the authentication step but every subsequent command fails signature verification.
The session key for SMB signing is derived as: HMAC-MD5(NT_hash, NTProofStr). The attacker who relayed the authentication has the NTProofStr (it passed through them) but not the NT_hash (the user's password hash). Without the NT_hash, they cannot compute the session key and cannot sign any subsequent messages. This is why signing is the effective control — it makes the authenticated session useless to a relaying attacker.
Coercion — Forcing Authentication Without Waiting
Passive relay (waiting for LLMNR broadcasts) requires the attacker to be on the same network segment and wait for a victim to make a name resolution error. Coercion techniques actively force domain computers — including domain controllers — to authenticate to the attacker on demand. This is a fundamentally different threat model.
Detection via Windows Event IDs
| Event ID | Log | Description | Relevance |
|---|---|---|---|
| 4624 | Security | Successful logon | Logon Type 3 (network) from unexpected sources; logons from machine accounts (DC$) to unusual targets |
| 4625 | Security | Failed logon | High rate of Type 3 failures from single source = relay attempt or spray |
| 4648 | Security | Logon with explicit credentials | Indicates pass-the-hash or runas — machine account authenticating interactively |
| 5140 | Security | Network share access | Machine accounts (DC$, WS$) accessing shares they normally wouldn't |
| 4768 | Security | Kerberos TGT request | TGTs requested for machine accounts from unexpected IPs |
- NTLM relay is possible because nothing in the Type 3 AUTHENTICATE message binds it to the intended server — the challenge from any server produces a valid response that any server will accept
- SMB signing breaks relay because the attacker cannot compute the session key (requires the NT hash they don't have) and therefore cannot sign subsequent messages
- Coercion (PrinterBug, PetitPotam, DFSCoerce) forces authentication on demand from any domain computer — making relay independent of victim error or network position
- Relay to LDAP with shadow credentials or RBCD achieves full domain compromise from a single coerced DC authentication
- Detection: Event ID 4624 Logon Type 3 with NTLM from machine accounts (ending in $) to non-DC hosts is a high-fidelity indicator of relay activity
IPv6 Attacks and Modern Network Abuse
Why "we don't use IPv6" is wrong, SLAAC and DHCPv6 mechanics, the mitm6 attack chain, what IPv6 attack traffic looks like, and detection and mitigation
The most common response to the mitm6 attack is "but we don't use IPv6." This misunderstands the threat. The attack doesn't require the organisation to have deployed IPv6. It only requires Windows — which, by default, prefers IPv6 over IPv4 and sends DHCPv6 solicits periodically even on IPv4-only networks. An attacker who understands this can often achieve MITM position and NTLM relay on networks that have never consciously touched IPv6 configuration.
SLAAC and DHCPv6 — The Protocols Being Abused
IPv6 Stateless Address Autoconfiguration (SLAAC) allows hosts to configure their own IPv6 addresses based on Router Advertisement (RA) messages sent by routers. DHCPv6 provides stateful IPv6 address assignment. Both use multicast: RA messages go to ff02::1 (all nodes), DHCPv6 solicits go to ff02::1:2 (all DHCPv6 agents). Any host on the segment can send these messages.
What mitm6 Traffic Looks Like
Mitigation
- Block DHCPv6 on switches — deploy DHCP Guard / RA Guard on switch ports to drop DHCPv6 Advertise and Router Advertisement messages from non-authorised ports. This is the switch-level equivalent of DHCP snooping for IPv4.
- Disable IPv6 where not needed — via GPO: Computer Configuration → Administrative Templates → Network → TCPIP Settings → Disable IPv6 components. Prevents Windows from sending DHCPv6 SOLICITs entirely.
- Disable WPAD — the Web Proxy Auto-Discovery protocol is the mechanism that triggers automatic NTLM authentication. Disable via GPO or set the
WpadOverrideregistry key. Remove the WPAD DNS entry if it exists. - Enable LDAP signing and channel binding — even if relay occurs, LDAP signing prevents the relayed session from being used for LDAP writes (the objective of the ntlmrelayx LDAP relay chain).
- Windows sends periodic DHCPv6 SOLICITs even on IPv4-only networks — "we don't use IPv6" does not prevent mitm6
- mitm6 is more powerful than LLMNR poisoning because it doesn't require DNS failures — it works on networks with fully functioning DNS
- The WPAD mechanism forces automatic NTLM authentication from all Windows hosts — disabling WPAD eliminates the primary authentication trigger for mitm6
- RA Guard and DHCP Guard on switches prevent unauthorised DHCPv6 Advertise and Router Advertisement messages from reaching hosts
- The complete mitigation stack: disable IPv6 if unused (GPO), disable WPAD (GPO), enable RA/DHCP Guard (switch), enable LDAP signing (DC policy), enable SMB signing (GPO)
Network Scanning, Evasion, and Fingerprinting
What nmap is doing at the packet level, TCP state machine mechanics, OS fingerprinting via stack behaviour, evasion techniques and their signatures, and detecting scans in logs
The Penetration Testing module shows nmap flags and their outputs. This chapter shows what those flags produce at the wire level — which packets are sent, what responses are expected, and why the TCP state machine's behaviour differs between open, closed, and filtered ports. This is the knowledge that lets you write IDS rules that detect scanning despite evasion, because you understand what the evasion is actually doing.
The TCP State Machine — What nmap Exploits
OS Fingerprinting — TCP Stack Behaviour Differences
Different operating systems implement the TCP/IP stack differently — initial TTL values, TCP window sizes, IP flags, ICMP response behaviour, and TCP options in SYN packets all vary by OS and version. nmap's -O flag collects these values and compares them against a fingerprint database of thousands of OS/version combinations.
Scan Evasion Techniques and Their Signatures
| Evasion Technique | nmap Flag | Mechanism | IDS Signature Despite Evasion |
|---|---|---|---|
| Timing reduction | -T1 / -T0 | Slows scan to evade rate-based detection | Still produces SYN packets to sequential ports — just slower. Threshold detection fails; pattern detection still works. |
| IP fragmentation | -f | Splits TCP header across multiple fragments — some IDS can't reassemble | High fragmentation rate from single source; tiny fragments (8 bytes) are unusual |
| Decoy scanning | -D decoy1,decoy2 | Spoofs source IP — scan appears to come from multiple hosts | Real source still in the set; all "sources" send SYNs to exactly the same ports at the same time — impossible for uncoordinated hosts |
| Source port spoofing | --source-port 53 | Sets source port to 53 — some firewalls trust DNS replies | Responses to port 53 source go to DNS port — SYN/ACK from host to port 53 with no prior DNS query is anomalous |
| Randomised order | --randomize-hosts | Scans targets in random order | Still produces characteristic SYN pattern; NetFlow analysis shows the full picture regardless of order |
- SYN scan sends one SYN and reads the response: SYN/ACK = open, RST/ACK = closed, no response = filtered — the TCP state machine determines port status, not the application
- OS fingerprinting compares TCP/IP stack behaviours (TTL, window size, TCP options) against a database — the values are set by the OS kernel and are difficult to spoof without breaking connectivity
- Scan evasion reduces the signal for rate-based detection but doesn't eliminate the scan's characteristic pattern — sequential port access, consistent SYN timing ratios, and decoy anomalies all survive evasion
- Passive fingerprinting (p0f) identifies OS from normal traffic with zero packets sent — useful for inventory and anomaly detection without active scanning
- NetFlow/IPFIX data is the most reliable scan detection source — it shows connection attempts across the entire network regardless of whether individual hosts log them
Covert Channels and C2 Traffic
DNS and ICMP tunnelling mechanics, HTTP/S C2 traffic patterns, JA3/JA3S TLS fingerprinting, domain fronting, beaconing detection, and Cobalt Strike malleable profiles
Command and control infrastructure is the nervous system of a post-exploitation engagement. Once an attacker has code execution on a host, they need a communication channel back to their infrastructure. The challenge for the attacker is making that channel blend into legitimate traffic — and the challenge for defenders is finding the pattern that distinguishes C2 from legitimate communications despite the blending effort.
HTTP/S C2 — What It Looks Like
Modern C2 frameworks (Cobalt Strike, Sliver, Havoc) communicate over HTTPS because HTTPS traffic is nearly universally permitted and the encryption prevents content inspection. The distinguishing characteristics of C2 traffic are not in the content — they are in the metadata: timing, frequency, size patterns, and certificate details.
JA3/JA3S — TLS Fingerprinting
JA3 creates a fingerprint of TLS ClientHello messages — the combination of TLS version, cipher suites, extensions, elliptic curves, and elliptic curve point formats produces a hash that identifies the TLS implementation, not just the content. C2 frameworks have characteristic JA3 hashes that differ from browser TLS stacks even when the User-Agent is spoofed.
Beaconing Detection — Statistical Analysis
- C2 beaconing is detectable via timing regularity — machine-precision intervals with low standard deviation are not produced by human-driven traffic
- JA3 fingerprints the TLS ClientHello fields — C2 frameworks have characteristic JA3 hashes that differ from browser implementations even when User-Agent is spoofed
- DNS tunnelling produces high-entropy, long subdomains at high query rates — statistical analysis detects it; content inspection doesn't help because the data is in the labels
- Malleable C2 profiles add jitter and pad request/response sizes — detection shifts from absolute values to statistical patterns (low stddev relative to mean interval)
- Domain fronting uses a legitimate CDN's TLS certificate while routing to attacker infrastructure — JA3S fingerprinting of the CDN vs the actual backend can surface this mismatch
Lateral Movement at the Network Level
What lateral movement looks like as network traffic, WMI/SMB/WinRM/RDP signatures, NetFlow as a detection source, Sigma rules for movement detection, and the challenge of legitimate protocol abuse
The Penetration Testing module covers lateral movement tools and commands. This chapter covers what those tools produce on the wire and in logs — because defenders detecting lateral movement rarely see the tool output, they see Event IDs, NetFlow records, and proxy logs. Understanding the network signature of each technique is what allows defenders to write detection logic that fires on the behaviour regardless of which specific tool is used.
Lateral Movement Technique Network Signatures
| Technique | Protocol / Port | Network Signature | Event IDs |
|---|---|---|---|
| PsExec / SMB exec | SMB 445/tcp | SMB connection; IPC$ share access; service creation; ADMIN$ share write (uploads binary) | 4624 (Type 3), 7045 (new service), 5140 (share access) |
| WMI remote exec | RPC 135/tcp + dynamic high ports | Initial RPC on 135, then random high port negotiation; DCOM traffic pattern | 4624 (Type 3), 4688 (process create on target), Sysmon 1 |
| WinRM / PowerShell remoting | 5985/tcp (HTTP) or 5986/tcp (HTTPS) | HTTP to port 5985; WSMan protocol; large base64-encoded payloads in HTTP body | 4624 (Type 3), PowerShell 4103/4104 (script block logging) |
| Pass-the-Hash SMB | SMB 445/tcp | NTLM authentication (not Kerberos) from unexpected source; unusual time for the account | 4624 (Type 3, NTLM, no prior 4768) |
| RDP | 3389/tcp | RDP connection; large data transfer (screen bitmap); keyboard/mouse events pattern | 4624 (Type 10 = RemoteInteractive), 4778 (reconnect) |
| DCOM lateral movement | RPC dynamic | DCOM activation requests; MMC20 or ShellWindows COM object instantiation | 4624 (Type 3), 4688, Sysmon 8/10 (remote thread/process access) |
Pass-the-Hash vs Legitimate Authentication — The Detection Signal
- Pass-the-Hash produces NTLM authentication to port 445 without any preceding Kerberos traffic to the DC — the absence of Event IDs 4768/4769 is as significant as the presence of 4624
- PsExec's signature is a service creation (Event ID 7045) with a random name and a binary path under ADMIN$ — this pattern is consistent regardless of which tool executes it
- WinRM/PowerShell remoting generates HTTP connections on port 5985 with large base64 payloads — script block logging (Event ID 4104) is essential for seeing what was executed
- NetFlow data sees all lateral movement attempts regardless of whether the target host logs them — it's the detection source least affected by an attacker who has compromised endpoint logging
- The challenge of lateral movement detection is that it uses legitimate protocols (SMB, WMI, RDP) — detection requires behavioural baselines (who normally connects to what) not just signature matching
Network Forensics and Attack Reconstruction
Reconstructing an attack chain from PCAP, tshark forensic techniques, extracting credentials and files from captures, building the network timeline, and corroborating endpoint forensics
Network forensics answers questions that endpoint forensics cannot. An attacker who clears Windows event logs, deletes PowerShell history, and removes tools from disk has eliminated most endpoint evidence. The network traffic — if captured — is outside their control. PCAP and NetFlow data captured on network infrastructure tells the story of what happened regardless of what the attacker did to the endpoints they touched.
The Network Forensics Toolkit
| Tool | Purpose | Best For |
|---|---|---|
| Wireshark | Interactive PCAP analysis, stream following, protocol dissection | Manual investigation, credential extraction, protocol-specific analysis |
| tshark | CLI Wireshark — scriptable, pipeline-friendly | Automated analysis, large PCAP processing, field extraction |
| Zeek | Network traffic analysis framework — generates structured logs from PCAP | Turning raw PCAP into queryable logs (conn.log, dns.log, http.log, ssl.log) |
| NetworkMiner | Passive network sniffer and forensic analyser | Extracting files, images, and credentials from PCAP automatically |
| Arkime (Moloch) | Full-packet capture storage and search platform | Enterprise-scale PCAP with indexed search and JA3 integration |
Reconstructing an Attack from PCAP
Extracting Credentials from Captures
Network Evidence Limitations
Network forensics is powerful but has structural limitations that investigations must account for:
- Encryption — TLS-encrypted traffic (HTTPS, SMB3 with encryption, RDP) cannot be decrypted without the server's private key. You can see the connection happened, the timing, and the data volumes, but not the content.
- Capture points — you can only analyse traffic that passed through a capture point (SPAN port, TAP, firewall log). East-west traffic on the same switch segment may not have been captured.
- Storage limitations — full PCAP at scale is expensive. Most organisations retain NetFlow data (connection metadata, no payload) for longer periods than full PCAP. NetFlow shows who connected to whom; PCAP shows what was said.
- Timestamps — network timestamps are only as reliable as the clock synchronisation of the capture device. NTP skew between capture devices can misalign the timeline by seconds to minutes.
- Network PCAP is outside the attacker's control after the fact — it tells the story of what happened even when endpoint evidence has been destroyed
- tshark's
-z follow,tcp,asciireconstructs full TCP streams — interactive shell sessions, file transfers, and protocol exchanges are readable from PCAP - Credentials in unencrypted protocols (HTTP Basic Auth, FTP, Telnet) are extractable directly from PCAP with one-line tshark commands
- Zeek converts raw PCAP into structured logs (conn.log, dns.log, http.log, ssl.log) that are queryable like a database — essential for large-scale network forensics
- NetFlow shows who connected to whom even without full PCAP — it is the minimum viable network forensics artifact and should be retained for at least 90 days on all network segments