Passa al contenuto principale

2. Dettagli e varianti del protocollo IKE

IKE in ascolto e in invio usa normalmente la porta UDP 500; i messaggi IKE possono essere ricevuti anche sulla porta UDP 4500 con formato leggermente diverso (Sezione 2.23). Poiché UDP è inaffidabile, IKE prevede il recupero da errori di trasmissione, inclusi perdita, replay e falsificazione di pacchetti. IKE è progettato per funzionare se (1) almeno un pacchetto di una serie di ritrasmissioni arriva a destinazione prima del timeout e (2) il canale non è così pieno di pacchetti falsi e rigiocati da esaurire rete o CPU. Anche senza tali requisiti minimi, IKE deve fallire in modo pulito.

I messaggi IKEv2 sono pensati per essere brevi, ma contengono strutture senza limite superiore rigido (in particolare certificati digitali) e IKEv2 non frammenta i messaggi grandi. IP può frammentare UDP di grandi dimensioni, ma le implementazioni variano nel massimo supportato. Inoltre la frammentazione IP espone a DoS [DOSUDPPROT]. Alcuni NAT o firewall possono bloccare i frammenti.

Tutte le implementazioni IKEv2 DEVONO poter inviare, ricevere ed elaborare messaggi IKE fino a 1280 ottetti e DOVREBBERO fino a 3000. Devono conoscere la dimensione massima UDP supportata e POSSONO accorciare i messaggi omettendo certificati o proposte di suite. L'uso di formati « Hash and URL » evita molti problemi. Se le ricerche URL sono possibili solo dopo il Child SA, possono esserci problemi di ricorsione.

Il payload UDP di tutti i pacchetti IKE sulla porta 4500 DEVE iniziare con quattro ottetti zero; altrimenti il ricevente non sa come gestirli.

2.1. Uso dei timer di ritrasmissione​

Tutti i messaggi IKE sono coppie richiesta/risposta. L'istituzione di una IKE SA consiste normalmente in due scambi. Una volta stabilita la IKE SA, ciascuna estremità della Security Association può avviare richieste in qualsiasi momento e molte richieste e risposte possono essere « in volo ». Ogni messaggio è etichettato come richiesta o risposta e, per ogni scambio, un'estremità è l'iniziatore e l'altra il risponditore.

Per ogni coppia di messaggi IKE, l'iniziatore è responsabile della ritrasmissione in caso di timeout. Il risponditore NON DEVE MAI ritrasmettere una risposta salvo che riceva una ritrasmissione della richiesta. In tal caso DEVE ignorare la richiesta ritrasmettiva salvo nella misura in cui provoca la ritrasmissione della risposta. L'iniziatore DEVE ricordare ogni richiesta fino alla risposta corrispondente. Il risponditore DEVE ricordare ogni risposta finché non riceve una richiesta con numero di sequenza maggiore o uguale al numero nella risposta più la dimensione della finestra (Sezione 2.3). Per risparmiare memoria, i risponditori POSSONO dimenticare la risposta dopo alcuni minuti. Se riceve una richiesta ritrasmettiva per una risposta già dimenticata, DEVE ignorarla.

IKE è affidabile: l'iniziatore DEVE ritrasmettere fino alla risposta o fino a considerare fallita la IKE SA, eliminando tutto lo stato della IKE SA e dei Child SA negoziati con essa. Una ritrasmissione DEVE essere identica bit a bit alla richiesta originale dall'intestazione IKE in poi; gli elementi prima (IP/UDP) non devono esserlo.

Le ritrasmissioni IKE_SA_INIT richiedono gestione speciale: il risponditore deve distinguere ritrasmissione di una IKE SA semi-aperta, nuova richiesta o IKE SA con IKE_AUTH già ricevuto.

Non basta SPI iniziatore e/o indirizzo IP: due peer dietro lo stesso NAT possono scegliere lo stesso SPI iniziatore. Un risponditore robusto cerca la IKE SA sull'intero pacchetto, hash o payload Ni.

Per i messaggi unidirezionali non c'è ACK: non ha senso ritrasmettere gratuitamente; limitare comunque le ritrasmissioni degli errori.

2.2. Numeri di sequenza per Message ID​

Ogni messaggio IKE contiene un Message ID nell'intestazione fissa per associare richieste e risposte e identificare le ritrasmissioni. Una ritrasmissione DEVE usare lo stesso Message ID dell'originale.

Il Message ID è a 32 bit, zero per IKE_SA_INIT (inclusi i tentativi per COOKIE o INVALID_KE_PAYLOAD), poi incrementato per ogni scambio successivo. La prima coppia IKE_AUTH ha ID 1, la seconda (con EAP) 2, ecc. Dopo il rekey della IKE SA, il Message ID sulla nuova IKE SA è azzerato.

Ogni estremità mantiene due Message ID « correnti »: il prossimo per una richiesta che inizia e il prossimo atteso dalle richieste dell'altra parte. Le risposte portano sempre lo stesso Message ID della richiesta. Dopo lo scambio iniziale, lo stesso intero n può comparire in quattro messaggi distinti; i flag Initiator e Response nell'intestazione distinguono il caso.

« Initiator » indica chi ha avviato lo scambio descritto. « Original initiator » indica sempre chi ha avviato lo scambio che ha prodotto la IKE SA corrente.

I Message ID sono protetti crittograficamente e mitigano il replay. Se crescessero oltre 32 bit, la IKE SA DEVE essere chiusa o sottoposta a rekey.

2.3. Dimensione finestra per richieste sovrapposte​

La notifica SET_WINDOW_SIZE indica che il mittente può mantenere lo stato per più scambi pendenti, consentendo al destinatario di inviare più richieste prima della prima risposta. I dati associati DEVONO essere 4 ottetti (big-endian del numero di messaggi promessi). La finestra è 1 fino al completamento degli scambi iniziali.

Un endpoint IKE DEVE attendere la risposta a ogni messaggio prima del successivo, salvo aver ricevuto SET_WINDOW_SIZE dal peer che indica capacità di gestire più messaggi pendenti.

Dopo la IKE SA, per massimizzare il throughput, un endpoint PUÒ emettere più richieste prima di qualsiasi risposta, entro il limite SET_WINDOW_SIZE del peer. Le richieste possono incrociarsi sulla rete. Un endpoint DEVE essere pronto ad accettare richieste mentre ne ha una pendente (evitare deadlock) e può accettarne più di una.

Un endpoint NON DEVE superare la finestra dichiarata dal peer: se N è la finestra, prima della richiesta X devono essere arrivate le risposte fino a X-N. Ogni endpoint DEVE conservare (o rigenerare esattamente) ogni richiesta inviata fino alla risposta e un numero di risposte precedenti pari alla finestra dichiarata.

Finestre maggiori di 1 dovrebbero supportare l'elaborazione fuori ordine.

La finestra è proprietà dell'implementazione, non controllo di congestione. Non è definito cosa fare se SET_WINDOW_SIZE è minore del valore corrente: non si può ridurre la finestra di una IKE SA esistente, solo aumentarla. Dopo rekey la nuova IKE SA riparte da 1 fino a un nuovo SET_WINDOW_SIZE.

INVALID_MESSAGE_ID per Message ID fuori finestra: non in risposta; la richiesta non valida non va riconosciuta; informare con scambio INFORMATIONAL e 4 ottetti dell'ID. Invio opzionale; limitare la frequenza.

2.4. Sincronizzazione dello stato e timeout​

Un endpoint IKE PUÒ dimenticare in qualsiasi momento tutto lo stato associato a una IKE SA e ai Child SA corrispondenti (ad es. dopo crash e riavvio). È importante che l'altro endpoint rilevi il fallimento e non continui a sprecare banda su SA scartate.

La notifica INITIAL_CONTACT afferma che questa IKE SA è l'unica attiva tra le identità autenticate. PUÒ essere inviata dopo un crash; il destinatario PUÒ eliminare altre IKE SA verso la stessa identità senza attendere un timeout. NON DEVE essere inviata da entità replicabili. Se inviata, DEVE essere nella prima richiesta o risposta IKE_AUTH, non in uno scambio separato dopo; i destinatari POSSONO ignorarla altrove.

Poiché IKE resiste ai DoS sulla rete, un endpoint NON DEVE concludere che l'altro è fallito solo in base a informazioni di routing (ICMP) o messaggi IKE non protetti (Notify su SPI sconosciuti). DEVE concludere il fallimento solo dopo tentativi ripetuti senza risposta entro un timeout o su ricezione di INITIAL_CONTACT protetto su un'altra IKE SA verso la stessa identità. Può sospettare un fallimento dal routing e avviare un controllo di vitalità. IKE specifica una richiesta INFORMATIONAL vuota che richiede acknowledgement (in una IKE SA, « vuoto » significa intestazione IKE seguita da payload criptato senza payload interni). Se è stato ricevuto di recente un messaggio protetto fresco, i Notify non protetti POSSONO essere ignorati. Le implementazioni DEVONO limitare la frequenza delle azioni basate su messaggi non protetti.

Numero di tentativi e durata dei timeout non sono specificati; si suggeriscono almeno una dozzina di ritrasmissioni su diversi minuti; i tempi di ritrasmissione DEVONO crescere in modo esponenziale. Se c'è stato solo traffico in uscita su tutte le SA associate a una IKE SA, è essenziale confermare la vitalità dell'altro endpoint. Senza messaggi protetti recenti su IKE SA o Child SA, serve un controllo di vitalità (« DPD », in realtà rilevamento di peer vivi). Un messaggio protetto fresco su IKE SA o Child SA garantisce la vitalità dell'IKE SA e di tutti i Child SA. Un'implementazione DEVE smettere di inviare su qualsiasi SA se un guasto impedisce la ricezione su tutte le SA associate. Se i Child SA possono fallire indipendentemente senza che l'IKE SA possa inviare delete, tali Child SA DEVONO essere negoziati con IKE SA separate.

Un tipo di DoS sull'iniziatore delle prime due fasi non protette può essere evitato se l'iniziatore PUÒ accettare più risposte al primo messaggio, rispondere a ciascuna e scartare le connessioni semi-aperte non valide quando arriva una risposta protetta valida a una richiesta; dopo, ignorare tutte le risposte successive.

Con queste regole non serve negoziare una durata di vita della SA: se IKE presume il partner morto per mancanza ripetuta di acknowledgement, elimina IKE SA e Child SA.

Un endpoint PUÒ eliminare Child SA inattivi; in tal caso DEVE inviare payload Delete. PUÒ anche far scadere la IKE SA. Chiudere la IKE SA chiude implicitamente i Child SA; in tal caso DOVREBBE inviare Delete per la IKE SA salvo che l'altro endpoint non risponda più.

