online posts 16
wireshark 101

What a Packet Capture Shows You (Wireshark 101, Lesson 1)

A packet capture is a recording of the frames that crossed one point in the network. Wireshark’s three panes, timestamps, pcap vs pcapng, and why where you capture decides what you see.

One switch with four cables, and a capture clipped onto two of them: one cable carries a whole ping conversation, the other a single broadcast
lesson 1 of 8 · course Wireshark 101
  1. 1What a capture shows
  2. 2Capture vs display filters
  3. 3ARP: finding the neighbor
  4. 4DHCP: getting an address
  5. 5DNS: names to addresses
  6. 6TCP: handshake, data, teardown
  7. 7TLS without decrypting it
  8. 8Troubleshooting a broken path
course overview →

A packet capture is a recording of every frame that crossed one point in the network while the recording ran: each one bit for bit, with the time it was seen. Wireshark opens that recording and decodes it, layer by layer. The most important thing to know about a capture is that it only shows its own point. Pick the wrong cable and you see nothing, and nothing looks exactly like it never happened.

Networking 101 explained what MAC addresses, IP addresses, switches and routers are. This course shows you what they actually put on the wire. This first lesson is about the tool itself: what’s in a capture, how Wireshark lays it out, what the timestamps mean, the two file formats, and the question every capture starts with: where am I listening?


What is a packet capture?

Everything you’ve used to look at a network so far is a summary. ip neigh shows what a host concluded about its neighbors. show mac address-table shows what a switch learned. A routing table shows what a router decided. They’re all useful, and they’re all someone’s interpretation.

A capture isn’t. It’s the frames themselves, in the order they were seen, with nothing left out and nothing summarized. When a show command and a capture disagree, the capture is the one that’s telling you what happened. That’s why engineers reach for it when everything else says the network is fine and the application says it isn’t.

Two words before we go on. A frame is a message in its layer 2 envelope: an Ethernet header with a to and a from MAC address, and something inside. A packet is, strictly, the layer 3 thing inside it, with IP addresses. Wireshark and everyone else say “packet” for both, and so will I, except where the difference matters.

Each frame in a capture is stored with a few extra facts the capture added:

  • when it was seen, to the nanosecond in the lab’s files;
  • where it was seen: the name of the interface it was captured on;
  • how long it was on the wire, and how many of those bytes were saved (more on that in lesson 2).

Then the bytes, exactly as they were.


How do Wireshark’s three panes map to the layers?

Open a capture and Wireshark shows three panes, top to bottom.

PaneWhat it shows
Packet listone line per frame: number, time, source, destination, protocol, length, a one-line summary
Packet detailsthe frame you clicked, one layer per line, each one opens to show its fields
Packet bytesthe same frame as raw hex. Click a field in the details and its bytes light up

The packet list is for finding things. Here’s the start of the lab’s first capture, taken on the laptop’s cable while it pings the printer, as tshark (Wireshark’s command-line twin, version 4.6.5 here) prints it:

    3 2.177114918 aa:aa:aa:11:11:11 → Broadcast    ARP 42 Who has 192.168.1.20? Tell 192.168.1.175
    4 2.177311459 aa:aa:aa:22:22:22 → aa:aa:aa:11:11:11 ARP 42 192.168.1.20 is at aa:aa:aa:22:22:22
    5 2.177313709 192.168.1.175 → 192.168.1.20 ICMP 98 Echo (ping) request  id=0x0926, seq=1/256, ttl=64
    6 2.177450834 192.168.1.20 → 192.168.1.175 ICMP 98 Echo (ping) reply    id=0x0926, seq=1/256, ttl=64 (request in 5)

Two things in that list are worth knowing straight away. The Protocol column is the highest layer Wireshark recognized, not the only one: a ping is ICMP inside IP inside Ethernet. And the source and destination columns show IP addresses when there’s an IP layer, and fall back to MAC addresses when there isn’t, which is why the ARP lines look different.

The details pane is where the layers from Networking 101’s OSI lesson become visible. Click frame 5 and you get:

