Home › Topics › Packet Capture & Analysis › Wireshark Fundamentals

Wireshark Fundamentals the Courses Skip


Wireshark is the free graphical packet analyzer that nearly everyone in networking eventually opens. Nearly everyone opens the same way: a wall of scrolling packets, a moment of awe, and then quiet despair about what to actually do. Courses respond by touring every menu, which teaches you where things are and not when they matter. This guide does the opposite. It skips the tour and teaches the seven working habits that make Wireshark useful in a real incident. These are the moves experienced people make in the first five minutes, in roughly the order they make them.


No prior Wireshark experience is assumed, but this guide pairs best with a capture to poke at. That could be a file a colleague handed you, or a live capture of your own machine's traffic. The latter is exactly what the practice drill at the end uses. If you are still deciding whether a capture is the right tool at all, start with when to reach for packet capture. If you have decided but have no packets yet, getting the packets comes first.


In this guide

  • Habit 1: two filter languages, two moments
  • Habit 2: the display-filter phrasebook
  • Habit 3: follow the stream
  • Habit 4: Expert Info without panic
  • Habit 5: make time visible
  • Habit 6: columns and profiles, set up once
  • Habit 7: the Statistics menus that matter
  • Working with capture files
  • The fifteen-minute drill
  • Where to go next

Habit 1: two filter languages, two moments


Wireshark has two completely different filter systems, and confusing them is the most common beginner injury. A capture filter is applied while capturing: packets it rejects are discarded on the spot and are gone forever. It is written in BPF — the same terse language tcpdump uses. So the twenty tcpdump filters work verbatim in Wireshark's capture-filter box. A display filter is applied after the fact: it merely hides packets from view, and clearing it brings everything back. It is written in Wireshark's own, much richer language — the one with thousands of named fields.


Different languages, different moments, different jobs. Capture filters exist for volume control. On a busy link, or for a capture that must run a long time, you genuinely cannot keep everything. In those cases, you scope what gets recorded. Display filters exist for exploration: slicing a recorded capture forty different ways while hunting the story. The classic mistake is using a capture filter for exploration. For example, you capture only port 445 because the complaint was about a file share. Then you discover an hour later that the real fault was in DNS or authentication traffic that your filter threw away. The context is not hidden; it does not exist, and the problem must now be reproduced all over again. So the working rule is: capture generously, display narrowly. Capture-filter only as tightly as disk space, link volume, and privacy demand. Do all your narrowing afterward, reversibly, with display filters.


When are capture filters the right call? Three cases. On a genuinely busy link, where unfiltered capture would overwhelm the disk or drop packets, scope to the subnet or server in question — broad strokes, not surgical ones. For long-running captures that wait hours for an intermittent fault, where volume compounds relentlessly. And for privacy scoping: if the investigation concerns one server, a capture filter that excludes everyone else's traffic means the sensitive data never lands on your disk at all. That is the cleanest kind of data protection. In each case, filter by place (hosts, subnets) rather than by protocol. That way, the surrounding context — the DNS lookup, the authentication exchange — survives to tell its part of the story.


Habit 2: the display-filter phrasebook


The display-filter language rewards a small starter vocabulary. Type these into the filter bar at the top. It turns green when the expression is valid, red when it is not. It autocompletes field names as you type, which is how you discover new ones forever after.


Display filterWhat it finds
ip.addr==10.0.8.5Every packet to or from that address
tcp.port==445A service, at either end of the conversation
ip.src==10.0.20.31 && tcp.port==443Combinations — this host's HTTPS traffic only
http contains "report.pdf"Plain-HTTP packets whose text includes a string
dns.qry.name contains "vendor"DNS lookups for names containing a string
tcp.flags.reset==1Every reset — who is slamming doors
tcp.analysis.retransmissionEvery packet Wireshark identifies as a retransmission
tcp.analysis.flagsEverything TCP-suspicious in one filter

Notice the last two: they are stateful. Wireshark has read the whole capture and compared packets to each other. So it can name retransmissions, duplicate acknowledgments, and window trouble as filterable facts. This is the analysis tcpdump's stateless filters structurally cannot do. This is a large part of why the capture-with-tcpdump, analyze-with-Wireshark workflow is standard.


And here is how the vocabulary grows without studying: you rarely have to write filters from scratch. Click any field in the packet-detail pane: an address, a port, an error code. Its official filter name appears in the status bar at the bottom of the window. Better still, right-click the field and choose Apply as Filter → Selected. Wireshark writes the expression for you, correctly, and applies it. Found one interesting packet and want all its relatives? Click the thing that makes it interesting and apply it as a filter. Most working filter knowledge is accumulated exactly this way, one right-click at a time.


