Skip to content

Wireshark Advanced Capture and Protocol Reference

github-actions[bot] edited this page Nov 15, 2026 · 1 revision

Important

Canonical filter library: Wireshark Master Filter List Β· Field Cheat Sheet Β· 133-entry validated filter catalog. This existing page remains the advanced capture/hardware reference. The examples below contain explanatory comments inside some fenced blocks; paste only the actual filter expression, not a comment or a complete block. Filter matches do not prove that an attack occurred. Verify remote capture commands and hardware features before use.

🎯 Purpose

Comprehensive Wireshark display and capture filter reference for network analysis, security operations, threat hunting, and protocol-specific capture (Bluetooth/BLE, Zigbee, WiFi, remote SSH streaming).

βš™οΈ Function

Organized by filter type: core protocol filters, port-based filters, IP/subnet filters, TCP flag and state analysis, security/threat detection patterns, noise reduction, remote SSH-to-Wireshark streaming, BLE/Bluetooth capture, Zigbee, MikroTik RouterOS sniffer, OpenWRT/tcpdump, and ready-to-paste starter filter sets for common scenarios.

πŸ† Goal

Serve as a field reference for copy-paste-ready Wireshark filters during live network analysis, security assessments, and lab exercises - reducing time spent looking up syntax during active captures.

πŸ“‹ When to Use

  • Live packet analysis during penetration tests or incident response
  • Analyzing brute-force/exfiltration traffic from tools like Bjorn (blue-team detection)
  • Capturing and inspecting BLE, Bluetooth, or Zigbee traffic alongside hardware tools
  • Setting up remote captures from routers (MikroTik, OpenWRT) via SSH
  • Building Suricata/Zeek detection rules from real Wireshark captures

Complete Wireshark display and capture filter reference for network analysis and security operations

Part of the ULTIMATE CYBERSECURITY MASTER GUIDE

Documentation Network Analysis Security Operations


πŸ“‹ Table of Contents


🎯 Overview

This document provides a comprehensive Wireshark filter reference compiled from real-world network analysis, security assessments, and homelab operations. It covers display filters, capture filters, remote streaming, and protocol-specific analysis for wireless, Bluetooth, and IoT traffic.

What You'll Find Here:

  • πŸ“‘ Core protocol and port-based display filters
  • πŸ” IP, subnet, and TCP flag filters
  • πŸ›‘οΈ Security and threat detection filters
  • πŸ“‰ Noise reduction for cleaner captures
  • πŸ–₯️ Remote SSH-to-Wireshark live streaming
  • πŸ“Ά BLE/Bluetooth and Zigbee capture setup
  • πŸ”§ MikroTik RouterOS and OpenWRT sniffer configs
  • ⚑ Ready-to-paste minimum starter filter sets

Focused Wi-Fi deauthentication analysis

For a protocol-level explanation of legitimate 802.11 disconnects versus forged deauthentication/disassociation, PMF, monitor-mode requirements, and passive detection filters, see the Wi-Fi Deauthentication Detection Guide. An Ethernet or managed-mode capture typically cannot show raw 802.11 management frames.

πŸ“‚ Capture Methods

Before filtering, choose the right capture mode for your scenario.

Method Use Case Notes
Promiscuous mode Capture all frames the NIC receives Standard for wired analysis
Monitor mode Capture all 802.11 frames including other stations Requires compatible wireless NIC
Port mirroring / SPAN Mirror another switch port to your monitoring interface Requires managed switch
Network tap Passive in-line capture on a physical link Most accurate, no network impact
Remote SSH capture Live stream from router or remote device into Wireshark See Remote Capture section

βœ… Tip: Enable promiscuous mode in Capture β†’ Options β†’ Promiscuous before starting. For wireless, use Capture β†’ Options β†’ Monitor Mode.


πŸ—‚οΈ Core Protocol Filters

These are Wireshark display filters - enter them in the filter bar after a capture is running or loaded.

Transport Layer

tcp                    # All TCP traffic
udp                    # All UDP traffic
icmp                   # ICMP (ping, traceroute)
arp                    # ARP (address resolution, network mapping)

Application Layer

dns                    # DNS queries and responses
dhcp                   # DHCPv4 traffic (legacy versions may use bootp)
http                   # HTTP (cleartext web traffic)
tls                    # TLS/HTTPS (encrypted; metadata only)
ftp                    # FTP control channel
ftp-data               # FTP data transfer
smb || smb2            # SMB / Windows file sharing
ssh                    # SSH (filtered by protocol field)

Wireless & IoT

