Home › Topics › Network Blind Spots › Encrypted Traffic

What Encrypted Traffic Still Tells You


Somewhere in your first months of running a network you will open a packet capture or a firewall log and notice that almost everything in it is encrypted. Web, mail, chat, file sync, even the printers phoning home: all of it sealed. The padlock won. The worry that follows is a reasonable one. If it is all encrypted, am I blind?


No. Encryption hides content, not behavior, and for monitoring, behavior was always the interesting part. Think of sealed envelopes. You cannot read the letters, but you can still see who writes to whom, how often, and how thick each envelope is. You can see whether one address suddenly starts shipping parcels at three in the morning. That envelope-side information is called metadata, the data about the data, and it is enough to run a network on. I ran one on it for years before I noticed I had never once needed to read a payload.


This guide walks through everything encrypted traffic still tells you without breaking any encryption and what you can practically do with it. It then answers the question every admin eventually asks out loud: should we just decrypt it? The short answer is probably not, and the honest tradeoffs are below.


In this guide

  • What encryption seals — and what it can't
  • Addresses, ports, and who-talks-to-whom
  • Volume and timing: the 2 a.m. gigabyte
  • DNS: the visibility gift
  • The handshake: introductions happen in the open
  • Traffic shape: beacons vs. humans
  • What all this metadata enables
  • The decryption question, answered honestly
  • The reference table — and a reframe

What encryption seals — and what it can't


The encryption you meet everywhere is TLS (Transport Layer Security), the protocol behind the browser padlock and the S in HTTPS. When a client and a server set up a TLS session, they agree on keys that only the two of them hold. Everything they say afterward is scrambled with those keys. Any device in the middle — your switch, your firewall, your capture laptop — sees the scrambled version. That is the entire point, and it is a good point. The same property that stops you from casually reading staff traffic also stops an attacker on the network from reading it.


But a network cannot deliver what it cannot address. For traffic to move at all, the outside of every packet must stay readable. You can see where it came from, where it is going, how big it is, and when it was sent. The mail service is a decent model. A sealed letter still carries a destination, a return address, a postmark, and a weight, because the courier needs them to do its job. So do you. So every encrypted conversation has two layers: the content, sealed between the endpoints, and the metadata, visible to the network by necessity. The next five sections are a tour of that second layer, from the obvious to the surprisingly revealing.


Addresses, ports, and who-talks-to-whom


The most basic metadata is the addressing. Every conversation shows a source address, a destination address, and a pair of port numbers. These are numbered doors on each machine that let one device run many services at once. A web server answers on one door, file sharing on another. From addressing alone you learn which of your devices talked to which servers, inside and outside, and roughly what kind of service each conversation was.


One honest caveat about ports: on the public internet they say less than they used to, because nearly everything now travels through port 443, the standard HTTPS door. Externally, "port 443" translates to "it is a modern application," which narrows down approximately nothing. Internally, though, ports still speak clearly — file sharing, databases, printing, directory services each use their own well-known doors, so internal conversations remain quite legible. And destination addresses always carry information. They cluster into providers and services, and a simple list of "which clouds does this device talk to" is more revealing than it has any right to be. The conference-room TV that chats with an advertising network every few minutes has told you something about itself, content unseen.


Volume and timing: the 2 a.m. gigabyte


The next layer is how much and when — and this is where encrypted traffic starts confessing. Byte counts in each direction and timestamps are visible for every flow (one recorded conversation between two addresses), encrypted or not. They support a style of reasoning that never needs a payload. A workstation that uploads a gigabyte at two in the morning is suspicious no matter what is inside the upload. The owner is asleep. The machine is not. That asymmetry of expectations is the entire analysis, and it required zero decryption.


Direction is the underrated half of this. Ordinary knowledge-worker machines download much and upload little — pages, files, and video in; clicks and keystrokes out. A workstation that inverts that ratio and starts pushing serious volume outbound is telling you something changed. That might be a legitimate cloud backup, a sync client digesting a photo library, or data leaving that should not be. Servers run the opposite pattern — upload-heavy, but stably so — which means the signal to watch on servers is not the ratio but a change in it. All of this comes from counters and flow records you can already collect; if the terms are new, the Flow Monitoring guides cover the plumbing.


DNS: the visibility gift


Before almost any connection, a device performs a DNS lookup. DNS is the Domain Name System — the phone book that turns names like files.example.com into addresses computers can reach. The gift is that on most business networks, devices send those lookups to your internal DNS server. And your server sees every question in the clear. The conversations that follow may be sealed end to end, but the device first walked up to your reception desk and asked for the address. Log the questions and you have a running record of who every device tried to find. That is often more useful than knowing what they said after finding it.