The != trap: ip.addr!=10.0.8.5 does not mean "hide this host." A packet has two addresses, and the expression is true whenever either of them differs — which is essentially always. To exclude a host, write !(ip.addr==10.0.8.5). Wireshark even paints the filter bar yellow to warn you; believe the yellow.


Habit 3: follow the stream


A TCP conversation arrives at your screen as soup: its packets interleaved with every other conversation's, each one showing a fragment of payload. The single most satisfying command in Wireshark reassembles the soup: right-click any packet of the conversation, then Follow → TCP Stream. A window opens containing the conversation's entire payload, in order, as readable text — one direction in one color, the replies in another. For a plain-text protocol it reads like a transcript: the request, the response, the error message the application never showed the user. Mail refusals, web server errors, file-transfer failures — protocol conversations are often startlingly literate once you can read them as prose. A real example, from a ticket that began as "email suddenly stopped working" and ended two minutes after this stream was followed:


220 mail.corp.example ESMTP
HELO app01
250 mail.corp.example
MAIL FROM:<reports@corp.example>
250 2.1.0 Ok
RCPT TO:<manager@partner.example>
554 5.7.1 Relay access denied

The mail server states its objection in plain text; the application had been swallowing it and reporting a generic failure. No packet-level wizardry involved — just reading the conversation the application refused to relay.


Two supporting details. First, following a stream quietly applies a display filter like tcp.stream eq 42. Every conversation gets a stream number, which is a wonderfully compact way to bookmark and revisit one conversation. Second, the sibling Follow → UDP Stream does the same for connectionless traffic like DNS and syslog. And the honest caveat: follow an encrypted session and you get gibberish, by design. The metadata around the session still talks (what encrypted traffic still tells you). But the transcript trick belongs to cleartext protocols.


Habit 4: Expert Info without panic


Wireshark reads every capture with a critical eye and volunteers its findings. Open Analyze → Expert Information (or click the small colored circle at the bottom-left of the window). There they all are, grouped and counted: retransmissions, duplicate acknowledgments, resets, out-of-order arrivals, zero-window conditions. For triage this is a gift — a capture of fifty thousand packets summarized as "here are the four places something struggled."


The habit worth building is reading it without believing every yellow line is a crisis. Retransmissions are TCP's loss-recovery working as designed. A small scattering in a large capture is ordinary life, not an incident. The count only means something next to the total. Two hundred retransmissions is alarming in ten thousand packets and a rounding error in two million. Out-of-order packets are frequently harmless. Resets end many perfectly successful sessions, because plenty of software hangs up abruptly rather than closing politely. What actually deserves your attention is pattern. Look for a burst of retransmissions clustered exactly at the moment users complained. Or the same conversation may rack up dozens of duplicate ACKs. Then there is the aristocrat of meaningful warnings, zero window — a receiver announcing its buffer is full. That almost always means the pause lives in the receiving application or host, not the network. Treat Expert Info as a map of where to look next, never as a verdict list. Then go look, packet by packet, at one flagged spot. (What those sequences mean, frame by frame, is the subject of reading a TCP conversation like a story.)


Habit 5: make time visible


This is the habit that solves slow-application mysteries, and it is criminally under-taught. By default, Wireshark timestamps each packet as seconds since the capture began. That is accurate and useless, because what you care about is never "when" but "how long since the previous thing." Two moves fix it.


Move one: a delta column. Add a column showing the time elapsed since the previous displayed packet (the setup is in Habit 6). Now filter the view to a single conversation, and the column becomes a list of every pause in that dialogue. Scan down it: 0.0002, 0.0003, 0.0001, 3.9012, 0.0002. There is your incident, in the fourth row.


Move two: a time reference. Right-click a packet — say, the client's request — and Set/Unset Time Reference (Ctrl+T). That packet becomes time zero and every later packet displays its distance from it. This acts as a stopwatch started at the moment of your choosing, perfect for measuring one transaction end to end.


Together they answer the eternal question — who paused? — in seconds. Here is the pattern, as a filtered conversation with the delta column reads on screen:


No.   Delta      Source        Destination   Info
118   0.00021    10.0.20.31    10.0.8.44     GET /bigreport  (the request)
119   0.00033    10.0.8.44     10.0.20.31    ACK             (request arrived)
120   3.90185    10.0.8.44     10.0.20.31    first byte of the reply

The acknowledgment came back in a third of a millisecond, so the network delivered the request promptly and stood ready. Then 3.9 seconds passed before the server produced its first byte of reply: the pause happened inside the server, full stop. Had the reply started instantly but arrived in fits — gaps scattered mid-transfer, retransmissions among them — the same column would have convicted the path instead. One column, one keystroke, argument over.


Habit 6: columns and profiles, set up once


