Aller au contenu principal

2. Détails et variations du protocole IKE

IKE écoute et envoie normalement sur le port UDP 500, mais les messages IKE peuvent aussi être reçus sur le port UDP 4500 avec un format légèrement différent (voir la Section 2.23). Comme UDP est un protocole de datagrammes (non fiable), IKE intègre la récupération après erreurs de transmission, y compris perte, rejeu et falsification de paquets. IKE est conçu pour fonctionner tant que (1) au moins un paquet d'une série de retransmissions atteint sa destination avant expiration; et (2) le canal n'est pas tellement rempli de paquets falsifiés et rejoués qu'il épuise les capacités réseau ou CPU de l'une des extrémités. Même sans ces exigences minimales, IKE doit échouer proprement (comme si le réseau était rompu).

Bien que les messages IKEv2 soient courts, ils contiennent des structures sans borne supérieure stricte (notamment certificats numériques), et IKEv2 n'a pas de mécanisme de fragmentation des grands messages. IP définit une fragmentation des messages UDP surdimensionnés, mais les tailles maximales varient selon les implémentations. De plus, la fragmentation IP expose à des attaques par déni de service [DOSUDPPROT]. Enfin, certains NAT ou pare-feu peuvent bloquer les fragments IP.

Toutes les implémentations IKEv2 DOIVENT pouvoir envoyer, recevoir et traiter des messages IKE jusqu'à 1280 octets, et DEVRAIENT le faire jusqu'à 3000 octets. Elles doivent connaître la taille maximale UDP supportée et PEUVENT raccourcir les messages en omettant certains certificats ou propositions de suite cryptographique. L'usage des formats « Hash and URL » plutôt que l'inclusion de certificats évite la plupart des problèmes. Si les recherches d'URL ne sont possibles qu'après établissement du Child SA, des problèmes de récursion peuvent empêcher cette technique.

La charge UDP de tous les paquets contenant des messages IKE envoyés sur le port 4500 DOIT commencer par un préfixe de quatre zéros; sinon le récepteur ne sait pas les traiter.

2.1. Utilisation des temporisateurs de retransmission​

Tous les messages IKE existent par paires : une requête et une réponse. L'établissement d'une IKE SA comporte normalement deux échanges. Une fois l'IKE SA établie, chaque extrémité de l'Association de sécurité peut initier des requêtes à tout moment, et plusieurs requêtes et réponses peuvent être « en vol ». Chaque message est toutefois étiqueté comme requête ou réponse, et pour chaque échange une extrémité est l'initiateur et l'autre le répondant.

Pour chaque paire de messages IKE, l'initiateur est responsable de la retransmission en cas de délai d'attente. Le répondant NE DOIT JAMAIS retransmettre une réponse sauf s'il reçoit une retransmission de la requête. Dans ce cas, le répondant DOIT ignorer la requête retransmise sauf dans la mesure où elle provoque une retransmission de la réponse. L'initiateur DOIT mémoriser chaque requête jusqu'à la réponse correspondante. Le répondant DOIT mémoriser chaque réponse jusqu'à recevoir une requête dont le numéro de séquence est supérieur ou égal au numéro de la réponse plus la taille de sa fenêtre (Section 2.3). Pour économiser la mémoire, les répondants PEUVENT oublier la réponse après quelques minutes. Si le répondant reçoit une requête retransmise dont il a déjà oublié la réponse, il DOIT ignorer la requête (sans tenter par exemple de construire une nouvelle réponse).

IKE est fiable : l'initiateur DOIT retransmettre une requête jusqu'à réception de la réponse correspondante ou jusqu'à considérer l'IKE SA comme ayant échoué. Dans ce dernier cas, l'initiateur supprime tout état lié à l'IKE SA et aux Child SA négociées avec elle. Une retransmission de l'initiateur DOIT être bit à bit identique à la requête d'origine : tout à partir de l'en-tête IKE (SPI initiateur de l'IKE SA) doit être identique ; les éléments avant (en-têtes IP et UDP) peuvent différer.

Les retransmissions de la requête IKE_SA_INIT nécessitent un traitement particulier. Lorsqu'un répondant reçoit une requête IKE_SA_INIT, il doit déterminer s'il s'agit d'une retransmission liée à une IKE SA « semi-ouverte » existante (retransmettre la même réponse), d'une nouvelle requête (créer une nouvelle IKE SA et une réponse neuve), ou d'une IKE SA existante où la requête IKE_AUTH a déjà été reçue (ignorer).

Il ne suffit pas d'utiliser le SPI initiateur et/ou l'adresse IP pour distinguer ces cas : deux pairs derrière un même NAT pourraient choisir le même SPI initiateur. Un répondant robuste effectue la recherche d'IKE SA sur le paquet entier, son hachage ou la charge Ni.

La politique de retransmission des messages unidirectionnels diffère légèrement : aucun accusé de réception n'étant envoyé, il ne faut pas retransmettre gratuitement. Comme ce sont des erreurs, il est logique de les envoyer une fois par paquet « fautif » et de ne retransmettre que si d'autres paquets fautifs arrivent. Il reste pertinent de limiter ces retransmissions.

2.2. Utilisation des numéros de séquence pour l'ID de message​

Chaque message IKE contient un Message ID dans son en-tête fixe. Il sert à associer requêtes et réponses et à identifier les retransmissions. Une retransmission DOIT utiliser le même Message ID que le message d'origine.

Le Message ID est un quantité sur 32 bits, nulle pour les messages IKE_SA_INIT (y compris les nouvelles tentatives suite à COOKIE ou INVALID_KE_PAYLOAD), puis incrémenté pour chaque échange suivant. La première paire IKE_AUTH a l'ID 1, la seconde (avec EAP) 2, etc. Après rekey de l'IKE SA, le Message ID est remis à zéro sur la nouvelle IKE SA.

Chaque extrémité de l'IKE SA maintient deux Message ID « courants » : le prochain pour une requête qu'elle initie et le prochain attendu dans une requête de l'autre. Les compteurs s'incrémentent à l'émission et à la réception des requêtes. Les réponses portent toujours le même Message ID que la requête. Ainsi, après l'échange initial, un entier n peut apparaître dans quatre messages distincts : la n-ième requête de l'initiateur IKE d'origine, la réponse, la n-ième requête du répondant d'origine, et sa réponse. Si les deux extrémités émettent très différemment, les Message ID peuvent diverger fortement ; il n'y a pas d'ambiguïté car les drapeaux Initiateur et Réponse dans l'en-tête précisent lequel des quatre cas s'applique.

Dans tout ce document, « initiateur » désigne la partie qui a initié l'échange décrit. « Initiateur d'origine » désigne toujours celle qui a initié l'échange ayant conduit à l'IKE SA courante. Si le « répondant d'origine » lance un rekey IKE, il devient l'« initiateur d'origine » de la nouvelle IKE SA.

Les Message ID sont protégés cryptographiquement et limitent le rejeu de messages. Si les Message ID dépassent 32 bits (peu probable), l'IKE SA DOIT être fermée ou rekeyée.

2.3. Taille de fenêtre pour les requêtes qui se chevauchent​

La notification SET_WINDOW_SIZE indique que l'émetteur peut conserver l'état de plusieurs échanges en cours, permettant au destinataire d'envoyer plusieurs requêtes avant la première réponse. Les données associées DOIVENT faire 4 octets et contenir, en grand-boutiste, le nombre de messages que l'émetteur s'engage à mémoriser. La taille de fenêtre reste 1 jusqu'à la fin des échanges initiaux.

Une extrémité IKE DOIT attendre la réponse à chaque message avant d'en envoyer un autre, sauf si elle a reçu un Notify SET_WINDOW_SIZE indiquant que le pair peut gérer plusieurs messages en suspens pour améliorer le débit.

Après établissement de l'IKE SA, pour maximiser le débit IKE, une extrémité PEUT émettre plusieurs requêtes avant toute réponse, jusqu'à la limite du SET_WINDOW_SIZE du pair. Les requêtes peuvent se croiser sur le réseau. Une extrémité DOIT être prête à accepter et traiter une requête pendant qu'une autre est en cours, pour éviter l'interblocage. Elle PEUT aussi accepter plusieurs requêtes pendant qu'une sienne est en cours.

Une extrémité NE DOIT PAS dépasser la fenêtre déclarée du pair. Si le répondant a déclaré N, lorsqu'il faut envoyer la requête X, l'initiateur DOIT avoir reçu les réponses jusqu'à X-N. Chaque extrémité DOIT conserver (ou régénérer exactement) chaque requête envoyée jusqu'à la réponse, et conserver autant de réponses passées que la taille de fenêtre déclarée, au cas où la réponse serait perdue et la requête retransmise.

Une extrémité avec fenêtre supérieure à 1 devrait traiter les requêtes entrantes dans le désordre pour limiter l'impact des pannes ou du réordonnancement.

La taille de fenêtre est en principe une propriété d'implémentation (configurable), sans lien avec le contrôle de congestion (contrairement à TCP). Le comportement si le répondant reçoit un SET_WINDOW_SIZE plus petit que la valeur en vigueur n'est pas défini : on ne peut pas réduire la fenêtre d'une IKE SA existante, seulement l'augmenter. Lors d'un rekey, la nouvelle IKE SA repart à 1 jusqu'à un nouveau SET_WINDOW_SIZE.

INVALID_MESSAGE_ID est envoyé lorsqu'un Message ID est hors fenêtre. Ce Notify NE DOIT PAS figurer dans une réponse ; la requête invalide NE DOIT PAS être acquittée. Il faut informer l'autre extrémité par un échange INFORMATIONAL avec les données de notification contenant les 4 octets du Message ID invalide. L'envoi est OPTIONNEL ; ces notifications DOIVENT être limitées en débit.