wlan                   # 802.11 WiFi frames
eapol                  # WPA handshake capture (key exchange)
btle                   # Bluetooth Low Energy
btatt                  # BLE GATT operations (IoT attribute reads/writes)
smp                    # BLE Security Manager (pairing events)
wpan                   # 802.15.4 / Zigbee frames
zbee_nwk               # Zigbee network layer
zbee_zcl               # Zigbee cluster library (application layer)

πŸ”Œ Port-Based Filters

# Single port (either direction)
tcp.port == 443

# Multiple ports
tcp.port == 80 || tcp.port == 443

# Destination port only
tcp.dstport == 8080

# Source port only
tcp.srcport == 443

# Port range
(tcp.srcport >= 8000 && tcp.srcport <= 9000) || (tcp.dstport >= 8000 && tcp.dstport <= 9000)

Common Port Reference

Port Protocol Filter
22 SSH tcp.port == 22
25 SMTP tcp.port == 25
53 DNS udp.port == 53 || tcp.port == 53
67/68 DHCP dhcp
80 HTTP http
110 POP3 tcp.port == 110
143 IMAP tcp.port == 143
443 HTTPS tls
445 SMB smb || smb2
993 IMAPS tcp.port == 993
995 POP3S tcp.port == 995
3389 RDP tcp.port == 3389
8291 MikroTik Winbox tcp.port == 8291

🌐 IP & Subnet Filters

# Traffic from a specific source
ip.src == 192.168.1.100

# Traffic to a specific destination
ip.dst == 192.168.1.1

# Traffic to OR from an IP (either direction)
ip.addr == 192.168.1.100

# Entire subnet (CIDR)
ip.src == 192.168.1.0/24

# Exclude an IP from results
!(ip.addr == 192.168.1.1)

# Traffic between two specific hosts
ip.addr == 192.168.1.10 && ip.addr == 192.168.1.20

# Sources not inside three RFC1918 ranges (still includes loopback, link-local, multicast, etc.)
!(ip.src == 10.0.0.0/8) && !(ip.src == 172.16.0.0/12) && !(ip.src == 192.168.0.0/16)

🚩 TCP Flag & State Filters

# SYN only - connection initiations
tcp.flags.syn == 1 && tcp.flags.ack == 0

# SYN-ACK - handshake responses
tcp.flags.syn == 1 && tcp.flags.ack == 1

# RST - connection resets / failures
tcp.flags.reset == 1

# FIN - connection teardowns
tcp.flags.fin == 1

# PSH+ACK - push flag set (does not guarantee useful application payload)
tcp.flags.push == 1 && tcp.flags.ack == 1

# Retransmissions - packet loss / congestion indicator
tcp.analysis.retransmission

# Duplicate ACKs
tcp.analysis.duplicate_ack

# Zero window - receiver buffer full (performance issue)
tcp.analysis.zero_window

πŸ›‘οΈ Security & Threat Detection Filters

# TCP SYN without ACK - often a routine handshake; rate/context needed for scan triage
tcp.flags.syn == 1 && tcp.flags.ack == 0

# TCP resets - ordinary refusals and tear-downs also produce these
tcp.flags.reset == 1

# Large frames - common for ordinary data transfer, not evidence of exfiltration
frame.len > 1400

# Fragmented IP packets - possible evasion technique
ip.flags.mf == 1 || ip.frag_offset > 0

# Broadcast traffic - network discovery or flood
eth.dst == ff:ff:ff:ff:ff:ff

# ICMP echo request - normal ping and monitoring traffic
icmp.type == 8

# Decoded DNS over an unusual port (not a general tunneling detector)
dns && !(udp.port == 53) && !(tcp.port == 53)

# Decoded HTTP on a non-default port (common in legitimate services)
http && !(tcp.port == 80)

# Decoded TLS on non-default port (common in legitimate services)
tls && !(tcp.port == 443) && !(tcp.port == 8443)

# All ARP replies - independently validate claimed sender; not proof of spoofing
arp.opcode == 2

# Long DNS query names - weak heuristic; legitimate names may be long
dns.qry.name.len > 50

πŸ”‡ Noise Reduction Filters

Use these to strip background chatter and focus on relevant traffic.

# Exclude ARP and ICMP (noisy on busy LANs)
!(arp || icmp)

# Exclude Ethernet broadcast only (multicast is a separate category)
!(eth.dst == ff:ff:ff:ff:ff:ff)

# Exclude DHCPv4 noise
!(dhcp)

