# how does a reflection attack work?

I am trying to understand reflection attacks but unfortunately wikipedia is too vague. I understand that in such an attack the attacker tries to authenticate with the target but does so in such a way that the target authentication system's challenge is sent to a spoofed client (instead of to the attacker). I also understand that this can somehow cause a loop or DOS. But I'm missing the details. Can someone explain how this works?

-

So these are two quite different things, the first is a classification of protocol exploit, the second is a method sometimes employed by DDoSsers. I give examples of both.

# Authentication Reflection

The classic example used to explain the concept of a reflection attack is the MIG in the middle.

## How it should work

A military decides to implement a system that allows them to tell immediately if an aircraft on their radar is a good guy or a bad guy (referred to as Identify Friend from Foe (IFF) systems).

The system they implement goes something like;

``````1: Alice > Bob:   n              <-- challenge
2: Bob > Alice:   E(K, n)        <-- response
``````

Where `n` is a unique random nonce, `K` is a pre-shared key, and `E` is a suitable encryption/derivation function.

Since only friendly aircraft know the value of the secret key `K`, only friendly aircraft can calculate the correct response to a given nonce `n`. If Bob fails to generate and send the correct response within a few seconds, Alice promptly shoots him down.

Otherwise, Alice knows that Bob must have known the value of `K` in order to generate the response he sent, and that Bob must therefore be on the same team.

This process can be repeated in reverse so that Alice and Bob are mutually authenticated.

This system as it stands is completely broken, but lets first focus on the reflection attack you asked about.

## The Reflection Attack

An enemy aircraft can defeat the system by reflecting the challenge back to some other member of the good guys team.

``````1: Alice > Bob:     n
2: Bob > Charlie:   n           <-- reflection attack
3: Charlie > Bob:   E(K, n)     <-- bob receives the correct response to Alice's challenge
4: Bob > Alice:     E(K, n)     <-- and authenticates himself to Alice
``````

At the 4th interaction, Bob has authenticated himself to Alice who lets him fly past peacefully. Bob did this without knowledge of `K`, simply by sending the same challenge to someone else, hence the name reflection. Bob reflected the challenge to Charlie, who is on Alice's team and therefore knows the value of `K` and can generate the correct response. Charlie answers Bob's IFF challenge as he normally would, giving Bob the correct response to the original challenge.

## Other Attacks

Replay: If the values of `n` are taken from a small enough space, they will start to be repeated. If Bob keeps track of every challenge `n` and response `E(K,n)` pair that he hears, he will eventually be able to build a dictionary of correct responses without ever needing to know the secret key `K`. He can then start replaying previous responses when he receives a challenge that has an entry in his dictionary.

Brute Force: Bob will probably be aware of the derivation function `E`. If he knows a `n`, `E(K,n)` pair, he can try different values of `J` until `E(K,n) == E(J,n)` which implies that `J == K` and he has brute forced the secret key `K`.

# DDoS Reflection

A basic Denial of Service attack is essentially a traffic flood, designed to exhaust bandwidth, memory or other resources at the target machine.

The idea is that the attacker is in control of a significantly larger amount of bandwidth than the victim, and so can easily overwhelm the victim.

``````1. Attacker > Victim: x
``````

If `x` is of sufficient magnitude, then the victim cannot handle it (one of many resources gets exhausted) and the victim goes offline.

The attacker can make life easier by using a technique referred to as traffic amplification by reflecting his traffic from one or more third-party machines.

It looks something like;

``````1. Attacker > ThirdParty: x
2. ThirdParty > Victim: y
``````

The attacker sends a message `x` to a third party, while spoofing the source IP of the victim. When the third party replies to the message `x`, the reply is sent to the victim.

If the magnitude of of the reply `y` is greater than the magnitude of the message `x`, then the attacker has multiplied his DoS potential.

I use the term 'magnitude' here to indicate that it can be anything: number of connections, data bandwidth, packet frequency etc. The point is if `y` is harder to process than `x`, then the attacker has increased his potency by the ratio of magnitudes of `y` to `x`.

If the attacker can use a large number of third parties simultaneously, such that the attacker's bandwidth is fully consumed, then he has truly multiplied his attack potency.

-
Awesome answer, thanks for the read. – Peleus May 8 '13 at 22:52