<|tool▁calls▁begin|><|tool▁call▁begin|> StrReplace

2.4. Synchronisation d'état et délais de connexion​

Une extrémité IKE PEUT oublier tout état lié à une IKE SA et aux Child SA associées à tout moment, notamment après crash et redémarrage. Lorsqu'une extrémité échoue ou réinitialise son état, l'autre DOIT détecter la situation et ne pas continuer à gaspiller la bande passante sur des SA abandonnées.

La notification INITIAL_CONTACT indique que cette IKE SA est la seule active entre les identités authentifiées. Elle PEUT être envoyée après un crash ; le destinataire PEUT supprimer d'autres IKE SA vers la même identité sans attendre un délai. Elle NE DOIT PAS être envoyée par une entité réplicable (ex. : utilisateur autorisé à deux connexions simultanées). Si envoyée, elle DOIT figurer dans la première requête ou réponse IKE_AUTH, pas dans un échange ultérieur ; les destinataires PEUVENT l'ignorer ailleurs.

Comme IKE résiste aux attaques DoS, une extrémité NE DOIT PAS conclure à la panne du pair sur la seule base d'informations de routage (ICMP) ou de messages IKE non protégés (Notify d'SPI inconnus). Elle NE DOIT conclure à la panne qu'après échecs répétés jusqu'à expiration ou réception d'un INITIAL_CONTACT protégé sur une autre IKE SA vers la même identité. Elle peut suspecter une panne à partir du routage et lancer une vérification de présence. IKE définit une requête INFORMATIONAL vide exigeant un accusé (dans une IKE SA, « vide » signifie en-tête IKE puis charge chiffrée sans charges internes). Si un message protégé récent a été reçu, les Notify non protégés PEUVENT être ignorés. Les implémentations DOIVENT limiter le débit des actions basées sur des messages non protégés.

Le nombre de tentatives et les durées de temporisation ne sont pas normalisés. Il est suggéré d'effectuer au moins une douzaine de retransmissions sur plusieurs minutes avant d'abandonner ; les temporisations DOIVENT croître exponentiellement. S'il n'y a eu que du trafic sortant sur toutes les SA liées à une IKE SA, il faut confirmer la présence du pair. Sans message protégé récent sur l'IKE SA ou ses Child SA, un contrôle de présence est nécessaire (« DPD », bien qu'il détecte plutôt les pairs vivants). Un message protégé récent sur l'IKE SA ou un Child SA garantit la vivacité de l'IKE SA et de tous ses Child SA. Une implémentation DOIT cesser d'émettre sur une SA si une défaillance l'empêche de recevoir sur toutes les SA associées. Si des Child SA peuvent échouer indépendamment sans que l'IKE SA puisse envoyer de suppression, ces Child SA DOIVENT être négociées via des IKE SA distinctes.

Pour limiter une attaque sur l'initiateur pendant les deux premiers messages non protégés, l'initiateur PEUT accepter plusieurs réponses à son premier message, répondre à chacune, puis abandonner les connexions semi-ouvertes invalides lorsqu'une réponse protégée valide arrive. Après cela, toutes les réponses suivantes doivent être ignorées.

Avec ces règles, il n'est pas nécessaire de négocier une durée de vie de SA : si IKE déclare le pair mort faute d'accusés répétés, l'IKE SA et les Child SA associées sont supprimées.

Une extrémité PEUT supprimer des Child SA inactives. Si elle le fait, elle DOIT envoyer des charges Delete. Elle PEUT aussi expirer l'IKE SA. Fermer l'IKE SA ferme implicitement les Child SA ; dans ce cas elle DEVRAIT envoyer une Delete pour l'IKE SA sauf si le pair ne répond plus.

2.5. Numéros de version et compatibilité ascendante​

Ce document décrit IKE version 2.0 (majeur 2, mineur 0) et remplace [IKEV2]. Certaines implémentations voudront supporter 1.0 et 2.0, et d'autres versions à l'avenir.

Le numéro majeur ne devrait augmenter que si les formats ou actions requis changent au point qu'un nœud ancien ne pourrait pas interopérer avec un nœud récent en ignorant les champs inconnus. Le mineur indique de nouvelles capacités : un nœud au mineur inférieur DOIT l'ignorer ; un nœud au mineur supérieur peut l'utiliser à titre informatif (ex. : nouveau type de Notify). Le nœud au mineur supérieur saura que son correspondant ne comprendra pas certains messages et ne les enverra pas.

Si la version majeure reçue est supérieure, l'extrémité DOIT abandonner le message et DEVRAIT envoyer un Notify non authentifié INVALID_MAJOR_VERSION avec la plus haute version supportée. Si elle supporte les majeurs n et m, elle DOIT supporter toutes les versions entre n et m. Pour une version majeure supportée, la réponse DOIT utiliser ce numéro majeur. Un drapeau indique la capacité de parler une version majeure plus élevée afin d'éviter qu'un attaquant force une version trop basse.

Le majeur dans l'en-tête IKE est celui du message, pas le maximum supporté par l'émetteur. Si l'initiateur parle n, n+1, n+2 et le répondant n et n+1, ils négocient n+1 avec drapeau de capacité supérieure. S'ils tombent à n par erreur ou attaque, ils DOIVENT rompre et se reconnecter en n+1.

IKEv1 ne suit pas ces règles (pas de signal de version supérieure) : un attaquant peut forcer deux nœuds v2 à parler v1. Les nœuds v2 devraient journaliser une telle dégradation.

Pour la compatibilité future, les champs RESERVED DOIVENT être mis à zéro en 2.0 et ignorés en 2.0 (« soyez conservateurs en émission, libéraux en réception » [IP]). Les types de charge non définis sont réservés ; les implémentations DOIVENT les sauter et ignorer leur contenu.

IKEv2 ajoute un drapeau « critical » sur chaque en-tête de charge. Si critical est positionné et le type inconnu, le message DOIT être rejeté et la réponse DOIT inclure UNSUPPORTED_CRITICAL_PAYLOAD avec l'octet de type dans les données de notification. Si critical est absent et le type non supporté, la charge DOIT être ignorée. Les réponses NE DOIVENT PAS avoir critical. Si le type est reconnu mais le contenu inconnu (transform inconnue dans une SA, type de Notify inconnu), critical est ignoré.

De nouveaux types de charges pourront être entrelacés ; les implémentations DEVRAIENT envoyer les charges dans l'ordre des figures des Sections 1 et 2, mais NE DOIVENT PAS rejeter un autre ordre comme invalide.

2.6. SPI et cookies de l'IKE SA​

Les deux premiers champs de huit octets de l'en-tête, appelés « IKE SPI », identifient la connexion au début des paquets IKE. Chaque extrémité en choisit un et DOIT les choisir comme identifiants uniques d'une IKE SA. La valeur zéro est spéciale : l'émetteur ne connaît pas encore le SPI distant.

Les paquets IKE entrants sont associés à une IKE SA uniquement par le SPI du paquet, pas par exemple par l'adresse IP source.

Contrairement à ESP et AH où seul le SPI du destinataire apparaît, IKE envoie aussi le SPI de l'émetteur. Comme le SPI choisi par l'initiateur d'origine est toujours envoyé en premier, une extrémité avec plusieurs IKE SA doit consulter le drapeau Initiateur pour savoir si elle a assigné les huit premiers ou les huit suivants octets.

Dans le premier message d'un échange initial, l'initiateur ignore le SPI du répondant et met ce champ à zéro. Si IKE_SA_INIT n'aboutit pas à une IKE SA (INVALID_KE_PAYLOAD, NO_PROPOSAL_CHOSEN, COOKIE), le SPI du répondant peut aussi être nul dans la réponse. Si le répondant envoie un SPI répondant non nul, l'initiateur ne devrait pas rejeter la réponse pour cette seule raison.

Deux attaques attendues sont l'épuisement d'état et de CPU par inondation de demandes d'ouverture depuis des adresses IP falsifiées. Un répondant qui n'engage presque pas de CPU ni d'état tant qu'il n'a pas vérifié que l'initiateur reçoit bien à l'adresse annoncée limite l'efficacité de l'attaque.

Lorsqu'un répondant détecte de nombreuses IKE SA semi-ouvertes, il DEVRAIT répondre aux IKE_SA_INIT par une réponse contenant la notification COOKIE. Les données associées DOIVENT faire entre 1 et 64 octets inclus ; leur génération est décrite plus bas. Si la réponse IKE_SA_INIT inclut COOKIE, l'initiateur DOIT réessayer IKE_SA_INIT en plaçant la notification COOKIE avec les données reçues en première charge, les autres charges inchangées. L'échange initial est alors :

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}

Les deux premiers messages ne modifient l'état que pour le cookie. Les numéros de séquence des quatre premiers messages sont nuls, ceux des deux derniers valent 1. « A » est le SPI de l'initiateur, « B » celui du répondant.

Une implémentation peut générer le cookie répondant sans état persistant pour reconnaître un cookie valide au second IKE_SA_INIT. Les algorithmes exacts n'affectent pas l'interopérabilité et ne sont pas spécifiés. Voici un exemple de protection DoS limitée :

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

où <secret> est un secret aléatoire connu seulement du répondant, changé périodiquement, et | est la concaténation. <VersionIDofSecret> change quand <secret> est régénéré. Le cookie peut être recalculé au second IKE_SA_INIT et comparé. S'il correspond, le cookie date du dernier changement de <secret> et IPi doit être la source vue la première fois. SPIi distingue les ouvertures parallèles. Ni empêche de forger le message 3 en ne voyant que le message 2. SPIi empêche d'obtenir un cookie puis de lancer de nombreux IKE_SA_INIT avec des SPI différents pour simuler une armée derrière un NAT.

