# Protocollo Woo-Lam

Il protocollo Woo-Lam rappresenta un protocollo di comunicazione progettato per permettere comunicazioni cifrate su reti non sicure. Questo fu dovuto a Thomas Woo e Simon S. Lam nella metà degli anni ottanta.
Il protocollo si basa su due concetti:
* Uso della crittografia simmetrica, quindi di un'unica chiave per la fase di codifica e decodifica;
* Uso del TTP (Trusted Third Party), ossia un organo fidato che contiene tutte le chiavi degli utenti che vogliono effettuare le comunicazioni.

## Il protocollo a chiave segreta
### Scenario

* Alice ($A$) e Bob ($B$) sono due entità di rete che devono comunicare in modo sicuro utilizzando un collegamento di rete non sicuro.
* $TTP$ è un server fidato, ovvero che gode della fiducia di entrambe le parti.
* $K_{A}$ è una chiave simmetrica nota esclusivamente ad A e TTP.
* $K_{B}$ è una chiave simmetrica nota esclusivamente a B e TTP.
* $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

L'obiettivo del protocollo è quello di far autenticare un utente $A$ da un utente $B$. I passi su cui si basa il protocollo sono:
    $1)A\rightarrow B:A$
Alice manda un messaggio a Bob dicendogli Sono Alice.
    $2)B\rightarrow A:N_{B}$
Bob manda ad Alice la relativa nonce creata appositamente.
    $3)A\rightarrow B:\lbrace N_{B}\rbrace _{K_{A}}$
Alice manda a Bob la stessa nonce appena ricevuta criptandola con la sua chiave.
    $4)B\rightarrow TTP:B,\lbrace A,\lbrace N_{B}\rbrace _{K_{A}}\rbrace _{K_{B}}$
Bob, una volta ricevuto il messaggio precedente, fa richiesta al TTP, inviandogli informazioni aggiuntive riguardo all'attuale comunicazione con Alice. Il tutto cifrato con la chiave di Bob.
    $5)TTP\rightarrow B:\lbrace N_{B}\rbrace _{K_{B}}$
Il TTP, che conosce sia la chiave di Alice che di Bob, decodifica tramite la chiave di Bob il messaggio che ha ricevuto da Bob stesso. Di tale messaggio, sfruttando la chiave di Alice, decodifica la nonce che verrà poi rispedita a Bob crittografata con la chiave di Bob.

### Vulnerabilità

Il protocollo è suscettibile ad attacchi. In questo caso, vediamo come può avvenire un attacco.
    $1)C\rightarrow B:A$
C, che finge di essere A, manda il messaggio a B dicendo di essere A.
    $1')C\rightarrow B:C$
C questa volta dice la verità, inviando correttamente il messaggio secondo protocollo.
    $2)B\rightarrow A:N_{B}$
B risponde ad A (C lo intercetta) indicando la nonce $N_{B}$ cifrata con la propria chiave.
    $2')B\rightarrow C:N_{B'}$
B risponde a C indicando la nonce $N_{B'}$ cifrata con la propria chiave.
Dopo questi due passi, abbiamo che:
* all'utente A è associata la nonce $N_{B}$;
* all'utente C è associata la nonce $N_{B'}$.
    $3)C\rightarrow B:\lbrace N_{B}\rbrace _{K_{C}}$
Secondo protocollo, C (che impersona A) dovrebbe mandare a B la stessa nonce $N_{B}$ cifrata con la chiave di A, ma per creare confusione, cifra in modo errato con la chiave di C.
    $3')C\rightarrow B:\lbrace N_{B}\rbrace _{K_{C}}$
Secondo protocollo, C dovrebbe mandare a B la stessa nonce $N_{B'}$ cifrata con la chiave di C, ma per creare confusione, utilizza erroneamente la nonce $N_{B}$.
In questi due passaggi, ci sono due violazioni al sistema:
* C (che impersona A) invia la nonce esatta cifrando con una chiave errata;
* C invia la nonce sbagliata cifrando con una chiave giusta.
    $4)B\rightarrow TTP:\lbrace A,\lbrace N_{B}\rbrace _{K_{C}}\rbrace _{K_{B}}$
B invia al TTP ciò che ha ricevuto da A (ossia da C).
    $4')B\rightarrow TTP:\lbrace C,\lbrace N_{B}\rbrace _{K_{C}}\rbrace _{K_{B}}$
B invia al TTP ciò che ha ricevuto da C.
    $5)TTP\rightarrow B:\lbrace N_{B''}\rbrace _{K_{B}}$
Quando il TTP riceve questo messaggio da B lo decodifica, in quanto possiede tutte le chiavi. Quando apre il messaggio, il TTP si rende conto che il mittente è A, quindi apre ciò con la chiave di A. Ma dato che era codificato con la chiave di C, quello che si otterrà alla fine è un numero sballato, perciò una nonce non giusta, chiamata $N_{B''}$.
    $5')TTP\rightarrow B:\lbrace N_{B}\rbrace _{K_{B}}$
Quando il TTP riceve questo messaggio da B, lo decodifica, lo apre esattamente in quanto mittente e chiave di codifica sono esatti, e ritorna la nonce $N_{B}$.

#### Conclusioni

B, quando riceve dal TTP le due nonce capisce che:
* la nonce $N_{B''}$ è sballata, perciò la scarta;
* la nonce $N_{B}$ è giusta, e quindi l'associa all'utente A (che in realtà è C).
Quindi, ogni messaggio successivo tra C e B risulta valido, solamente che B crede di comunicare con A, ma ciò non è vero.

#### Possibile soluzione

La possibile soluzione al problema consiste nel far sì che il TTP, dopo aver decodificato un messaggio, lo inoltri nuovamente al richiedente specificando esplicitamente la corrispondenza tra nonce e l'utente per cui era stata creata tale nonce. In pratica equivale a sostituire il passo:
    $5)TTP\rightarrow B:\lbrace N_{B}\rbrace _{K_{B}}$
con
    $5^{*})TTP\rightarrow B:\lbrace A,N_{B}\rbrace _{K_{B}}$
Così facendo ogni messaggio restituito dal TTP sarà univocamente associato ad un utente. Ciò pertanto permette la gestione di più comunicazioni parallele evitando di creare confusione nei messaggi di ritorno e quindi evitando il sopracitato attacco.