Frame 5: Packet, 98 bytes on wire (784 bits), 98 bytes captured (784 bits) on interface laptop:eth1, id 0
Ethernet II, Src: aa:aa:aa:11:11:11 (aa:aa:aa:11:11:11), Dst: aa:aa:aa:22:22:22 (aa:aa:aa:22:22:22)
Internet Protocol Version 4, Src: 192.168.1.175, Dst: 192.168.1.20
Internet Control Message Protocol
LineLayerWhat it holds
Framenone: Wireshark’s own noteswhen and where the capture saw it, its length
Ethernet II2, data linkthe MAC addresses, and the type of what’s inside
Internet Protocol Version 43, networkthe IP addresses, the TTL, the protocol inside
Internet Control Message Protocol3, carried in IPthe ping itself

For a web request you’d see TCP (layer 4) under IP, and HTTP under that. The order is the order of the envelopes on the wire: outermost first. Reading top to bottom is unwrapping the package.

The Frame line is the one people misread. It isn’t a protocol and nothing on the wire sent it. It’s the capture’s own label on the frame: the arrival time, the interface, the lengths. You’ll use it more than you’d think, because “on interface laptop:eth1” is the answer to “where was this seen?”.

The bytes pane is the honest one. The details pane is Wireshark’s interpretation of those bytes, made by a dissector: the piece of Wireshark that knows how to decode one protocol. Dissectors are very good, but when one guesses wrong (a protocol on an unusual port, say), the bytes are still right.


What do the timestamps mean?

Every frame gets a timestamp from the machine doing the capturing, at the moment the capture saw it. Not when the sender built it, and not when the receiver read it. That distinction matters as soon as you capture at more than one place, because two capture points have two clocks.

Wireshark shows the time in the packet list as seconds since the first frame by default. You can switch it (View › Time Display Format) to the time of day, or to the time since the previous frame, which is what you want when you’re looking for a pause. The real time is always in the Frame line:

Arrival Time: Nov 11, 2026 01:46:20.722588928 UTC

Timestamps are where a capture turns into measurements. In the capture above, the printer’s ARP reply came 196.5 microseconds after the laptop’s question (frame 3 to frame 4), and the first ping’s reply came 137 microseconds after the request (frame 5 to frame 6). Those numbers are from the laptop’s cable, so they include the switch, the printer’s own processing, and the switch again. A ping in the lab’s second capture, to a web server two routers away, took 566 microseconds, measured on the switch’s port towards the first router. Time between a question and its answer, measured on the asker’s cable, is the round trip that user actually experienced. Measured anywhere else, it’s the round trip from that point onwards.


What’s the difference between pcap and pcapng?

Captures are saved in one of two file formats.

pcap is the original, from the tcpdump world. It’s simple: a short file header, then one record per frame. pcapng (pcap next generation) is what Wireshark saves by default today, and what the lab’s captures use. It’s built from blocks, so it can say much more about the capture.

pcappcapng
Interfaces per fileone link type, no namesseveral, each with its name
Timestamp resolutionmicroseconds (the classic format)per interface; nanoseconds in the lab’s files
Commentsnoon the file and on each frame
Which program made itnoyes
Who can read itnearly everythingWireshark, tshark, tcpdump’s libpcap and most current tools

Here’s what that means in practice. The lab’s capture of two switch ports, converted from pcapng to pcap with Wireshark’s editcap, went from 1,524 bytes to 1,186. The bytes saved are the bad news: the interface names sw1:eth1 and sw1:eth3 were gone (every frame now came from one nameless interface), and every timestamp lost its last three digits:

pcapng: 1794361588.669028918
pcap:   1794361588.669028000

The interface name is the bit you’ll miss. When one file holds two capture points, that name is the only way to tell them apart. So keep captures in pcapng, and only convert when a tool demands pcap.


Why does where you capture decide what you see?

This is the section to remember. A capture records one point in the network, and what crosses that point depends on what’s around it.

A host’s own port

Capture on a host’s cable, as the lab’s first task does on the laptop, and you see everything that host sends and everything sent to it, plus the network’s broadcasts. That’s the easy case, because the host is one end of every conversation you’re looking at.

A switch port: other people’s unicast isn’t there

Networking 101’s lesson on switches gave the rule. A switch sends a frame for one MAC address out of one port, the one where it learned that address. It sends a broadcast out of every port. It floods a frame for an address it hasn’t learned yet out of every port too, but only until it learns it.