Si <secret> change pendant des initialisations en cours, un IKE_SA_INIT peut porter un ancien <VersionIDofSecret>. Le répondant PEUT rejeter avec un nouveau cookie ou PEUT garder brièvement l'ancien <secret> et accepter les deux. Il ne devrait pas accepter indéfiniment après rotation. Il devrait changer <secret> souvent, surtout sous attaque.

Si le cookie reçu ne correspond pas, la partie DOIT l'ignorer et traiter le message comme sans cookie (souvent nouvelle réponse avec cookie). L'initiateur devrait limiter les allers-retours cookie et utiliser un backoff exponentiel. Un attaquant peut provoquer deux paquets par faux cookie : rejet côté répondant puis réponse correcte.

Terminologie : « cookies » vient de Photuris [PHOTURIS]. ISAKMP [ISAKMP] nomme ainsi deux champs de huit octets ; IKEv2 les appelle « IKE SPI » et place le cookie dans une charge Notify séparée.

L'initiateur retente IKE_SA_INIT soit parce que le répondant exige un cookie, soit parce qu'il veut un autre groupe Diffie-Hellman que dans KEi. S'il reçoit un cookie, il doit décider de l'inclure seulement au prochain essai ou à tous les suivants.

Un aller-retour supplémentaire peut être nécessaire dans le premier cas, ou si tous les essais portent le cookie mais que le répondant ne le supporte pas (ex. : KEi inclus dans le calcul du cookie → nouveau cookie rejeté).

Si les deux pairs incluent le cookie à chaque reprise, l'échange peut être un peu plus court :

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

Les implémentations DEVRAIENT supporter cet échange plus court, mais NE DOIVENT PAS échouer si d'autres ne le supportent pas.

2.7. Négociation d'algorithmes cryptographiques​

Le type de charge « SA » propose un ensemble de choix de protocoles IPsec (IKE, ESP ou AH) pour la SA ainsi que les algorithmes associés.

Une charge SA comporte une ou plusieurs propositions. Chaque proposition inclut un protocole. Chaque protocole contient une ou plusieurs transformations, chacune spécifiant un algorithme. Chaque transformation contient zéro ou plusieurs attributs (nécessaires seulement si l'ID de transformation ne fixe pas entièrement l'algorithme).

Cette hiérarchie encode efficacement de grandes familles de suites lorsque plusieurs valeurs sont acceptables pour plusieurs transformations. Le répondant DOIT choisir une seule suite, sous-ensemble possible de la proposition selon les règles ci-dessous.

Chaque proposition contient un protocole. Si elle est acceptée, la réponse SA DOIT contenir le même protocole. Le répondant DOIT accepter une seule proposition ou toutes les rejeter avec une erreur de type NO_PROPOSAL_CHOSEN.

Chaque proposition de protocole IPsec contient une ou plusieurs transformations avec un type de transformation. La suite acceptée DOIT contenir exactement une transformation de chaque type présent dans la proposition. Exemple : si une proposition ESP inclut ENCR_3DES, ENCR_AES (128), ENCR_AES (256), AUTH_HMAC_MD5 et AUTH_HMAC_SHA, la suite retenue contient une transformation ENCR_ et une AUTH_ — six combinaisons possibles.

