Needham-Schroeder protocol

From Wikipedia, the free encyclopedia

The term Needham-Schroeder protocol can refer to one of two communication protocols intended for use over an insecure network, both proposed by Roger Needham and Michael Schroeder.^[1] These are:

The Needham-Schroeder Symmetric Key Protocol is based on a symmetric encryption algorithm. It forms the basis for the Kerberos protocol. This protocol aims to establish a session key between two parties on a network, typically to protect further communication.
The Needham-Schroeder Public-Key Protocol, based on public-key cryptography. This is intended to provide mutual authentication between two parties communicating on a network, but in its proposed form it is insecure.

1 The symmetric protocol
2 The public-key protocol
- 2.1 Attacks on the protocol
3 See also
4 External links
5 References

[edit] The symmetric protocol

Here, Alice (A) initiates the communication to Bob (B). Also,

S is a server trusted by both parties
K_AS is a symmetric key known only to A and S
K_BS is a symmetric key known only to B and S
N_A and N_B are nonces

The protocol can be specified as follows in security protocol notation:

$A \rightarrow S: A,B,N_A$

Alice sends a message to the server identifying herself and Bob, telling the server she wants to communicate with Bob.

$S \rightarrow A: \{N_A, K_{AB}, B, \{K_{AB}, A\}_{K_{BS}}\}_{K_{AS}}$

The server generates

K A B

and sends back to Alice a copy encrypted under

K B S

for Alice to forward to Bob and also a copy for Alice. Since Alice may be requesting keys for several different people, the nonce assures Alice that the message is fresh and that the server is replying to that particular message and the inclusion of Bob's name tells Alice who she is to share this key with.

$A \rightarrow B: \{K_{AB}, A\}_{K_{BS}}$

Alice forwards the key to Bob who can decrypt it with the key he shares with the server, thus authenticating the data.

$B \rightarrow A: \{N_B\}_{K_{AB}}$

Bob sends Alice a nonce encrypted under

K A B

to show that he has the key.

$A \rightarrow B: \{N_B-1\}_{K_{AB}}$

Alice performs a simple operation on the nonce, re-encrypts it and sends it back verifying that she is still alive and that she holds the key.

The protocol is vulnerable to a replay attack. If an attacker records one run of this protocol, then subsequently learns the value K_AB used, he can then replay the message $\{K_{AB}, A\}_{K_{BS}}$ to Bob, who will accept it, being unable to tell that the key is not fresh. This flaw is fixed in the Kerberos protocol by the inclusion of a timestamp.

[edit] The public-key protocol

This assumes the use of a public-key encryption algorithm.

Here, Alice (A) and Bob (B) use a trusted server (S) to distribute public keys on request. These keys are:

K_PA and K_SA, respectively public and private halves of an encryption key-pair belonging to A
K_PB and K_SB, similar belonging to B
K_PS and K_SS, similar belonging to S. (Note this has the property that K_SS is used to encrypt and K_PS to decrypt).

The protocol runs as follows:

$A \rightarrow S: A, B$

A requests B's public keys from S

$S \rightarrow A: \{K_{PB}, B\}_{K_{SS}}$

S responds. B's identity is placed alongside K_PB for confirmation.

$A \rightarrow B: \{N_A, A\}_{K_{PB}}$

A invents N_A and sends it to B.

$B \rightarrow S: B, A$

B requests A's public keys.

$S \rightarrow B: \{K_{PA}, A\}_{K_{SS}}$

Server responds.

$B \rightarrow A: \{N_A, N_B\}_{K_{PA}}$

B invents N_B, and sends it to A along with N_A to prove ability to decrypt with K_SB.

$A \rightarrow B: \{N_B\}_{K_{PB}}$

A confirms N_B to B, to prove ability to decrypt with K_SA

At the end of the protocol, A and B know each other's identities, and know both N_A and N_B. These nonces are not known to eavesdroppers.

[edit] Attacks on the protocol

Unfortunately, this protocol is vulnerable to a man-in-the-middle attack. If an impostor I can persuade A to initiate a session with him, he can relay the messages to B and convince B that he is communicating with A.

Ignoring the traffic to and from S, which is unchanged, the attack runs as follows:

$A \rightarrow I: \{N_A, A\}_{K_{PI}}$

A sends N_A to I, who decrypts the message with K_SI

$I \rightarrow B: \{N_A, A\}_{K_{PB}}$

I relays the message to B, pretending that A is communicating

$B \rightarrow I: \{N_A, N_B\}_{K_{PA}}$

B sends N_B

$I \rightarrow A: \{N_A, N_B\}_{K_{PA}}$

I relays it to A

$A \rightarrow I: \{N_B\}_{K_{PI}}$

A decrypts N_B and confirms it to I, who learns it

$I \rightarrow B: \{N_B\}_{K_{PB}}$

I re-encrypts N_B, and convinces B that he's decrypted it

At the end of the attack, B falsely believes that A is communicating with him, and that N_A and N_B are known only to A and B.

The attack was first described in a 1995 paper by Gavin Lowe.^[2] The paper also describes a fixed version of the scheme, referred to as the Needham-Schroeder-Lowe protocol. The fix involves the modification of message six, that is we replace:

$B \rightarrow A: \{N_A, N_B\}_{K_{PA}}$

with the fixed version:

$B \rightarrow A: \{N_A, N_B, B\}_{K_{PA}}$