Turning on query logging at your resolver (the DNS server your devices send their questions to) is typically one setting. It converts your DNS server into the cheapest visibility sensor you own. You see every service a device uses, every odd destination, and the rendezvous names that malware must look up like everyone else. The operational cost is log volume — DNS is chatty, so rotate the logs — and the analysis can start as crude as skimming for names you do not recognize. A step further in the same direction is a filtering DNS service, which both logs and refuses to answer for known-bad names: visibility and a seatbelt from the same feature.


What does the skim actually look like? Three simplified lines from a resolver log:


09:14:02  PC-SALES-11   query  files.example-corp.example
09:14:05  PC-SALES-11   query  cdn.web-platform.example
02:17:44  PRINTER-2FL   query  telemetry.printer-vendor.example

The first two lines are a salesperson having an ordinary morning. The third is the second-floor printer filing a report with its manufacturer at a quarter past two in the morning. That is almost certainly routine telemetry, but until this moment it was invisible, and now it is a known behavior you have consciously accepted. That is the whole skill: every name should have a story, and the ones without a story go on the follow-up list. You will be surprised how short the list is, and how interesting.


The honest caveat: some devices and browsers now support encrypted DNS to outside resolvers, which bypasses your server and takes the questions with it. The practical response is steering — configure your machines to use your resolver, and restrict outbound DNS paths at the edge so devices cannot quietly freelance. Perfect enforcement is elusive, but on a managed network you can keep the large majority of questions flowing past your desk.


The handshake: introductions happen in the open


One more place information leaks politely: the start of the TLS conversation itself, called the handshake. Big servers host many websites and services on one address, so the client's opening message states which name it wants to talk to. The field is called SNI (Server Name Indication). In common configurations that name is visible during setup, before encryption fully closes over the conversation. The server then presents its certificate, its notarized identity document, parts of which are also observable in many setups. So even a fully sealed conversation often begins with a legible sentence: "I would like to speak with this named service."


This matters because names are finer-grained than addresses: dozens of unrelated services can share one cloud address, and the handshake name tells them apart. Edge devices and targeted captures can collect these names into an inventory of which services your devices actually use. The caveat to state plainly: the protocol keeps evolving, and newer extensions can encrypt even the handshake name. Treat handshake visibility as a bonus where present, not a foundation. When you design a control, assume the name may one day be sealed too, and lean on DNS and addressing, which delivery itself requires.


Traffic shape: beacons vs. humans


The subtlest metadata is rhythm. Human network activity is bursty and irregular: a flurry of clicks, a pause to read, a meeting, lunch, home time. Software talking to software is regular, patient, and tireless — and one particular regularity is worth knowing by name. Beaconing is the pattern of a compromised machine checking in with its controller. The compromised machine makes a small connection to the same destination at a fixed interval — every five minutes, every hour — for days or weeks, asking "any instructions?" Each check-in is tiny, encrypted, and individually invisible. Together they form a drumbeat that stands out sharply in flow history: identical small flows, metronomic spacing, no human irregularity, often continuing straight through nights and weekends.


Rhythm reasoning generalizes past security. A device that holds one quiet connection open for days is a different creature from one that makes short bursts all day. Steady heartbeat traffic at exact intervals is an automation signature wherever it appears. None of this requires reading a single payload byte — just timestamps, sizes, and the patience to look at a week of history rather than a moment.


What all this metadata enables


Add the layers together and you get three practical capabilities, no decryption involved. First, health and performance monitoring is untouched by encryption. Newcomers often assume the padlock era broke their tools. It did not, because metrics never needed payloads. A ping measures round-trip time. An SNMP poll asks a switch about its own counters. Then there is a latency graph, a loss percentage, an interface utilization curve, or a CPU reading. Every one of these is a conversation about a device, not a peek inside user traffic. The entire metrics side of monitoring operates below the encryption and always has.


Second, anomaly spotting: new destinations, inverted upload ratios, off-hours volume, beacon rhythms — the deviations from baseline that this guide has been assembling piece by piece. Third, inventory: a metadata record answers "which services does this device depend on?" for every device you own. That is how you discover the printer that talks to its vendor nightly and the TV with the advertising habit.


The second capability, worked through. Suppose your flow history for one accounting workstation shows this (addresses from the documentation range):


time    device       destination     port  bytes out  bytes in
02:11   PC-ACCT-07   203.0.113.40    443   412 MB     2 MB
02:41   PC-ACCT-07   203.0.113.40    443   398 MB     2 MB
03:12   PC-ACCT-07   203.0.113.40    443   405 MB     2 MB

Read it like an investigator. The machine is an accounting workstation, so its owner works business hours: strike one for two-in-the-morning activity. The byte counts are massively upload-heavy — hundreds of megabytes out, almost nothing in — on a machine class that normally downloads: strike two. The transfers repeat on a near-regular half-hour cadence to a single unfamiliar destination: strike three. Could it be innocent — a cloud backup agent? Absolutely, and that is the point: your backup destinations are known, documented, and expected, so checking takes one minute. If this destination is not on that list, that machine gets a visit before coffee. Content: never seen. Conclusion: solid.