Si l'initiateur propose à la fois des chiffres classiques avec intégrité et des chiffres en mode combiné, il faut deux propositions : l'une avec intégrité pour les classiques, l'autre avec tous les modes combinés sans algorithme d'intégrité (les modes combinés n'autorisent que « NONE » hors intégrité).

2.8. Renouvellement de clés​

Les IKE, ESP et AH Security Associations utilisent des clés secrètes pour une durée et un volume de données limités, ce qui borne la durée de vie de la SA. Une SA expirée NE DOIT PAS être utilisée. De nouvelles SA PEUVENT être créées si nécessaire. Le remplacement des SA expirées s'appelle « rekeying ».

Pour les implémentations IPsec minimales, le rekey sans redémarrer toute l'IKE SA est optionnel. Une implémentation PEUT refuser tous les CREATE_CHILD_SA dans une IKE SA. Si une SA a expiré ou va expirer et que le rekey échoue, l'implémentation DOIT fermer l'IKE SA et les Child SA associées, puis PEUT en créer de nouvelles. Le rekey sur place améliore les performances et réduit souvent la perte de paquets.

Pour rekey un Child SA dans une IKE SA existante, créer une SA équivalente (Section 2.17), puis supprimer l'ancienne une fois la nouvelle établie. Lors d'un rekey, le nouveau Child SA NE DEVRAIT PAS différer par sélecteurs de trafic ni algorithmes.

Pour rekey une IKE SA, établir une nouvelle IKE SA équivalente (Section 2.18) via CREATE_CHILD_SA dans l'IKE SA actuelle. Elle hérite de tous les Child SA ; la nouvelle IKE SA porte le trafic de contrôle. Après création, l'initiateur supprime l'ancienne IKE SA ; la charge Delete pour soi-même DOIT être la dernière requête sur l'ancienne IKE SA.

Le rekey doit être proactif : la nouvelle SA avant expiration de l'ancienne, avec marge pour basculer le trafic.

IKEv1 négociait les durées de vie ; en IKEv2 chaque extrémité applique sa propre politique. Si les politiques diffèrent, celle au plus court délai demandera toujours le rekey. SA inactive longtemps : l'extrémité PEUT fermer plutôt que rekey à expiration, ou s'il n'y a pas eu de trafic depuis le dernier rekey.

IKEv2 autorise des SA parallèles avec les mêmes Traffic Selectors (QoS, voir [DIFFSERVFIELD], [DIFFSERVARCH], [DIFFTUNNEL] §4.1). Contrairement à IKEv1, extrémités + sélecteurs n'identifient pas toujours une SA ; l'heuristique IKEv1 de suppression par sélecteurs dupliqués NE DEVRAIT PAS être utilisée.

Avec pertes de paquets, les extrémités peuvent désaccorder sur l'état d'une SA. Le répondant à CREATE_CHILD_SA DOIT accepter des messages sur une SA avant d'envoyer sa réponse de création. L'initiateur PEUT émettre dès traitement de la réponse mais ne peut recevoir sur la nouvelle SA qu'après réception et traitement de cette réponse. Le répondant PEUT émettre dès envoi de sa réponse (correct en interop) mais PEUT différer pour éviter des pertes inutiles.

Le répondant sait que l'initiateur est prêt à recevoir si (1) il a reçu un message valide sur l'autre moitié de la paire, ou (2) la nouvelle SA rekey une existante et une requête IKE ferme l'ancienne. Lors d'un rekey, le répondant continue sur l'ancienne SA jusqu'à l'un de ces événements. Nouvelle SA : il PEUT attendre un message entrant ou un timeout. Si l'initiateur reçoit sans avoir eu la réponse CREATE_CHILD_SA, il retransmet. Il PEUT envoyer un paquet ESP factice sur un nouvel ESP SA vide pour signaler sa disponibilité.

2.8.1. Renouvellement simultané des Child SA​

Mêmes politiques de durée : rekey simultané possible (SA redondantes). Les demandes DEVRAIENT être jitterées.

Plusieurs SA similaires peuvent coexister brièvement ; un nœud DOIT accepter les paquets sur l'une ou l'autre SA éligible. En cas de collision, la SA créée avec le plus petit des quatre nonces DEVRAIT être fermée par son créateur. « Plus petit » = comparaison octet par octet ; si une nonce se termine avant, elle est plus petite. Le nœud qui a initié la SA rekey survivante DEVRAIT supprimer l'ancienne après établissement.

Exemple avec A et B et paire (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 sait qu'un rekey simultané se produit mais pas encore quel nonce est minimal.

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

B le sait aussi et répond.

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

Trois paires existent. Si Nr1 dans resp2 est minimal, B (req2) supprime le nouveau redondant, A supprime l'ancien.

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

Avec perte du premier req1 de 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

B croit le rekey terminé sans savoir que A retransmettra req1.

resend req1 -->
--> recv req1

B répond par exemple CHILD_SA_NOT_FOUND.

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

A peut ignorer l'erreur s'il sait déjà qu'un rekey simultané a eu lieu.

2.8.2. Renouvellement simultané des IKE SA​

Le cas le plus complexe : rekey simultané de IKE_SA. La Section 2.8 s'applique ; les Child SA doivent hériter de la bonne IKE_SA.

Si les deux extrémités détectent le simultané, comme pour Child SA : trois IKE SA après CREATE_CHILD_SA. La nouvelle IKE SA au nonce minimal DEVRAIT être supprimée par son créateur ; l'autre nouvelle IKE SA DOIT hériter de tous les Child SA.

Cas particulier : une extrémité termine avant de remarquer l'autre. Sans détection des deux côtés, pas de SA redondantes. L'extrémité qui n'a pas vu le simultané et reçoit un rekey d'une IKE SA déjà rekeyée DEVRAIT renvoyer TEMPORARY_FAILURE (IKE SA en cours de fermeture). Si l'autre extrémité reçoit la suppression de l'ancienne IKE SA, elle comprend que le pair n'a pas vu le simultané et peut abandonner sa propre tentative.

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 voit la fermeture IKE_SA ; il répond. B devrait cesser de retransmettre req2 car A supprimera l'état après resp3.

                          <-- send resp3: ()

TEMPORARY_FAILURE n'était pas dans RFC 4306 et n'est pas négocié ; les pairs RFC 4306 l'ignorent comme erreur inconnue et arrêtent l'échange, sans effet néfaste si l'autre a déjà rekeyé.

2.8.3. Renouvellement de l'IKE SA versus réauthentification​

Rekey IKE SA et réauthentification diffèrent : le rekey change les clés et remet les Message ID sans nouvelle authentification (pas d'AUTH/EAP). La réauthentification vérifie souvent davantage les identités à long terme.

IKEv2 ne prévoit pas de réauthentification dédiée : nouvelle IKE SA complète (IKE_SA_INIT/IKE_AUTH sans REKEY_SA), nouveaux Child SA sans REKEY_SA, suppression de l'ancienne IKE SA.

La réauthentification change aussi les clés ; on ne peut pas avoir une « durée d'authentification » plus courte que la « durée de clé » de manière cohérente.

Création d'une nouvelle IKE SA : soit l'initiateur soit le répondant d'origine peut lancer, mais EAP / Configuration impose en pratique le même côté qu'à l'origine. Le répondant ne peut pas encore demander la réauthentification ; des extensions comme [REAUTH] existent.

2.9. Négociation de sélecteur de trafic​

Lorsqu'un sous-système IPsec conforme à RFC4301 reçoit un paquet IP correspondant à un sélecteur « protect » dans la SPD, il applique IPsec. Sans SA existante, IKE la crée. La maintenance de la SPD est hors scope d'IKE (certaines implémentations peuvent la mettre à jour, voir 1.1.3).

Les charges Traffic Selector (TS) transmettent une partie de la SPD au pair. Elles DOIVENT être fournies par la SPD à IKE (ex. : PF_KEY [PFKEY], SADB_ACQUIRE). Elles précisent les critères des paquets qui transiteront sur la nouvelle SA.

Cela peut servir de cohérence ou guider une mise à jour dynamique de la SPD.

Deux charges TS apparaissent dans chaque message de l'échange créant une paire de Child SA. Chaque charge contient un ou plusieurs sélecteurs (plage d'adresses IPv4/IPv6, plage de ports, ID de protocole IP).

La première est TSi (initiateur), la seconde TSr (répondant). TSi décrit la source du trafic depuis l'initiateur de la paire (ou la destination vers l'initiateur). TSr la destination vers le répondant (ou la source depuis le répondant). Exemple : tunneliser 198.51.100.* vers 192.0.2.* : une plage par charge ; si le répondant accepte, il renvoie les mêmes TS.

IKEv2 permet au répondant de choisir un sous-ensemble proposé (mises à jour asymétriques de configuration, ou politiques volontairement différentes).

Le répondant réduit les TS à un sous-ensemble non vide du proposé. Un type inconnu est ignoré et n'apparaît pas dans l'ensemble réduit.

Si la demande vient d'un paquet de données, l'initiateur DEVRAIT mettre en premier dans TSi et TSr un TS très spécifique avec les adresses du paquet déclencheur, puis des plages plus larges. Sans paquet déclencheur (ex. : démarrage), les premières entrées peuvent être des plages.

Réduction côté répondant :

  • Aucune partie acceptable → TS_UNACCEPTABLE.

  • Tout acceptable → renvoyer les mêmes TSi/TSr.

  • Premier sélecteur acceptable → réduire en incluant le premier choix de l'initiateur (ex. : hôte unique 198.51.100.43).

  • Sinon → sous-ensemble acceptable quelconque.

Si plusieurs sous-ensembles disjoints sont acceptables, le répondant en choisit un arbitrairement et PEUT ajouter ADDITIONAL_TS_POSSIBLE (sans données). N'arrive que si configurations diffèrent.

Si la politique exige une SA par paire d'adresses mais que l'initiateur n'a pas fourni de premier TS précis, le répondant devine ou envoie SINGLE_PAIR_REQUIRED : la demande n'accepte qu'une seule paire d'adresses ; le demandeur doit restreindre au trafic réel.

Peu de politiques exigent une SA par paire ; si seule une partie des TS est acceptable, les répondants DEVRAIENT réduire plutôt que SINGLE_PAIR_REQUIRED.

2.9.1. Sélecteurs de trafic violant leur propre politique​

L'initiateur ne doit pas proposer des TS violant sa propre politique sous peine de perte de trafic valide. Les politiques décorrélées [IPSECARCH] évitent ce cas.

Exemple : A envoie 198.51.100.66 via B en AES et le reste du /24 en 3DES ; B accepte tout. Si A propose 3DES avec TSr couvrant tout le /24, B peut envoyer depuis .66 vers A qui jette le trafic. A aurait dû partitionner TSr en excluant .66 de la SA 3DES.

En général, si l'initiateur propose une SA pour X mais refuse une partie X' avec cette SA tout en acceptant X' avec une autre SA', le trafic peut être perdu car le répondant peut choisir l'une ou l'autre SA.

2.9.2. Sélecteurs de trafic lors du renouvellement​

Le rekey remplace un Child SA : une nouvelle SA avec des sélecteurs plus étroits ferait tomber du trafic autorisé sur l'ancienne, contraire au principe de remplacement. La nouvelle SA NE DOIT PAS avoir des sélecteurs plus étroits. Un besoin plus étroit signifie changement de politique : l'ancienne SA aurait dû être supprimée après le changement.

Lors d'un rekey, les TS proposés DEVRAIENT être identiques ou sur-ensemble de l'ancien Child SA (politique active décorrélée). Le répondant NE DOIT PAS réduire en dessous de l'étendue actuellement utilisée.

Comme le rekey ne peut pas rétrécir, les sélecteurs issus du paquet ne sont pas nécessaires et NE DEVRAIENT PAS être envoyés.

2.10. Nonces​

Les messages IKE_SA_INIT contiennent chacun un nonce pour les fonctions cryptographiques. Les requêtes et réponses CREATE_CHILD_SA en contiennent aussi pour la fraîcheur du dérivé de clés des Child SA et pour de forts bits pseudo-aléatoires à partir de la clé Diffie-Hellman. Les nonces IKEv2 DOIVENT être aléatoires, faire au moins 128 bits et au moins la moitié de la taille de clé du PRF négocié. L'initiateur choisit le nonce avant le résultat de la négociation : il doit donc être assez long pour tous les PRF proposés. Si la même source alimente clés et nonces, veiller à ce que l'usage des nonces ne compromette pas les clés.

2.11. Agilité d'adresse et de port​

IKE utilise les ports UDP 500 et 4500 et établit implicitement des associations ESP et AH sur les mêmes adresses IP. Les adresses et ports de l'en-tête externe ne sont pas protégés cryptographiquement ; IKE fonctionne aussi derrière la traduction d'adresses (NAT). Une implémentation DOIT accepter les requêtes entrantes même si le port source n'est ni 500 ni 4500, et DOIT répondre vers l'adresse et le port d'où la requête est arrivée, en les utilisant comme source de la réponse. IKE se comporte de la même façon sur IPv4 et IPv6.

2.12. Réutilisation des exponentielles Diffie-Hellman​

IKE dérive le matériel de clé via un échange Diffie-Hellman éphémère pour obtenir la « perfect forward secrecy » : après fermeture et oubli des clés, même avec enregistrement intégral du trafic et accès aux clés long terme, on ne peut pas retrouver les clés de session sans recherche exhaustive.

Pour cela, à la fermeture chaque extrémité DOIT oublier les clés et toute information permettant de les recalculer.

Le calcul des exposants est coûteux ; les réutiliser pour plusieurs sessions peut être avantageux (nouvel exposant seulement périodiquement, avec risque de PFS réduite si la session est plus courte que la vie de l'exposant ; ou suivi par connexion et suppression d'état à la fermeture, coû mémoire mais PFS préservée).

Réutiliser ou non est une décision privée sans impact interop. Une implémentation PEUT mémoriser l'exposant distant et éviter la moitié du calcul en cas de réutilisation. Voir [REUSE] et [RFC6989] pour l'analyse de sécurité.

2.13. Génération de matériel de clé​

Dans le contexte de l'IKE SA (association de sécurité Internet Key Exchange), quatre algorithmes cryptographiques sont négociés: un algorithme de chiffrement, un algorithme de protection d'intégrité, un groupe Diffie-Hellman et une fonction pseudo-aléatoire (PRF). La PRF sert à construire le matériel de clé (keying material) pour tous les algorithmes cryptographiques utilisés dans l'IKE SA et les Child SA.

On suppose que chaque algorithme de chiffrement et de protection d'intégrité utilise une clé de taille fixe et que toute valeur aléatoire de cette taille peut servir de clé. Pour les algorithmes à clé de longueur variable, une taille de clé fixe DOIT être spécifiée dans la transformation cryptographique négociée (voir la section 3.3.5 pour l'attribut de transformation Key Length). Pour les algorithmes où toutes les valeurs ne sont pas des clés valides (comme DES ou 3DES avec parité de clé), l'algorithme dérivant les clés à partir de valeurs arbitraires DOIT être spécifié par la transformation. Pour les fonctions de protection d'intégrité basées sur HMAC (Hashed Message Authentication Code), la taille fixe de clé est celle de la sortie de la fonction de hachage sous-jacente.

On suppose que les PRF acceptent des clés de toute longueur mais ont une taille de clé préférée. La taille préférée DOIT être utilisée pour la longueur de SK_d, SK_pi et SK_pr (section 2.14). Pour les PRF basées sur HMAC, la taille préférée égale la longueur de sortie du hachage sous-jacent. Les autres types de PRF DOIVENT spécifier leur taille préférée.

Le matériel de clé est toujours dérivé comme sortie de la PRF négociée. Comme la quantité nécessaire peut dépasser la taille de sortie de la PRF, celle-ci est utilisée de façon itérative. Le terme "prf+" désigne une fonction produisant un flux pseudo-aléatoire à partir des entrées d'une fonction pseudo-aléatoire appelée "prf".

Ci-dessous, | indique la concaténation. prf+ est défini par:

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

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