2.5. Numeri di versione e compatibilità in avanti​

Questo documento descrive IKE versione 2.0 (maggiore 2, minore 0) e sostituisce [IKEV2]. Alcune implementazioni vorranno supportare 1.0 e 2.0 e versioni future.

Il numero maggiore va incrementato solo se formati o azioni richieste cambiano così tanto che un nodo vecchio non potrebbe interoperare ignorando i campi sconosciuti. Il minore indica nuove capacità: un nodo con minore inferiore DEVE ignorarlo; con minore superiore può usarlo informativamente (es. nuovo tipo di Notify).

Se la versione maggiore ricevuta è superiore, l'endpoint DEVE scartare il messaggio e DOVREBBE inviare Notify non autenticato INVALID_MAJOR_VERSION con la versione più alta supportata. Se supporta i maggiori n e m, DEVE supportare tutte le versioni tra n e m. Per un maggiore supportato, la risposta DEVE usare quel maggiore. Un flag indica capacità di parlare una versione maggiore più alta per evitare downgrade ingannevoli.

Il maggiore nell'intestazione IKE è quello del messaggio, non il massimo supportato dal trasmettitore. Se negoziano erroneamente una versione più bassa pur potendo entrambi di più, DEVONO interrompere e riconnettersi con la versione superiore.

IKEv1 non segue queste regole; un attaccante può far parlare due nodi v2 in v1; va annotato nei log.

Per compatibilità futura, i campi RESERVED DEVONO essere zero in 2.0 e ignorati in 2.0 [IP]. I tipi di payload non definiti sono riservati; le implementazioni DEVONO saltarli e ignorarne il contenuto.

IKEv2 aggiunge il flag « critical »: se critical è impostato e il tipo è sconosciuto, il messaggio DEVE essere rifiutato e la risposta DEVE includere UNSUPPORTED_CRITICAL_PAYLOAD con l'ottetto del tipo nei dati. Senza critical e tipo non supportato, ignorare il payload. I payload di risposta NON DEVONO avere critical. Se il tipo è riconosciuto ma il contenuto no, critical è ignorato.

Nuovi tipi di payload possono essere intercalati; le implementazioni DOVREBBERO inviare nell'ordine delle figure delle Sezioni 1 e 2, ma NON DEVONO rifiutare altri ordini come non validi.

I primi due campi di otto ottetti nell'intestazione, chiamati « IKE SPI », identificano la connessione all'inizio dei pacchetti IKE. Ogni endpoint ne sceglie uno e DEVE sceglierli come identificatori unici di una IKE SA. Il valore zero è speciale: il mittente non conosce ancora il SPI remoto.

I pacchetti IKE in ingresso sono mappati a una IKE SA solo tramite lo SPI del pacchetto, non ad esempio tramite l'indirizzo IP sorgente.

A differenza di ESP e AH, dove nell'intestazione compare solo lo SPI del destinatario, in IKE viene inviato anche lo SPI del mittente. Poiché lo SPI scelto dall'iniziatore originale della IKE SA viene sempre inviato per primo, un endpoint con più IKE SA aperte deve guardare il flag Initiator per sapere se ha assegnato i primi o i secondi otto ottetti.

Nel primo messaggio di uno scambio iniziale l'iniziatore non conosce lo SPI del risponditore e mette il campo a zero. Se lo scambio IKE_SA_INIT non crea una IKE SA a causa di INVALID_KE_PAYLOAD, NO_PROPOSAL_CHOSEN o COOKIE, lo SPI del risponditore può essere zero anche nella risposta. Se il risponditore invia uno SPI risponditore non nullo, l'iniziatore non dovrebbe rifiutare la risposta solo per questo.

Due attacchi attesi sono esaurimento di stato e CPU mediante richieste di apertura sessione da IP falsi. Un risponditore che usa poca CPU e non impegna stato nella SA finché non sa che l'iniziatore riceve all'indirizzo dichiarato riduce l'efficacia dell'attacco.

Quando un risponditore rileva molte IKE SA semi-aperte, DOVREBBE rispondere alle IKE_SA_INIT con una risposta contenente la notifica COOKIE. I dati associati DEVONO essere tra 1 e 64 ottetti inclusi; la generazione è descritta più sotto. Se la risposta IKE_SA_INIT include COOKIE, l'iniziatore DEVE ritentare IKE_SA_INIT includendo la notifica COOKIE con i dati ricevuti come primo payload, gli altri invariati. Lo scambio iniziale è allora:

Initiator                         Responder
-------------------------------------------------------------------
HDR(A,0), SAi1, KEi, Ni -->
<-- HDR(A,0), N(COOKIE)
HDR(A,0), N(COOKIE), SAi1,
KEi, Ni -->
<-- HDR(A,B), SAr1, KEr,
Nr, [CERTREQ]
HDR(A,B), SK {IDi, [CERT,]
[CERTREQ,] [IDr,] AUTH,
SAi2, TSi, TSr} -->
<-- HDR(A,B), SK {IDr, [CERT,]
AUTH, SAr2, TSi, TSr}

I primi due messaggi non alterano lo stato salvo per il cookie. I numeri di sequenza dei primi quattro messaggi sono zero, degli ultimi due sono uno. « A » è lo SPI dell'iniziatore, « B » del risponditore.

Un'implementazione IKE può generare il cookie del risponditore senza stato salvato per riconoscere un cookie valido al secondo IKE_SA_INIT. Gli algoritmi esatti non sono normativi. Esempio di protezione DoS limitata:

Cookie = <VersionIDofSecret> | Hash(Ni | IPi | SPIi | <secret>)

dove <secret> è un segreto casuale noto solo al risponditore, cambiato periodicamente, e | è concatenazione. <VersionIDofSecret> cambia quando si rigenera <secret>. Al secondo IKE_SA_INIT il cookie può essere ricalcolato e confrontato. Se coincide, il cookie è stato generato dall'ultimo cambio di <secret> e IPi deve essere la sorgente vista la prima volta. SPIi distingue aperture parallele. Ni impedisce di falsificare il messaggio 3 vedendo solo il 2. SPIi impedisce di prendere un cookie e avviare molte IKE_SA_INIT con SPI iniziatori diversi simulando molte macchine dietro un NAT.

Se <secret> cambia durante inizializzazioni in corso, un IKE_SA_INIT può portare un <VersionIDofSecret> non corrente. Il risponditore PUÒ rifiutare con nuovo cookie o PUÒ tenere brevemente il vecchio <secret> e accettare entrambi. Non dovrebbe accettare indefinitamente dopo il cambio. <secret> dovrebbe cambiare spesso, soprattutto sotto attacco.

Se il cookie non corrisponde, la parte DEVE ignorarlo e trattare come senza cookie (di solito risposta con nuovo cookie). L'iniziatore dovrebbe limitare i tentativi di scambio cookie (backoff esponenziale). Un attaccante può causare due pacchetti per ogni cookie falso.

Terminologia: « cookies » da Photuris [PHOTURIS]. ISAKMP [ISAKMP] ha due campi di otto ottetti così chiamati; IKEv2 li chiama « IKE SPI » e tiene il cookie in un campo separato nella Notify.

L'iniziatore ritenta IKE_SA_INIT perché il risponditore chiede un cookie o vuole un gruppo Diffie-Hellman diverso da KEi. Ricevuto un cookie, deve decidere se includerlo solo nel prossimo tentativo o in tutti i successivi.

Un round trip in più può servire nel primo caso, o se tutti i tentativi portano il cookie ma il risponditore non lo supporta (es. KEi nel calcolo del cookie → nuovo cookie).

Se entrambi i peer supportano il cookie in tutti i tentativi, lo scambio può essere più breve:

Initiator                   Responder
-----------------------------------------------------------
HDR(A,0), SAi1, KEi, Ni -->
<-- HDR(A,0), N(COOKIE)
HDR(A,0), N(COOKIE), SAi1, KEi, Ni -->
<-- HDR(A,0), N(INVALID_KE_PAYLOAD)
HDR(A,0), N(COOKIE), SAi1, KEi', Ni -->
<-- HDR(A,B), SAr1, KEr, Nr

Le implementazioni DOVREBBERO supportare questo scambio più breve, ma NON DEVONO fallire se altre non lo supportano.

2.7. Negoziazione degli algoritmi crittografici​

Il tipo di payload « SA » indica una proposta di insiemi di protocolli IPsec (IKE, ESP o AH) per la SA e algoritmi crittografici associati.

Un payload SA consiste in una o più proposte. Ogni proposta include un protocollo. Ogni protocollo contiene una o più transform, ciascuna specifica un algoritmo. Ogni transform contiene zero o più attributi (necessari solo se l'ID transform non specifica completamente l'algoritmo).

Questa struttura gerarchica codifica efficientemente molte suite. Il risponditore DEVE scegliere una sola suite, eventualmente sottoinsieme della proposta secondo le regole seguenti.

Ogni proposta contiene un protocollo. Se accettata, la risposta SA DEVE contenere lo stesso protocollo. Il risponditore DEVE accettare una singola proposta o rifiutarle tutte con errore NO_PROPOSAL_CHOSEN.

Ogni proposta di protocollo IPsec contiene una o più transform con Transform Type. La suite accettata DEVE contenere esattamente una transform di ogni tipo incluso nella proposta. Esempio: proposta ESP con ENCR_3DES, ENCR_AES 128, ENCR_AES 256, AUTH_HMAC_MD5, AUTH_HMAC_SHA → una transform ENCR_ e una AUTH_, sei combinazioni accettabili.

Se l'iniziatore propone sia cifrari normali con integrità sia cifrari a modo combinato, servono due proposte: una con integrità per i normali, una con tutti i combinati senza integrità (i combinati ammettono solo « NONE » per integrità).

2.8. Rinegoziazione delle chiavi​

Le IKE, ESP e AH Security Association usano chiavi segrete per un tempo e un volume di dati limitati, il che limita la vita dell'intera SA. Una SA scaduta NON DEVE essere usata. Nuove SA POSSONO essere istituite se necessario. Sostituire SA scadute si chiama « rekeying ».

Per implementazioni IPsec minime, la capacità di rekey senza riavviare l'intera IKE SA è opzionale. Un'implementazione PUÒ rifiutare tutte le richieste CREATE_CHILD_SA in una IKE SA. Se una SA è scaduta o sta per scadere e i tentativi di rekey falliscono, l'implementazione DEVE chiudere l'IKE SA e i Child SA associati e POI PUÒ avviarne di nuovi. Il rekey sul posto migliora spesso le prestazioni e riduce i pacchetti persi.

