skip to content

Which two properties make a network protocol usable as a reflection amplifier?

level: middleimportance: must knowfreq 55%

answer

  1. one datagram in, full answer out
  2. the reply address is taken on trust
  3. a bulky request/response pair supplies the ratio
  4. no defect is on the list
  5. a refusal can amplify too

basics

~10 s

Connectionless carriage, so one arriving datagram is enough to commit a full answer, and no check that the address being answered is the address that asked. A bulky request/response pair then supplies the ratio.

solid answer

~50 s

First, the service must answer without any prior exchange: one datagram arrives, the answer goes out, and nothing was established beforehand. Second, the service must never verify that the address it is answering is the address that actually asked — it replies to the sender field it was handed. Those two together mean an attacker can spend one small packet and cause bytes to be delivered somewhere else entirely. A third, practical condition supplies the leverage: there must exist a request whose answer is much larger than the request, which is why the factor belongs to a request type rather than to the protocol as a whole. Nothing on this list is a defect. A service that satisfies all three is fully patched, correctly configured to its own specification, and still usable as an amplifier.

go deeper

for a junior

Recall the two structural properties as a pair: no prior exchange before answering, and no check on who the answer is being sent to. Being able to say them plainly is most of the answer at this level.

for a middle

Explain the mechanics: why one arriving datagram is enough to commit an answer, why the reply address is simply copied from the request, and why the ratio is chosen by picking the bulkiest request the service offers.

for a senior

Show the boundary cases — a refusal message that still amplifies, and a handshake protocol that reflects at roughly 1x — and argue which of scope or protocol change actually removes the property in a given estate.

for a principal

Be ready to apply the checklist to a service your own organisation is about to publish, and to decide up front whether it ships closed by default or carries a return-path proof.

## The shortlist an attacker applies When someone is looking for new amplifier stock, they are screening protocols against a very short checklist. Two properties are structural and one is economic. ### 1. The answer is committed on the strength of a single arriving datagram The service must be willing to produce output after receiving one packet, with no preceding exchange. There is no round trip in which the requester has to demonstrate anything before the answer is generated and sent. This is the ordinary behaviour of connectionless request/response services: they exist precisely so that a lookup costs one packet each way, and that efficiency is the point of the design. ### 2. The answer's destination is taken on trust from the request The service replies to whatever sender address the arriving datagram carried. It performs no test that the party at that address is the party that asked. From inside the service this is not even a decision — the reply is simply addressed back to where the request said it came from, which is the only information available. Take those two together and the consequence is mechanical: a request can be sent that causes bytes to be delivered to a third party who never asked for them. This is the whole shape of reflection, and it is present with no defect anywhere in the chain. ### 3. There exists a request whose answer is much larger than it The first two properties give reflection. This one gives amplification. The attacker is not looking for a service that answers; they are looking for a *question* whose answer is bulky. Enumerations, full status dumps, discovery responses, bulk record sets and anything that returns a list are the interesting ones; a single-value lookup is not. That is why quoting a factor for a protocol without naming the request is imprecise: the same daemon can be a 3x amplifier and a several-hundred-x amplifier depending on which request it is handed. ## What is deliberately not on the list **A vulnerability.** No memory corruption, no authentication bypass, no unpatched release. Nothing is being exploited in the sense of subverting the service's intended behaviour. The service is being *used*, at scale and on someone else's behalf. **Compromise of the answerer.** The attacker never gains any access to the answering host, never runs code there, and never needs to. They are a client, and a well-behaved one at the protocol level. **A misconfiguration, necessarily.** Sometimes the service is exposed more widely than intended, and narrowing that exposure is the practical remedy. But a service that is intentionally public and intentionally connectionless still satisfies the checklist. Reachability is a scoping decision, not an error. ## Why a connection-oriented equivalent is a poor amplifier If the protocol completes a handshake before the payload flows, the requester must receive something at the address it claimed and echo it back. A party sending from an address it cannot receive at never completes that step, so the large payload is never produced. You can still bounce the handshake response itself off a listening host, but that response is roughly the size of what provoked it, so the factor sits near 1 — reflection without leverage. The handshake is not a security feature bolted on; the return-path proof is a side effect of establishing state, and it happens to remove exactly the property the amplifier needs. ## The refusal that still amplifies A subtle case worth being able to state: adding an access check does not by itself remove amplification unless the check happens *before* bytes are committed to the claimed address. A service that receives a 60-byte request from an address it does not recognise and replies with a 500-byte structured refusal is still an amplifier, at roughly 8x, and it is now amplifying on behalf of anyone at all rather than only authorised clients. The rule is about the size and destination of what leaves the host, not about whether the request was granted. ## What actually removes the property Only two levers exist, and both are choices rather than fixes. **Scope**: decide which networks may ask at all, so the population of reachable answerers shrinks. **Protocol**: adopt an exchange in which the answerer sends something cheap to the claimed address and requires it back before committing the expensive answer — a token or cookie echoed in a second, small exchange. That second lever is the only one that removes amplification while keeping the service public, and it is a design decision taken in the protocol, not a patch shipped by a vendor.

  • Why can't the same trick be run against a protocol that completes a handshake first?
    Because the large payload is only produced after the requester has received something at the address it claimed and echoed it back. A party that cannot receive at that address never gets past that step. The handshake response itself can still be bounced, but it is roughly the size of what provoked it, so the factor sits near 1.
  • Does requiring authentication on the service remove the amplification?
    Only if the check completes before any bytes are sent to the claimed address. A 500-byte structured refusal to a 60-byte request is still an 8x amplifier, and it now answers everybody rather than only authorised clients. What matters is the size and destination of what leaves the host, not whether the request was granted.
  • Given one amplifier, how would an attacker choose which request to send it?
    They pick the request with the bulkiest answer relative to its own size — an enumeration, a full status dump, a discovery response, anything returning a list rather than a single value. The factor is a property of that request/response pair, so protocol-level factor figures are only meaningful when the request is named.

saying these in an interview costs you the question

  • Says the datagram protocol itself is the vulnerability
  • Claims the answerer must be misconfigured or unpatched
  • Treats the factor as a constant of the protocol
  • Thinks an error or refusal response is harmless by definition
  • Believes access control alone removes the multiplier

context