# Exclude LLMNR, mDNS, SSDP (Windows/IoT background noise)
!(udp.port == 5355 || udp.port == 5353 || udp.port == 1900)

# Exclude Spanning Tree Protocol
!(stp)

# Exclude NetBIOS Name Service
!(nbns)

# Show only your subnet's outbound internet traffic
ip.src == 192.168.1.0/24 && !(ip.dst == 192.168.1.0/24)

# Clean view - application traffic only, no management noise
(tcp || udp) && !(dhcp || nbns || ssdp || mdns || stp || arp)

πŸ–₯️ Remote Capture via SSH

Warning

Redirected SSH PCAP streams must stay byte-for-byte binary, and remote shell startup messages can corrupt them. PowerShell 7.4+ has different native-command byte-stream behavior than Windows PowerShell 5.1; do not rely on a legacy PowerShell text pipeline for binary PCAP capture. Prefer supported extcap/SSH remote capture, or collect with tcpdump on the sensor and transfer the file as a binary artifact. Pin the interface, exclude only appropriate management traffic, and limit duration and file size.

Stream live captures from a remote device directly into your local Wireshark instance.

Basic SSH Streaming

# Linux/macOS - stream from a remote Linux device
ssh root@192.168.1.1 "tcpdump -i eth0 -U -s0 -w -" | wireshark -k -i -

# OpenWRT / GL.iNet router
ssh root@192.168.8.1 "tcpdump -i br-lan -U -s0 -w -" | wireshark -k -i -

# Apply a capture filter at source to reduce bandwidth
ssh root@192.168.1.1 "tcpdump -i eth0 -U -s0 -w - 'tcp port 80 or tcp port 443'" | wireshark -k -i -

Windows

# Via WSL or direct (Wireshark in PATH)
ssh root@192.168.1.1 "tcpdump -i eth0 -U -s0 -w -" | "C:\Program Files\Wireshark\Wireshark.exe" -k -i -

Save to File Instead

# Save remote capture to local .pcap
ssh root@192.168.1.1 "tcpdump -i eth0 -U -s0 -w -" > /tmp/capture.pcap

βœ… Note: -U flushes each packet immediately (required for live streaming). -s0 captures the full packet without truncation.


πŸ“Ά BLE & Bluetooth Capture

Hardware Setup

Hardware Firmware / Software Wireshark Integration
nRF52840 Dongle Nordic nRF Sniffer firmware Install nRF Sniffer for Wireshark plugin
Ubertooth One Default (ubertooth-btle) Pipe to pcap or use as live interface
# Ubertooth - capture to pcap file, open in Wireshark after
ubertooth-btle -f -c /tmp/ble.pcap

# Ubertooth - live stream directly into Wireshark
ubertooth-btle -f -w /dev/stdout | wireshark -k -i -

BLE Display Filters

# All BLE advertising packets
btle.advertising_header

# Filter by BLE device address (BD_ADDR)
btle.advertising_address == aa:bb:cc:dd:ee:ff

# BLE connection data events only
btle.data_header

# BLE pairing / security events
smp

# GATT read/write operations (IoT device interaction)
btatt

# HCI layer (host controller interface)
hci_cmd || hci_evt

πŸ•ΈοΈ Zigbee Capture

Hardware & Capture Tools

# KillerBee - capture on Zigbee channel 15
zbdump -c 15 -w /tmp/zigbee.pcap

# Scan for active Zigbee PANs
zbstumbler

# Replay a capture
zbreplay -f /tmp/zigbee.pcap

Zigbee Display Filters

# 802.15.4 / Zigbee base frames
wpan

# Zigbee network layer
zbee_nwk

# Zigbee application / cluster library
zbee_zcl

# Filter by Zigbee PAN ID
wpan.dst_pan == 0x1234

βœ… Tip: Go to Analyze β†’ Decode As β†’ IEEE 802.15.4 to decode Zigbee frames. Add your network key under Protocols β†’ IEEE 802.15.4 β†’ Decryption Keys.


πŸ”§ MikroTik RouterOS Sniffer

RouterOS has a built-in packet sniffer with its own syntax, separate from Wireshark display filters.

Basic Sniffer Control

# Configure and start the sniffer
/tool sniffer set filter-protocol=tcp,udp,icmp filter-port=53,80,443,22 streaming-enabled=yes
/tool sniffer start

# View captured packets
/tool sniffer packet print

# Stop sniffer
/tool sniffer stop

Protocol & Interface Filters

# Web traffic only
/tool sniffer set filter-protocol=tcp filter-port=80,443