Cela continue jusqu'à ce que tout le matériel nécessaire aux clés ait été produit. Les clés sont extraites de la chaîne de sortie sans respecter des frontières (par exemple, si des clés AES 256 bits et HMAC 160 bits sont requises et que prf produit 160 bits, la clé AES provient de T1 et du début de T2, la clé HMAC du reste de T2 et du début de T3).

La constante concaténée à chaque appel prf est un seul octet. prf+ n'est pas défini au-delà de 255 fois la taille de sortie de prf.

2.14. Matériel de clé pour l'IKE SA​

Les clés partagées se calculent comme suit. Une quantité SKEYSEED est calculée à partir des nonces échangés pendant IKE_SA_INIT et du secret partagé Diffie-Hellman établi lors de cet échange. SKEYSEED sert à calculer sept autres secrets: SK_d pour dériver de nouvelles clés pour les Child SA de cette IKE SA; SK_ai et SK_ar comme clés de l'algorithme de protection d'intégrité des messages des échanges suivants; SK_ei et SK_er pour chiffrer (et déchiffrer) tous les échanges suivants; SK_pi et SK_pr pour générer les charges AUTH. Les longueurs de SK_d, SK_pi et SK_pr DOIVENT être la longueur de clé préférée de la PRF convenue.

SKEYSEED et ses dérivés:

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)

(les quantités SK_d, SK_ai, SK_ar, SK_ei, SK_er, SK_pi et SK_pr sont prises dans l'ordre dans les bits générés par prf+). g^ir est le secret partagé de l'échange Diffie-Hellman éphémère, représenté en octets big-endian, complété par des zéros si nécessaire à la longueur du module. Ni et Nr sont les nonces sans en-têtes. Pour compatibilité ascendante, deux PRF sont traitées spécialement: si la PRF négociée est AES-XCBC-PRF-128 [AESXCBCPRF128] ou AES-CMAC-PRF-128 [AESCMACPRF128], seuls les 64 premiers bits de Ni et de Nr servent au calcul de SKEYSEED, mais tous les bits entrent dans prf+.

Les deux directions utilisent des clés différentes. SK_ai et SK_ei protègent les messages de l'initiateur d'origine; SK_ar et SK_er l'autre sens.

2.15. Authentification de l'IKE SA​

Sans authentification extensible (section 2.16), les pairs s'authentifient en signant (ou MAC avec secret partagé rembourré comme clé, voir ci-dessous) un bloc de données. IDi' et IDr' sont les charges ID entières sans l'en-tête fixe. Pour le répondant, les octets à signer commencent au premier octet du premier SPI de l'en-tête du deuxième message (réponse IKE_SA_INIT) et se terminent au dernier octet de la dernière charge. On y ajoute pour la signature le nonce Ni de l'initiateur (la valeur seule) et prf(SK_pr, IDr'). Ni ni prf(SK_pr, IDr') ne sont transmis. L'initiateur signe le premier message (requête IKE_SA_INIT) du premier SPI au dernier octet de la dernière charge, et ajoute Nr et prf(SK_pi, IDi'). Chaque côté DOIT signer le nonce de l'autre.

Octets signés par l'initiateur:

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)

Octets signés par le répondant:

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)

Toutes les charges sont incluses sous la signature, y compris les types non définis ici. Si le premier message est envoyé plusieurs fois (cookie, autre groupe DH), c'est la dernière version qui est signée.

En option, les messages 3 et 4 PEUVENT inclure un certificat ou une chaîne prouvant que la clé de signature numérique appartient au nom de la charge ID. La signature ou le MAC est calculé selon les algorithmes dictés par le type de clé du signataire et le champ Auth Method de la charge Authentication. Il n'est pas exigé que l'initiateur et le répondant signent avec les mêmes algorithmes cryptographiques. Le choix dépend du type de clé de chacun. En particulier, l'initiateur peut utiliser un secret partagé tandis que le répondant a une clé de signature publique et un certificat. Il est fréquent (mais non requis) qu'avec un secret partagé pour l'authentification, la même clé serve dans les deux sens.

Noter qu'il est courant mais typiquement peu sûr de n'avoir qu'un secret partagé dérivé uniquement d'un mot de passe choisi par l'utilisateur sans autre source d'aléa. C'est typiquement peu sûr car les mots de passe choisis ont peu de chances d'avoir assez d'imprévisibilité pour résister aux attaques par dictionnaire, et ces attaques ne sont pas empêchées par cette méthode d'authentification. (Les applications utilisant l'authentification par mot de passe pour amorcer l'IKE SA devraient utiliser la méthode de la section 2.16, conçue pour empêcher les attaques par dictionnaire hors ligne.) Le secret pré-partagé doit contenir autant d'imprévisibilité que la clé la plus forte négociée. Avec secret pré-partagé, la valeur AUTH est calculée comme suit:

Pour l'initiateur:

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

Pour le répondant:

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

La chaîne "Key Pad for IKEv2" comporte 17 caractères ASCII sans terminaison nulle. Le secret partagé peut être de longueur variable. La chaîne de remplissage permet, si le secret est dérivé d'un mot de passe, que l'implémentation IKE n'ait pas à stocker le mot de passe en clair mais puisse stocker prf(Shared Secret,"Key Pad for IKEv2"), inutilisable comme équivalent de mot de passe pour d'autres protocoles qu'IKEv2. Comme indiqué, dériver le secret d'un mot de passe seul n'est pas sûr. Cette construction est utilisée car l'on anticipe que des personnes le feront quand même. L'interface de gestion par laquelle le secret est fourni DOIT accepter des chaînes ASCII d'au moins 64 octets et NE DOIT PAS ajouter de terminateur nul avant usage comme secret. Elle DOIT aussi accepter un encodage hexadécimal du secret. Elle PEUT accepter d'autres encodages si l'algorithme de traduction vers une chaîne binaire est spécifié.

Il existe deux types d'authentification EAP (section 2.16), et chaque type utilise des valeurs différentes dans les calculs AUTH ci-dessus. Si la méthode EAP génère une clé, substituer la master session key (MSK) au secret partagé. Pour les méthodes sans génération de clé, substituer respectivement SK_pi et SK_pr au secret partagé dans les deux calculs AUTH.

2.16. Méthodes EAP​

Outre l'authentification par signature à clé publique et secrets partagés, IKE prend en charge les méthodes définies dans RFC 3748 [EAP]. Souvent asymétriques (utilisateur vers serveur), elles peuvent ne pas être mutuelles. Elles servent typiquement à authentifier l'initiateur vers le répondant et DOIVENT être combinées avec une authentification du répondant vers l'initiateur par signature à clé publique. On parle souvent de mécanismes d'« authentification héritée ».

Ce document référence [EAP] pour permettre de nouvelles méthodes sans mise à jour; des variantes simples sont documentées ici. [EAP] exige un nombre variable de messages. L'authentification extensible dans IKE s'implémente par des échanges IKE_AUTH supplémentaires qui DOIVENT être menés à bien pour initialiser l'IKE SA.

L'initiateur signale EAP en omettant la charge AUTH du premier message IKE_AUTH. (Pour l'authentification non-EAP, AUTH est requise.) Avec IDi mais sans AUTH, l'identité est déclarée mais non prouvée. Si le répondant accepte EAP, il place une charge EAP dans la réponse IKE_AUTH et retarde SAr2, TSi, TSr jusqu'à l'authentification ultérieure. Établissement minimal:

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}

Comme en section 2.2, avec EAP chaque paire de messages d'établissement incrémente les numéros; la première paire IKE_AUTH a l'ID 1, la seconde 2, etc.

Pour les méthodes EAP créant une clé partagée, celle-ci DOIT être utilisée par les deux pour générer les AUTH des messages 7 et 8 selon la section 2.15. La clé est le champ MSK de la spécification EAP. Cette clé générée pendant l'échange IKE NE DOIT PAS servir à autre chose.

Les méthodes EAP sans clé partagée ne DEVRAIENT PAS être utilisées: elles sont vulnérables aux attaques homme-du-milieu [EAPMITM] dans d'autres protocoles sans tunnel authentifié par le serveur. Voir les considérations de sécurité. Si de telles méthodes sont utilisées, les AUTH des messages 7 et 8 DOIVENT utiliser SK_pi et SK_pr respectivement.

L'initiateur avec EAP DOIT pouvoir étendre l'échange initial à au moins dix échanges IKE_AUTH si le répondant envoie des notifications ou réessaie l'invite d'authentification. Après succès de la méthode EAP, le répondant DOIT envoyer une charge EAP Success; en cas d'échec, Failure. Le répondant PEUT à tout moment terminer par une charge EAP Failure.

Après un tel échange étendu, les AUTH EAP DOIVENT figurer dans les deux messages suivant celui qui contient EAP Success.

Avec EAP, le contenu de IDi peut servir uniquement au routage AAA et au choix de la méthode EAP, et différer de l'identité authentifiée par EAP. Les décisions de politique et d'accès DOIVENT utiliser l'identité réellement authentifiée. Souvent le serveur EAP est sur un serveur AAA séparé; l'identité authentifiée, si différente de IDi, DOIT être transmise de l'AAA au répondant IKEv2.

2.17. Matériel de clé pour les Child SA​

Une Child SA est créée par IKE_AUTH; d'autres peuvent l'être dans CREATE_CHILD_SA. Le matériel de clé:

KEYMAT = prf+(SK_d, Ni | Nr)

Ni et Nr viennent de IKE_SA_INIT pour la première Child SA, ou des Ni et Nr frais de CREATE_CHILD_SA pour les suivantes.

Avec échange Diffie-Hellman optionnel dans CREATE_CHILD_SA:

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

g^ir (new) est le secret partagé DH éphémère de cet échange (chaîne d'octets big-endian, zéros en tête si besoin jusqu'à la longueur du module).