Per rekey un Child SA in una IKE SA esistente, creare una nuova SA equivalente (Sezione 2.17) e, quando la nuova è stabilita, eliminare la vecchia. In un rekey, il nuovo Child SA NON DOVREBBE avere Traffic Selector o algoritmi diversi dalla vecchia.

Per rekey una IKE SA, istituire una nuova IKE SA equivalente (Sezione 2.18) con il peer che condivide la vecchia IKE SA usando CREATE_CHILD_SA nell'IKE SA esistente. Una IKE SA così creata eredita tutti i Child SA della originale; la nuova IKE SA è usata per tutti i messaggi di controllo necessari a mantenerli. Dopo la creazione della nuova IKE SA equivalente, l'iniziatore elimina la vecchia IKE SA e il payload Delete per se stesso DEVE essere l'ultima richiesta sulla vecchia IKE SA.

Le SA dovrebbero essere rekey in modo proattivo: la nuova SA prima che la vecchia scada e diventi inutilizzabile, con tempo sufficiente per spostare il traffico.

IKEv1 negoziava le durate di vita; in IKEv2 ogni estremità applica la propria politica. Se le politiche differiscono, quella con vita più breve sarà sempre a richiedere il rekey. SA a lungo inattiva: l'estremità PUÒ chiudere invece di rekey alla scadenza, o se non c'è stato traffico dall'ultimo rekey.

IKEv2 consapevolmente permette SA parallele con gli stessi Traffic Selectors (QoS, vedi [DIFFSERVFIELD], [DIFFSERVARCH], [DIFFTUNNEL] sezione 4.1). A differenza di IKEv1, la combinazione di estremità e Traffic Selectors può non identificare univocamente una SA; l'euristica IKEv1 di eliminare SA per Traffic Selectors duplicati NON DOVREBBE essere usata.

Ci sono finestre temporali, soprattutto con pacchetti persi, in cui le estremità possono non concordare sullo stato di una SA. Il risponditore a CREATE_CHILD_SA DEVE essere pronto ad accettare messaggi su una SA prima di inviare la sua risposta alla richiesta di creazione. L'iniziatore PUÒ iniziare a inviare su una SA non appena elabora la risposta; tuttavia non può ricevere su una SA appena creata finché non riceve ed elabora la risposta alla sua richiesta CREATE_CHILD_SA. Come fa il risponditore a sapere quando è lecito inviare sulla nuova SA?

Da correttezza tecnica e interoperabilità, il risponditore PUÒ iniziare a inviare su una SA non appena invia la risposta CREATE_CHILD_SA; in alcuni casi ciò può far cadere pacchetti inutilmente, quindi un'implementazione PUÒ differire.

Il risponditore può essere certo che l'iniziatore è pronto a ricevere se (1) ha ricevuto un messaggio crittograficamente valido sull'altra metà della coppia di SA, o (2) la nuova SA rekey una SA esistente e riceve una richiesta IKE per chiudere la SA sostituita. In un rekey, il risponditore continua a inviare traffico sulla vecchia SA fino a uno di questi eventi. Con una nuova SA, il risponditore PUÒ differire l'invio finché non riceve un messaggio o scatta un timeout. Se l'iniziatore riceve un messaggio su una SA per cui non ha ancora ricevuto risposta CREATE_CHILD_SA, interpreta come probabile perdita e ritrasmette CREATE_CHILD_SA. L'iniziatore PUÒ inviare un messaggio ESP fittizio su un nuovo ESP SA se non ha messaggi in coda per assicurare al risponditore che è pronto a ricevere.

2.8.1. Rinegoziazione simultanea delle Child SA​

Se le due estremità hanno le stesse politiche di vita, entrambe possono avviare un rekey contemporaneamente (SA ridondanti). La tempistica delle richieste di rekey DOVREBBE essere jitterata.

Questo rekey può produrre temporaneamente più SA simili tra le stesse coppie di nodi. Quando due SA sono idonee a ricevere pacchetti, un nodo DEVE accettare pacchetti in ingresso su entrambe. Se collisioni creano SA ridondanti, la SA creata con il minore dei quattro nonce usati nei due scambi DOVREBBE essere chiusa dall'estremità che l'ha creata. « Minore » significa confronto ottetto per ottetto. Il nodo che ha avviato la SA rekey sopravvissuta DOVREBBE eliminare la SA sostituita dopo che la nuova è stabilita.

Esempio con host A e B e coppia (SPIa1,SPIb1):

Host A                            Host B
-------------------------------------------------------------------
send req1: N(REKEY_SA,SPIa1),
SA(..,SPIa2,..),Ni1,.. -->
<-- send req2: N(REKEY_SA,SPIb1),
SA(..,SPIb2,..),Ni2
recv req2 <--

A sa che c'è un rekey simultaneo ma non sa ancora quale nonce è minimo.

send resp2: SA(..,SPIa3,..),
Nr1,.. -->
--> recv req1

B sa lo stesso e risponde.

                              <--  send resp1: SA(..,SPIb3,..),
Nr2,..
recv resp1 <--
--> recv resp2

Esistono tre coppie. Se Nr1 in resp2 è minimo, B (mittente di req2) elimina la nuova SA ridondante, A la vecchia.

send req3: D(SPIa1) -->
<-- send req4: D(SPIb2)
--> recv req3
<-- send resp3: D(SPIb1)
recv req4 <--
send resp4: D(SPIa3) -->

Con perdita del primo req1 di A:

Host A                            Host B
-------------------------------------------------------------------
send req1: N(REKEY_SA,SPIa1),
SA(..,SPIa2,..),
Ni1,.. --> (lost)
<-- send req2: N(REKEY_SA,SPIb1),
SA(..,SPIb2,..),Ni2
recv req2 <--
send resp2: SA(..,SPIa3,..),
Nr1,.. -->
--> recv resp2
<-- send req3: D(SPIb1)
recv req3 <--
send resp3: D(SPIa1) -->
--> recv resp3

Per B il rekey è completato e non sa ancora che A ritrasmetterà req1.

resend req1 -->
--> recv req1

B risponde ad esempio con CHILD_SA_NOT_FOUND.

                               <--  send resp1: N(CHILD_SA_NOT_FOUND)
recv resp1 <--

A PUÒ ignorare l'errore se sa già che c'è stato un rekey simultaneo.

2.8.2. Rinegoziazione simultanea delle IKE SA​

Il caso più complesso è il rekey simultaneo della IKE_SA. Vale il testo della Sezione 2.8; i Child SA devono essere ereditati dalla IKE_SA corretta.

Se entrambe le estremità notano il simultaneo, come per i Child SA: dopo gli scambi CREATE_CHILD_SA esistono tre IKE SA tra A e B. La nuova IKE SA con il nonce minimo DOVREBBE essere eliminata da chi l'ha creata; l'altra nuova IKE SA DEVE ereditare tutti i Child SA.

Caso speciale: un peer termina il rekey prima di accorgersi dell'altro. Se solo un peer rileva il simultaneo, non si creano SA ridondanti. Il peer che non ha notato il simultaneo e riceve richiesta di rekey di una IKE SA già rekeyata DOVREBBE restituire TEMPORARY_FAILURE (IKE SA in chiusura). Se il peer che ha notato il simultaneo riceve la richiesta di eliminazione della vecchia IKE SA dall'altro, sa che l'altro non ha rilevato il simultaneo e PUÒ abbandonare il proprio tentativo di rekey.

Host A                      Host B
-------------------------------------------------------------------
send req1:
SA(..,SPIa1,..),Ni1,.. -->
<-- send req2: SA(..,SPIb1,..),Ni2,..
--> recv req1
<-- send resp1: SA(..,SPIb2,..),Nr2,..
recv resp1 <--
send req3: D() -->
--> recv req3

B vede una richiesta di chiusura IKE_SA e risponde come al solito. B dovrebbe smettere di ritrasmettere req2 perché quando A riceve resp3 eliminerà tutto lo stato della vecchia IKE_SA e non potrà più rispondere.

                          <-- send resp3: ()

TEMPORARY_FAILURE non era in RFC 4306 e non è negoziato; i peer più vecchi che implementano RFC 4306 ma non questo documento possono ricevere queste notifiche e le trattano come altre notifiche di errore sconosciute, interrompendo lo scambio. Poiché l'altro ha già rekey, non ci sono effetti negativi.

2.8.3. Rinegoziazione della IKE SA rispetto alla riautenticazione​

Rekey della IKE SA e riautenticazione sono concetti distinti in IKEv2. Il rekey della IKE SA stabilisce nuove chiavi e azzera i contatori Message ID ma non autentica di nuovo le parti (nessun payload AUTH o EAP).

Sebbene il rekey IKE SA possa essere importante in alcuni ambienti, la riautenticazione (verifica che le parti abbiano ancora accesso alle credenziali a lungo termine) è spesso più importante.

IKEv2 non ha supporto speciale per la riautenticazione: si crea una nuova IKE SA da zero (scambi IKE_SA_INIT/IKE_AUTH senza payload Notify REKEY_SA), nuovi Child SA nella nuova IKE SA (senza REKEY_SA), poi si elimina la vecchia IKE SA (che elimina anche i vecchi Child SA).

La riautenticazione stabilisce anche nuove chiavi per IKE SA e Child SA; quindi, sebbene il rekey possa essere più frequente della riautenticazione, una « durata di autenticazione » più breve della « durata delle chiavi » non ha senso.

Sebbene la creazione di una nuova IKE SA possa essere avviata da entrambe le parti (iniziatore o risponditore nella IKE SA originale), l'uso di EAP e/o payload Configuration implica in pratica che la riautenticazione sia avviata dalla stessa parte della IKE SA originale. IKEv2 attualmente non consente al risponditore di richiedere la riautenticazione in questo caso; esistono estensioni come [REAUTH].

2.9. Negoziazione dei Traffic Selector​

Quando un sottosistema IPsec conforme a RFC4301 riceve un pacchetto IP che corrisponde a un selettore « protect » nel Security Policy Database (SPD), protegge il pacchetto con IPsec. Se non esiste ancora una SA, spetta a IKE crearla. La manutenzione della SPD è fuori dall'ambito di IKE, sebbene alcune implementazioni possano aggiornare la SPD in connessione con IKE (esempio in Sezione 1.1.3).