# DNS only
/tool sniffer set filter-protocol=udp filter-port=53

# SSH and management ports
/tool sniffer set filter-protocol=tcp filter-port=22,23,8291

# Scope to a specific interface
/tool sniffer set filter-interface=ether1

# Scope to a specific subnet
/tool sniffer set filter-ip-address=192.168.1.0/24

Firewall Logging Rules

# Log HTTP/HTTPS (passthrough - does not block)
/ip firewall filter add chain=forward protocol=tcp dst-port=80,443 action=passthrough log=yes

# Log DNS queries
/ip firewall filter add chain=forward protocol=udp dst-port=53 action=passthrough log=yes

# Log SSH attempts
/ip firewall filter add chain=input protocol=tcp dst-port=22 action=passthrough log=yes

# Drop and log invalid state connections
/ip firewall filter add chain=input connection-state=invalid action=drop log=yes

# SYN flood basic protection
/ip firewall filter add chain=input protocol=tcp connection-state=new limit=25,5:packet action=accept
/ip firewall filter add chain=input protocol=tcp connection-state=new action=drop log=yes

# View firewall log
/log print where topics~"firewall"

Additional Monitoring Tools

# Real-time interface traffic monitor
/tool torch interface=ether1

# Active connection tracking
/ip firewall connection print

# Interface bandwidth stats
/interface monitor-traffic interface=ether1

# Export logs to file
/log export file=traffic-log

πŸ“‹ OpenWRT & tcpdump Reference

# Basic capture to file
tcpdump -i eth0 -w /tmp/capture.pcap

# Capture with BPF filter (web traffic only)
tcpdump -i eth0 -w /tmp/web.pcap 'tcp port 80 or tcp port 443'

# DNS queries live
tcpdump -i eth0 -n udp port 53

# Live display, no file write, limit to 100 packets
tcpdump -i eth0 -n -c 100

# Read a saved .pcap
tcpdump -r /tmp/capture.pcap

# Filter a saved .pcap by host
tcpdump -r /tmp/capture.pcap host 10.0.1.100

# Count packets by source
tcpdump -r /tmp/capture.pcap -n | awk '{print $3}' | sort | uniq -c | sort -rn

# Stream live to Wireshark on your PC
ssh root@192.168.8.1 "tcpdump -i br-lan -U -s0 -w -" | wireshark -k -i -

⚑ Minimum Starter Filter Sets

Ready-to-paste filters for common scenarios.

Scenario Filter
General troubleshooting tcp || udp.port == 53
Threat hunting tcp.flags.syn == 1 || tcp.flags.reset == 1 || icmp || dns
Isolate one device ip.addr == 192.0.2.10
Reduce noise !(arp || icmp || stp || bootp || mdns || ssdp || nbns)
Outbound internet only ip.src == 192.168.1.0/24 && !(ip.dst == 192.168.0.0/16 || ip.dst == 10.0.0.0/8 || ip.dst == 172.16.0.0/12)
WPA handshake capture eapol
BLE security assessment btle || smp || btatt

⚠️ Security & Legal Disclaimer

πŸ”΄ CRITICAL: Authorized Use Only

⚠️ IMPORTANT: AUTHORIZED USE ONLY ⚠️

This documentation is provided for:

βœ… AUTHORIZED USES:
   β€’ Network troubleshooting and diagnostics on networks you own/administer
   β€’ Authorized security assessments with written permission
   β€’ Educational use in isolated lab environments
   β€’ Wireless analysis on networks you own or have explicit authorization
   β€’ Security research within legal and ethical boundaries
   β€’ CTF competitions and authorized practice environments
   β€’ Professional penetration testing with signed scope agreements

🚫 STRICTLY PROHIBITED:
   β€’ Capturing or analyzing traffic on networks you do not own or manage
   β€’ Intercepting communications without authorization
   β€’ Cracking WiFi passwords on unauthorized networks
   β€’ Using BLE/Zigbee capture against devices you do not own
   β€’ Any activity violating the Computer Fraud and Abuse Act (CFAA)
   β€’ Any activity violating the Wiretap Act (18 U.S.C. Β§ 2511)

Wireless & Packet Capture Legal Requirements

Federal Laws (United States):
β€’ Computer Fraud and Abuse Act (CFAA) - 18 U.S.C. Β§ 1030
  - Unauthorized access to protected computers/networks
  - Penalties: Up to 10 years imprisonment and fines

β€’ Wiretap Act - 18 U.S.C. Β§ 2511
  - Intercepting electronic communications
  - Penalties: Up to 5 years imprisonment and fines