Une négociation CREATE_CHILD_SA peut produire plusieurs associations de sécurité. Les SA ESP et AH sont par paires; une négociation Child peut aussi inclure d'autres protocoles IPsec futurs (ex. ROHC_INTEG [ROHCV2]). Dans tous les cas, le matériel de chaque Child SA DOIT être extrait du KEYMAT étendu selon:

  • Toutes les clés des SA initiator→responder avant celles responder→initiator.

  • Si plusieurs protocoles IPsec, l'ordre suit l'ordre des en-têtes dans le paquet encapsulé.

  • Si un protocole exige plusieurs clés, l'ordre d'extraction est défini dans sa spécification. Pour ESP et AH, [IPSECARCH]: la clé de chiffrement (si présente) des premiers bits, la clé d'intégrité (si présente) du reste.

Chaque algorithme prend un nombre fixe de bits défini par l'algorithme ou négocié dans les charges SA (longueurs section 2.13, attribut Key Length section 3.3.5).

2.18. Recléage IKE SA via CREATE_CHILD_SA​

CREATE_CHILD_SA peut recléer une IKE SA existante (sections 1.3.2 et 2.8). Les nouveaux SPI initiateur et répondant sont dans les champs SPI des structures Proposal des charges SA (pas ceux de l'en-tête IKE). Les charges TS sont omises pour recléer l'IKE SA. SKEYSEED de la nouvelle IKE SA utilise SK_d de l'ancienne:

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

g^ir (new) est le secret DH éphémère de cet échange (octets big-endian, zéros si besoin), Ni et Nr sans en-têtes.

L'ancienne et la nouvelle IKE SA peuvent avoir des PRF différentes. Comme l'échange de recléage appartient à l'ancienne IKE SA, c'est la PRF de l'ancienne qui génère SKEYSEED.

Le recléage vise à empêcher qu'une compromission d'anciennes clés révèle les actuelles, et inversement. Les implémentations DOIVENT effectuer un nouvel échange Diffie-Hellman lors du recléage IKE SA. L'initiateur NE DOIT PAS proposer "NONE" pour la transformation DH, et le répondant NE DOIT PAS l'accepter. Un recléage réussi inclut toujours KEi/KEr.

La nouvelle IKE SA DOIT remettre ses compteurs de messages à 0.

SK_d, SK_ai, SK_ar, SK_ei et SK_er se calculent depuis SKEYSEED comme en section 2.14 avec SPIi, SPIr, Ni, Nr du nouvel échange et la PRF de la nouvelle IKE SA.

2.19. Adresse interne sur un réseau distant​

Souvent dans le scénario endpoint-passerelle, un endpoint peut avoir besoin d'une adresse IP dans le réseau protégé par la passerelle, avec attribution dynamique. Une demande peut être incluse dans toute création de Child SA (y compris la demande implicite du message 3) via une charge CP. Habituellement une seule adresse est assignée pendant IKE_AUTH; elle dure au moins jusqu'à la suppression de l'IKE SA.

Cette fonction attribue des adresses à un client d'accès distant IPsec (IRAC) tunnelant vers un serveur d'accès distant IPsec (IRAS). Comme IKE_AUTH crée IKE SA et Child SA, l'IRAC DOIT demander l'adresse contrôlée par l'IRAS (et optionnellement d'autres informations) dans IKE_AUTH. L'IRAS peut obtenir l'adresse via DHCP/BOOTP ou un pool local.

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}

La charge CP DOIT précéder la charge SA. S'il y a plusieurs IKE_AUTH, les CP DOIVENT être dans les messages contenant les SA.

CP(CFG_REQUEST) DOIT contenir au moins INTERNAL_ADDRESS (IPv4 ou IPv6) et PEUT contenir d'autres attributs à retourner.

Exemple initiateur→répondant:

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)

NOTE: les sélecteurs de trafic = (protocole, plage de ports, plage d'adresses).

Répondant→initiateur:

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)

Les valeurs dépendent de l'implémentation. L'IRAS PEUT envoyer des attributs non demandés et PEUT ignorer les attributs non obligatoires non supportés.

Le répondant NE DOIT PAS envoyer CFG_REPLY sans avoir reçu CP(CFG_REQUEST), pour éviter une recherche de configuration inutile si l'IRAC ne peut pas traiter la réponse.

Si la configuration de l'IRAS exige CP pour un IDi donné mais l'IRAC n'a pas envoyé CP(CFG_REQUEST), l'IRAS DOIT échouer avec FAILED_CP_REQUIRED. Ce n'est pas fatal pour l'IKE SA; seule la création de Child SA échoue. L'initiateur peut corriger plus tard. Aucune donnée associée à FAILED_CP_REQUIRED.

2.20. Version du pair​

Un pair IKE souhaitant connaître la version du logiciel IKE de l'autre PEUT utiliser la méthode ci-dessous. Exemple de demande de configuration dans un échange INFORMATIONAL après création de l'IKE SA et de la première Child SA.

Une implémentation IKE PEUT refuser de divulguer la version avant ou après authentification si une implémentation est connue pour être faible. Dans ce cas, elle DOIT renvoyer une chaîne vide ou aucune charge CP si CP n'est pas supporté.

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. Gestion des erreurs​

De nombreuses erreurs peuvent survenir pendant le traitement IKE. Règle générale: si une requête est mal formée ou inacceptable par politique (par exemple aucun algorithme cryptographique compatible), la réponse contient une charge Notify d'erreur. L'envoi dépend de l'existence d'une IKE SA authentifiée.

En cas d'erreur d'analyse ou de traitement d'une réponse, on n'envoie généralement pas d'erreur en retour, car les réponses ne doivent pas générer de nouvelles requêtes. Ces erreurs doivent néanmoins amener le destinataire à nettoyer l'état IKE (par exemple envoyer un Delete pour une mauvaise SA).

Seuls les échecs d'authentification (AUTHENTICATION_FAILED et échec EAP) et les messages mal formés (INVALID_SYNTAX) entraînent la suppression de l'IKE SA sans échange INFORMATIONAL explicite avec Delete. D'autres erreurs PEUVENT exiger un tel échange si la politique l'exige. Si l'échange se termine par EAP Failure, AUTHENTICATION_FAILED n'est pas envoyé.

2.21.1. Erreurs dans IKE_SA_INIT​

Les erreurs avant l'établissement d'une IKE SA protégée cryptographiquement exigent une grande prudence. Il faut arbitrer entre aider le pair à diagnostiquer et éviter de participer à une attaque DoS par messages forgés.

Dans IKE_SA_INIT, toute notification d'erreur fait échouer l'échange. Certaines (COOKIE, INVALID_KE_PAYLOAD, INVALID_MAJOR_VERSION) peuvent mener à un échange ultérieur réussi. Comme toutes les notifications sont non authentifiées, le destinataire devrait continuer à essayer un certain temps avant d'abandonner. Il ne devrait pas agir immédiatement sur la notification sauf si des actions correctives sont définies ici (COOKIE, INVALID_KE_PAYLOAD, INVALID_MAJOR_VERSION).

2.21.2. Erreurs dans IKE_AUTH​

Toutes les erreurs IKE_AUTH menant à l'échec d'authentification (secret partagé invalide, ID invalide, émetteur de certificat non fiable, certificat révoqué ou expiré, etc.) DEVRAIENT produire AUTHENTICATION_FAILED. Si l'erreur est côté répondant, la notification est dans la réponse protégée, souvent seule charge. Même chiffré, le pair qui n'a pas encore authentifié l'autre doit rester prudent.

Si l'erreur est côté initiateur, la notification PEUT être dans un échange INFORMATIONAL séparé, souvent seule. Exception à la règle de ne pas démarrer d'échanges sur erreur de réponse.