Harbourview Clinic had a reception workstation that uploaded about four hundred megabytes to the same outside address every night at ten past one. The flow had been noticed and a ticket raised. And the ticket was closed with the note "encrypted, so we can't tell what it is, probably the backup". The clinic's backups went to a different address entirely, which nobody checked. The clinic did not log DNS, which would have named the destination in one line. It was a consumer file-sync client, set up so a member of the team could finish letters at home, copying the shared correspondence folder to a personal account. The traffic had been "fine" for five months. It had been fine in the sense that nobody could read it, which turned out to be the only sense in which it was.


The decryption question, answered honestly


Eventually someone will ask: why not just decrypt it all? The technique exists and has a name — TLS inspection. Your edge device (firewall or proxy) sits in the middle of every connection. It terminates the TLS session from the client, decrypts and inspects the content, then re-encrypts it onward to the real server. Clients accept this only because you install a certificate on every managed device telling it to trust the middle-box. (Structurally, it is the exact attack TLS exists to prevent, with paperwork.) It is a legitimate, widely deployed technique in some industries, and it genuinely delivers content-level filtering and inspection. It also arrives with a bill:


  • Performance: the box must decrypt and re-encrypt everyone's traffic in real time. Cryptography at line rate is expensive, and an undersized inspection device becomes the slowest point on your network.
  • Breakage: some applications use certificate pinning — they accept only the exact certificate they expect and treat your middle-box as an attack. Banking apps, software updaters, and various cloud clients simply stop working until you add them to a bypass list. That list becomes a permanent maintenance chore.
  • Privacy, policy, and law: you are opening staff traffic that may include personal banking, health portals, and private correspondence. That requires a written policy, informed users, leadership sign-off, and sensible exclusions for sensitive categories. And, in many jurisdictions, it requires a real conversation with legal counsel before deployment, not after.
  • Operational weight: the trust certificate must reach every device (guest and bring-your-own devices make this permanently awkward). The middle-box becomes a single point where one bad update breaks everything at once.

Warning: if you do deploy TLS inspection, never deploy it quietly. Document it, announce it, and exclude sensitive personal categories from inspection. An inspection setup that staff discover by accident costs you more trust than its filtering ever earns back.


So when is it worth it? Rarely, for a small shop. I say that as someone who once sized the inspection box for the network we had rather than the one we would have a year later. If a compliance regime or a serious content-filtering mandate applies to you, TLS inspection may be the required tool, and the costs above are simply the price of the mandate. For everyone else, the better first moves are the cheap ones this guide already covered — DNS logging and filtering, metadata baselines, flow visibility. There is one more worth naming: the endpoint. Your users' machines see every payload in plaintext after decryption, which is why endpoint protection software inspects content there without any middle-box at all. Between resolver logs, flow records, and endpoint agents, most small networks get the coverage they actually need while their encrypted traffic stays sealed in transit.


The reference table — and a reframe


Everything you can see without touching the encryption, in one place:


SignalWhere you get itWhat it tells you
Source and destination addressesFlow records, firewall logsWhich device talked to which service
PortsFlow records, firewall logsService type — still very legible internally
Volume and directionInterface counters, flowsHow much data moved, and which way
Timing and frequencyFlow historyOff-hours surprises, schedule drift, beacon rhythms
DNS queriesYour resolver's logsEvery name a device tried to find
Handshake name and certificateEdge device, targeted captureThe named service requested (where still visible)
Traffic shapeFlow history over daysHuman vs. automated behavior

When admins say "we can't see inside TLS," they are usually naming the wrong problem. The visibility failures that actually hurt small networks are almost never about payload. They are the east-west conversations nobody watches, the devices nobody enrolled, and the segments and sites nobody can reach. Encrypted content is, in practice, the blind spot you can most gracefully live with, because the envelope keeps talking even when the letter is sealed. Rank your real gaps with The Eight Places Your Monitoring Can't See before spending anything on this one.


Where to go next


If this guide changes one habit, make it the cheap one. Turn on DNS query logging this week, and let a fortnight of questions teach you what your devices are up to. Then build the metadata muscles, flows, baselines and rhythm-reading, with the rest of the Network Blind Spots guides. Go deeper on conversation records in Flow Monitoring whenever you are ready for the plumbing. The padlock won. It was never your opponent.


Put this into practice with SysPeep Monitor

Nothing in this guide required reading a payload, and neither does device monitoring. SysPeep Monitor works entirely from the metadata devices volunteer — reachability, interface traffic, errors, CPU, disk. This metadata is collected over SNMP, WMI, and SSH, with thresholds and alerts for the moments behavior breaks pattern. Encrypted world or not, the basics stay watchable; the free trial takes minutes on a Windows machine.

Download Free TrialLearn About SysPeep