So a capture on a switch port sees that port’s own host, the broadcasts, and the occasional flood. Nothing else. The lab shows it with two captures taken at once, on sw1’s port towards r1 and its port towards the printer, while the laptop pings a server on another network:

Seen onARPICMP (pings and replies)
r1’s port, sw1:eth1the laptop’s request and r1’s replyall 6
the printer’s port, sw1:eth3the laptop’s request only0

The printer’s cable carried exactly one frame of that conversation: the ARP request, because it was a broadcast. r1’s reply was addressed to the laptop alone, and the pings were addressed to r1’s MAC address, so the switch never sent them anywhere near the printer. That’s the switch doing its job.

It’s also why “I’ll plug my laptop into a spare switch port and capture” doesn’t work. You’ll see broadcasts, your own traffic, and very little else. In the days of hubs, which repeated everything to everyone, it did work. Switches ended that.

Mirror ports and taps

Real networks solve this in two ways.

A mirror port (Cisco calls it SPAN, for switched port analyzer) is a switch feature: you tell the switch to send a copy of everything on one or more ports, or a whole VLAN, out of another port, where your capture machine sits. It costs nothing but configuration. The catch is that it’s the switch’s best effort: a mirror port can only send as much as its own link carries, so if you mirror more traffic than that, some copies are dropped, and your capture is missing frames the real network delivered.

A tap is a small device you put in the cable itself. It passes the traffic through and copies it to a monitoring port. It sees exactly what was on the wire, but you have to break the cable to install it, which is why taps go in during planned work and stay there.

The lab does something closer to a tap: containerlab capture records a port from outside the node, so nothing on the laptop or the switch knows it’s being watched, and you can capture any cable in the network.

Inside a host versus on the wire

There’s one more place to capture: on the host itself, with Wireshark installed on the laptop. That’s the most common capture there is, and it comes with a surprise.

Modern network cards do work the operating system used to do. Two kinds of this offload change what a capture on the host shows. With checksum offload, the card fills in the IP and TCP checksums just before the frame leaves, so a capture of outgoing traffic, taken before the card, sees checksums that haven’t been calculated yet. With segmentation offload, the operating system hands the card one big block of data and the card cuts it into frames, so the capture shows “packets” larger than the network’s MTU, which no real cable could have carried. Wireshark’s own page on offloading explains both.

Neither is a fault. Both are the capture being honest about where it is: above the card, not on the wire. If a host capture shows bad checksums on everything it sent, or 1,500-byte limits apparently ignored, check offloads before you suspect the network.

Capture pointSeesDoesn’t see
on the host itselfwhat that host sent and received, as the OS saw itother hosts’ traffic; the final checksums and frame sizes
a switch portthat port’s host, broadcasts, floodsother hosts’ unicast
a mirror (SPAN) portcopies of the ports or VLAN you chosecopies the switch dropped when the mirror was full
a tapexactly what was on that cableanything on another cable

What I see go wrong

Capturing in the wrong place, and believing the silence. Someone captures on the server, sees no request, and concludes the client never sent one. Maybe it didn’t. Or maybe it was dropped on the way, or went to a different server. A capture can prove a frame crossed a point. Its absence only proves it didn’t cross that point. The fix is a second capture closer to the sender, and lesson 8 of this course is built around it.

Expecting a switch port to show everyone. It won’t, as the table above shows. If you need someone else’s traffic, capture on their port, on the uplink they use, or on a mirror of it.

Comparing timestamps from two machines. Two captures taken on two computers use two clocks. A few milliseconds’ difference between them is often just the clocks disagreeing. Compare times within one capture, or use one machine that records both points into one file, which is what the lab does.

Reading checksum errors as damage. On a host capture, outgoing frames with “incorrect” checksums are almost always checksum offload. Damaged frames on a real wire usually don’t reach a capture at all, because the receiving card throws them away.

Saving in a format that loses the answer. A multi-point capture converted to pcap has lost the one field that says which point each frame came from.


Try it

Chapter 1 of the lab has you take your first capture on the laptop’s cable, open it in Wireshark in your browser, read the three panes, and then capture two switch ports at once to see for yourself which cable carried which frames.

What’s next

A busy network gives you thousands of frames a second. Lesson 2 is about cutting that down: capture filters, which decide what’s saved at all, and display filters, which decide what you look at, and the one small operator whose meaning changed under everyone’s feet.