The default column layout was chosen for nobody in particular. Five minutes of setup makes every future incident faster. Open Edit → Preferences → Columns (or right-click any column header). Add a delta time displayed column — the star of Habit 5. Also add source port and destination port, which the default layout omits and every TCP investigation wants. A handy shortcut for anything else: find the field once in the packet-detail pane, right-click it, and choose Apply as Column.


Then make the arrangement permanent: open Edit → Configuration Profiles and create one named Troubleshooting. Switch profiles in one click from the bottom-right corner of the status bar. Your tuned layout — columns, filters you have saved, preferences — lives there without disturbing the pristine default. While you are in a customizing mood, glance at View → Coloring Rules just long enough to learn one thing. The defaults already paint TCP trouble black-and-red, which is why problems visually pop in the packet list. Writing custom rules can wait; knowing the colors mean something cannot.


Habit 7: the Statistics menus that matter


The Statistics menu is where Wireshark stops being a microscope and becomes a survey of the whole capture. Two entries do most of the work. Statistics → Protocol Hierarchy shows what the capture is made of: which protocols, in what proportions. It is the fastest sanity check there is — expected traffic present, unexpected guests exposed, cleartext where you assumed encryption. Statistics → Conversations lists every conversation in the capture — every pair of endpoints — sortable by packets, bytes, and duration. Sort by bytes and the elephant surfaces instantly; right-click it and apply it as a display filter. And you have gone from "80 megabytes of soup" to "the one conversation that matters" in three clicks. The Endpoints sibling does the same per individual address rather than per pair. This is the view you want when the question is "which machine," not "which conversation."


If this feels familiar, it should. It is the flow view, rebuilt inside a single capture file. This is the same who-talked-to-whom summary that flow data provides network-wide and continuously. The workflow lesson carries over exactly: survey first, packets second. Find the elephant before you read a single frame.


Working with capture files


Wireshark captures live traffic itself — pick an interface on the welcome screen, optionally set a capture filter (BPF again), press start. But in practice a lot of analysis begins with a file. This could be a colleague's attachment, a firewall's export, or your own tcpdump -w server.pcap from a remote shell. All of it opens directly. Wireshark reads both the classic .pcap format and the newer .pcapng it writes by default, and converts between them on save. The tcpdump-to-Wireshark handoff is the standard division of labor: capture at the command line where the problem lives. Analyze in the GUI where your eyes live.


For big files, add discipline: never start at packet one and scroll. Start with Statistics (Protocol Hierarchy, then Conversations). Pick the conversation that matters, display-filter down to it, and only then read packets. The delta column tells you where the story pauses. If files are routinely enormous, the fix belongs at capture time: snap lengths, tighter capture filters, or the rotating ring-buffer setups covered in catching the intermittent.


The fifteen-minute drill


Habits form by doing, and your own machine's traffic is a safe, legal, endlessly renewable practice range. Fifteen minutes, seven habits exercised once:


  • 1. Start a capture on your active interface, no capture filter — capture generously, remember.
  • 2. Generate familiar traffic: browse two or three sites, download one decent-sized file, then press the red stop button after a couple of minutes.
  • 3. Open Protocol Hierarchy and account for what you see — DNS, TLS, and, instructively, background chatter you did not consciously cause.
  • 4. Open Conversations, sort by bytes, and identify your download at the top. That is elephant-hunting, learned.
  • 5. Display-filter dns and skim the query names: your browsing session in outline, including lookups you never asked for.
  • 6. Right-click a packet from the download and Follow the stream: handshake fragments, then gibberish — the encryption lesson, learned firsthand rather than taken on faith.
  • 7. Add the delta-time-displayed column, filter to one conversation, and find its single longest pause. Then explain it: server think time, or the gap while you moved the mouse?
  • 8. Save the whole arrangement as a Troubleshooting profile, so the next incident starts configured.

Practice boundary: your own machine's traffic is yours to inspect; other people's is not. The moment practice ends and real captures begin, authorization and careful file handling apply. The page on capture hygiene is the short guide to doing that properly.


Where to go next


Seven habits turn Wireshark from an intimidating wall into a fast, methodical instrument. Filter at the right moment, speak the display language, follow streams, and triage Expert Info calmly. Make time visible, configure once, and survey before reading. The next level of skill is narrative: reading a whole TCP conversation the way you would read a story. That is exactly what the next guide teaches with one annotated capture. Then watch everything above applied under pressure in five solved cases, or step back to the full path at Packet Capture & Analysis.


Put this into practice with SysPeep Monitor

Wireshark answers "what exactly happened?" — but something has to tell you when and where to look. That is the job SysPeep Monitor does around the clock. It offers auto-discovered devices, port status, traffic, errors, and health on live dashboards. Its alert rules are tuned to stay quiet until it matters. The graphs point, you dive with Wireshark. The free trial installs on a Windows machine in minutes.

Download Free TrialLearn About SysPeep