Protocollo di Needham-Schroeder

Con il termine generico di protocollo di Needham-Schroeder si possono identificare due protocolli di comunicazione progettati per permettere comunicazioni cifrate su reti non sicure.

I protocolli furono proposti da Roger Needham e Michael Schroeder nel 1978.

Il protocollo di Needham-Schroeder a chiave segreta è basato sulla crittografia simmetrica ed è alla base del protocollo di rete Kerberos. Il protocollo permette di stabilire una chiave di sessione utilizzabile da due entità di rete per proteggere le successive comunicazioni.
Il protocollo di Needham-Schroeder a chiave pubblica è invece basato sulla crittografia asimmetrica e permette di assicurare la mutua autenticazione tra due entità di rete. Nella sua forma proposta non è sicuro.

Il protocollo a chiave segreta modifica

Scenario modifica

Alice ( $A$ ) e Bob ( $B$ ) sono due entità di rete che devono comunicare in modo sicuro utilizzando un collegamento di rete non sicuro.
$S$ è un server fidato, ovvero che gode della fiducia di entrambe le parti.
$K_{AS}$ è una chiave simmetrica nota esclusivamente ad $A$ e $S$ .
$K_{BS}$ è una chiave simmetrica nota esclusivamente a $B$ e $S$ .
$K_{AB}$ è una chiave simmetrica di sessione generata da $S$ durante l'esecuzione dei passi del protocollo.
$N_{A}$ e $N_{B}$ sono nonce crittografici, ovvero numeri casuali da usare una volta sola.

Si suppone che sia $A$ a cominciare la comunicazione.

Descrizione modifica

Alice spedisce un messaggio al server con la sua identità e quella di Bob, per dichiarare che intende comunicare con Bob. Allega anche un numero $N_{A}$ :

A\rightarrow S:A,B,N_{A}

Il server genera la chiave di sessione ${K_{AB}}$ e risponde ad Alice inviandole:

la chiave ${K_{AB}}$ appena generata,
la coppia $(K_{AB},A)$ criptata con la chiave $K_{BS}$ , in modo che possa essere inoltrata a Bob perché venga reso partecipe,
il nonce $N$ che assicura ad Alice che il messaggio è nuovo e che il server sta rispondendo a quel particolare messaggio.
B: l'inclusione dell'identificatore di Bob dice ad Alice con chi lei sta condividendo la chiave.

Il tutto è criptato con la chiave segreta $K_{AS}$ , nota solo ad Alice e al server:

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

Alice comunica a Bob la chiave di sessione e il proprio identificativo, criptati con la chiave $K_{BS}$ , come comunicata dal server con il precedente messaggio. Bob può decriptare il messaggio e il fatto che sia stato cifrato da una entità fidata (il server) lo rende autentico:

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

Bob risponde ad Alice con un nonce criptato con la chiave di sessione ${K_{AB}}$ , per mostrare che è in possesso della chiave:

B\rightarrow A:\{N_{B}\}_{K_{AB}}

Alice decifra il nonce di Bob, lo modifica con una semplice operazione, lo cifra nuovamente e lo rispedisce indietro, provando così che è ancora attiva e in possesso della chiave:

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

Da questo momento in poi la comunicazione è pienamente stabilita e viene condotta da entrambe le parti inviando messaggi cifrati con la chiave di sessione $K_{AB}$ .

Vulnerabilità modifica

Il protocollo è suscettibile ad attacchi di tipo replay.

Attacco Replay:

Se un attaccante $E$ conosce una vecchia chiave $K'_{AB}$ scambiata in una precedente esecuzione del protocollo, allora:

$E$ può replicare il messaggio $\{K'_{AB},A\}_{K_{BS}}$ a Bob
Bob accetta la chiave $K'_{AB}$ non sapendo che è compromessa (quindi non sa che la chiave non è nuova)

Soluzione:

utilizzare i timestamp all'interno dei messaggi (ciò si vedrà come si utilizza nel protocollo di rete Kerberos)

Il protocollo a chiave pubblica modifica

Scenario modifica

Alice ( $A$ ) e Bob ( $B$ ) sono due entità di rete che devono comunicare in modo sicuro utilizzando un collegamento di rete non sicuro.
$S$ è un server che gode della fiducia di entrambi e si occupa di distribuire chiavi pubbliche su richiesta.
$K_{PA}$ e $K_{SA}$ sono rispettivamente la chiave pubblica e la chiave segreta di Alice.
$K_{PB}$ e $K_{SB}$ similmente sono le chiavi Bob.
$K_{PS}$ e $K_{SS}$ similmente sono le chiavi del server.

È importante specificare che mentre Alice e Bob usano la chiave pubblica per cifrare e quella privata per decifrare, il server usa la chiave privata $K_{SS}$ per cifrare e la chiave pubblica $K_{PS}$ per decifrare; così facendo il server firma le proprie comunicazioni.

Descrizione modifica

Alice chiede al server la chiave pubblica di Bob:

A\rightarrow S:A,B

Il server risponde, inviando anche l'identificativo di Bob per conferma. Alice può usare la chiave pubblica $K_{PS}$ per verificare la firma di $S$ e verificarne l'autenticità confrontando l'id di Bob ricevuto con quello in suo possesso:

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

Alice genera un nonce $N_{A}$ e lo invia a Bob cifrandolo con la chiave appena ricevuta:

A\rightarrow B:\{N_{A},A\}_{K_{PB}}

Bob decifra il messaggio mediante la sua chiave privata, vede che è di Alice e richiede la sua chiave pubblica al server:

B\rightarrow S:B,A

Il server soddisfa la richiesta di Bob:

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

Bob genera un nounce $N_{B}$ e lo invia ad Alice insieme a $N_{A}$ , per provare che è in possesso della chiave privata $K_{SB}$ :

B\rightarrow A:\{N_{A},N_{B}\}_{K_{PA}}

Alice conferma $N_{B}$ a Bob per provare a sua volta che è in possesso della chiave privata $K_{SA}$

A\rightarrow B:\{N_{B}\}_{K_{PB}}

Da questo momento in poi Alice e Bob si sono autenticati a vicenda e sono gli unici a conoscenza di $N_{A}$ e $N_{B}$ .

Vulnerabilità modifica

Il protocollo è suscettibile ad attacchi di tipo man in the middle: un impostore $I$ può ingannare Alice e convincerla a iniziare una sessione di comunicazione con lui e successivamente inoltrare i messaggi a Bob convincendolo di essere in comunicazione con Alice.

A parte le comunicazioni con $S$ , che rimangono inalterate, l'attacco si svolge come segue:

Alice invia $N_{A}$ a $I$ , che decifra il messaggio con $K_{SI}$ :

A\rightarrow I:\{N_{A},A\}_{K_{PI}}

$I$ inoltra il messaggio a Bob, cifrandolo con la corrispettiva chiave pubblica, fingendo che sia Alice a voler comunicare con lui:

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

Bob risponde inviando $N_{B}$ . Questo messaggio arriva a $I$ , che non può decifrarlo perché non è in possesso di $K_{SA}$ :

B\rightarrow I:\{N_{A},N_{B}\}_{K_{PA}}

$I$ lo inoltra ad Alice:

I\rightarrow A:\{N_{A},N_{B}\}_{K_{PA}}

Alice crede che $N_{B}$ sia il nounce di $I$ , quindi lo conferma come da protocollo:

A\rightarrow I:\{N_{B}\}_{K_{PI}}

Ora $I$ conosce $N_{B}$ , lo cifra con $K_{PB}$ e invia a Bob, che vede una conferma valida.

I\rightarrow B:\{N_{B}\}_{K_{PB}}

$I$ agisce da "uomo nel mezzo" e intercetta tutti i messaggi di Bob, che crede di essere in comunicazione sicura con Alice.

L'attacco è stato descritto per la prima volta da Gavin Lowe nel 1995. La versione corretta del protocollo, chiamata Needham-Schroeder-Lowe, sostituisce il sesto messaggio