β€’ Electronic Communications Privacy Act (ECPA)
  - Protecting electronic communications
  - Civil and criminal penalties apply

State Laws:
β€’ Most states have additional computer crime statutes
β€’ Unauthorized network access is often classified as a felony
β€’ Civil liability applies in addition to criminal charges

Risk Mitigation

βœ… Mitigation Strategies:

Authorization:
β€’ Always obtain written authorization before any capture
β€’ Document scope, interfaces, and time windows
β€’ Maintain authorization records for all client work

Technical Controls:
β€’ Capture in isolated lab environments whenever possible
β€’ Apply capture filters at source to minimize unintended data collection
β€’ Delete captures containing sensitive data when no longer needed

Professional Standards:
β€’ Follow ethical guidelines and responsible disclosure practices
β€’ Maintain professional liability insurance for client work
β€’ Document all activities thoroughly
β€’ Consult legal counsel when uncertain about scope

🀝 Contributing

We welcome contributions from security professionals, researchers, and practitioners.

Contribution Guidelines

To Submit Additions or Corrections:

  1. Fork the repository
  2. Add or update filters with tested examples
  3. Include a brief description of use case and context
  4. Submit a pull request with a clear description

Documentation Standards:

# [Filter Category]

## Overview
Brief description of what these filters are for

## Filters
Tested filter syntax with inline comments

## Use Cases
Authorized scenarios where these filters apply

## Notes
Tips, caveats, hardware requirements

All Contributions Must Include:

  • βœ… Tested filter syntax
  • βœ… Clear use case description
  • βœ… Authorization requirements noted where applicable
  • βœ… Hardware or plugin dependencies documented

πŸ“š Resources

Wireshark Documentation

Protocol & Tool References

Legal Resources

Internal Links


πŸ“Š Document Info

πŸ“ Document:     wireshark-filters.md
πŸ“– Category:     Network Security / Packet Analysis
πŸ”„ Last Updated: April 2026
πŸ‘₯ Maintained by: Pacific Northwest Computers (PNWC)
πŸ“ Status:       Active

πŸŽ“ Best Practices Summary

Always Remember

Legal Requirements:

  • βœ… Written authorization before any capture on non-owned networks
  • βœ… Compliance with CFAA, Wiretap Act, and local laws
  • βœ… Responsible handling and deletion of captured data
  • βœ… Proper scope documentation for client engagements

Technical Safety:

  • βœ… Apply capture filters at source to reduce data collection footprint
  • βœ… Use isolated lab or VM environments for analysis
  • βœ… Delete pcap files containing sensitive data after analysis
  • βœ… Never store captures containing credentials or PII unnecessarily

Professional Ethics:

  • βœ… Act with integrity and transparency
  • βœ… Protect confidential information discovered during captures
  • βœ… Report vulnerabilities responsibly
  • βœ… Follow industry standards and responsible disclosure

Related Files

  • hcxtoolshashcat.md - hcxpcapngtool for converting WiFi captures to Hashcat format; Wireshark for verifying the EAPOL frames
  • Aircrack-ng_Commands.md - Aircrack-ng captures the .cap files that Wireshark can open and analyze
  • bjorn_pi.md - Bjorn's brute-force and exfiltration traffic is exactly what Wireshark blue-team exercises analyze
  • evil_m5.md - Evil-M5 EAPOL/deauth detection exercises benefit from parallel Wireshark verification
  • python.md - Python Scapy scripts generate traffic that Wireshark can inspect and validate
  • ../Mobile/mobile_pentest_sop.md - Mobile pentest SOP (Wardriving and BadUSB MITM captures analyzed in Wireshark/KeX)
  • ../Mobile/OnePlus_A6003/Nethunter_SOP.md - NetHunter KeX section runs Wireshark GUI on the phone over VNC

🦈 Use Wireshark Responsibly: Always Obtain Authorization Before Capturing Traffic

Legal, ethical, and authorized use only.

Repository: ULTIMATE CYBERSECURITY MASTER GUIDE

Maintained by: Pacific Northwest Computers


⚠️ WARNING: Unauthorized packet capture is illegal and prosecutable ⚠️

⚠️ Wiretap Act violations carry up to 5 years imprisonment ⚠️

⚠️ Always obtain written authorization before capturing on any network you do not own ⚠️

⭐ Star this repo if you find it useful! ⭐


πŸ“„ Source: Documentation/wireshark.md | ✏️ Suggest an edit | ⬅️ Back to Technical Guides & Cheat Sheets

Clone this wiki locally