Cependant, les requêtes avec charge critique non supportée ou message entièrement mal formé (pas seulement le contenu d'une charge) DOIVENT être rejetées entièrement et NE DOIVENT produire qu'une notification UNSUPPORTED_CRITICAL_PAYLOAD ou INVALID_SYNTAX. Le récepteur ne devrait pas vérifier les charges d'authentification dans ce cas.

Si l'authentification IKE_AUTH a réussi, l'IKE SA est établie; la Child SA ou la configuration peut encore échouer. Cet échec ne supprime pas automatiquement l'IKE SA. Le répondant peut inclure IDr, CERT, AUTH tout en envoyant des erreurs pour les échanges parallèles (FAILED_CP_REQUIRED, NO_PROPOSAL_CHOSEN, etc.), et l'initiateur NE DOIT PAS considérer l'authentification comme échouée pour autant. L'initiateur PEUT plus tard supprimer l'IKE SA pour politique.

Dans IKE_AUTH ou l'INFORMATIONAL qui suit immédiatement (erreur lors du traitement de la réponse à IKE_AUTH), seules UNSUPPORTED_CRITICAL_PAYLOAD, INVALID_SYNTAX et AUTHENTICATION_FAILED suppriment ou empêchent l'IKE SA sans Delete. Les extensions peuvent définir d'autres notifications avec la même sémantique mais NE DOIVENT PAS les utiliser sans preuve que le pair les comprend (par ex. Vendor ID).

2.21.3. Après authentification IKE SA​

Après authentification de l'IKE SA, toute requête en erreur DOIT produire une réponse notifiant l'autre extrémité.

Normalement une réponse valide d'un pair ne devrait pas créer d'erreur chez l'autre; il ne devrait pas y avoir de raison d'envoyer des erreurs autrement que en réponse. Envoyer des erreurs en INFORMATIONAL peut provoquer des boucles; on ne DEVRAIT PAS le faire. Des erreurs d'état incohérent peuvent justifier de supprimer l'IKE SA.

Si un pair analysant une requête la trouve mal formée (après MAC et fenêtre) et renvoie INVALID_SYNTAX, cette notification est fatale pour les deux: l'IKE SA est supprimée sans Delete explicite.

2.21.4. Hors IKE SA​

Un nœud doit limiter le débit de réponses aux messages non protégés.

Si un message arrive sur UDP 500 ou 4500 hors contexte d'une IKE SA connue (et ce n'est pas une demande d'ouverture), cela peut suivre un crash. S'il est marqué réponse, audit possible mais NE PAS répondre. S'il est marqué requête, audit possible et réponse possible. Si réponse: même adresse IP et port source, mêmes SPI IKE, Message ID copié; pas de protection cryptographique; charge INVALID_IKE_SPI. Cela indique un SPI de destination IKE non reconnu (souvent reboot).

Le pair recevant une telle Notify non protégée NE DOIT PAS répondre ni modifier l'état des SA. Message forgé ou réponse d'un correspondant trompé. Traiter comme indice de problème possible avec les SA vers cette IP et lancer une vérification de vivacité pour chaque IKE SA concernée. L'implémentation DEVRAIT limiter la fréquence pour éviter la participation à un DoS.

Hors contexte de requête IKE (par ex. ESP sur SPI inexistant), le nœud DEVRAIT lancer un INFORMATIONAL avec Notify décrivant le problème.

Un message suspect depuis une adresse IP (et port si NAT-T) avec laquelle une IKE SA existe DEVRAIT recevoir une réponse Notify en INFORMATIONAL sur cette SA. Le destinataire NE DOIT PAS changer l'état des SA mais peut auditer.

2.22. IPComp​

L'utilisation de la compression IP [IP-COMP] peut être négociée lors de la création d'une Child SA. La compression IP ajoute un en-tête et un CPI par paquet, mais l'« association de compression » virtuelle n'existe qu'à l'intérieur de la SA ESP ou AH qui la contient. Elle disparaît avec cette SA et n'est pas mentionnée dans un Delete.

La négociation IPComp est distincte de celle des paramètres cryptographiques. Un nœud demandant une Child SA PEUT annoncer une ou plusieurs algorithmes via une ou plusieurs Notify IPCOMP_SUPPORTED, uniquement dans un message contenant une SA négociant une Child SA, indiquant la volonté d'utiliser IPComp sur cette SA. La réponse PEUT accepter un algorithme avec une Notify IPCOMP_SUPPORTED. Ces charges NE DOIVENT PAS apparaître sans charge SA.

Les données associées comprennent un CPI IPComp sur deux octets, un Transform ID sur un octet, puis des attributs optionnels. Une proposition peut contenir plusieurs IPCOMP_SUPPORTED; une acceptation au plus une.

Les Transform ID sont listés ci-dessous. Les valeurs ne sont à jour qu'à la date de RFC 4306; consulter [IKEV2IANA] pour les valeurs actuelles.

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

Malgré les discussions sur plusieurs algorithmes ou des algorithmes différents par direction, les implémentations de cette spécification NE DOIVENT PAS accepter un algorithme IPComp non proposé, NE DOIVENT PAS en accepter plus d'un, et NE DOIVENT PAS compresser avec autre chose que l'algorithme proposé et accepté.

Effet secondaire: on ne peut pas proposer plusieurs suites cryptographiques avec IPComp seulement pour certaines.

Dans certains cas ROHC peut convenir mieux. [ROHCV2] définit ROHC avec IKEv2 et IPsec.

2.23. Traversée NAT​

Les passerelles de traduction d'adresse réseau (NAT) sont controversées. Cette section décrit brièvement ce qu'elles sont et comment elles affectent probablement le trafic IKE. Beaucoup pensent que les NAT sont nuisibles et qu'il ne faut pas adapter les protocoles pour mieux les accommoder. IKEv2 définit en effet des règles de traitement peu intuitives pour que les NAT fonctionnent plus souvent.

Les NAT existent surtout à cause du manque d'adresses IPv4. Les nœuds « derrière » un NAT n'ont pas d'adresses globalement uniques; elles sont uniques dans le réseau derrière le NAT mais souvent réutilisées derrière d'autres NAT. Généralement, les nœuds derrière un NAT communiquent avec d'autres derrière le même NAT et avec des nœuds à adresses globalement uniques, mais pas avec des nœuds derrière d'autres NAT (exceptions possibles). Lorsqu'ils se connectent à Internet, la passerelle NAT « traduit » l'adresse source IP vers une adresse routable vers la passerelle. Les messages Internet vers la passerelle voient leur destination « traduite » vers l'adresse interne qui route vers le bon nœud terminal.

Les NAT visent la « transparence » pour les extrémités. Ni le logiciel derrière le NAT ni le nœud Internet n'a besoin d'être modifié. Cette transparence est plus difficile pour certains protocoles. Les protocoles incluant des adresses IP des extrémités dans la charge échouent si la passerelle NAT ne comprend pas le protocole et ne modifie pas les références internes et les en-têtes. Une telle connaissance est intrinsèquement peu fiable, viole la couche réseau et cause souvent des problèmes subtils.

Ouvrir une connexion IPsec à travers un NAT pose des problèmes particuliers. En mode transport, modifier les adresses IP casse les sommes de contrôle et le NAT ne peut pas les corriger car elles sont protégées cryptographiquement. Même en mode tunnel, la traduction transparente des adresses des paquets AH et ESP exige une logique spéciale au NAT, heuristique et peu fiable. IKEv2 utilise donc l'encapsulation UDP d'IKE et d'ESP. C'est un peu moins efficace mais plus facile pour les NAT. Les pare-feu peuvent aussi n'autoriser que le trafic IPsec encapsulé UDP.

Les NAT traduisent souvent aussi les ports TCP et UDP et utilisent les ports des paquets entrants pour choisir le nœud interne. Ainsi, même si IKE DOIT utiliser les ports UDP 500 ou 4500, IKE DOIT être accepté depuis n'importe quel port et les réponses DOIVENT être renvoyées au port d'origine, car les ports peuvent changer en traversant les NAT. De même, les adresses des extrémités IKE ne sont généralement pas dans les charges IKE car elles sont protégées et ne pourraient pas être modifiées par les NAT.

Le port 4500 est réservé à ESP et IKE encapsulés UDP. Un extrémité IPsec découvrant un NAT (voir ci-dessous) DOIT envoyer tout le trafic ultérieur depuis le port 4500, que les NAT ne devraient pas traiter spécialement comme le port 500.

L'initiateur PEUT utiliser le 4500 pour IKE et ESP dès le début, NAT ou non. Si une extrémité utilise 4500, l'envoi d'ESP encapsulé UDP n'est pas requis mais la réception d'ESP encapsulé UDP l'est. L'encapsulation UDP NE DOIT PAS se faire sur le port 500. Si le NAT-T est supporté (échange NAT_DETECTION_*_IP pendant IKE_SA_INIT), tous les équipements DOIVENT pouvoir recevoir et traiter à tout moment ESP encapsulé UDP et non encapsulé. Chaque extrémité choisit indépendamment l'encapsulation ESP. Si un NAT est détecté, les deux DOIVENT utiliser l'encapsulation UDP pour ESP.

Les exigences [NATREQ] pour le support de traversée NAT sont listées ci-dessous. Le support est optionnel. Dans cette section seulement, MUST ne s'applique qu'aux implémentations qui supportent la traversée NAT.

  • L'initiateur et le répondant IKE DOIVENT inclure dans IKE_SA_INIT des Notify NAT_DETECTION_SOURCE_IP et NAT_DETECTION_DESTINATION_IP. Elles détectent la présence de NAT et quel extrémité est derrière le NAT. Elles se placent juste après Ni et Nr (avant CERTREQ optionnel).

  • Les données NAT_DETECTION_SOURCE_IP sont un digest SHA-1 des SPI (ordre d'apparition dans l'en-tête), de l'adresse IP et du port d'envoi.

    Il PEUT y avoir plusieurs NAT_DETECTION_SOURCE_IP si l'expéditeur ignore quelle interface enverra le paquet.

  • Les données NAT_DETECTION_DESTINATION_IP sont un digest SHA-1 des SPI, de l'adresse IP et du port de destination du paquet.

  • Le destinataire PEUT comparer à un hachage SHA-1 des SPI, adresse IP source ou destination et port; en cas de divergence, il DEVRAIT activer la traversée NAT. Si le hachage SOURCE ne correspond à aucune charge SOURCE reçue, le destinataire PEUT rejeter si pas de support NAT-T. Si DESTINATION ne correspond pas, le système recevant est derrière un NAT et DEVRAIT envoyer des keepalives [UDPENCAPS]; ou PEUT rejeter sans NAT-T.

  • Si aucune charge NAT_DETECTION_SOURCE_IP reçue ne correspond à l'IP/port source attendus depuis l'en-tête IP du paquet, l'expéditeur des charges est derrière un NAT (la source a été remplacée en route). Le récepteur devrait alors permettre la mise à jour dynamique de l'adresse de l'autre système (voir plus loin).

  • L'initiateur IKE DOIT vérifier NAT_DETECTION_SOURCE_IP ou DESTINATION_IP si présentes; si elles ne correspondent pas aux adresses externes du paquet, il DOIT tunneliser tous les IKE et ESP futurs de cette IKE SA sur UDP 4500.

  • Pour tunneliser IKE sur 4500: préfixer l'en-tête IKE de quatre octets nuls, puis UDP. Pour ESP: l'en-tête ESP suit immédiatement UDP. Les quatre premiers octets d'ESP sont le SPI, jamais zéro valide, donc IKE et ESP sont distinguables.

  • Les implémentations DOIVENT traiter l'ESP UDP encapsulé reçu même sans NAT détecté.

  • Les adresses IP source et destination d'origine pour la correction des sommes TCP/UDP en mode transport ([UDPENCAPS]) proviennent des sélecteurs de trafic de l'échange. En traversée NAT mode transport, les TS DOIVENT contenir exactement une adresse IP, utilisée comme adresse d'origine. Voir 2.23.1.

  • Un NAT peut supprimer des mappings encore actifs (keepalive trop long, reboot). Un hôte le voit s'il reçoit un paquet à intégrité valide mais avec port et/ou adresse différents de ceux associés à la SA. Un hôte sans autre récupération (MOBIKE [MOBIKE]) et pas derrière un NAT DEVRAIT envoyer tous les paquets (retransmissions incluses) vers l'IP/port du paquet validé et DEVRAIT mémoriser cette nouvelle combinaison pour la SA. Un hôte derrière un NAT NE DEVRAIT PAS faire cette mise à jour dynamique si port/adresse diffèrent (risque DoS). La mise à jour dynamique ne doit répondre qu'à un nouveau paquet (sinon rejeu d'anciens paquets). Elle n'est sûre qu'avec protection anti-rejeu. Avec MOBIKE, cette mise à jour interfère avec la récupération MOBIKE; voir [MOBIKE] 3.8.

