Recognizing an Attack in Your Graphs (vs. a Bad Day)
The hardest part of a denial-of-service incident is not the response. It is the twenty minutes before the response, when the graphs are strange and users are complaining. You have to decide whether you are looking at an attack or a marketing email that worked too well. Or is it a laptop stuck in a retry loop, or a backup job that picked a terrible time to run? Guess wrong in one direction and you wake up your provider's emergency line for a backup job. Guess wrong in the other and you spend an hour tuning a web server while the circuit is full.
The good news is that attacks leave fingerprints. And the fingerprints are visible in monitoring you probably already have. That includes interface counters, firewall session counts, server response times, and whatever flow or log data your edge produces. This guide walks through what each family looks like in those graphs and what the four most common look-alikes look like instead. It gives you a first-look checklist that gets you to a defensible answer in minutes. If you have not yet met the three families, read DDoS in plain language first. This guide assumes you know that "volumetric" means the circuit, "protocol" means the tables, and "application" means the server.
In this guide
- The six graphs that matter
- Signature one: the circuit floods
- Signature two: the tables fill
- Signature three: the server drowns
- Flow signatures across all three
- The four look-alikes
- Symptom, cause, and the check that separates them
- The first-look checklist and how long to look
- Where to go next
The six graphs that matter
You cannot recognize abnormal without a picture of normal. Every signature in this guide is a comparison against your own baseline. That is why the most important preparation for spotting an attack is boring. Collect these six things continuously, so that on the bad day you have last Tuesday to hold up against it.
- WAN interface bandwidth, inbound and outbound separately, in bits per second. The ceiling is your circuit's rated speed. If you are unsure how to judge a utilization graph, how full is too full covers it.
- WAN packet rate, in packets per second, on the same interface. Dividing bits by packets gives you average packet size, which turns out to be one of the best tells there is.
- Firewall session count against the device's maximum, plus the rate of new sessions per second if the device exposes it.
- Top sources and top destinations, from flow export, firewall logs, or the firewall's own "top talkers" view. This is the graph that says who and what.
- Application health: web server request rate, response time, CPU, and error rate.
- A real-user metric: logins per minute, orders placed, searches completed, calls connected — whatever proves a human finished something. This one is the secret weapon, because attackers generate load but never generate outcomes.
Each family lights up a different subset of these six, and the ones that stay flat are as informative as the ones that spike.
Signature one: the circuit floods
A volumetric attack is the loudest of the three and, once you have seen one, the easiest to name. The inbound bandwidth graph climbs in a matter of seconds — a step, not a ramp — and flattens against the circuit ceiling, where it stays. Outbound usually does not rise to match. Real traffic is a conversation: requests come in, responses go out. A flood is a monologue. A wide gap between an inbound line pinned at the top and an outbound line that is flat or even falling is a strong signal on its own.
Packet rate tells you more. Normal traffic is a jumble of sizes: tiny acknowledgements, medium web requests, full-size downloads. A flood tends to be uniform, because it is generated rather than lived. Suppose you divide the bit rate by the packet rate and get a nearly constant answer minute after minute — every packet the same size. In that case, you are looking at something manufactured. Some floods run the other way, with the bit rate merely elevated but the packet rate many times normal. Those are aimed at exhausting your router's forwarding capacity rather than the wire. Either way, the ratio is the tell.
Two more places to look. The WAN interface's discard counters will climb, because the device is receiving more than it can queue. And if your provider offers a graph of your circuit from their side, it will show more inbound than yours. That is because the excess is dropped before it reaches you. That difference is the attack's true size. Here is the kind of readout that settles it, using rates computed from standard interface counters over a one-minute window:
Interface: wan0 baseline (last Tue 14:00) now (14:07) ifHCInOctets rate 38 Mbit/s 498 Mbit/s (circuit: 500) ifHCOutOctets rate 22 Mbit/s 4 Mbit/s ifHCInUcastPkts rate 6,100 pkt/s 84,000 pkt/s avg inbound packet size ~780 bytes (mixed) ~740 bytes (constant) ifInDiscards (delta/min) 0 41,200 Firewall sessions 1,900 / 200,000 2,400 / 200,000 Web app median response 180 ms timeouts (starved)
Read the last two lines carefully. The session table is barely moving, and the application is failing not because it is busy but because its packets cannot get through. Everything behind a full circuit starves, so do not let the application's misery send you chasing the wrong family. For a general refresher on what a healthy WAN interface looks like, see WAN circuit health.
Signature two: the tables fill
A protocol or state-exhaustion attack lives in the firewall session graph, and its shape is a ramp rather than a step. The session count climbs steadily, often over a few minutes, and then flattens at the device's maximum. The mechanics of why that ceiling is hard and what happens when it is reached are covered in session-table monitoring. Here the point is recognition. The bandwidth graph during this climb looks like an ordinary afternoon. That mismatch — sessions at maximum, bandwidth unremarkable — is the family's signature.
The next question is what those sessions are. On a normal day, most entries in the table are established conversations with a mix of durations. During a state attack, the table is full of half-open entries. These are connections that began the handshake and never finished, each sitting in the table until a timeout clears it. If your firewall breaks out session state, you will see the half-open or "embryonic" count dwarfing the established count. If it does not, the rate of new sessions per second will be far above baseline while the number of established, long-lived sessions barely changes.
The source view completes the picture. A state attack is distributed by design. So you will see a great many source addresses, each holding a small number of entries. All are pointed at the same destination and usually the same port. Contrast that with a legitimate busy period, where you see a great many sources each holding a handful of completed sessions. Or contrast it with a single broken client holding hundreds. The pattern "thousands of sources, a few unfinished sessions each, one target" is one you will not see from real users.
Servers have their own version of this. A web server keeps a backlog of connections waiting to be accepted. When that queue overflows the operating system refuses new connections while established ones carry on. From your side it shows up as a listen-queue overflow counter climbing, with CPU and bandwidth both calm.
Signature three: the server drowns
An application-layer attack is the hardest to distinguish from success, because it is designed to look like traffic. Request rate rises, CPU rises, response time stretches, the database is busy, and eventually the application returns errors. The circuit and the session table report nothing unusual. If you only watch the server, you will conclude that the site is popular today.
The real-user metric is what breaks the illusion. Look at request rate and logins, or orders, or completed searches, on the same time axis. On a genuinely busy day they rise together, because more people are doing more things. During an application attack, request rate climbs while outcomes stay flat or fall. The server is doing more work for no more customers. That divergence is the signature, and it is visible even during a "low and slow" attack that never produces a dramatic spike.
The web server log adds the detail. A real browser session requests a page and then the images, stylesheets, and scripts that go with it. Attack traffic tends to hit one expensive endpoint — a search, a login form, a report, a cart operation. It tends to hit that endpoint over and over with nothing around it. The mix of requested URLs collapses toward a handful. Client identifiers are missing, identical, or nonsensical. Requests arrive without the cookies a returning user would carry. None of these is proof by itself; together they describe a crowd that is not shopping. General triage for a slow or failing website, including the non-attack causes, is in web outage triage.
Flow signatures across all three
A flow record is a summary your router or firewall can export for every conversation it forwards. It includes source address, destination address, ports, protocol, packet count, byte count, and timing. Flow export is the single most useful data source for this whole topic, because it answers the who-and-what questions the bandwidth graph cannot. Several patterns show up in flow data regardless of which family you are facing.
- Many sources, one target. The destination column collapses to a single address, often a single port, while the source column explodes into thousands of entries. Normal traffic is many-to-many.
- Sources you have never seen. Your customer base has a shape — regions, networks, times of day. Attack sources are scattered in ways that do not match it, and a large share will be addresses that have never appeared in your logs before.
- Uniform sizes and durations. Real conversations vary. Generated traffic repeats: the same byte count, the same packet count, the same one-second lifetime, thousands of times.
- Answers to questions you never asked. Some floods consist of replies — from name servers, time servers, and similar public services — arriving in response to requests your network never sent. From your side this looks like heavy inbound volume from one service port on many unrelated servers, with no matching outbound. Someone is using your address as the return address; note it for your provider, because it identifies exactly what they should filter.
Tip: never decide from one graph. The single most reliable habit in this whole guide is to put two lines on the same time axis and ask whether they moved together. Inbound against outbound. Sessions against bandwidth. Requests against logins. Attacks break the relationships that real traffic keeps.
The four look-alikes
Most "are we under attack?" moments are not attacks. The following four explain the large majority of false alarms, and each has a check that separates it quickly.
The viral day
A newsletter lands, a post gets shared, a product goes on sale, and traffic doubles. The differences: it ramps over minutes rather than stepping in seconds. Outbound rises along with inbound because the server is actually answering. The URL mix stays broad and full of static assets. Sources look like your customers. And above all, real users complete transactions. Orders, sign-ups, and logins climb with the request rate. Attack "users" never buy anything.
The broken client
A script with a bug, an integration whose token expired, or a user's laptop stuck retrying: one source hammering one endpoint hundreds of times a minute. It can fill a session table or bury an application all by itself. The tell is in the source column — there is one, or one small network. Distributed attacks are, by definition, not this. Fix: find the owner and ask them to stop; block the single address only if you cannot reach them.
The misconfigured monitor
Your own uptime checks, a partner's health probe, a security scanner someone scheduled, or an internal load test that was supposed to point at staging. These arrive from known addresses, at machine-regular intervals, hitting the exact endpoints a checker would hit. Look at the timing: humans and attackers are both irregular; monitors are metronomes. Cross-check with whoever owns the addresses before assuming malice.
The backup or replication misfire
An off-site backup, a cloud sync, or a database replica catching up will pin a circuit just as flat as a flood. So will a large file transfer that started during business hours. The differences: the traffic is usually outbound, or inbound from a single known address. It is one long-lived flow, or a few, rather than thousands of short ones; packets are full-size; and it started at a scheduled time. A full circuit made of one big conversation is a scheduling problem, not an attack.
Symptom, cause, and the check that separates them
This table is the short version of everything above. The right-hand column is the one check that most quickly tells the attack row from its look-alike.
| What you see | Attack explanation | Innocent explanation | The differentiating check |
|---|---|---|---|
| Inbound pinned at circuit ceiling | Volumetric flood | Backup, sync, or large transfer | Flow count and direction: thousands of short inbound flows from many sources vs. one or a few long flows to or from a known address |
| Packet rate far above normal, bit rate only elevated | Packet-rate flood aimed at the router | Chatty new application or scanner | Packet size: constant and tiny from many sources vs. mixed sizes from a few known sources |
| Session table at maximum, bandwidth normal | State-exhaustion attack | Broken client in a retry loop, or timeouts set too long | Sessions per source: thousands of sources with a few half-open each vs. one source holding hundreds |
| Web CPU and response time up, network calm | Application-layer flood | Viral day, or a slow query someone just deployed | Request rate against completed transactions: diverging means attack; rising together means popular; flat requests with slow responses means a code or database problem |
| One endpoint hit repeatedly at a fixed interval | Low-and-slow application attack | Your own or a partner's monitor | Source address and timing: a known checker on a metronome vs. many unknown sources with jitter |
| Inbound replies from service ports on unfamiliar servers, no matching outbound | Reflected flood using your address as the return address | Rarely innocent; occasionally a misconfigured internal resolver | Outbound requests to those servers: none means reflection; some means your own device is asking |
| Everything slow, all graphs vaguely worse | Possibly a flood upstream of a shared link (collateral) | Provider fault, failing hardware, or a routing change | Provider-side circuit graph and error counters: inbound far above what you receive means flood; clean counters with high latency means a fault |
The first-look checklist and how long to look
When the question arrives, run this sequence in order. Each step takes a minute or less if the graphs already exist. Write down each answer as you go, because those six lines are exactly what your provider and your manager are about to ask for.
- Bandwidth. Is inbound at or near the circuit ceiling? If yes, you are in volumetric territory and the rest of the list is confirmation, not diagnosis. Note inbound and outbound in bits per second. If no, continue.
- Packet rate. Is packets-per-second many times baseline? Compute average packet size. Constant and small means manufactured traffic; note both numbers.
- Session count. Where is the firewall's session table against its maximum, and what is the new-session rate? Note the count and, if available, the half-open share.
- Top sources. One, a few, or thousands? Known or unknown? Does the spread match your customer base? "Thousands, unknown, scattered" is the answer that separates attack from look-alike.
- Top destination. Which of your addresses and ports is receiving it? This is the target, and it is the single most important fact for both scoping and upstream filtering.
- Application response. Are request rate and CPU up? Is the real-user metric up with them? Divergence points to an application attack; a flat request rate with slow responses points to a fault rather than a flood.
How long should you look before deciding? Longer than one sample and shorter than you want to. One polling interval is noise: a single spike can be a counter glitch or a burst that ends on its own. Two or three consecutive intervals of the same abnormal pattern, plus one differentiating check from the table, is enough to act on. In practice, that means five to ten minutes from first alert to a working hypothesis. Do not wait for certainty. You are choosing between "call the provider," "find the broken client," and "protect the application," and a reasonable choice made now is easily corrected. A perfect choice made in an hour may arrive after the damage.
A useful discipline is to say the hypothesis out loud in resource terms: "Inbound is at the ceiling from thousands of sources to our web address on one port; sessions are normal. Volumetric, targeting the website." That sentence is the hand-off to the response playbook, and every word of it came from a graph you can screenshot.
Capture as you go
Before you touch anything, grab the evidence. Screenshot the six graphs with their time axes visible. Export or copy the top-sources and top-destination views. Note the exact minute the pattern started, in a timezone you will remember. This takes three minutes and is worth far more, for two reasons. First, your provider will ask for it. A ticket that arrives with rates, target, start time, and source pattern gets worked immediately rather than after a round of questions. Second, once you start making changes the graphs change with them. Then you lose the picture of what the attack looked like before you intervened. The ISP guide in this pillar lists exactly which numbers to have ready.
Where to go next
You can now read the three families in your own graphs. You can spot a step to the ceiling with silent outbound, and a ramp to the session maximum with calm bandwidth. You can spot a server working harder for no more customers. You know the four innocent explanations that mimic them and the one check that separates each pair. And you have a six-line first look that produces a hypothesis in minutes. The next guide, the DDoS response playbook for small teams, picks up at exactly that hypothesis and walks through the first hour. When it is quiet, preparing before the flood shows how to make sure the six graphs exist and alert before anyone asks the question. Both live under DDoS Detection & Response.
Put this into practice with SysPeep Monitor
The six graphs in this guide are all things a monitoring system can collect without special hardware. These include interface bits and packets over SNMP, firewall session counts, and server response times and CPU. SysPeep Monitor keeps that history on one Windows machine, draws the lines on a shared time axis, and alerts when inbound, sessions, or response time cross a threshold. So the comparison against last Tuesday is one click, not a memory. The free trial is a quick download.
Download Free TrialLearn About SysPeep