I payload Traffic Selector (TS) consentono agli endpoint di comunicare parte delle informazioni della SPD ai peer. Devono essere comunicati a IKE dalla SPD (ad esempio l'API PF_KEY [PFKEY] usa il messaggio SADB_ACQUIRE). I payload TS specificano i criteri di selezione per i pacchetti che saranno inoltrati sulla SA appena creata.

Ciò può servire da controllo di coerenza o guidare l'aggiornamento dinamico della SPD.

Due payload TS compaiono in ciascun messaggio dello scambio che crea una coppia di Child SA. Ogni payload TS contiene uno o più Traffic Selector, ciascuno con intervallo di indirizzi (IPv4 o IPv6), intervallo di porte e ID protocollo IP.

Il primo payload è TSi (Traffic Selector-initiator), il secondo TSr (Traffic Selector-responder). TSi specifica l'indirizzo sorgente del traffico inoltrato dall'iniziatore della coppia Child SA (o destinazione del traffico verso l'iniziatore). TSr la destinazione del traffico verso il risponditore (o sorgente dal risponditore). Esempio: tunnelizzare 198.51.100.* verso 192.0.2.* : un selettore per payload; se accettabile, il risponditore rimanda gli stessi TS.

IKEv2 permette al risponditore di scegliere un sottoinsieme del traffico proposto dall'iniziatore (aggiornamenti asimmetrici o configurazioni intenzionalmente diverse).

Il risponditore restringe i Traffic Selector a un sottoinsieme non vuoto della proposta. Tipi sconosciuti vengono ignorati e non restituiti nell'insieme ristretto.

Se l'iniziatore richiede la SA per un pacchetto dati, DOVREBBE includere come primo Traffic Selector in TSi e TSr un TS molto specifico con gli indirizzi del pacchetto che ha innescato la richiesta, poi intervalli più ampi. Senza pacchetto innescante (es. all'avvio), i primi valori possono essere intervalli.

Restrizione da parte del risponditore:

  • Nessuna parte accettabile → TS_UNACCEPTABLE.

  • Tutto accettabile → stessi TSi/TSr.

  • Primo selettore accettabile → restringere includendo le prime scelte dell'iniziatore.

  • Altrimenti → sottoinsieme accettabile di TSi/TSr.

Se esistono più sottoinsiemi accettabili la cui unione non lo è, il risponditore ne sceglie uno arbitrariamente e PUÒ includere ADDITIONAL_TS_POSSIBLE (senza dati).

Se la politica richiede una SA per ogni coppia di indirizzi ma l'iniziatore non ha fornito un primo TS preciso, il risponditore indovina o invia SINGLE_PAIR_REQUIRED.

Poche politiche richiedono SA separate per ogni coppia; se solo parte dei TS proposti è accettabile, i risponditori DOVREBBERO restringere invece di usare SINGLE_PAIR_REQUIRED.

2.9.1. Traffic Selector che violano la propria policy​

Creando una nuova SA, l'iniziatore deve evitare TS che violano la propria politica, altrimenti traffico valido può essere scartato. Politiche decorrelate [IPSECARCH] evitano questo.

Esempio: host A invia verso 198.51.100.66 via B con AES e il resto del /24 con 3DES; B accetta entrambi. Se A propone 3DES con TSr su tutto il /24, B può usare quella SA anche da .66 e A scarta. A avrebbe dovuto partizionare TSr.

In generale, se l'iniziatore propone SA per X ma non accetta una parte X' con quella SA pur accettando X' con un'altra SA', il traffico può essere perso.

2.9.2. Traffic Selector nella rinegoziazione​

Il rekey sostituisce un Child SA esistente: una nuova SA con selettori più stretti farebbe cadere traffico consentito sulla vecchia, violando l'idea di « sostituzione ». La nuova SA NON DEVE avere selettori più stretti della originale. Se servisse un ambito più stretto, la politica è cambiata e la SA attuale sarebbe già dovuta essere eliminata.

Quando l'iniziatore tenta il rekey del Child SA, i TS proposti DOVREBBERO essere uguali o sovrainsieme di quelli del vecchio Child SA. Il risponditore NON DEVE restringere più strettamente dell'ambito attualmente in uso.

Poiché un SA rekey non può essere più stretto dell'uso corrente, i selettori dal pacchetto non servono e NON DOVREBBERO essere inviati.

2.10. Nonce​

I messaggi IKE_SA_INIT contengono ciascuno un nonce usato come input alle funzioni crittografiche. La richiesta e la risposta CREATE_CHILD_SA contengono nonce usati per aggiungere freschezza alla derivazione delle chiavi dei Child SA e per garantire bit pseudo-casuali forti dalla chiave Diffie-Hellman. I nonce in IKEv2 DEVONO essere scelti casualmente, avere almeno 128 bit e almeno metà della dimensione della chiave del PRF negoziato. L'iniziatore sceglie il nonce prima dell'esito della negoziazione: deve essere abbastanza lungo per tutti i PRF proposti. Se la stessa sorgente casuale serve per chiavi e nonce, accertarsi che l'uso dei nonce non comprometta le chiavi.

2.11. Agilità di indirizzo e porta​

IKE opera sulle porte UDP 500 e 4500 e istituisce implicitamente associazioni ESP e AH sugli stessi indirizzi IP su cui opera. Gli indirizzi IP e le porte nell'intestazione esterna non sono protetti crittograficamente; IKE è progettato per funzionare anche attraverso box di Network Address Translation (NAT). Un'implementazione DEVE accettare richieste in arrivo anche se la porta sorgente non è 500 o 4500, e DEVE rispondere all'indirizzo e alla porta da cui è arrivata la richiesta. DEVE specificare come indirizzo e porta sorgente nella risposta quelli a cui è stata ricevuta la richiesta. IKE si comporta allo stesso modo su IPv4 e IPv6.

2.12. Riutilizzo degli esponenziali Diffie-Hellman​

IKE genera materiale di chiave usando uno scambio Diffie-Hellman effimero per ottenere la « perfect forward secrecy »: una volta chiusa la connessione e dimenticate le chiavi, anche chi ha registrato tutto il traffico e ottiene tutte le chiavi a lungo termine non può ricostruire le chiavi che proteggevano la conversazione senza ricerca esaustiva dello spazio delle chiavi di sessione.

Per ottenere ciò, alla chiusura ogni estremità DEVE dimenticare non solo le chiavi usate ma ogni informazione che potrebbe servire a ricalcolarle.

Calcolare gli esponenziali Diffie-Hellman è costoso; un estremo può trovare vantaggioso riutilizzarli per più stabilimenti di connessione (strategie: nuovo esponenziale solo periodicamente con PFS ridotta se la connessione dura meno della vita dell'esponenziale; oppure tracciare quale esponenziale è usato per quale connessione e cancellare lo stato solo alla chiusura corrispondente, a costo di più stato ma con PFS).

Se e quando riutilizzare sono decisioni private senza effetto sull'interoperabilità. Un'implementazione che riutilizza gli esponenziali PUÒ ricordare l'esponenziale usato dal peer in scambi passati e, se riutilizzato, evitare la seconda metà del calcolo. Vedi [REUSE] e [RFC6989] per l'analisi di sicurezza.

2.13. Generazione del materiale di chiave​

Nel contesto dell'IKE SA si negoziano quattro algoritmi crittografici: crittografia, protezione dell'integrità, gruppo Diffie-Hellman e funzione pseudo-casuale (PRF). La PRF costruisce il materiale di chiave (keying material) per tutti gli algoritmi usati nell'IKE SA e nelle Child SA.

Si assume che ogni algoritmo di crittografia e integrità usi una chiave di dimensione fissa e che qualsiasi valore casuale di quella dimensione sia una chiave valida. Per chiavi di lunghezza variabile, una lunghezza fissa DEVE essere specificata nella trasformazione negoziata (sezione 3.3.5, attributo Key Length). Per algoritmi in cui non tutti i valori sono chiavi valide, la trasformazione DEVE specificare la derivazione. Per funzioni HMAC-based, la dimensione fissa è l'output del hash sottostante.

Si assume che le PRF accettino chiavi di qualsiasi lunghezza ma abbiano una lunghezza preferita. SK_d, SK_pi e SK_pr DEVONO usare la lunghezza preferita della PRF concordata (sezione 2.14). Per PRF HMAC-based, la lunghezza preferita coincide con l'output del hash. Altri tipi di PRF DEVONO specificare la lunghezza preferita.

Il materiale di chiave è sempre l'output della PRF negoziata. Se serve più materiale dell'output della PRF, questa si usa in modo iterativo. Il termine "prf+" indica una funzione che produce un flusso pseudo-casuale dagli input di una PRF "prf".

Nel seguito, | indica concatenazione. prf+ è definita come:

prf+ (K,S) = T1 | T2 | T3 | T4 | ...

dove:
T1 = prf (K, S | 0x01)
T2 = prf (K, T1 | S | 0x02)
T3 = prf (K, T2 | S | 0x03)
T4 = prf (K, T3 | S | 0x04)
...

Si continua finché non è stato prodotto tutto il materiale necessario. Le chiavi si estraggono dalla stringa di output senza rispettare confini tra blocchi. La costante concatenata a ogni prf è un ottetto singolo. prf+ non è definita oltre 255 volte la dimensione dell'output di prf.

2.14. Materiale di chiave per l'IKE SA​

Le chiavi condivise si calcolano così. SKEYSEED deriva dai nonce scambiati in IKE_SA_INIT e dal segreto condiviso Diffie-Hellman stabilito in quello scambio. SKEYSEED produce altri sette segreti: SK_d per derivare nuove chiavi per le Child SA di questa IKE SA; SK_ai e SK_ar per l'integrità dei messaggi successivi; SK_ei e SK_er per cifrare (e decifrare) tutti gli scambi successivi; SK_pi e SK_pr per generare il payload AUTH. Le lunghezze di SK_d, SK_pi e SK_pr DEVONO essere la lunghezza preferita della PRF concordata.

SKEYSEED e derivati:

SKEYSEED = prf(Ni | Nr, g^ir)

{SK_d | SK_ai | SK_ar | SK_ei | SK_er | SK_pi | SK_pr}
= prf+ (SKEYSEED, Ni | Nr | SPIi | SPIr)

g^ir è il segreto dell'exchange DH effimero, come stringa di ottetti big-endian con zeri se necessario fino alla lunghezza del modulo. Ni e Nr sono i nonce senza header. Per compatibilità, due PRF sono speciali: con AES-XCBC-PRF-128 [AESXCBCPRF128] o AES-CMAC-PRF-128 [AESCMACPRF128], solo i primi 64 bit di Ni e Nr per SKEYSEED, ma tutti i bit per prf+.

Le due direzioni usano chiavi diverse: SK_ai e SK_ei proteggono i messaggi dall'iniziatore originale; SK_ar e SK_er l'altra direzione.

2.15. Autenticazione dell'IKE SA​

Senza autenticazione estensibile (sezione 2.16), i peer si autenticano firmando (o MAC con segreto condiviso imbottito come chiave) un blocco di dati. IDi' e IDr' sono l'intero payload ID senza header fisso. Per il rispondente, gli ottetti da firmare iniziano dal primo ottetto del primo SPI nell'header del secondo messaggio (risposta IKE_SA_INIT) e finiscono all'ultimo ottetto dell'ultimo payload. Si aggiungono per la firma il nonce Ni dell'iniziatore (solo il valore) e prf(SK_pr, IDr'). Ni e prf(SK_pr, IDr') non sono trasmessi. L'iniziatore firma il primo messaggio (richiesta IKE_SA_INIT) dallo stesso modo e aggiunge Nr e prf(SK_pi, IDi'). È critico che ciascun lato firmi il nonce dell'altro.

InitiatorSignedOctets = RealMessage1 | NonceRData | MACedIDForI
GenIKEHDR = [ four octets 0 if using port 4500 ] | RealIKEHDR
RealIKEHDR = SPIi | SPIr | . . . | Length
RealMessage1 = RealIKEHDR | RestOfMessage1
NonceRPayload = PayloadHeader | NonceRData
InitiatorIDPayload = PayloadHeader | RestOfInitIDPayload
RestOfInitIDPayload = IDType | RESERVED | InitIDData
MACedIDForI = prf(SK_pi, RestOfInitIDPayload)
ResponderSignedOctets = RealMessage2 | NonceIData | MACedIDForR
GenIKEHDR = [ four octets 0 if using port 4500 ] | RealIKEHDR
RealIKEHDR = SPIi | SPIr | . . . | Length
RealMessage2 = RealIKEHDR | RestOfMessage2
NonceIPayload = PayloadHeader | NonceIData
ResponderIDPayload = PayloadHeader | RestOfRespIDPayload
RestOfRespIDPayload = IDType | RESERVED | RespIDData
MACedIDForR = prf(SK_pr, RestOfRespIDPayload)

Tutti i payload sono inclusi nella firma, anche tipi non definiti in questo documento. Se il primo messaggio è inviato più volte, vale l'ultima versione.

Opzionalmente, i messaggi 3 e 4 POSSONO includere certificato o catena che fornisca evidenza che la chiave per la firma digitale appartiene al nome nel payload ID. Firma o MAC usano algoritmi dettati dal tipo di chiave del firmatario e dal campo Auth Method nel payload Authentication. Non è richiesto che iniziatore e rispondente firmino con gli stessi algoritmi crittografici. La scelta dipende dal tipo di chiave; l'iniziatore può usare un segreto condiviso e il rispondente una chiave pubblica e certificato. Con segreto condiviso è frequente (non richiesto) usare la stessa chiave in entrambe le direzioni.

Nota: è pratica comune ma tipicamente insicura avere un segreto condiviso derivato solo da password scelta dall'utente senza altra sorgente di casualità. Le password scelte raramente hanno imprevedibilità sufficiente contro attacchi a dizionario, non impediti da questo metodo. (Le applicazioni con autenticazione basata su password per bootstrap e IKE SA dovrebbero usare il metodo della sezione 2.16.) Il PSK deve contenere tanta imprevedibilità quanto la chiave più forte negoziata. Con PSK, AUTH si calcola come:

Iniziatore:

AUTH = prf( prf(Shared Secret, "Key Pad for IKEv2"),
<InitiatorSignedOctets>)

Rispondente:

AUTH = prf( prf(Shared Secret, "Key Pad for IKEv2"),
<ResponderSignedOctets>)

La stringa "Key Pad for IKEv2" ha 17 caratteri ASCII senza terminazione null. Il segreto condiviso può essere di lunghezza variabile. La stringa di pad consente, se il segreto deriva da password, di non memorizzare la password in chiaro ma prf(Shared Secret,"Key Pad for IKEv2"), non equivalente a password per protocolli diversi da IKEv2. Come già detto, derivare solo dalla password non è sicuro; questa costruzione anticipa che lo si faccia comunque. L'interfaccia di gestione DEVE accettare stringhe ASCII di almeno 64 ottetti e NON DEVE aggiungere terminatore null prima dell'uso come segreto. DEVE accettare codifica esadecimale e PUÒ accettare altre codifiche se l'algoritmo di traduzione in stringa binaria è specificato.

Esistono due tipi di autenticazione EAP (sezione 2.16), ciascuno con valori diversi nei calcoli AUTH sopra. Se il metodo EAP genera chiave, sostituire la master session key (MSK) al segreto condiviso. Per metodi non generanti chiave, sostituire rispettivamente SK_pi e SK_pr al segreto condiviso nei due calcoli AUTH.

2.16. Metodi EAP​

Oltre a firme a chiave pubblica e segreti condivisi, IKE supporta metodi definiti in RFC 3748 [EAP]. Spesso asimmetrici (utente verso server), possono non essere reciproci. Di solito autenticano l'iniziatore verso il rispondente e DEVONO essere usati insieme all'autenticazione del rispondente verso l'iniziatore basata su firma a chiave pubblica.

Questo documento cita [EAP] per aggiungere metodi senza aggiornare la specifica; qui si documentano varianti semplici. [EAP] richiede un numero variabile di messaggi. L'autenticazione estensibile in IKE sono scambi IKE_AUTH aggiuntivi che DEVONO completarsi per inizializzare l'IKE SA.

L'iniziatore indica EAP omettendo AUTH dal primo messaggio IKE_AUTH. Con IDi senza AUTH dichiara identità senza provarla. Se il rispondente accetta EAP, mette payload EAP nella risposta IKE_AUTH e ritarda SAr2, TSi, TSr fino all'autenticazione successiva dell'iniziatore.

Initiator                         Responder
-------------------------------------------------------------------
HDR, SAi1, KEi, Ni -->
<-- HDR, SAr1, KEr, Nr, [CERTREQ]
HDR, SK {IDi, [CERTREQ,]
[IDr,] SAi2,
TSi, TSr} -->
<-- HDR, SK {IDr, [CERT,] AUTH,
EAP}
HDR, SK {EAP} -->
<-- HDR, SK {EAP (success)}
HDR, SK {AUTH} -->
<-- HDR, SK {AUTH, SAr2, TSi, TSr}

Come in 2.2, con EAP ogni coppia di messaggi iniziali incrementa il numero; prima coppia IKE_AUTH ID 1, seconda 2, ecc.

Se il metodo EAP crea un segreto condiviso, quel segreto DEVE essere usato da entrambi per AUTH nei messaggi 7 e 8 come in 2.15. Il campo è MSK nella specifica EAP. Questo segreto generato durante IKE NON DEVE servire ad altri scopi.

Metodi EAP che non stabiliscono chiave condivisa NON DOVREBBERO essere usati: vulnerabili a MITM [EAPMITM] in altri protocolli senza tunnel autenticato dal server. Se usati, AUTH in 7 e 8 DEVONO usare SK_pi e SK_pr rispettivamente.

L'iniziatore con EAP DEVE poter estendere lo scambio iniziale ad almeno dieci scambi IKE_AUTH (notifiche, ripetizione prompt). Dopo successo EAP, il rispondente DEVE inviare payload EAP Success; in caso di fallimento Failure. Il rispondente PUÒ terminare in qualsiasi momento con Failure.

Dopo tale scambio esteso, i payload AUTH EAP DEVONO comparire nei due messaggi dopo quello con Success.

Con EAP, IDi può servire solo a routing AAA e scelta metodo, diverso dall'identità autenticata da EAP. Policy e controllo accesso DEVONO usare l'identità realmente autenticata. Spesso il server EAP è su server AAA separato; l'identità autenticata, se diversa da IDi, DEVE essere inviata dall'AAA al rispondente IKEv2.

2.17. Materiale di chiave per le Child SA​

Una Child SA è creata da IKE_AUTH; altre opzionalmente da CREATE_CHILD_SA.

KEYMAT = prf+(SK_d, Ni | Nr)

Ni e Nr da IKE_SA_INIT per la prima Child, o Ni/Nr freschi da CREATE_CHILD_SA per le successive.

Con Diffie-Hellman opzionale in CREATE_CHILD_SA:

KEYMAT = prf+(SK_d, g^ir (new) | Ni | Nr)

g^ir (new) è il segreto DH effimero di quello scambio (ottetti big-endian, zeri in alto se necessario).

Una negoziazione CREATE_CHILD_SA può produrre più Security Association. ESP e AH sono a coppie; possono esserci protocolli IPsec futuri (es. ROHC_INTEG [ROHCV2]). Per ogni Child SA il materiale DEVE essere preso da KEYMAT espanso con queste regole:

  • Chiavi per SA da iniziatore a rispondente prima di quelle nella direzione opposta.

  • Se più protocolli IPsec, ordine come gli header nel pacchetto incapsulato.

  • Se un protocollo richiede più chiavi, l'ordine è nella sua specifica. Per ESP e AH, [IPSECARCH]: chiave di cifratura (se presente) dai primi bit, chiave di integrità (se presente) dal resto.

Ogni algoritmo prende un numero fisso di bit dall'algoritmo o dai payload SA (lunghezze sezione 2.13, Key Length 3.3.5).

2.18. Rekey IKE SA con CREATE_CHILD_SA​

CREATE_CHILD_SA può rifare le chiavi di un'IKE SA esistente (sezioni 1.3.2 e 2.8). Nuovi SPI iniziatore e rispondente sono nei campi SPI delle Proposal nei payload SA (non nell'header IKE). I payload TS sono omessi per rekey IKE SA. SKEYSEED della nuova IKE SA usa SK_d della vecchia:

SKEYSEED = prf(SK_d (old), g^ir (new) | Ni | Nr)

g^ir (new) è il segreto DH effimero (big-endian, padding), Ni e Nr senza header.

Vecchia e nuova IKE SA possono avere PRF diverse. Lo scambio di rekey appartiene alla vecchia IKE SA, quindi la PRF vecchia genera SKEYSEED.

Il rekey mira a evitare che il compromesso di materiale vecchio riveli quello attuale e viceversa. Le implementazioni DEVONO eseguire un nuovo Diffie-Hellman nel rekey IKE SA. L'iniziatore NON DEVE proporre "NONE" per DH, il rispondente NON DEVE accettarlo. Un rekey riuscito include sempre KEi/KEr.

La nuova IKE SA DEVE azzerare i contatori messaggi.

SK_d, SK_ai, SK_ar, SK_ei, SK_er si calcolano da SKEYSEED come in 2.14 con SPIi, SPIr, Ni, Nr del nuovo scambio e la PRF della nuova IKE SA.

2.19. Indirizzo interno su rete remota​

Spesso nello scenario endpoint-gateway di sicurezza, un endpoint necessita di un indirizzo IP nella rete protetta dal gateway, con assegnazione dinamica. La richiesta può essere in qualsiasi creazione di Child SA (inclusa quella implicita nel messaggio 3) tramite payload CP. Di solito si assegna un solo indirizzo durante IKE_AUTH; persiste almeno fino alla cancellazione dell'IKE SA.

La funzione assegna indirizzi a un client di accesso remoto IPsec (IRAC) che effettua tunnel verso una rete protetta da un server di accesso remoto IPsec (IRAS). Poiché IKE_AUTH crea IKE SA e Child SA, l'IRAC DEVE richiedere l'indiriaggio controllato dall'IRAS (e opzionalmente altre informazioni) in IKE_AUTH. L'IRAS può ottenere indirizzi da DHCP/BOOTP o pool proprio.

Initiator                         Responder
-------------------------------------------------------------------
HDR, SK {IDi, [CERT,]
[CERTREQ,] [IDr,] AUTH,
CP(CFG_REQUEST), SAi2,
TSi, TSr} -->
<-- HDR, SK {IDr, [CERT,] AUTH,
CP(CFG_REPLY), SAr2,
TSi, TSr}

CP DEVE precedere SA. Con più IKE_AUTH, i CP DEVONO stare nei messaggi con SA.

CP(CFG_REQUEST) DEVE contenere almeno INTERNAL_ADDRESS (IPv4 o IPv6) e PUÒ contenere altri attributi richiesti in risposta.

Esempio iniziatore→rispondente:

CP(CFG_REQUEST)=
INTERNAL_ADDRESS()
TSi = (0, 0-65535, 0.0.0.0-255.255.255.255)
TSr = (0, 0-65535, 0.0.0.0-255.255.255.255)

NOTA: Traffic Selector = (protocollo, intervallo porte, intervallo indirizzi).

Rispondente→iniziatore:

CP(CFG_REPLY)=
INTERNAL_ADDRESS(192.0.2.202)
INTERNAL_NETMASK(255.255.255.0)
INTERNAL_SUBNET(192.0.2.0/255.255.255.0)
TSi = (0, 0-65535, 192.0.2.202-192.0.2.202)
TSr = (0, 0-65535, 192.0.2.0-192.0.2.255)

I valori dipendono dall'implementazione. L'IRAS PUÒ inviare attributi non richiesti e PUÒ ignorare attributi non obbligatori non supportati.

Il rispondente NON DEVE inviare CFG_REPLY senza aver ricevuto CP(CFG_REQUEST).

Se la configurazione IRAS richiede CP per un dato IDi ma l'IRAC non ha inviato CP(CFG_REQUEST), l'IRAS DEVE fallire con FAILED_CP_REQUIRED. Non è fatale per l'IKE SA. Nessun dato associato.

2.20. Versione del peer​

Un peer IKE che desidera informazioni sulla versione del software IKE dell'altro PUÒ usare il metodo seguente. Esempio di richiesta di configurazione in uno scambio INFORMATIONAL dopo IKE SA e prima Child SA.

Un'implementazione IKE PUÒ rifiutare di fornire la versione prima o dopo autenticazione se un'implementazione è nota per debolezze. In tal caso DEVE restituire stringa vuota o nessun payload CP se CP non è supportato.

Initiator                          Responder
-------------------------------------------------------------------
HDR, SK {CP(CFG_REQUEST)} -->
<-- HDR, SK {CP(CFG_REPLY)}

CP(CFG_REQUEST)=
APPLICATION_VERSION("")

CP(CFG_REPLY) APPLICATION_VERSION("foobar v1.3beta, (c) Foo Bar
Inc.")

2.21. Gestione degli errori​

Durante l'elaborazione IKE possono verificarsi molti tipi di errore. Regola generale: se una richiesta è malformata o inaccettabile per policy (nessun algoritmo compatibile), la risposta contiene un payload Notify di errore. Inviare o meno dipende dall'esistenza di un'IKE SA autenticata.

In caso di errore nell'analisi o nell'elaborazione di un pacchetto di risposta, in genere non si invia errore in quanto le risposte non devono generare nuove richieste. Tali errori devono comunque indurre il destinatario a ripulire lo stato IKE (es. Delete per SA errata).

Solo fallimenti di autenticazione (AUTHENTICATION_FAILED ed errore EAP) e messaggi malformati (INVALID_SYNTAX) causano eliminazione dell'IKE SA senza scambio INFORMATIONAL esplicito con Delete. Altri errori POSSONO richiedere tale scambio se la policy lo impone. Con terminazione EAP Failure non si invia AUTHENTICATION_FAILED.

2.21.1. Gestione degli errori in IKE_SA_INIT​

Gli errori prima di un'IKE SA protetta crittograficamente richiedono cautela. Bilanciamento tra aiutare il peer a diagnosticare ed evitare DoS con messaggi falsi.

In IKE_SA_INIT ogni notifica di errore fa fallire lo scambio. Alcune (COOKIE, INVALID_KE_PAYLOAD, INVALID_MAJOR_VERSION) possono portare a uno scambio successivo riuscito. Tutte le notifiche sono non autenticate; il destinatario dovrebbe continuare a tentare per un po' prima di arrendersi. Non agire subito sulla notifica salvo azioni correttive definite qui.

2.21.2. Gestione degli errori in IKE_AUTH​

Tutti gli errori in IKE_AUTH che fanno fallire l'autenticazione (segreto condiviso non valido, ID non valido, emittente certificato non attendibile, certificato revocato/scaduto, ecc.) DOVREBBERO produrre AUTHENTICATION_FAILED. Se l'errore è sul rispondente, la notifica è nella risposta protetta, spesso unica payload. Anche cifrata, il peer che non ha ancora autenticato l'altro deve essere cauto.

Se l'errore è sull'iniziatore, la notifica PUÒ essere in uno scambio INFORMATIONAL separato, spesso senza altri payload. Eccezione alla regola di non avviare scambi per errori nelle risposte.

Richieste con payload critico non supportato o messaggio interamente malformato DEVONO essere rifiutate per intero e DEVONO produrre solo UNSUPPORTED_CRITICAL_PAYLOAD o INVALID_SYNTAX. Non verificare in tal caso i payload di autenticazione.

Se l'autenticazione IKE_AUTH è riuscita, l'IKE SA è stabilita; la Child SA o la configurazione possono ancora fallire. Ciò non elimina automaticamente l'IKE SA. Il rispondente può includere IDr, CERT, AUTH con notifiche di errore per scambi accoppiati (FAILED_CP_REQUIRED, NO_PROPOSAL_CHOSEN, ecc.); l'iniziatore NON DEVE considerare fallita l'autenticazione per questo.

In IKE_AUTH o nell'INFORMATIONAL immediatamente successivo, solo UNSUPPORTED_CRITICAL_PAYLOAD, INVALID_SYNTAX e AUTHENTICATION_FAILED eliminano o impediscono l'IKE SA senza Delete. I documenti di estensione POSSONO definire altre notifiche con la stessa semantica ma NON DEVONO usarle senza prova che il peer le capisca (es. Vendor ID).

2.21.3. Gestione degli errori dopo l'autenticazione della IKE SA​

Dopo autenticazione IKE SA, ogni richiesta con errori DEVE produrre una risposta che notifichi l'estremità opposta.

Normalmente una risposta valida non dovrebbe creare errore nell'altro peer; non si dovrebbero inviare messaggi di erroro come INFORMATIONAL non di risposta (rischio loop). Errori di stato incoerente possono giustificare eliminazione dell'IKE SA.

Se un peer che analizza una richiesta la trova malformata (dopo MAC e controlli finestra) e restituisce INVALID_SYNTAX, tale notifica è fatale per entrambi: IKE SA eliminata senza Delete esplicito.

2.21.4. Gestione degli errori al di fuori della IKE SA​

Un nodo deve limitare la frequenza di risposte a messaggi non protetti.

Messaggi su UDP 500 o 4500 fuori contesto di IKE SA nota (e non richiesta di avvio IKE): possibile crash recente. Se marcati come risposta: audit ma NON rispondere. Se richiesta: audit e si PUÒ rispondere. Risposta: stesso IP/porta sorgente, stessi SPI IKE, Message ID copiato, non protetta crittograficamente, Notify INVALID_IKE_SPI.

Il peer che riceve tale Notify non protetta NON DEVE rispondere né cambiare stato SA. Trattare come suggerimento di possibili problemi SA verso quell'IP e avviare controllo di vitalità; limitare frequenza (DoS).

Errori fuori contesto richiesta IKE (es. ESP su SPI inesistente): avviare INFORMATIONAL con Notify.

Messaggio sospetto da IP/porta (con NAT-T) con cui esiste IKE SA: inviare Notify IKE in INFORMATIONAL su quella SA. Il destinatario NON DEVE cambiare stato SA; può registrare per diagnostica.

2.22. IPComp​

L'uso della compressione IP [IP-COMP] può essere negoziato nella creazione di una Child SA. La compressione IP aggiunge un header extra e un CPI per pacchetto; l'«associazione di compressione» virtuale non ha vita al di fuori della SA ESP o AH che la contiene e scompare con essa, senza menzione esplicita in Delete.

La negoziazione IPComp è separata dai parametri crittografici. Un nodo che richiede una Child SA PUÒ annunciare uno o più algoritmi tramite Notify IPCOMP_SUPPORTED, solo in messaggi con payload SA che negozia Child SA. La risposta PUÒ accettare un algoritmo con una IPCOMP_SUPPORTED. Questi payload NON DEVONO comparire senza payload SA.

I dati associati: due ottetti CPI IPComp, un ottetto Transform ID, attributi opzionali. Più IPCOMP_SUPPORTED nella proposta; al massimo una nell'accettazione.

NameNumberDefined In
IPCOMP_OUI1(UNSPECIFIED)
IPCOMP_DEFLATE2RFC 2394
IPCOMP_LZS3RFC 2395
IPCOMP_LZJH4RFC 3051

Valori aggiornati in [IKEV2IANA].

Le implementazioni di questa specifica NON DEVONO accettare algoritmi IPComp non proposti, non più di uno, né comprimere con algoritmo diverso da quello proposto e accettato.

Effetto collaterale: non si possono proporre più suite crittografiche con IPComp solo su alcune.

In alcuni casi ROHC è più appropriato. [ROHCV2] definisce ROHC con IKEv2 e IPsec.

2.23. Attraversamento NAT​

I gateway di traduzione degli indirizzi di rete (NAT) sono controversi. Questa sezione descrive brevemente cosa sono e come probabilmente agiscono sul traffico IKE. Molti ritengono i NAT dannosi e che i protocolli non dovrebbero essere progettati per funzionare meglio con essi. IKEv2 definisce infatti alcune regole di elaborazione poco intuitive affinché i NAT funzionino più spesso.

I NAT esistono soprattutto a causa della scarsità di indirizzi IPv4. I nodi «dietro» un NAT non hanno indirizzi globalmente unici; sono unici nella rete dietro il NAT ma spesso riutilizzati dietro altri NAT. In generale, i nodi dietro un NAT comunicano con altri dietro lo stesso NAT e con nodi a indirizzi globalmente unici, ma non con nodi dietro altri NAT (eccezioni possibili). Quando si connettono a Internet, il gateway NAT «traduce» l'indirizzo IP sorgente in un indirizzo instradabile verso il gateway. I messaggi da Internet al gateway hanno l'indirizzo di destinazione «tradotto» verso l'indirizzo interno che instrada al nodo finale.

I NAT sono progettati per essere «trasparenti» agli endpoint. Né il software dietro il NAT né il nodo su Internet richiedono modifiche per comunicare attraverso il NAT. Ottenere questa trasparenza è più difficile per alcuni protocolli. I protocolli che includono indirizzi IP degli endpoint nel payload falliscono se il gateway NAT non comprende il protocollo e non modifica i riferimenti interni e gli header. Tale conoscenza è intrinsecamente inaffidabile, viola il modello a strati e spesso causa problemi sottili.

Aprire una connessione IPsec attraverso un NAT introduce problemi speciali. In modalità transport, modificare gli indirizzi IP fa fallire i checksum e il NAT non può correggerli perché sono protetti crittograficamente. Anche in modalità tunnel, tradurre in modo trasparente gli indirizzi dei pacchetti AH ed ESP richiede logica speciale nel NAT, euristica e inaffidabile. Per questo IKEv2 usa incapsulamento UDP di IKE ed ESP. È leggermente meno efficiente ma più facile per i NAT. Inoltre i firewall possono essere configurati per far passare solo traffico IPsec incapsulato UDP o viceversa.

È pratica comune dei NAT tradurre anche le porte TCP e UDP oltre agli indirizzi e usare le porte dei pacchetti in ingresso per decidere quale nodo interno riceva un dato pacchetto. Per questo, anche se i pacchetti IKE DEVONO essere inviati da e verso le porte UDP 500 o 4500, DEVONO essere accettati da qualsiasi porta e le risposte DEVONO essere inviate alla porta di provenienza, perché le porte possono essere modificate attraversando i NAT. Analogamente, gli indirizzi degli endpoint IKE in genere non sono inclusi nei payload IKE perché i payload sono protetti crittograficamente e non potrebbero essere modificati in modo trasparente dai NAT.

La porta 4500 è riservata a ESP e IKE incapsulati UDP. Un endpoint IPsec che scopre un NAT tra sé e il corrispondente (come sotto) DEVE inviare tutto il traffico successivo dalla porta 4500, che i NAT non dovrebbero trattare in modo speciale come la 500.

L'iniziatore PUÒ usare la porta 4500 per IKE ed ESP fin dall'inizio, con o senza NAT. Quando una delle due parti usa la 4500, l'invio di ESP con incapsulamento UDP non è richiesto, ma la comprensione degli ESP ricevuti incapsulati UDP sì. L'incapsulamento UDP NON DEVE essere fatto sulla porta 500. Se è supportato l'attraversamento NAT (NAT_DETECTION_*_IP scambiati durante IKE_SA_INIT), tutti i dispositivi DEVONO poter ricevere ed elaborare in qualsiasi momento sia ESP incapsulati UDP sia non incapsulati. Ogni lato decide in modo indipendente se usare l'incapsulamento UDP per ESP. Se viene rilevato un NAT, entrambi i dispositivi DEVONO usare l'incapsulamento UDP per ESP.

I requisiti specifici [NATREQ] per il supporto dell'attraversamento NAT sono elencati sotto. Il supporto è opzionale. Solo in questa sezione, i requisiti indicati come MUST si applicano solo alle implementazioni che supportano l'attraversamento NAT.

  • Sia l'iniziatore IKE sia il rispondente DEVONO includere nei pacchetti IKE_SA_INIT payload Notify di tipo NAT_DETECTION_SOURCE_IP e NAT_DETECTION_DESTINATION_IP. Servono a rilevare se c'è NAT tra gli host e quale estremità è dietro il NAT. La posizione è subito dopo Ni e Nr (prima del CERTREQ opzionale).

  • I dati NAT_DETECTION_SOURCE_IP sono un digest SHA-1 degli SPI (nell'ordine in cui compaiono nell'header), indirizzo IP e porta da cui è stato inviato il pacchetto.

    POSSONO esserci più payload NAT_DETECTION_SOURCE_IP se il mittente non sa quale interfaccia invierà il pacchetto.

  • I dati NAT_DETECTION_DESTINATION_IP sono un digest SHA-1 degli SPI, indirizzo IP e porta a cui il pacchetto è stato inviato.

  • Il destinatario di NAT_DETECTION_SOURCE_IP o NAT_DETECTION_DESTINATION_IP PUÒ confrontare il valore fornito con un hash SHA-1 di SPI, indirizzo IP sorgente o destinatario e porta; se non coincidono, DOVREBBE abilitare l'attraversamento NAT. Se l'hash SOURCE non coincide con nessuno dei payload SOURCE ricevuti, il destinatario PUÒ rifiutare il tentativo di connessione se l'attraversamento NAT non è supportato. In caso di hash DESTINATION non corrispondente, il sistema che riceve il payload NAT_DETECTION_DESTINATION_IP è dietro un NAT e DOVREBBE iniziare a inviare pacchetti keepalive come in [UDPENCAPS]; in alternativa PUÒ rifiutare se l'attraversamento NAT non è supportato.

  • Se nessuno dei payload NAT_DETECTION_SOURCE_IP ricevuti corrisponde al valore atteso di IP e porta sorgente dall'header IP del pacchetto che contiene il payload, il sistema che invia quei payload è dietro un NAT. In tal caso il sistema che riceve dovrebbe consentire aggiornamenti dinamici dell'indirizzo IP dell'altro sistema, come descritto più avanti.

  • L'iniziatore IKE DEVE controllare i payload NAT_DETECTION_SOURCE_IP o NAT_DETECTION_DESTINATION_IP se presenti; se non corrispondono agli indirizzi nel pacchetto esterno, DEVE incapsulare in tunnel tutti i futuri pacchetti IKE ed ESP associati a questa IKE SA sulla porta UDP 4500.

  • Per tunnelizzare IKE sulla 4500: quattro ottetti zero prima dell'header IKE, subito dopo l'header UDP. Per ESP: l'header ESP segue immediatamente l'header UDP. Poiché i primi quattro ottetti dell'header ESP contengono lo SPI e lo SPI non può essere validamente zero, si possono sempre distinguere IKE ed ESP.

  • Le implementazioni DEVONO elaborare i pacchetti ESP ricevuti incapsulati UDP anche quando non è stato rilevato alcun NAT.

  • Gli indirizzi IP sorgente e destinazione originali richiesti per la correzione dei checksum TCP e UDP in modalità transport ([UDPENCAPS]) si ottengono dai Traffic Selector associati allo scambio. In caso di attraversamento NAT in modalità transport, i Traffic Selector DEVONO contenere esattamente un indirizzo IP, usato come indirizzo originale. Maggior dettaglio in 2.23.1.

  • Ci sono casi in cui un NAT rimuove mapping ancora attivi (intervallo keepalive troppo lungo, riavvio del NAT). Un host se ne accorge se riceve un pacchetto la cui protezione di integrità è valida ma con porta e/o indirizzo diversi da quelli associati alla SA nel pacchetto validato. In tal caso, un host che non supporta altri metodi di ripristino come MOBIKE [MOBIKE] e non è dietro un NAT DOVREBBE inviare tutti i pacchetti (inclusi i ritrasmetti) all'indirizzo IP e alla porta nel pacchetto validato e DOVREBBE memorizzare questa nuova combinazione per la SA. Un host dietro un NAT NON DOVREBBE fare questo tipo di aggiornamento dinamico dell'indirizzo se un pacchetto validato ha porte e/o indirizzi diversi, perché apre un possibile attacco DoS. Inoltre l'aggiornamento dinamico va fatto solo in risposta a un nuovo pacchetto; altrimenti un attaccante può ripristinare gli indirizzi con vecchi pacchetti replayati. Per questo gli aggiornamenti dinamici sono sicuri solo se la protezione anti-replay è abilitata. Quando IKEv2 è usato con MOBIKE, aggiornare dinamicamente gli indirizzi come sopra interferisce con il ripristino MOBIKE; vedere [MOBIKE] sezione 3.8.

2.23.1. Modalità transport e attraversamento NAT​

La modalità transport usata con attraversamento NAT richiede un'elaborazione speciale dei Traffic Selector in IKEv2. Lo scenario completo:

+------+        +------+            +------+         +------+
|Client| IP1 | NAT | IPN1 IPN2 | NAT | IP2 |Server|
|node |<------>| A |<---------->| B |<------->| |
+------+ +------+ +------+ +------+

(Altri scenari sono semplificazioni di questo caso complesso.)

In questo scenario ci sono due NAT che traduono indirizzi: NAT A e NAT B. NAT A è dinamico e mappa l'indirizzo sorgente del client IP1 su IPN1. NAT B è statico e configurato in modo che le connessioni verso IPN2 siano mappate sull'indirizzo IP2 del gateway, cioè l'indirizzo di destinazione IPN2 è mappato su IP2. Ciò consente al client di connettersi al server connettendosi a IPN2. NAT B non deve necessariamente essere statico, ma il client deve sapere come connettersi al server, e può farlo solo se conosce in qualche modo l'indirizzo esterno di NAT B, cioè IPN2. Se NAT B è statico, l'indirizzo può essere configurato sul client. Un'altra opzione è trovarlo con un altro protocollo (come DNS), ma è fuori ambito IKEv2.

In questo scenario, sia il client sia il server sono configurati per usare la modalità transport per il traffico dal nodo client verso il server.

Quando il client inizia a creare l'IKEv2 SA e la Child SA per inviare traffico al server, può avere un pacchetto di attivazione con indirizzo IP sorgente IP1 e indirizzo di destinazione IPN2. Il suo PAD e SPD devono avere una configurazione che corrisponda a quegli indirizzi (o voci jolly). Poiché è modalità transport, usa esattamente gli stessi indirizzi dei Traffic Selector e dell'IP esterno dei pacchetti IKE. In modalità transport DEVE usare esattamente un indirizzo IP nei payload TSi e TSr. Può avere più Traffic Selector se ha, ad esempio, più intervalli di porte da negoziare, ma tutte le voci TSi devono usare l'intervallo IP1-IP1 come indirizzi IP e tutte le voci TSr devono avere l'intervallo IPN2-IPN2. Il primo Traffic Selector di TSi e TSr DOVREBBE essere molto specifico, inclusi protocollo e numeri di porta, ad esempio dal pacchetto che attiva la richiesta.

NAT A sostituisce quindi l'indirizzo sorgente del pacchetto IKE da IP1 a IPN1, e NAT B sostituisce l'indirizzo di destinazione da IPN2 a IP2, così quando il pacchetto arriva al server ha ancora esattamente gli stessi Traffic Selector inviati dal client, ma l'indirizzo IP del pacchetto IKE è stato sostituito con IPN1 e IP2.

Quando il server riceve il pacchetto, di norma consulta il PAD descritto in RFC 4301 [IPSECARCH] in base all'ID e poi cerca nell'SPD in base ai Traffic Selector. Poiché IP1 non ha significato reale per il server (è l'indirizzo del client dietro il NAT), è inutile fare una ricerca basata su quello se si usa la modalità transport. D'altra parte, il server non può sapere se la modalità transport è consentita dalla policy prima di trovare la voce SPD corrispondente.

In questo caso, il server dovrebbe prima verificare che l'iniziatore abbia richiesto la modalità transport, poi fare sostituzione degli indirizzi sui Traffic Selector. Deve prima memorizzare i vecchi indirizzi IP dei Traffic Selector per la correzione incrementale dei checksum (l'IP in TSi può essere memorizzato come indirizzo sorgente originale e l'IP in TSr come destinazione originale). Dopo, se l'altra estremità è stata rilevata dietro un NAT, il server sostituisce l'indirizzo IP nei payload TSi con l'indirizzo ottenuto dall'indirizzo sorgente del pacchetto IKE ricevuto (sostituisce IP1 in TSi con IPN1). Se l'estremità del server è stata rilevata dietro NAT, sostituisce l'indirizzo IP nei payload TSr con l'indirizzo ottenuto dall'indirizzo di destinazione del pacchetto IKE ricevuto (sostituisce IPN2 in TSr con IP2).

Dopo questa sostituzione, sia i Traffic Selector sia gli indirizzi UDP sorgente/destinazione IKE coincidono, e il server fa ricerca SPD su quei nuovi Traffic Selector. Se trova una voce e consente la modalità transport, usa quella voce. Se trova una voce ma non consente la modalità transport, il server PUÒ annullare la sostituzione degli indirizzi e rifare la ricerca SPD con i Traffic Selector originali. Se la seconda ricerca ha successo, il server creerà una SA in modalità tunnel con i Traffic Selector reali inviati dall'altra estremità.

Questa sostituzione degli indirizzi in modalità transport è necessaria perché l'SPD è consultato con gli indirizzi che vedrà l'host locale. Ciò garantisce anche che le voci SAD per i controlli all'uscita del tunnel e i pacchetti di ritorno siano aggiunte con gli indirizzi visti dallo stack del sistema operativo locale.

Il caso più comune è che l'SPD del server contenga voci jolly che corrispondono a qualsiasi indirizzo, ma ciò consente anche voci SPD diverse, ad esempio per indirizzi esterni noti di NAT diversi.

Dopo la ricerca SPD, il server restringe i Traffic Selector in base alla voce SPD trovata. Userà di nuovo i Traffic Selector già sostituiti e quindi invierà indietro Traffic Selector con IPN1 e IP2 come indirizzi IP; può ancora restringere numero di protocollo o intervalli di porta. La voce SAD creata per la Child SA avrà gli indirizzi visti dal server, cioè IPN1 e IP2.

Quando il client riceve la risposta del server alla Child SA, farà elaborazione simile. Se è stata creata la SA in modalità transport, il client può memorizzare i Traffic Selector restituiti originali come indirizzi sorgente e destinazione originali. Sostituirà gli indirizzi IP nei Traffic Selector con quelli dall'header IP del pacchetto IKE: sostituirà IPN1 con IP1 e IP2 con IPN2. Poi userà quei Traffic Selector quando verifica la SA rispetto ai Traffic Selector inviati e quando installa la voce SAD.

Riassunto delle regole per l'attraversamento NAT in modalità transport:

Per il client che propone la modalità transport:

  • Le voci TSi DEVONO avere esattamente un indirizzo IP, che DEVE corrispondere all'indirizzo sorgente dell'IKE SA.

  • Le voci TSr DEVONO avere esattamente un indirizzo IP, che DEVE corrispondere all'indirizzo di destinazione dell'IKE SA.

  • I primi Traffic Selector TSi e TSr DOVREBBERO essere molto specifici, inclusi protocollo e porte, ad esempio dal pacchetto di attivazione.

  • POSSONO esserci più voci TSi e TSr.

  • Se per la SA è stata selezionata la modalità transport (cioè se il server ha incluso la notifica USE_TRANSPORT_MODE nella risposta):

    • Memorizzare i Traffic Selector originali come indirizzi sorgente e destinazione ricevuti.

    • Se il server è dietro un NAT, sostituire l'indirizzo IP nelle voci TSr con l'indirizzo remoto dell'IKE SA.

    • Se il client è dietro un NAT, sostituire l'indirizzo IP nelle voci TSi con l'indirizzo locale dell'IKE SA.

    • Effettuare la sostituzione degli indirizzi prima di usare quei Traffic Selector per qualsiasi scopo diverso dal memorizzarne il contenuto originale, inclusa la verifica che l'altra estremità abbia ristretto correttamente, la creazione della voce SAD, ecc.

Per il rispondente, quando il client propone la modalità transport:

  • Memorizzare gli indirizzi IP originali dei Traffic Selector come sorgente e destinazione ricevute, nel caso serva annullare la sostituzione, per usare come «indirizzi sorgente e destinazione reali» in [UDPENCAPS] e per la correzione checksum TCP/UDP.

  • Se il client è dietro un NAT, sostituire l'indirizzo IP nelle voci TSi con l'indirizzo remoto dell'IKE SA.

  • Se il server è dietro un NAT, sostituire l'indirizzo IP nelle voci TSr con l'indirizzo locale dell'IKE SA.

  • Eseguire ricerca PAD e SPD usando l'ID e i Traffic Selector sostituiti.

  • Se non è stata trovata alcuna voce SPD, o (se trovata) la voce non consente la modalità transport, annullare le sostituzioni dei Traffic Selector. Eseguire di nuovo ricerca PAD e SPD con l'ID e i Traffic Selector originali, cercando anche voci SPD in modalità tunnel (fallback a tunnel).

  • Se invece è stata trovata una voce SPD in modalità transport, eseguire il restringimento normale dei traffic selector in base ai Traffic Selector sostituiti e alla voce SPD. Usare i Traffic Selector risultanti quando si creano le voci SAD e quando si inviano i Traffic Selector al client.

2.24. Notifica esplicita di congestione (ECN)​

Quando i tunnel IPsec si comportano come originariamente specificato in [IPSECARCH-OLD], l'uso di ECN sugli header IP esterni non è appropriato perché il decapsulamento del tunnel scarta le indicazioni di congestione ECN a danno della rete. Il supporto ECN per tunnel IPsec basati su IKEv1 richiede più modalità e negoziazione ([ECN]). IKEv2 semplifica richiedendo che ECN sia utilizzabile sugli header IP esterni di tutte le Child SA in modalità tunnel create da IKEv2. In particolare, incapsulatori e decapsulatori di tunnel per tutte le SA in modalità tunnel create da IKEv2 DEVONO supportare l'opzione ECN a piena funzionalità per tunnel in [ECN] e DEVONO implementare incapsulamento e decapsulamento in [IPSECARCH] per evitare di scartare indicazioni di congestione ECN.

2.25. Collisioni di scambio​

Poiché gli scambi IKEv2 possono essere avviati da entrambi i peer, due scambi che riguardano la stessa SA possono sovrapporsi parzialmente. Lo stato SA può essere temporaneamente non sincronizzato; un peer può ricevere una richiesta che non può elaborare normalmente.

Una finestra maggiore di 1 complica la situazione, soprattutto con elaborazione fuori ordine. Questa sezione si concentra sui problemi possibili anche con finestra 1.

Si DOVREBBE inviare TEMPORARY_FAILURE quando una richiesta non può essere completata per una condizione temporanea (es. rekey). Il peer che la riceve NON DEVE ritentare subito; DEVE attendere. PUÒ ritentare una o più volte in alcuni minuti. Se TEMPORARY_FAILURE persiste sulla stessa IKE SA dopo diversi minuti, DOVREBBE concludere per stato fuori sincrono e chiudere l'IKE SA.

Si DOVREBBE inviare CHILD_SA_NOT_FOUND per richiesta di rekey di una Child SA inesistente. Lo SPI nel Notify è copiato da REKEY_SA. Il peer che riceve CHILD_SA_NOT_FOUND DOVREBBE eliminare silenziosamente la Child SA (se esiste ancora) e inviare richiesta di creazione nuova Child SA (se non esiste ancora).

2.25.1. Collisioni durante la rinegoziazione o chiusura delle Child SA​

Rekey mentre si chiude la stessa Child SA: TEMPORARY_FAILURE. Rekey durante rekey: rispondere normalmente, preparare chiusura SA ridondanti in base ai nonce (2.8.1). Rekey di Child SA inesistente: CHILD_SA_NOT_FOUND.

Chiusura durante chiusura: rispondere senza Delete (1.4.1). Chiusura durante rekey: con Delete. Chiusura di Child SA inesistente: senza Delete.

Rekey IKE SA durante creazione, rekey o chiusura di Child SA di quell'IKE SA: TEMPORARY_FAILURE.

2.25.2. Collisioni durante la rinegoziazione o chiusura delle IKE SA​

Rekey IKE SA durante rekey IKE SA: rispondere normalmente, preparare chiusura e migrazione Child SA in base ai nonce (2.8.2). Rekey durante tentativo di chiusura IKE SA: TEMPORARY_FAILURE.

Chiusura IKE SA durante rekey IKE SA: rispondere normalmente, dimenticare la propria richiesta di rekey. Chiusura durante chiusura: rispondere normalmente, dimenticare la propria chiusura.

Creazione o rekey Child SA durante rekey IKE SA: TEMPORARY_FAILURE. Eliminazione Child SA durante rekey IKE SA: normalmente con Delete.