2.23.1. Mode transport et traversée NAT​

Le mode transport avec traversée NAT exige un traitement spécial des sélecteurs de trafic IKEv2. Schéma complet:

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

(Les autres scénarios simplifient ce cas.)

Deux NAT: A dynamique (IP1→IPN1), B statique (connexions vers IPN2 mappées vers IP2 du serveur). Le client joint le serveur via IPN2. B n'a pas besoin d'être statique mais le client doit connaître l'adresse externe de B (IPN2), par configuration ou autre protocole (DNS), hors périmètre IKEv2.

Client et serveur utilisent le mode transport pour le trafic client→serveur.

À la création IKEv2 SA et Child SA, un paquet déclencheur peut avoir source IP1 et destination IPN2. PAD et SPD doivent correspondre. En mode transport, les TS et l'IP externe IKE sont les mêmes adresses. TSi et TSr DOIVENT avoir exactement une adresse IP chacun; plusieurs TS sont possibles pour plusieurs plages de ports, mais toutes les TSi utilisent IP1-IP1 et toutes les TSr IPN2-IPN2. Les premiers TSi/TSr DEVRAIENT être très spécifiques (protocole, ports du paquet déclencheur).

NAT A remplace la source IKE IP1→IPN1, NAT B la destination IPN2→IP2; au serveur les TS restent ceux du client mais l'IP du paquet IKE est IPN1 et IP2.

Le serveur consulte d'habitude le PAD [IPSECARCH] RFC 4301 par ID puis le SPD par TS. IP1 n'a pas de sens pour le serveur en mode transport pour la recherche; mais il ignore si le mode transport est permis avant d'avoir une entrée SPD correspondante.

Le serveur vérifie d'abord que l'initiateur a demandé le mode transport, puis substitue les adresses dans les TS. Il stocke les anciennes adresses TS pour la correction incrémentale des sommes (TSi = source d'origine, TSr = destination d'origine). Si l'autre extrémité est derrière un NAT, il remplace l'IP dans TSi par la source du paquet IKE reçu (IP1→IPN1). Si le serveur est derrière un NAT, il remplace l'IP dans TSr par la destination du paquet reçu (IPN2→IP2).

Après substitution, TS et adresses UDP IKE coïncident; recherche SPD sur les nouveaux TS. Si entrée trouvée et mode transport autorisé, on l'utilise. Si entrée trouvée mais pas de transport, le serveur PEUT annuler la substitution et refaire la recherche SPD avec les TS d'origine; si la seconde réussit, création d'une SA tunnel avec les vrais TS de l'autre extrémité.

Cette substitution est nécessaire car le SPD est consulté avec les adresses vues par l'hôte local. Les entrées SAD pour sortie de tunnel et paquets retour utilisent les adresses vues par la pile OS.

Souvent le SPD serveur a des entrées joker; on peut aussi différencier par adresse externe de NAT connue.

Après SPD, rétrécissement des TS selon l'entrée, toujours avec TS substitués; réponse avec IPN1 et IP2; on peut encore rétrécir protocole/ports. La SAD Child SA utilise IPN1 et IP2 vus par le serveur.

Le client, à la réponse Child SA, stocke les TS retournés comme adresses source/destination d'origine, remplace les IP par celles de l'en-tête IKE (IPN1→IP1, IP2→IPN2), puis vérifie la SA et installe la SAD.

Résumé des règles mode transport:

Client proposant le mode transport:

  • TSi: exactement une adresse IP, DOIT égaler la source de l'IKE SA.

  • TSr: exactement une adresse IP, DOIT égaler la destination de l'IKE SA.

  • Premiers TSi/TSr DEVRAIENT inclure protocole et ports précis (paquet déclencheur).

  • Plusieurs TSi/TSr PEUVENT exister.

  • Si mode transport choisi (USE_TRANSPORT_MODE dans la réponse):

    • Conserver les TS d'origine comme adresses reçues.

    • Si serveur derrière NAT: remplacer l'IP des TSr par l'adresse distante de l'IKE SA.

    • Si client derrière NAT: remplacer l'IP des TSi par l'adresse locale de l'IKE SA.

    • Substitutions avant toute autre utilisation que le stockage d'origine (vérification du rétrécissement, création SAD, etc.).

Répondant (proposition transport par le client):

  • Stocker les IP TS d'origine pour annulation éventuelle, adresses « réelles » [UDPENCAPS], correction TCP/UDP.

  • Client derrière NAT: TSi → adresse distante IKE SA.

  • Serveur derrière NAT: TSr → adresse locale IKE SA.

  • Recherche PAD/SPD avec ID et TS substitués.

  • Pas d'entrée SPD ou transport non autorisé: annuler substitutions, recherche avec ID et TS d'origine incluant entrées tunnel (repli tunnel).

  • Si entrée transport trouvée: rétrécissement normal sur TS substitués et entrée SPD; utiliser les TS résultants pour SAD et réponse au client.

2.24. Notification explicite d'encombrement (ECN)​

Lorsque les tunnels IPsec se comportent comme spécifié à l'origine dans [IPSECARCH-OLD], l'usage d'ECN sur les en-têtes IP externes n'est pas approprié car le décapsulage de tunnel supprime les indications d'encombrement ECN au détriment du réseau. Le support ECN pour les tunnels IPsec basés sur IKEv1 exige plusieurs modes et une négociation (voir [ECN]). IKEv2 simplifie en exigeant qu'ECN soit utilisable sur les en-têtes IP externes de toutes les Child SA en mode tunnel créées par IKEv2. Spécifiquement, les encapsuleurs et décapsuleurs de tunnel pour toutes les SA en mode tunnel créées par IKEv2 DOIVENT prendre en charge l'option ECN pleine fonctionnalité pour tunnels de [ECN] et DOIVENT implémenter l'encapsulation et le décapsulage de tunnel de [IPSECARCH] afin d'éviter de supprimer les indications d'encombrement ECN.

2.25. Collisions d'échanges​

Comme les échanges IKEv2 peuvent être initiés par chaque pair, deux échanges affectant la même SA peuvent se chevaucher partiellement, désynchronisant temporairement l'état; un pair peut recevoir une requête qu'il ne peut traiter normalement.

Une fenêtre supérieure à 1 complique la situation, surtout si les requêtes sont traitées hors ordre. Cette section se concentre sur les problèmes possibles même avec une fenêtre de 1.

Une notification TEMPORARY_FAILURE DEVRAIT être envoyée lorsqu'une requête ne peut être complétée pour une raison temporaire (recléage). Le récepteur NE DOIT PAS réessayer immédiatement; il DOIT attendre. Il PEUT réessayer une ou plusieurs fois sur plusieurs minutes. Si TEMPORARY_FAILURE persiste après plusieurs minutes sur la même IKE SA, il DEVRAIT conclure à une désynchronisation et fermer l'IKE SA.

Une notification CHILD_SA_NOT_FOUND DEVRAIT être envoyée pour une requête de recléage d'une Child SA inexistante. Le SPI dans la Notify est copié depuis REKEY_SA. Le récepteur DEVRAIT supprimer silencieusement la Child SA si elle existe encore et envoyer une demande de création d'une nouvelle Child SA si elle n'existe pas encore.

2.25.1. Collisions lors du renouvellement ou de la fermeture des Child SA​

Recléage demandé pendant fermeture de la même Child SA: répondre TEMPORARY_FAILURE. Recléage pendant recléage: répondre normalement et préparer la fermeture des SA redondantes selon les nonces (section 2.8.1). Recléage d'une Child SA inexistante: CHILD_SA_NOT_FOUND.

Fermeture demandée pendant fermeture de la même Child SA: répondre sans Delete (section 1.4.1). Fermeture pendant recléage: répondre avec Delete. Fermeture d'une Child SA inexistante: répondre sans Delete.

Recléage IKE SA pendant création, recléage ou fermeture d'une Child SA de cette IKE SA: TEMPORARY_FAILURE.

2.25.2. Collisions lors du renouvellement ou de la fermeture des IKE SA​

Recléage IKE SA pendant recléage IKE SA: répondre normalement, préparer fermeture et migration des Child SA selon les nonces (section 2.8.2). Recléage pendant tentative de fermeture IKE SA: TEMPORARY_FAILURE.

Fermeture IKE SA pendant recléage IKE SA: répondre normalement, abandonner sa propre demande de recléage. Fermeture pendant fermeture: répondre normalement, abandonner sa propre fermeture.

Création ou recléage Child SA pendant recléage IKE SA: TEMPORARY_FAILURE. Suppression Child SA pendant recléage IKE SA: répondre normalement avec Delete.