src/plugins/ikev2/ikev2.c

   1 /*
   2  * Copyright (c) 2015 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <vlib/vlib.h>
  17 #include <vlib/unix/plugin.h>
  18 #include <vlibmemory/api.h>
  19 #include <vpp/app/version.h>
  20 #include <vnet/vnet.h>
  21 #include <vnet/pg/pg.h>
  22 #include <vppinfra/error.h>
  23 #include <vppinfra/random.h>
  24 #include <vnet/udp/udp.h>
  25 #include <vnet/ipsec/ipsec.h>
  26 #include <vnet/ipsec/ipsec_tun.h>
  27 #include <vnet/ipip/ipip.h>
  28 #include <plugins/ikev2/ikev2.h>
  29 #include <plugins/ikev2/ikev2_priv.h>
  30 #include <openssl/sha.h>
  31 #include <vnet/ipsec/ipsec_punt.h>
  32
  33 #define IKEV2_LIVENESS_RETRIES 3
  34 #define IKEV2_LIVENESS_PERIOD_CHECK 30
  35
  36 ikev2_main_t ikev2_main;
  37
  38 static int ikev2_delete_tunnel_interface (vnet_main_t * vnm,
  39                                           ikev2_sa_t * sa,
  40                                           ikev2_child_sa_t * child);
  41
  42 #define ikev2_set_state(sa, v) do { \
  43     (sa)->state = v; \
  44     ikev2_elog_sa_state("ispi %lx SA state changed to " #v, sa->ispi); \
  45   } while(0);
  46
  47 typedef struct
  48 {
  49   u32 next_index;
  50   u32 sw_if_index;
  51 } ikev2_trace_t;
  52
  53 static u8 *
  54 format_ikev2_trace (u8 * s, va_list * args)
  55 {
  56   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  57   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  58   ikev2_trace_t *t = va_arg (*args, ikev2_trace_t *);
  59
  60   s = format (s, "ikev2: sw_if_index %d, next index %d",
  61               t->sw_if_index, t->next_index);
  62   return s;
  63 }
  64
  65 static vlib_node_registration_t ikev2_node;
  66
  67 #define foreach_ikev2_error \
  68 _(PROCESSED, "IKEv2 packets processed") \
  69 _(IKE_SA_INIT_RETRANSMIT, "IKE_SA_INIT retransmit ") \
  70 _(IKE_SA_INIT_IGNORE, "IKE_SA_INIT ignore (IKE SA already auth)") \
  71 _(IKE_REQ_RETRANSMIT, "IKE request retransmit") \
  72 _(IKE_REQ_IGNORE, "IKE request ignore (old msgid)") \
  73 _(NOT_IKEV2, "Non IKEv2 packets received")
  74
  75 typedef enum
  76 {
  77 #define _(sym,str) IKEV2_ERROR_##sym,
  78   foreach_ikev2_error
  79 #undef _
  80     IKEV2_N_ERROR,
  81 } ikev2_error_t;
  82
  83 static char *ikev2_error_strings[] = {
  84 #define _(sym,string) string,
  85   foreach_ikev2_error
  86 #undef _
  87 };
  88
  89 typedef enum
  90 {
  91   IKEV2_NEXT_IP4_LOOKUP,
  92   IKEV2_NEXT_ERROR_DROP,
  93   IKEV2_N_NEXT,
  94 } ikev2_next_t;
  95
  96 typedef u32 ikev2_non_esp_marker;
  97
  98 static_always_inline u16
  99 ikev2_get_port (ikev2_sa_t * sa)
 100 {
 101   return sa->natt ? IKEV2_PORT_NATT : IKEV2_PORT;
 102 }
 103
 104 static_always_inline int
 105 ikev2_insert_non_esp_marker (ike_header_t * ike, int len)
 106 {
 107   memmove ((u8 *) ike + sizeof (ikev2_non_esp_marker), ike, len);
 108   clib_memset (ike, 0, sizeof (ikev2_non_esp_marker));
 109   return len + sizeof (ikev2_non_esp_marker);
 110 }
 111
 112 static ikev2_sa_transform_t *
 113 ikev2_find_transform_data (ikev2_sa_transform_t * t)
 114 {
 115   ikev2_main_t *km = &ikev2_main;
 116   ikev2_sa_transform_t *td;
 117
 118   vec_foreach (td, km->supported_transforms)
 119   {
 120     if (td->type != t->type)
 121       continue;
 122
 123     if (td->transform_id != t->transform_id)
 124       continue;
 125
 126     if (td->type == IKEV2_TRANSFORM_TYPE_ENCR)
 127       {
 128         if (vec_len (t->attrs) != 4 || t->attrs[0] != 0x80
 129             || t->attrs[1] != 14)
 130           continue;
 131
 132         if (((t->attrs[2] << 8 | t->attrs[3]) / 8) != td->key_len)
 133           continue;
 134       }
 135     return td;
 136   }
 137   return 0;
 138 }
 139
 140 static ikev2_sa_proposal_t *
 141 ikev2_select_proposal (ikev2_sa_proposal_t * proposals,
 142                        ikev2_protocol_id_t prot_id)
 143 {
 144   ikev2_sa_proposal_t *rv = 0;
 145   ikev2_sa_proposal_t *proposal;
 146   ikev2_sa_transform_t *transform, *new_t;
 147   u8 mandatory_bitmap, optional_bitmap;
 148
 149   if (prot_id == IKEV2_PROTOCOL_IKE)
 150     {
 151       mandatory_bitmap = (1 << IKEV2_TRANSFORM_TYPE_ENCR) |
 152         (1 << IKEV2_TRANSFORM_TYPE_PRF) | (1 << IKEV2_TRANSFORM_TYPE_DH);
 153       optional_bitmap = mandatory_bitmap | (1 << IKEV2_TRANSFORM_TYPE_INTEG);
 154     }
 155   else if (prot_id == IKEV2_PROTOCOL_ESP)
 156     {
 157       mandatory_bitmap = (1 << IKEV2_TRANSFORM_TYPE_ENCR) |
 158         (1 << IKEV2_TRANSFORM_TYPE_ESN);
 159       optional_bitmap = mandatory_bitmap |
 160         (1 << IKEV2_TRANSFORM_TYPE_INTEG) | (1 << IKEV2_TRANSFORM_TYPE_DH);
 161     }
 162   else if (prot_id == IKEV2_PROTOCOL_AH)
 163     {
 164       mandatory_bitmap = (1 << IKEV2_TRANSFORM_TYPE_INTEG) |
 165         (1 << IKEV2_TRANSFORM_TYPE_ESN);
 166       optional_bitmap = mandatory_bitmap | (1 << IKEV2_TRANSFORM_TYPE_DH);
 167     }
 168   else
 169     return 0;
 170
 171   vec_add2 (rv, proposal, 1);
 172
 173   vec_foreach (proposal, proposals)
 174   {
 175     u8 bitmap = 0;
 176     if (proposal->protocol_id != prot_id)
 177       continue;
 178
 179     vec_foreach (transform, proposal->transforms)
 180     {
 181       if ((1 << transform->type) & bitmap)
 182         continue;
 183
 184       if (ikev2_find_transform_data (transform))
 185         {
 186           bitmap |= 1 << transform->type;
 187           vec_add2 (rv->transforms, new_t, 1);
 188           clib_memcpy_fast (new_t, transform, sizeof (*new_t));
 189           new_t->attrs = vec_dup (transform->attrs);
 190         }
 191     }
 192
 193     if ((bitmap & mandatory_bitmap) == mandatory_bitmap &&
 194         (bitmap & ~optional_bitmap) == 0)
 195       {
 196         rv->proposal_num = proposal->proposal_num;
 197         rv->protocol_id = proposal->protocol_id;
 198         RAND_bytes ((u8 *) & rv->spi, sizeof (rv->spi));
 199         goto done;
 200       }
 201     else
 202       {
 203         vec_free (rv->transforms);
 204       }
 205   }
 206
 207   vec_free (rv);
 208 done:
 209   return rv;
 210 }
 211
 212 ikev2_sa_transform_t *
 213 ikev2_sa_get_td_for_type (ikev2_sa_proposal_t * p,
 214                           ikev2_transform_type_t type)
 215 {
 216   ikev2_sa_transform_t *t;
 217
 218   if (!p)
 219     return 0;
 220
 221   vec_foreach (t, p->transforms)
 222   {
 223     if (t->type == type)
 224       return ikev2_find_transform_data (t);
 225   }
 226   return 0;
 227 }
 228
 229 ikev2_child_sa_t *
 230 ikev2_sa_get_child (ikev2_sa_t * sa, u32 spi, ikev2_protocol_id_t prot_id,
 231                     int by_initiator)
 232 {
 233   ikev2_child_sa_t *c;
 234   vec_foreach (c, sa->childs)
 235   {
 236     ikev2_sa_proposal_t *proposal =
 237       by_initiator ? &c->i_proposals[0] : &c->r_proposals[0];
 238     if (proposal && proposal->spi == spi && proposal->protocol_id == prot_id)
 239       return c;
 240   }
 241
 242   return 0;
 243 }
 244
 245 void
 246 ikev2_sa_free_proposal_vector (ikev2_sa_proposal_t ** v)
 247 {
 248   ikev2_sa_proposal_t *p;
 249   ikev2_sa_transform_t *t;
 250
 251   if (!*v)
 252     return;
 253
 254   vec_foreach (p, *v)
 255   {
 256     vec_foreach (t, p->transforms)
 257     {
 258       vec_free (t->attrs);
 259     }
 260     vec_free (p->transforms);
 261   }
 262   vec_free (*v);
 263 };
 264
 265 static void
 266 ikev2_sa_free_child_sa (ikev2_child_sa_t * c)
 267 {
 268   ikev2_sa_free_proposal_vector (&c->r_proposals);
 269   ikev2_sa_free_proposal_vector (&c->i_proposals);
 270   vec_free (c->sk_ai);
 271   vec_free (c->sk_ar);
 272   vec_free (c->sk_ei);
 273   vec_free (c->sk_er);
 274   vec_free (c->tsi);
 275   vec_free (c->tsr);
 276 }
 277
 278 static void
 279 ikev2_sa_free_all_child_sa (ikev2_child_sa_t ** childs)
 280 {
 281   ikev2_child_sa_t *c;
 282   vec_foreach (c, *childs) ikev2_sa_free_child_sa (c);
 283
 284   vec_free (*childs);
 285 }
 286
 287 static void
 288 ikev2_sa_del_child_sa (ikev2_sa_t * sa, ikev2_child_sa_t * child)
 289 {
 290   ikev2_sa_free_child_sa (child);
 291   vec_del1 (sa->childs, child - sa->childs);
 292 }
 293
 294 static void
 295 ikev2_sa_free_all_vec (ikev2_sa_t * sa)
 296 {
 297   vec_free (sa->i_nonce);
 298   vec_free (sa->i_dh_data);
 299   vec_free (sa->dh_shared_key);
 300   vec_free (sa->dh_private_key);
 301
 302   ikev2_sa_free_proposal_vector (&sa->r_proposals);
 303   ikev2_sa_free_proposal_vector (&sa->i_proposals);
 304
 305   vec_free (sa->sk_d);
 306   vec_free (sa->sk_ai);
 307   vec_free (sa->sk_ar);
 308   vec_free (sa->sk_ei);
 309   vec_free (sa->sk_er);
 310   vec_free (sa->sk_pi);
 311   vec_free (sa->sk_pr);
 312
 313   vec_free (sa->i_id.data);
 314   vec_free (sa->i_auth.data);
 315   vec_free (sa->r_id.data);
 316   vec_free (sa->r_auth.data);
 317   if (sa->r_auth.key)
 318     EVP_PKEY_free (sa->r_auth.key);
 319
 320   vec_free (sa->del);
 321
 322   ikev2_sa_free_all_child_sa (&sa->childs);
 323 }
 324
 325 static void
 326 ikev2_delete_sa (ikev2_sa_t * sa)
 327 {
 328   ikev2_main_t *km = &ikev2_main;
 329   u32 thread_index = vlib_get_thread_index ();
 330   uword *p;
 331
 332   ikev2_sa_free_all_vec (sa);
 333
 334   p = hash_get (km->per_thread_data[thread_index].sa_by_rspi, sa->rspi);
 335   if (p)
 336     {
 337       hash_unset (km->per_thread_data[thread_index].sa_by_rspi, sa->rspi);
 338       pool_put (km->per_thread_data[thread_index].sas, sa);
 339     }
 340 }
 341
 342 static void
 343 ikev2_generate_sa_init_data (ikev2_sa_t * sa)
 344 {
 345   ikev2_sa_transform_t *t = 0, *t2;
 346   ikev2_main_t *km = &ikev2_main;
 347
 348   if (sa->dh_group == IKEV2_TRANSFORM_DH_TYPE_NONE)
 349     {
 350       return;
 351     }
 352
 353   /* check if received DH group is on our list of supported groups */
 354   vec_foreach (t2, km->supported_transforms)
 355   {
 356     if (t2->type == IKEV2_TRANSFORM_TYPE_DH && sa->dh_group == t2->dh_type)
 357       {
 358         t = t2;
 359         break;
 360       }
 361   }
 362
 363   if (!t)
 364     {
 365       sa->dh_group = IKEV2_TRANSFORM_DH_TYPE_NONE;
 366       return;
 367     }
 368
 369   if (sa->is_initiator)
 370     {
 371       /* generate rspi */
 372       RAND_bytes ((u8 *) & sa->ispi, 8);
 373
 374       /* generate nonce */
 375       sa->i_nonce = vec_new (u8, IKEV2_NONCE_SIZE);
 376       RAND_bytes ((u8 *) sa->i_nonce, IKEV2_NONCE_SIZE);
 377     }
 378   else
 379     {
 380       /* generate rspi */
 381       RAND_bytes ((u8 *) & sa->rspi, 8);
 382
 383       /* generate nonce */
 384       sa->r_nonce = vec_new (u8, IKEV2_NONCE_SIZE);
 385       RAND_bytes ((u8 *) sa->r_nonce, IKEV2_NONCE_SIZE);
 386     }
 387
 388   /* generate dh keys */
 389   ikev2_generate_dh (sa, t);
 390
 391 }
 392
 393 static void
 394 ikev2_complete_sa_data (ikev2_sa_t * sa, ikev2_sa_t * sai)
 395 {
 396   ikev2_sa_transform_t *t = 0, *t2;
 397   ikev2_main_t *km = &ikev2_main;
 398
 399   /*move some data to the new SA */
 400 #define _(A) ({void* __tmp__ = (A); (A) = 0; __tmp__;})
 401   sa->i_nonce = _(sai->i_nonce);
 402   sa->i_dh_data = _(sai->i_dh_data);
 403   sa->dh_private_key = _(sai->dh_private_key);
 404   sa->iaddr.as_u32 = sai->iaddr.as_u32;
 405   sa->raddr.as_u32 = sai->raddr.as_u32;
 406   sa->is_initiator = sai->is_initiator;
 407   sa->i_id.type = sai->i_id.type;
 408   sa->r_id.type = sai->r_id.type;
 409   sa->profile_index = sai->profile_index;
 410   sa->tun_itf = sai->tun_itf;
 411   sa->is_tun_itf_set = sai->is_tun_itf_set;
 412   sa->i_id.data = _(sai->i_id.data);
 413   sa->r_id.data = _(sai->r_id.data);
 414   sa->i_auth.method = sai->i_auth.method;
 415   sa->i_auth.hex = sai->i_auth.hex;
 416   sa->i_auth.data = _(sai->i_auth.data);
 417   sa->i_auth.key = _(sai->i_auth.key);
 418   sa->last_sa_init_req_packet_data = _(sai->last_sa_init_req_packet_data);
 419   sa->childs = _(sai->childs);
 420   sa->udp_encap = sai->udp_encap;
 421   sa->ipsec_over_udp_port = sai->ipsec_over_udp_port;
 422   sa->dst_port = sai->dst_port;
 423   sa->sw_if_index = sai->sw_if_index;
 424 #undef _
 425
 426
 427   if (sa->dh_group == IKEV2_TRANSFORM_DH_TYPE_NONE)
 428     {
 429       return;
 430     }
 431
 432   /* check if received DH group is on our list of supported groups */
 433   vec_foreach (t2, km->supported_transforms)
 434   {
 435     if (t2->type == IKEV2_TRANSFORM_TYPE_DH && sa->dh_group == t2->dh_type)
 436       {
 437         t = t2;
 438         break;
 439       }
 440   }
 441
 442   if (!t)
 443     {
 444       sa->dh_group = IKEV2_TRANSFORM_DH_TYPE_NONE;
 445       return;
 446     }
 447
 448
 449   /* generate dh keys */
 450   ikev2_complete_dh (sa, t);
 451
 452 }
 453
 454 static void
 455 ikev2_calc_keys (ikev2_sa_t * sa)
 456 {
 457   u8 *tmp;
 458   /* calculate SKEYSEED = prf(Ni | Nr, g^ir) */
 459   u8 *skeyseed = 0;
 460   u8 *s = 0;
 461   u16 integ_key_len = 0, salt_len = 0;
 462   ikev2_sa_transform_t *tr_encr, *tr_prf, *tr_integ;
 463   tr_encr =
 464     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_ENCR);
 465   tr_prf =
 466     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_PRF);
 467   tr_integ =
 468     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_INTEG);
 469
 470   if (tr_integ)
 471     integ_key_len = tr_integ->key_len;
 472   else
 473     salt_len = sizeof (u32);
 474
 475   vec_append (s, sa->i_nonce);
 476   vec_append (s, sa->r_nonce);
 477   skeyseed = ikev2_calc_prf (tr_prf, s, sa->dh_shared_key);
 478
 479   /* Calculate S = Ni | Nr | SPIi | SPIr */
 480   u64 *spi;
 481   vec_add2 (s, tmp, 2 * sizeof (*spi));
 482   spi = (u64 *) tmp;
 483   spi[0] = clib_host_to_net_u64 (sa->ispi);
 484   spi[1] = clib_host_to_net_u64 (sa->rspi);
 485
 486   /* calculate PRFplus */
 487   u8 *keymat;
 488   int len = tr_prf->key_trunc + /* SK_d */
 489     integ_key_len * 2 +         /* SK_ai, SK_ar */
 490     tr_encr->key_len * 2 +      /* SK_ei, SK_er */
 491     tr_prf->key_len * 2 +       /* SK_pi, SK_pr */
 492     salt_len * 2;
 493
 494   keymat = ikev2_calc_prfplus (tr_prf, skeyseed, s, len);
 495   vec_free (skeyseed);
 496   vec_free (s);
 497
 498   int pos = 0;
 499
 500   /* SK_d */
 501   sa->sk_d = vec_new (u8, tr_prf->key_trunc);
 502   clib_memcpy_fast (sa->sk_d, keymat + pos, tr_prf->key_trunc);
 503   pos += tr_prf->key_trunc;
 504
 505   if (integ_key_len)
 506     {
 507       /* SK_ai */
 508       sa->sk_ai = vec_new (u8, integ_key_len);
 509       clib_memcpy_fast (sa->sk_ai, keymat + pos, integ_key_len);
 510       pos += integ_key_len;
 511
 512       /* SK_ar */
 513       sa->sk_ar = vec_new (u8, integ_key_len);
 514       clib_memcpy_fast (sa->sk_ar, keymat + pos, integ_key_len);
 515       pos += integ_key_len;
 516     }
 517
 518   /* SK_ei */
 519   sa->sk_ei = vec_new (u8, tr_encr->key_len + salt_len);
 520   clib_memcpy_fast (sa->sk_ei, keymat + pos, tr_encr->key_len + salt_len);
 521   pos += tr_encr->key_len + salt_len;
 522
 523   /* SK_er */
 524   sa->sk_er = vec_new (u8, tr_encr->key_len + salt_len);
 525   clib_memcpy_fast (sa->sk_er, keymat + pos, tr_encr->key_len + salt_len);
 526   pos += tr_encr->key_len + salt_len;
 527
 528   /* SK_pi */
 529   sa->sk_pi = vec_new (u8, tr_prf->key_len);
 530   clib_memcpy_fast (sa->sk_pi, keymat + pos, tr_prf->key_len);
 531   pos += tr_prf->key_len;
 532
 533   /* SK_pr */
 534   sa->sk_pr = vec_new (u8, tr_prf->key_len);
 535   clib_memcpy_fast (sa->sk_pr, keymat + pos, tr_prf->key_len);
 536   pos += tr_prf->key_len;
 537
 538   vec_free (keymat);
 539 }
 540
 541 static void
 542 ikev2_calc_child_keys (ikev2_sa_t * sa, ikev2_child_sa_t * child)
 543 {
 544   u8 *s = 0;
 545   u16 integ_key_len = 0;
 546   u8 salt_len = 0;
 547
 548   ikev2_sa_transform_t *tr_prf, *ctr_encr, *ctr_integ;
 549   tr_prf =
 550     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_PRF);
 551   ctr_encr =
 552     ikev2_sa_get_td_for_type (child->r_proposals, IKEV2_TRANSFORM_TYPE_ENCR);
 553   ctr_integ =
 554     ikev2_sa_get_td_for_type (child->r_proposals, IKEV2_TRANSFORM_TYPE_INTEG);
 555
 556   if (ctr_integ)
 557     integ_key_len = ctr_integ->key_len;
 558   else
 559     salt_len = sizeof (u32);
 560
 561   vec_append (s, sa->i_nonce);
 562   vec_append (s, sa->r_nonce);
 563   /* calculate PRFplus */
 564   u8 *keymat;
 565   int len = ctr_encr->key_len * 2 + integ_key_len * 2 + salt_len * 2;
 566
 567   keymat = ikev2_calc_prfplus (tr_prf, sa->sk_d, s, len);
 568
 569   int pos = 0;
 570
 571   /* SK_ei */
 572   child->sk_ei = vec_new (u8, ctr_encr->key_len);
 573   clib_memcpy_fast (child->sk_ei, keymat + pos, ctr_encr->key_len);
 574   pos += ctr_encr->key_len;
 575
 576   if (ctr_integ)
 577     {
 578       /* SK_ai */
 579       child->sk_ai = vec_new (u8, ctr_integ->key_len);
 580       clib_memcpy_fast (child->sk_ai, keymat + pos, ctr_integ->key_len);
 581       pos += ctr_integ->key_len;
 582     }
 583   else
 584     {
 585       clib_memcpy (&child->salt_ei, keymat + pos, salt_len);
 586       pos += salt_len;
 587     }
 588
 589   /* SK_er */
 590   child->sk_er = vec_new (u8, ctr_encr->key_len);
 591   clib_memcpy_fast (child->sk_er, keymat + pos, ctr_encr->key_len);
 592   pos += ctr_encr->key_len;
 593
 594   if (ctr_integ)
 595     {
 596       /* SK_ar */
 597       child->sk_ar = vec_new (u8, integ_key_len);
 598       clib_memcpy_fast (child->sk_ar, keymat + pos, integ_key_len);
 599       pos += integ_key_len;
 600     }
 601   else
 602     {
 603       clib_memcpy (&child->salt_er, keymat + pos, salt_len);
 604       pos += salt_len;
 605     }
 606
 607   ASSERT (pos == len);
 608
 609   vec_free (keymat);
 610 }
 611
 612 static_always_inline u8 *
 613 ikev2_compute_nat_sha1 (u64 ispi, u64 rspi, u32 ip, u16 port)
 614 {
 615   /* ispi, rspi, ip, port */
 616   u8 buf[8 + 8 + 4 + 2];
 617   u8 *res = vec_new (u8, 20);
 618
 619   clib_memcpy_fast (&buf[0], &ispi, sizeof (ispi));
 620   clib_memcpy_fast (&buf[8], &rspi, sizeof (rspi));
 621   clib_memcpy_fast (&buf[8 + 8], &ip, sizeof (ip));
 622   clib_memcpy_fast (&buf[8 + 8 + 4], &port, sizeof (port));
 623   SHA1 (buf, sizeof (buf), res);
 624   return res;
 625 }
 626
 627 static void
 628 ikev2_process_sa_init_req (vlib_main_t * vm, ikev2_sa_t * sa,
 629                            ike_header_t * ike, udp_header_t * udp)
 630 {
 631   int p = 0;
 632   u32 len = clib_net_to_host_u32 (ike->length);
 633   u8 payload = ike->nextpayload;
 634
 635   ikev2_elog_exchange ("ispi %lx rspi %lx IKE_INIT request received "
 636                        "from %d.%d.%d.%d",
 637                        clib_net_to_host_u64 (ike->ispi),
 638                        clib_net_to_host_u64 (ike->rspi), sa->iaddr.as_u32);
 639
 640   sa->ispi = clib_net_to_host_u64 (ike->ispi);
 641
 642   /* store whole IKE payload - needed for PSK auth */
 643   vec_free (sa->last_sa_init_req_packet_data);
 644   vec_add (sa->last_sa_init_req_packet_data, ike, len);
 645
 646   while (p < len && payload != IKEV2_PAYLOAD_NONE)
 647     {
 648       ike_payload_header_t *ikep = (ike_payload_header_t *) & ike->payload[p];
 649       u32 plen = clib_net_to_host_u16 (ikep->length);
 650
 651       if (plen < sizeof (ike_payload_header_t))
 652         return;
 653
 654       if (payload == IKEV2_PAYLOAD_SA)
 655         {
 656           ikev2_sa_free_proposal_vector (&sa->i_proposals);
 657           sa->i_proposals = ikev2_parse_sa_payload (ikep);
 658         }
 659       else if (payload == IKEV2_PAYLOAD_KE)
 660         {
 661           ike_ke_payload_header_t *ke = (ike_ke_payload_header_t *) ikep;
 662           sa->dh_group = clib_net_to_host_u16 (ke->dh_group);
 663           vec_free (sa->i_dh_data);
 664           vec_add (sa->i_dh_data, ke->payload, plen - sizeof (*ke));
 665         }
 666       else if (payload == IKEV2_PAYLOAD_NONCE)
 667         {
 668           vec_free (sa->i_nonce);
 669           vec_add (sa->i_nonce, ikep->payload, plen - sizeof (*ikep));
 670         }
 671       else if (payload == IKEV2_PAYLOAD_NOTIFY)
 672         {
 673           ikev2_notify_t *n = ikev2_parse_notify_payload (ikep);
 674           if (n->msg_type == IKEV2_NOTIFY_MSG_NAT_DETECTION_SOURCE_IP)
 675             {
 676               u8 *src_sha =
 677                 ikev2_compute_nat_sha1 (clib_net_to_host_u64 (ike->ispi), 0,
 678                                         clib_net_to_host_u32 (sa->
 679                                                               iaddr.as_u32),
 680                                         udp->src_port);
 681               if (clib_memcmp (src_sha, n->data, vec_len (src_sha)))
 682                 {
 683                   sa->natt = 1;
 684                   ikev2_elog_uint (IKEV2_LOG_DEBUG, "ispi %lx initiator"
 685                                    " behind NAT", sa->ispi);
 686                 }
 687               vec_free (src_sha);
 688             }
 689           else if (n->msg_type ==
 690                    IKEV2_NOTIFY_MSG_NAT_DETECTION_DESTINATION_IP)
 691             {
 692               u8 *dst_sha =
 693                 ikev2_compute_nat_sha1 (clib_net_to_host_u64 (ike->ispi), 0,
 694                                         clib_net_to_host_u32 (sa->
 695                                                               raddr.as_u32),
 696                                         udp->dst_port);
 697               if (clib_memcmp (dst_sha, n->data, vec_len (dst_sha)))
 698                 {
 699                   sa->natt = 1;
 700                   ikev2_elog_uint (IKEV2_LOG_DEBUG, "ispi %lx responder"
 701                                    " (self) behind NAT", sa->ispi);
 702                 }
 703               vec_free (dst_sha);
 704             }
 705           vec_free (n);
 706         }
 707       else if (payload == IKEV2_PAYLOAD_VENDOR)
 708         {
 709           ikev2_parse_vendor_payload (ikep);
 710         }
 711       else
 712         {
 713           ikev2_elog_uint (IKEV2_LOG_ERROR, "Unknown payload! type=%d",
 714                            payload);
 715           if (ikep->flags & IKEV2_PAYLOAD_FLAG_CRITICAL)
 716             {
 717               ikev2_set_state (sa, IKEV2_STATE_NOTIFY_AND_DELETE);
 718               sa->unsupported_cp = payload;
 719               return;
 720             }
 721         }
 722
 723       payload = ikep->nextpayload;
 724       p += plen;
 725     }
 726
 727   ikev2_set_state (sa, IKEV2_STATE_SA_INIT);
 728 }
 729
 730 static void
 731 ikev2_process_sa_init_resp (vlib_main_t * vm, ikev2_sa_t * sa,
 732                             ike_header_t * ike, udp_header_t * udp)
 733 {
 734   int p = 0;
 735   u32 len = clib_net_to_host_u32 (ike->length);
 736   u8 payload = ike->nextpayload;
 737
 738   sa->ispi = clib_net_to_host_u64 (ike->ispi);
 739   sa->rspi = clib_net_to_host_u64 (ike->rspi);
 740
 741   ikev2_elog_exchange ("ispi %lx rspi %lx IKE_INIT response received "
 742                        "from %d.%d.%d.%d", sa->ispi, sa->rspi,
 743                        sa->raddr.as_u32);
 744
 745   /* store whole IKE payload - needed for PSK auth */
 746   vec_free (sa->last_sa_init_res_packet_data);
 747   vec_add (sa->last_sa_init_res_packet_data, ike, len);
 748
 749   while (p < len && payload != IKEV2_PAYLOAD_NONE)
 750     {
 751       ike_payload_header_t *ikep = (ike_payload_header_t *) & ike->payload[p];
 752       u32 plen = clib_net_to_host_u16 (ikep->length);
 753
 754       if (plen < sizeof (ike_payload_header_t))
 755         return;
 756
 757       if (payload == IKEV2_PAYLOAD_SA)
 758         {
 759           ikev2_sa_free_proposal_vector (&sa->r_proposals);
 760           sa->r_proposals = ikev2_parse_sa_payload (ikep);
 761           if (sa->r_proposals)
 762             {
 763               ikev2_set_state (sa, IKEV2_STATE_SA_INIT);
 764               ike->msgid =
 765                 clib_host_to_net_u32 (clib_net_to_host_u32 (ike->msgid) + 1);
 766             }
 767         }
 768       else if (payload == IKEV2_PAYLOAD_KE)
 769         {
 770           ike_ke_payload_header_t *ke = (ike_ke_payload_header_t *) ikep;
 771           sa->dh_group = clib_net_to_host_u16 (ke->dh_group);
 772           vec_free (sa->r_dh_data);
 773           vec_add (sa->r_dh_data, ke->payload, plen - sizeof (*ke));
 774         }
 775       else if (payload == IKEV2_PAYLOAD_NONCE)
 776         {
 777           vec_free (sa->r_nonce);
 778           vec_add (sa->r_nonce, ikep->payload, plen - sizeof (*ikep));
 779         }
 780       else if (payload == IKEV2_PAYLOAD_NOTIFY)
 781         {
 782           ikev2_notify_t *n = ikev2_parse_notify_payload (ikep);
 783           if (n->msg_type == IKEV2_NOTIFY_MSG_NAT_DETECTION_SOURCE_IP)
 784             {
 785               u8 *src_sha = ikev2_compute_nat_sha1 (ike->ispi,
 786                                                     ike->rspi,
 787                                                     clib_net_to_host_u32
 788                                                     (sa->raddr.as_u32),
 789                                                     udp->src_port);
 790               if (clib_memcmp (src_sha, n->data, vec_len (src_sha)))
 791                 {
 792                   ikev2_elog_uint (IKEV2_LOG_DEBUG, "ispi %lx responder"
 793                                    " behind NAT, unsupported", sa->ispi);
 794                 }
 795               vec_free (src_sha);
 796             }
 797           else if (n->msg_type ==
 798                    IKEV2_NOTIFY_MSG_NAT_DETECTION_DESTINATION_IP)
 799             {
 800               u8 *dst_sha = ikev2_compute_nat_sha1 (ike->ispi,
 801                                                     ike->rspi,
 802                                                     sa->iaddr.as_u32,
 803                                                     udp->dst_port);
 804               if (clib_memcmp (dst_sha, n->data, vec_len (dst_sha)))
 805                 {
 806                   sa->natt = 1;
 807                   ikev2_elog_uint (IKEV2_LOG_DEBUG, "ispi %lx initiator"
 808                                    " (self) behind NAT", sa->ispi);
 809                 }
 810               vec_free (dst_sha);
 811             }
 812           vec_free (n);
 813         }
 814       else if (payload == IKEV2_PAYLOAD_VENDOR)
 815         {
 816           ikev2_parse_vendor_payload (ikep);
 817         }
 818       else
 819         {
 820           ikev2_elog_uint (IKEV2_LOG_ERROR, "Unknown payload! type=%d",
 821                            payload);
 822           if (ikep->flags & IKEV2_PAYLOAD_FLAG_CRITICAL)
 823             {
 824               ikev2_set_state (sa, IKEV2_STATE_NOTIFY_AND_DELETE);
 825               sa->unsupported_cp = payload;
 826               return;
 827             }
 828         }
 829
 830       payload = ikep->nextpayload;
 831       p += plen;
 832     }
 833 }
 834
 835 static u8 *
 836 ikev2_decrypt_sk_payload (ikev2_sa_t * sa, ike_header_t * ike, u8 * payload)
 837 {
 838   ikev2_main_per_thread_data_t *ptd = ikev2_get_per_thread_data ();
 839   int p = 0;
 840   u8 last_payload = 0, *plaintext = 0;
 841   u8 *hmac = 0;
 842   u32 len = clib_net_to_host_u32 (ike->length);
 843   ike_payload_header_t *ikep = 0;
 844   u32 plen = 0;
 845   ikev2_sa_transform_t *tr_integ;
 846   ikev2_sa_transform_t *tr_encr;
 847   tr_integ =
 848     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_INTEG);
 849   tr_encr =
 850     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_ENCR);
 851   int is_aead = tr_encr->encr_type == IKEV2_TRANSFORM_ENCR_TYPE_AES_GCM_16;
 852
 853   if ((!sa->sk_ar || !sa->sk_ai) && !is_aead)
 854     return 0;
 855
 856   while (p < len &&
 857          *payload != IKEV2_PAYLOAD_NONE && last_payload != IKEV2_PAYLOAD_SK)
 858     {
 859       ikep = (ike_payload_header_t *) & ike->payload[p];
 860       plen = clib_net_to_host_u16 (ikep->length);
 861
 862       if (plen < sizeof (*ikep))
 863         return 0;
 864
 865       if (*payload == IKEV2_PAYLOAD_SK)
 866         {
 867           last_payload = *payload;
 868         }
 869       else
 870         {
 871           ikev2_elog_uint (IKEV2_LOG_ERROR, "Unknown payload! type=%d",
 872                            *payload);
 873           if (ikep->flags & IKEV2_PAYLOAD_FLAG_CRITICAL)
 874             {
 875               sa->unsupported_cp = *payload;
 876               return 0;
 877             }
 878         }
 879
 880       *payload = ikep->nextpayload;
 881       p += plen;
 882     }
 883
 884   if (last_payload != IKEV2_PAYLOAD_SK)
 885     {
 886       ikev2_elog_error ("Last payload must be SK");
 887       return 0;
 888     }
 889
 890   if (is_aead)
 891     {
 892       if (plen < sizeof (*ikep) + IKEV2_GCM_ICV_SIZE)
 893         return 0;
 894
 895       plen -= sizeof (*ikep) + IKEV2_GCM_ICV_SIZE;
 896       u8 *aad = (u8 *) ike;
 897       u32 aad_len = ikep->payload - aad;
 898       u8 *tag = ikep->payload + plen;
 899
 900       plaintext = ikev2_decrypt_aead_data (ptd, sa, tr_encr, ikep->payload,
 901                                            plen, aad, aad_len, tag);
 902     }
 903   else
 904     {
 905       if (len < tr_integ->key_trunc)
 906         return 0;
 907
 908       hmac =
 909         ikev2_calc_integr (tr_integ, sa->is_initiator ? sa->sk_ar : sa->sk_ai,
 910                            (u8 *) ike, len - tr_integ->key_trunc);
 911
 912       if (plen < sizeof (*ikep) + tr_integ->key_trunc)
 913         return 0;
 914
 915       plen = plen - sizeof (*ikep) - tr_integ->key_trunc;
 916
 917       if (memcmp (hmac, &ikep->payload[plen], tr_integ->key_trunc))
 918         {
 919           ikev2_elog_error ("message integrity check failed");
 920           vec_free (hmac);
 921           return 0;
 922         }
 923       vec_free (hmac);
 924
 925       plaintext = ikev2_decrypt_data (ptd, sa, tr_encr, ikep->payload, plen);
 926     }
 927
 928   return plaintext;
 929 }
 930
 931 static_always_inline int
 932 ikev2_is_id_equal (ikev2_id_t * i1, ikev2_id_t * i2)
 933 {
 934   if (i1->type != i2->type)
 935     return 0;
 936
 937   if (vec_len (i1->data) != vec_len (i2->data))
 938     return 0;
 939
 940   if (memcmp (i1->data, i2->data, vec_len (i1->data)))
 941     return 0;
 942
 943   return 1;
 944 }
 945
 946 static void
 947 ikev2_initial_contact_cleanup (ikev2_sa_t * sa)
 948 {
 949   ikev2_main_t *km = &ikev2_main;
 950   ikev2_sa_t *tmp;
 951   u32 i, *delete = 0;
 952   ikev2_child_sa_t *c;
 953   u32 thread_index = vlib_get_thread_index ();
 954
 955   if (!sa->initial_contact)
 956     return;
 957
 958   /* find old IKE SAs with the same authenticated identity */
 959   /* *INDENT-OFF* */
 960   pool_foreach (tmp, km->per_thread_data[thread_index].sas, ({
 961         if (!ikev2_is_id_equal (&tmp->i_id, &sa->i_id)
 962             || !ikev2_is_id_equal(&tmp->r_id, &sa->r_id))
 963           continue;
 964
 965         if (sa->rspi != tmp->rspi)
 966           vec_add1(delete, tmp - km->per_thread_data[thread_index].sas);
 967   }));
 968   /* *INDENT-ON* */
 969
 970   for (i = 0; i < vec_len (delete); i++)
 971     {
 972       tmp =
 973         pool_elt_at_index (km->per_thread_data[thread_index].sas, delete[i]);
 974       vec_foreach (c,
 975                    tmp->childs) ikev2_delete_tunnel_interface (km->vnet_main,
 976                                                                tmp, c);
 977       ikev2_delete_sa (tmp);
 978     }
 979
 980   vec_free (delete);
 981   sa->initial_contact = 0;
 982 }
 983
 984 static void
 985 ikev2_process_auth_req (vlib_main_t * vm, ikev2_sa_t * sa, ike_header_t * ike)
 986 {
 987   ikev2_child_sa_t *first_child_sa;
 988   int p = 0;
 989   u8 payload = ike->nextpayload;
 990   u8 *plaintext = 0;
 991   ike_payload_header_t *ikep;
 992   u32 plen;
 993
 994   ikev2_elog_exchange ("ispi %lx rspi %lx EXCHANGE_IKE_AUTH received "
 995                        "from %d.%d.%d.%d", clib_host_to_net_u64 (ike->ispi),
 996                        clib_host_to_net_u64 (ike->rspi),
 997                        sa->is_initiator ? sa->raddr.as_u32 : sa->
 998                        iaddr.as_u32);
 999
1000   ikev2_calc_keys (sa);
1001
1002   plaintext = ikev2_decrypt_sk_payload (sa, ike, &payload);
1003
1004   if (!plaintext)
1005     {
1006       if (sa->unsupported_cp)
1007         ikev2_set_state (sa, IKEV2_STATE_NOTIFY_AND_DELETE);
1008       goto cleanup_and_exit;
1009     }
1010
1011   /* select or create 1st child SA */
1012   if (sa->is_initiator)
1013     {
1014       first_child_sa = &sa->childs[0];
1015     }
1016   else
1017     {
1018       ikev2_sa_free_all_child_sa (&sa->childs);
1019       vec_add2 (sa->childs, first_child_sa, 1);
1020     }
1021
1022
1023   /* process encrypted payload */
1024   p = 0;
1025   while (p < vec_len (plaintext) && payload != IKEV2_PAYLOAD_NONE)
1026     {
1027       ikep = (ike_payload_header_t *) & plaintext[p];
1028       plen = clib_net_to_host_u16 (ikep->length);
1029
1030       if (plen < sizeof (ike_payload_header_t))
1031         goto cleanup_and_exit;
1032
1033       if (payload == IKEV2_PAYLOAD_SA)  /* 33 */
1034         {
1035           if (sa->is_initiator)
1036             {
1037               ikev2_sa_free_proposal_vector (&first_child_sa->r_proposals);
1038               first_child_sa->r_proposals = ikev2_parse_sa_payload (ikep);
1039             }
1040           else
1041             {
1042               ikev2_sa_free_proposal_vector (&first_child_sa->i_proposals);
1043               first_child_sa->i_proposals = ikev2_parse_sa_payload (ikep);
1044             }
1045         }
1046       else if (payload == IKEV2_PAYLOAD_IDI)    /* 35 */
1047         {
1048           ike_id_payload_header_t *id = (ike_id_payload_header_t *) ikep;
1049
1050           sa->i_id.type = id->id_type;
1051           vec_free (sa->i_id.data);
1052           vec_add (sa->i_id.data, id->payload, plen - sizeof (*id));
1053         }
1054       else if (payload == IKEV2_PAYLOAD_IDR)    /* 36 */
1055         {
1056           ike_id_payload_header_t *id = (ike_id_payload_header_t *) ikep;
1057
1058           sa->r_id.type = id->id_type;
1059           vec_free (sa->r_id.data);
1060           vec_add (sa->r_id.data, id->payload, plen - sizeof (*id));
1061         }
1062       else if (payload == IKEV2_PAYLOAD_AUTH)   /* 39 */
1063         {
1064           ike_auth_payload_header_t *a = (ike_auth_payload_header_t *) ikep;
1065
1066           if (sa->is_initiator)
1067             {
1068               sa->r_auth.method = a->auth_method;
1069               vec_free (sa->r_auth.data);
1070               vec_add (sa->r_auth.data, a->payload, plen - sizeof (*a));
1071             }
1072           else
1073             {
1074               sa->i_auth.method = a->auth_method;
1075               vec_free (sa->i_auth.data);
1076               vec_add (sa->i_auth.data, a->payload, plen - sizeof (*a));
1077             }
1078         }
1079       else if (payload == IKEV2_PAYLOAD_NOTIFY) /* 41 */
1080         {
1081           ikev2_notify_t *n = ikev2_parse_notify_payload (ikep);
1082           if (n->msg_type == IKEV2_NOTIFY_MSG_INITIAL_CONTACT)
1083             {
1084               sa->initial_contact = 1;
1085             }
1086           vec_free (n);
1087         }
1088       else if (payload == IKEV2_PAYLOAD_VENDOR) /* 43 */
1089         {
1090           ikev2_parse_vendor_payload (ikep);
1091         }
1092       else if (payload == IKEV2_PAYLOAD_TSI)    /* 44 */
1093         {
1094           vec_free (first_child_sa->tsi);
1095           first_child_sa->tsi = ikev2_parse_ts_payload (ikep);
1096         }
1097       else if (payload == IKEV2_PAYLOAD_TSR)    /* 45 */
1098         {
1099           vec_free (first_child_sa->tsr);
1100           first_child_sa->tsr = ikev2_parse_ts_payload (ikep);
1101         }
1102       else
1103         {
1104           ikev2_elog_uint (IKEV2_LOG_ERROR, "Unknown payload! type=%d",
1105                            payload);
1106
1107           if (ikep->flags & IKEV2_PAYLOAD_FLAG_CRITICAL)
1108             {
1109               ikev2_set_state (sa, IKEV2_STATE_NOTIFY_AND_DELETE);
1110               sa->unsupported_cp = payload;
1111               return;
1112             }
1113         }
1114
1115       payload = ikep->nextpayload;
1116       p += plen;
1117     }
1118
1119 cleanup_and_exit:
1120   vec_free (plaintext);
1121 }
1122
1123 static void
1124 ikev2_process_informational_req (vlib_main_t * vm, ikev2_sa_t * sa,
1125                                  ike_header_t * ike)
1126 {
1127   int p = 0;
1128   u8 payload = ike->nextpayload;
1129   u8 *plaintext = 0;
1130   ike_payload_header_t *ikep;
1131   u32 plen;
1132
1133   sa->liveness_retries = 0;
1134   ikev2_elog_exchange ("ispi %lx rspi %lx INFORMATIONAL received "
1135                        "from %d.%d.%d.%d", clib_host_to_net_u64 (ike->ispi),
1136                        clib_host_to_net_u64 (ike->rspi), sa->iaddr.as_u32);
1137
1138   plaintext = ikev2_decrypt_sk_payload (sa, ike, &payload);
1139
1140   if (!plaintext)
1141     goto cleanup_and_exit;
1142
1143   /* process encrypted payload */
1144   p = 0;
1145   while (p < vec_len (plaintext) && payload != IKEV2_PAYLOAD_NONE)
1146     {
1147       ikep = (ike_payload_header_t *) & plaintext[p];
1148       plen = clib_net_to_host_u16 (ikep->length);
1149
1150       if (plen < sizeof (ike_payload_header_t))
1151         goto cleanup_and_exit;
1152
1153       if (payload == IKEV2_PAYLOAD_NOTIFY)      /* 41 */
1154         {
1155           ikev2_notify_t *n = ikev2_parse_notify_payload (ikep);
1156           if (n->msg_type == IKEV2_NOTIFY_MSG_AUTHENTICATION_FAILED)
1157             ikev2_set_state (sa, IKEV2_STATE_AUTH_FAILED);
1158           vec_free (n);
1159         }
1160       else if (payload == IKEV2_PAYLOAD_DELETE) /* 42 */
1161         {
1162           sa->del = ikev2_parse_delete_payload (ikep);
1163         }
1164       else if (payload == IKEV2_PAYLOAD_VENDOR) /* 43 */
1165         {
1166           ikev2_parse_vendor_payload (ikep);
1167         }
1168       else
1169         {
1170           ikev2_elog_uint (IKEV2_LOG_ERROR, "Unknown payload! type=%d",
1171                            payload);
1172           if (ikep->flags & IKEV2_PAYLOAD_FLAG_CRITICAL)
1173             {
1174               sa->unsupported_cp = payload;
1175               return;
1176             }
1177         }
1178
1179       payload = ikep->nextpayload;
1180       p += plen;
1181     }
1182
1183 cleanup_and_exit:
1184   vec_free (plaintext);
1185 }
1186
1187 static void
1188 ikev2_process_create_child_sa_req (vlib_main_t * vm, ikev2_sa_t * sa,
1189                                    ike_header_t * ike)
1190 {
1191   int p = 0;
1192   u8 payload = ike->nextpayload;
1193   u8 *plaintext = 0;
1194   u8 rekeying = 0;
1195   u8 nonce[IKEV2_NONCE_SIZE];
1196
1197   ike_payload_header_t *ikep;
1198   u32 plen;
1199   ikev2_notify_t *n = 0;
1200   ikev2_ts_t *tsi = 0;
1201   ikev2_ts_t *tsr = 0;
1202   ikev2_sa_proposal_t *proposal = 0;
1203   ikev2_child_sa_t *child_sa;
1204
1205   ikev2_elog_exchange ("ispi %lx rspi %lx CREATE_CHILD_SA received "
1206                        "from %d.%d.%d.%d", clib_host_to_net_u64 (ike->ispi),
1207                        clib_host_to_net_u64 (ike->rspi), sa->raddr.as_u32);
1208
1209   plaintext = ikev2_decrypt_sk_payload (sa, ike, &payload);
1210
1211   if (!plaintext)
1212     goto cleanup_and_exit;
1213
1214   /* process encrypted payload */
1215   p = 0;
1216   while (p < vec_len (plaintext) && payload != IKEV2_PAYLOAD_NONE)
1217     {
1218       ikep = (ike_payload_header_t *) & plaintext[p];
1219       plen = clib_net_to_host_u16 (ikep->length);
1220
1221       if (plen < sizeof (ike_payload_header_t))
1222         goto cleanup_and_exit;
1223
1224       else if (payload == IKEV2_PAYLOAD_SA)
1225         {
1226           proposal = ikev2_parse_sa_payload (ikep);
1227         }
1228       else if (payload == IKEV2_PAYLOAD_NOTIFY)
1229         {
1230           n = ikev2_parse_notify_payload (ikep);
1231           if (n->msg_type == IKEV2_NOTIFY_MSG_REKEY_SA)
1232             {
1233               rekeying = 1;
1234             }
1235         }
1236       else if (payload == IKEV2_PAYLOAD_DELETE)
1237         {
1238           sa->del = ikev2_parse_delete_payload (ikep);
1239         }
1240       else if (payload == IKEV2_PAYLOAD_VENDOR)
1241         {
1242           ikev2_parse_vendor_payload (ikep);
1243         }
1244       else if (payload == IKEV2_PAYLOAD_NONCE)
1245         {
1246           clib_memcpy_fast (nonce, ikep->payload, plen - sizeof (*ikep));
1247         }
1248       else if (payload == IKEV2_PAYLOAD_TSI)
1249         {
1250           tsi = ikev2_parse_ts_payload (ikep);
1251         }
1252       else if (payload == IKEV2_PAYLOAD_TSR)
1253         {
1254           tsr = ikev2_parse_ts_payload (ikep);
1255         }
1256       else
1257         {
1258           ikev2_elog_uint (IKEV2_LOG_ERROR, "Unknown payload! type=%d",
1259                            payload);
1260           if (ikep->flags & IKEV2_PAYLOAD_FLAG_CRITICAL)
1261             {
1262               sa->unsupported_cp = payload;
1263               goto cleanup_and_exit;
1264             }
1265         }
1266
1267       payload = ikep->nextpayload;
1268       p += plen;
1269     }
1270
1271   if (sa->is_initiator && proposal->protocol_id == IKEV2_PROTOCOL_ESP)
1272     {
1273       ikev2_rekey_t *rekey = &sa->rekey[0];
1274       rekey->protocol_id = proposal->protocol_id;
1275       rekey->i_proposal =
1276         ikev2_select_proposal (proposal, IKEV2_PROTOCOL_ESP);
1277       rekey->i_proposal->spi = rekey->spi;
1278       rekey->r_proposal = proposal;
1279       rekey->tsi = tsi;
1280       rekey->tsr = tsr;
1281       /* update Nr */
1282       vec_free (sa->r_nonce);
1283       vec_add (sa->r_nonce, nonce, IKEV2_NONCE_SIZE);
1284       child_sa = ikev2_sa_get_child (sa, rekey->ispi, IKEV2_PROTOCOL_ESP, 1);
1285       if (child_sa)
1286         {
1287           child_sa->rekey_retries = 0;
1288         }
1289     }
1290   else if (rekeying)
1291     {
1292       ikev2_rekey_t *rekey;
1293       child_sa = ikev2_sa_get_child (sa, n->spi, n->protocol_id, 1);
1294       if (!child_sa)
1295         {
1296           ikev2_elog_uint (IKEV2_LOG_ERROR, "child SA spi %lx not found",
1297                            n->spi);
1298           goto cleanup_and_exit;
1299         }
1300       vec_add2 (sa->rekey, rekey, 1);
1301       rekey->protocol_id = n->protocol_id;
1302       rekey->spi = n->spi;
1303       rekey->i_proposal = proposal;
1304       rekey->r_proposal =
1305         ikev2_select_proposal (proposal, IKEV2_PROTOCOL_ESP);
1306       rekey->tsi = tsi;
1307       rekey->tsr = tsr;
1308       /* update Ni */
1309       vec_free (sa->i_nonce);
1310       vec_add (sa->i_nonce, nonce, IKEV2_NONCE_SIZE);
1311       /* generate new Nr */
1312       vec_free (sa->r_nonce);
1313       sa->r_nonce = vec_new (u8, IKEV2_NONCE_SIZE);
1314       RAND_bytes ((u8 *) sa->r_nonce, IKEV2_NONCE_SIZE);
1315     }
1316
1317 cleanup_and_exit:
1318   vec_free (plaintext);
1319   vec_free (n);
1320 }
1321
1322 static u8 *
1323 ikev2_sa_generate_authmsg (ikev2_sa_t * sa, int is_responder)
1324 {
1325   u8 *authmsg = 0;
1326   u8 *data;
1327   u8 *nonce;
1328   ikev2_id_t *id;
1329   u8 *key;
1330   u8 *packet_data;
1331   ikev2_sa_transform_t *tr_prf;
1332
1333   tr_prf =
1334     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_PRF);
1335
1336   if (is_responder)
1337     {
1338       id = &sa->r_id;
1339       key = sa->sk_pr;
1340       nonce = sa->i_nonce;
1341       packet_data = sa->last_sa_init_res_packet_data;
1342     }
1343   else
1344     {
1345       id = &sa->i_id;
1346       key = sa->sk_pi;
1347       nonce = sa->r_nonce;
1348       packet_data = sa->last_sa_init_req_packet_data;
1349     }
1350
1351   data = vec_new (u8, 4);
1352   data[0] = id->type;
1353   vec_append (data, id->data);
1354
1355   u8 *id_hash = ikev2_calc_prf (tr_prf, key, data);
1356   vec_append (authmsg, packet_data);
1357   vec_append (authmsg, nonce);
1358   vec_append (authmsg, id_hash);
1359   vec_free (id_hash);
1360   vec_free (data);
1361
1362   return authmsg;
1363 }
1364
1365 static int
1366 ikev2_ts_cmp (ikev2_ts_t * ts1, ikev2_ts_t * ts2)
1367 {
1368   if (ts1->ts_type == ts2->ts_type && ts1->protocol_id == ts2->protocol_id &&
1369       ts1->start_port == ts2->start_port && ts1->end_port == ts2->end_port &&
1370       ts1->start_addr.as_u32 == ts2->start_addr.as_u32 &&
1371       ts1->end_addr.as_u32 == ts2->end_addr.as_u32)
1372     return 1;
1373
1374   return 0;
1375 }
1376
1377 static void
1378 ikev2_sa_match_ts (ikev2_sa_t * sa)
1379 {
1380   ikev2_main_t *km = &ikev2_main;
1381   ikev2_profile_t *p;
1382   ikev2_ts_t *ts, *p_tsi, *p_tsr, *tsi = 0, *tsr = 0;
1383   ikev2_id_t *id_rem, *id_loc;
1384
1385   /* *INDENT-OFF* */
1386   pool_foreach (p, km->profiles, ({
1387
1388     if (sa->is_initiator)
1389       {
1390         p_tsi = &p->loc_ts;
1391         p_tsr = &p->rem_ts;
1392         id_rem = &sa->r_id;
1393         id_loc = &sa->i_id;
1394       }
1395     else
1396       {
1397         p_tsi = &p->rem_ts;
1398         p_tsr = &p->loc_ts;
1399         id_rem = &sa->i_id;
1400         id_loc = &sa->r_id;
1401       }
1402
1403     /* check id */
1404     if (!ikev2_is_id_equal (&p->rem_id, id_rem)
1405           || !ikev2_is_id_equal (&p->loc_id, id_loc))
1406       continue;
1407
1408     sa->profile_index = p - km->profiles;
1409
1410     vec_foreach(ts, sa->childs[0].tsi)
1411       {
1412         if (ikev2_ts_cmp(p_tsi, ts))
1413           {
1414             vec_add1 (tsi, ts[0]);
1415             break;
1416           }
1417       }
1418
1419     vec_foreach(ts, sa->childs[0].tsr)
1420       {
1421         if (ikev2_ts_cmp(p_tsr, ts))
1422           {
1423             vec_add1 (tsr, ts[0]);
1424             break;
1425           }
1426       }
1427
1428     break;
1429   }));
1430   /* *INDENT-ON* */
1431
1432   if (tsi && tsr)
1433     {
1434       vec_free (sa->childs[0].tsi);
1435       vec_free (sa->childs[0].tsr);
1436       sa->childs[0].tsi = tsi;
1437       sa->childs[0].tsr = tsr;
1438     }
1439   else
1440     {
1441       vec_free (tsi);
1442       vec_free (tsr);
1443       ikev2_set_state (sa, IKEV2_STATE_TS_UNACCEPTABLE);
1444     }
1445 }
1446
1447 static void
1448 ikev2_sa_auth (ikev2_sa_t * sa)
1449 {
1450   ikev2_main_t *km = &ikev2_main;
1451   ikev2_profile_t *p, *sel_p = 0;
1452   u8 *authmsg, *key_pad, *psk = 0, *auth = 0;
1453   ikev2_sa_transform_t *tr_prf;
1454
1455   tr_prf =
1456     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_PRF);
1457
1458   /* only shared key and rsa signature */
1459   if (!(sa->i_auth.method == IKEV2_AUTH_METHOD_SHARED_KEY_MIC ||
1460         sa->i_auth.method == IKEV2_AUTH_METHOD_RSA_SIG))
1461     {
1462       ikev2_elog_uint (IKEV2_LOG_ERROR,
1463                        "unsupported authentication method %u",
1464                        sa->i_auth.method);
1465       ikev2_set_state (sa, IKEV2_STATE_AUTH_FAILED);
1466       return;
1467     }
1468
1469   key_pad = format (0, "%s", IKEV2_KEY_PAD);
1470   authmsg = ikev2_sa_generate_authmsg (sa, sa->is_initiator);
1471
1472   ikev2_id_t *id_rem, *id_loc;
1473   ikev2_auth_t *sa_auth;
1474
1475   if (sa->is_initiator)
1476     {
1477       id_rem = &sa->r_id;
1478       id_loc = &sa->i_id;
1479       sa_auth = &sa->r_auth;
1480     }
1481   else
1482     {
1483       id_rem = &sa->i_id;
1484       id_loc = &sa->r_id;
1485       sa_auth = &sa->i_auth;
1486     }
1487
1488   /* *INDENT-OFF* */
1489   pool_foreach (p, km->profiles, ({
1490
1491     /* check id */
1492     if (!ikev2_is_id_equal (&p->rem_id, id_rem)
1493           || !ikev2_is_id_equal (&p->loc_id, id_loc))
1494       continue;
1495
1496     if (sa_auth->method == IKEV2_AUTH_METHOD_SHARED_KEY_MIC)
1497       {
1498         if (!p->auth.data ||
1499              p->auth.method != IKEV2_AUTH_METHOD_SHARED_KEY_MIC)
1500           continue;
1501
1502         psk = ikev2_calc_prf(tr_prf, p->auth.data, key_pad);
1503         auth = ikev2_calc_prf(tr_prf, psk, authmsg);
1504
1505         if (!memcmp(auth, sa_auth->data, vec_len(sa_auth->data)))
1506           {
1507             ikev2_set_state(sa, IKEV2_STATE_AUTHENTICATED);
1508             vec_free(auth);
1509             sel_p = p;
1510             break;
1511           }
1512
1513       }
1514     else if (sa_auth->method == IKEV2_AUTH_METHOD_RSA_SIG)
1515       {
1516         if (p->auth.method != IKEV2_AUTH_METHOD_RSA_SIG)
1517           continue;
1518
1519         if (ikev2_verify_sign(p->auth.key, sa_auth->data, authmsg) == 1)
1520           {
1521             ikev2_set_state(sa, IKEV2_STATE_AUTHENTICATED);
1522             sel_p = p;
1523             break;
1524           }
1525       }
1526
1527     vec_free(auth);
1528     vec_free(psk);
1529   }));
1530   /* *INDENT-ON* */
1531
1532   if (sel_p)
1533     {
1534       sa->udp_encap = sel_p->udp_encap;
1535       sa->ipsec_over_udp_port = sel_p->ipsec_over_udp_port;
1536     }
1537   vec_free (authmsg);
1538
1539   if (sa->state == IKEV2_STATE_AUTHENTICATED)
1540     {
1541       if (!sa->is_initiator)
1542         {
1543           vec_free (sa->r_id.data);
1544           sa->r_id.data = vec_dup (sel_p->loc_id.data);
1545           sa->r_id.type = sel_p->loc_id.type;
1546           sa->i_id.data = vec_dup (sel_p->rem_id.data);
1547           sa->i_id.type = sel_p->rem_id.type;
1548
1549           /* generate our auth data */
1550           authmsg = ikev2_sa_generate_authmsg (sa, 1);
1551           if (sel_p->auth.method == IKEV2_AUTH_METHOD_SHARED_KEY_MIC)
1552             {
1553               sa->r_auth.data = ikev2_calc_prf (tr_prf, psk, authmsg);
1554               sa->r_auth.method = IKEV2_AUTH_METHOD_SHARED_KEY_MIC;
1555             }
1556           else if (sel_p->auth.method == IKEV2_AUTH_METHOD_RSA_SIG)
1557             {
1558               sa->r_auth.data = ikev2_calc_sign (km->pkey, authmsg);
1559               sa->r_auth.method = IKEV2_AUTH_METHOD_RSA_SIG;
1560             }
1561           vec_free (authmsg);
1562
1563           /* select transforms for 1st child sa */
1564           ikev2_sa_free_proposal_vector (&sa->childs[0].r_proposals);
1565           sa->childs[0].r_proposals =
1566             ikev2_select_proposal (sa->childs[0].i_proposals,
1567                                    IKEV2_PROTOCOL_ESP);
1568
1569           if (~0 != sel_p->tun_itf)
1570             {
1571               sa->is_tun_itf_set = 1;
1572               sa->tun_itf = sel_p->tun_itf;
1573             }
1574         }
1575     }
1576   else
1577     {
1578       ikev2_elog_uint (IKEV2_LOG_ERROR, "authentication failed, no matching "
1579                        "profile found! ispi %lx", sa->ispi);
1580       ikev2_set_state (sa, IKEV2_STATE_AUTH_FAILED);
1581     }
1582   vec_free (psk);
1583   vec_free (key_pad);
1584 }
1585
1586
1587 static void
1588 ikev2_sa_auth_init (ikev2_sa_t * sa)
1589 {
1590   ikev2_main_t *km = &ikev2_main;
1591   u8 *authmsg, *key_pad, *psk = 0;
1592   ikev2_sa_transform_t *tr_prf;
1593
1594   tr_prf =
1595     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_PRF);
1596
1597   /* only shared key and rsa signature */
1598   if (!(sa->i_auth.method == IKEV2_AUTH_METHOD_SHARED_KEY_MIC ||
1599         sa->i_auth.method == IKEV2_AUTH_METHOD_RSA_SIG))
1600     {
1601       ikev2_elog_uint (IKEV2_LOG_ERROR,
1602                        "unsupported authentication method %u",
1603                        sa->i_auth.method);
1604       ikev2_set_state (sa, IKEV2_STATE_AUTH_FAILED);
1605       return;
1606     }
1607
1608   key_pad = format (0, "%s", IKEV2_KEY_PAD);
1609   authmsg = ikev2_sa_generate_authmsg (sa, 0);
1610   psk = ikev2_calc_prf (tr_prf, sa->i_auth.data, key_pad);
1611
1612   if (sa->i_auth.method == IKEV2_AUTH_METHOD_SHARED_KEY_MIC)
1613     {
1614       sa->i_auth.data = ikev2_calc_prf (tr_prf, psk, authmsg);
1615       sa->i_auth.method = IKEV2_AUTH_METHOD_SHARED_KEY_MIC;
1616     }
1617   else if (sa->i_auth.method == IKEV2_AUTH_METHOD_RSA_SIG)
1618     {
1619       sa->i_auth.data = ikev2_calc_sign (km->pkey, authmsg);
1620       sa->i_auth.method = IKEV2_AUTH_METHOD_RSA_SIG;
1621     }
1622
1623   vec_free (psk);
1624   vec_free (key_pad);
1625   vec_free (authmsg);
1626 }
1627
1628 static u32
1629 ikev2_mk_local_sa_id (u32 sai, u32 ci, u32 ti)
1630 {
1631   return (0x80000000 | (ti << 24) | (sai << 12) | ci);
1632 }
1633
1634 static u32
1635 ikev2_mk_remote_sa_id (u32 sai, u32 ci, u32 ti)
1636 {
1637   return (0xc0000000 | (ti << 24) | (sai << 12) | ci);
1638 }
1639
1640 typedef struct
1641 {
1642   u32 sw_if_index;
1643   u32 salt_local;
1644   u32 salt_remote;
1645   u32 local_sa_id;
1646   u32 remote_sa_id;
1647   ipsec_sa_flags_t flags;
1648   u32 local_spi;
1649   u32 remote_spi;
1650   ipsec_crypto_alg_t encr_type;
1651   ipsec_integ_alg_t integ_type;
1652   ip46_address_t local_ip;
1653   ip46_address_t remote_ip;
1654   ipsec_key_t loc_ckey, rem_ckey, loc_ikey, rem_ikey;
1655   u8 is_rekey;
1656   u32 old_remote_sa_id;
1657   u16 ipsec_over_udp_port;
1658   u16 src_port;
1659   u16 dst_port;
1660 } ikev2_add_ipsec_tunnel_args_t;
1661
1662 static void
1663 ikev2_add_tunnel_from_main (ikev2_add_ipsec_tunnel_args_t * a)
1664 {
1665   ikev2_main_t *km = &ikev2_main;
1666   u32 sw_if_index;
1667   int rv = 0;
1668
1669   if (~0 == a->sw_if_index)
1670     {
1671       /* no tunnel associated with the SA/profile - create a new one */
1672       rv = ipip_add_tunnel (IPIP_TRANSPORT_IP4, ~0,
1673                             &a->local_ip, &a->remote_ip, 0,
1674                             TUNNEL_ENCAP_DECAP_FLAG_NONE, IP_DSCP_CS0,
1675                             TUNNEL_MODE_P2P, &sw_if_index);
1676
1677       if (rv == VNET_API_ERROR_IF_ALREADY_EXISTS)
1678         {
1679           if (hash_get (km->sw_if_indices, sw_if_index))
1680             /* interface is managed by IKE; proceed with updating SAs */
1681             rv = 0;
1682         }
1683       hash_set1 (km->sw_if_indices, sw_if_index);
1684     }
1685   else
1686     {
1687       sw_if_index = a->sw_if_index;
1688       vnet_sw_interface_admin_up (vnet_get_main (), sw_if_index);
1689     }
1690
1691   if (rv)
1692     {
1693       ikev2_elog_peers (IKEV2_LOG_ERROR, "installing ipip tunnel failed! "
1694                         "loc:%d.%d.%d.%d rem:%d.%d.%d.%d",
1695                         a->local_ip.ip4.as_u32, a->remote_ip.ip4.as_u32);
1696       return;
1697     }
1698
1699   u32 *sas_in = NULL;
1700   vec_add1 (sas_in, a->remote_sa_id);
1701   if (a->is_rekey)
1702     {
1703       ipsec_tun_protect_del (sw_if_index, NULL);
1704
1705       /* replace local SA immediately */
1706       ipsec_sa_unlock_id (a->local_sa_id);
1707
1708       /* keep the old sa */
1709       vec_add1 (sas_in, a->old_remote_sa_id);
1710     }
1711
1712   rv |= ipsec_sa_add_and_lock (a->local_sa_id,
1713                                a->local_spi,
1714                                IPSEC_PROTOCOL_ESP, a->encr_type,
1715                                &a->loc_ckey, a->integ_type, &a->loc_ikey,
1716                                a->flags, 0, a->salt_local, &a->local_ip,
1717                                &a->remote_ip, NULL, a->src_port, a->dst_port);
1718   rv |= ipsec_sa_add_and_lock (a->remote_sa_id, a->remote_spi,
1719                                IPSEC_PROTOCOL_ESP, a->encr_type, &a->rem_ckey,
1720                                a->integ_type, &a->rem_ikey,
1721                                (a->flags | IPSEC_SA_FLAG_IS_INBOUND), 0,
1722                                a->salt_remote, &a->remote_ip,
1723                                &a->local_ip, NULL, a->ipsec_over_udp_port,
1724                                a->ipsec_over_udp_port);
1725
1726   rv |= ipsec_tun_protect_update (sw_if_index, NULL, a->local_sa_id, sas_in);
1727 }
1728
1729 static int
1730 ikev2_create_tunnel_interface (vlib_main_t * vm,
1731                                u32 thread_index,
1732                                ikev2_sa_t * sa,
1733                                ikev2_child_sa_t * child, u32 sa_index,
1734                                u32 child_index, u8 is_rekey)
1735 {
1736   ikev2_main_t *km = &ikev2_main;
1737   ipsec_crypto_alg_t encr_type;
1738   ipsec_integ_alg_t integ_type;
1739   ikev2_profile_t *p = 0;
1740   ikev2_sa_transform_t *tr;
1741   ikev2_sa_proposal_t *proposals;
1742   u8 is_aead = 0;
1743   ikev2_add_ipsec_tunnel_args_t a;
1744
1745   clib_memset (&a, 0, sizeof (a));
1746
1747   if (!child->r_proposals)
1748     {
1749       ikev2_set_state (sa, IKEV2_STATE_NO_PROPOSAL_CHOSEN);
1750       return 1;
1751     }
1752
1753   if (sa->is_initiator)
1754     {
1755       ip46_address_set_ip4 (&a.local_ip, &sa->iaddr);
1756       ip46_address_set_ip4 (&a.remote_ip, &sa->raddr);
1757       proposals = child->r_proposals;
1758       a.local_spi = child->r_proposals[0].spi;
1759       a.remote_spi = child->i_proposals[0].spi;
1760     }
1761   else
1762     {
1763       ip46_address_set_ip4 (&a.local_ip, &sa->raddr);
1764       ip46_address_set_ip4 (&a.remote_ip, &sa->iaddr);
1765       proposals = child->i_proposals;
1766       a.local_spi = child->i_proposals[0].spi;
1767       a.remote_spi = child->r_proposals[0].spi;
1768     }
1769
1770   a.flags = IPSEC_SA_FLAG_USE_ANTI_REPLAY;
1771   if (sa->udp_encap)
1772     {
1773       a.flags |= IPSEC_SA_FLAG_IS_TUNNEL;
1774       a.flags |= IPSEC_SA_FLAG_UDP_ENCAP;
1775     }
1776   if (sa->natt)
1777     a.flags |= IPSEC_SA_FLAG_UDP_ENCAP;
1778   a.is_rekey = is_rekey;
1779
1780   tr = ikev2_sa_get_td_for_type (proposals, IKEV2_TRANSFORM_TYPE_ESN);
1781   if (tr && tr->esn_type)
1782     a.flags |= IPSEC_SA_FLAG_USE_ESN;
1783
1784   tr = ikev2_sa_get_td_for_type (proposals, IKEV2_TRANSFORM_TYPE_ENCR);
1785   if (tr)
1786     {
1787       if (tr->encr_type == IKEV2_TRANSFORM_ENCR_TYPE_AES_CBC && tr->key_len)
1788         {
1789           switch (tr->key_len)
1790             {
1791             case 16:
1792               encr_type = IPSEC_CRYPTO_ALG_AES_CBC_128;
1793               break;
1794             case 24:
1795               encr_type = IPSEC_CRYPTO_ALG_AES_CBC_192;
1796               break;
1797             case 32:
1798               encr_type = IPSEC_CRYPTO_ALG_AES_CBC_256;
1799               break;
1800             default:
1801               ikev2_set_state (sa, IKEV2_STATE_NO_PROPOSAL_CHOSEN);
1802               return 1;
1803               break;
1804             }
1805         }
1806       else if (tr->encr_type == IKEV2_TRANSFORM_ENCR_TYPE_AES_GCM_16
1807                && tr->key_len)
1808         {
1809           switch (tr->key_len)
1810             {
1811             case 16:
1812               encr_type = IPSEC_CRYPTO_ALG_AES_GCM_128;
1813               break;
1814             case 24:
1815               encr_type = IPSEC_CRYPTO_ALG_AES_GCM_192;
1816               break;
1817             case 32:
1818               encr_type = IPSEC_CRYPTO_ALG_AES_GCM_256;
1819               break;
1820             default:
1821               ikev2_set_state (sa, IKEV2_STATE_NO_PROPOSAL_CHOSEN);
1822               return 1;
1823               break;
1824             }
1825           is_aead = 1;
1826         }
1827       else
1828         {
1829           ikev2_set_state (sa, IKEV2_STATE_NO_PROPOSAL_CHOSEN);
1830           return 1;
1831         }
1832     }
1833   else
1834     {
1835       ikev2_set_state (sa, IKEV2_STATE_NO_PROPOSAL_CHOSEN);
1836       return 1;
1837     }
1838   a.encr_type = encr_type;
1839
1840   if (!is_aead)
1841     {
1842       tr = ikev2_sa_get_td_for_type (proposals, IKEV2_TRANSFORM_TYPE_INTEG);
1843       if (tr)
1844         {
1845           switch (tr->integ_type)
1846             {
1847             case IKEV2_TRANSFORM_INTEG_TYPE_AUTH_HMAC_SHA2_256_128:
1848               integ_type = IPSEC_INTEG_ALG_SHA_256_128;
1849               break;
1850             case IKEV2_TRANSFORM_INTEG_TYPE_AUTH_HMAC_SHA2_384_192:
1851               integ_type = IPSEC_INTEG_ALG_SHA_384_192;
1852               break;
1853             case IKEV2_TRANSFORM_INTEG_TYPE_AUTH_HMAC_SHA2_512_256:
1854               integ_type = IPSEC_INTEG_ALG_SHA_512_256;
1855               break;
1856             case IKEV2_TRANSFORM_INTEG_TYPE_AUTH_HMAC_SHA1_96:
1857               integ_type = IPSEC_INTEG_ALG_SHA1_96;
1858               break;
1859             default:
1860               ikev2_set_state (sa, IKEV2_STATE_NO_PROPOSAL_CHOSEN);
1861               return 1;
1862             }
1863         }
1864       else
1865         {
1866           ikev2_set_state (sa, IKEV2_STATE_NO_PROPOSAL_CHOSEN);
1867           return 1;
1868         }
1869     }
1870   else
1871     {
1872       integ_type = IPSEC_INTEG_ALG_NONE;
1873     }
1874
1875   a.integ_type = integ_type;
1876   ikev2_calc_child_keys (sa, child);
1877
1878   if (sa->is_initiator)
1879     {
1880       ipsec_mk_key (&a.loc_ikey, child->sk_ai, vec_len (child->sk_ai));
1881       ipsec_mk_key (&a.rem_ikey, child->sk_ar, vec_len (child->sk_ar));
1882       ipsec_mk_key (&a.loc_ckey, child->sk_ei, vec_len (child->sk_ei));
1883       ipsec_mk_key (&a.rem_ckey, child->sk_er, vec_len (child->sk_er));
1884       if (is_aead)
1885         {
1886           a.salt_remote = child->salt_er;
1887           a.salt_local = child->salt_ei;
1888         }
1889       a.dst_port = a.src_port = sa->ipsec_over_udp_port;
1890     }
1891   else
1892     {
1893       ipsec_mk_key (&a.loc_ikey, child->sk_ar, vec_len (child->sk_ar));
1894       ipsec_mk_key (&a.rem_ikey, child->sk_ai, vec_len (child->sk_ai));
1895       ipsec_mk_key (&a.loc_ckey, child->sk_er, vec_len (child->sk_er));
1896       ipsec_mk_key (&a.rem_ckey, child->sk_ei, vec_len (child->sk_ei));
1897       if (is_aead)
1898         {
1899           a.salt_remote = child->salt_ei;
1900           a.salt_local = child->salt_er;
1901         }
1902       a.dst_port = sa->natt ? sa->dst_port : sa->ipsec_over_udp_port;
1903       a.src_port = sa->ipsec_over_udp_port;
1904     }
1905
1906   if (sa->is_initiator && sa->profile_index != ~0)
1907     p = pool_elt_at_index (km->profiles, sa->profile_index);
1908
1909   if (p && p->lifetime)
1910     {
1911       child->time_to_expiration = vlib_time_now (vm) + p->lifetime;
1912       if (p->lifetime_jitter)
1913         {
1914           // This is not much better than rand(3), which Coverity warns
1915           // is unsuitable for security applications; random_u32 is
1916           // however fast. If this perturbance to the expiration time
1917           // needs to use a better RNG then we may need to use something
1918           // like /dev/urandom which has significant overhead.
1919           u32 rnd = (u32) (vlib_time_now (vm) * 1e6);
1920           rnd = random_u32 (&rnd);
1921
1922           child->time_to_expiration += 1 + (rnd % p->lifetime_jitter);
1923         }
1924     }
1925
1926   if (thread_index & 0xffffffc0)
1927     ikev2_elog_error ("error: thread index exceeds max range 0x3f!");
1928
1929   if (child_index & 0xfffff000 || sa_index & 0xfffff000)
1930     ikev2_elog_error ("error: sa/child index exceeds max range 0xfff!");
1931
1932   child->local_sa_id =
1933     a.local_sa_id =
1934     ikev2_mk_local_sa_id (sa_index, child_index, thread_index);
1935
1936   u32 remote_sa_id = ikev2_mk_remote_sa_id (sa_index, child_index,
1937                                             thread_index);
1938
1939   if (is_rekey)
1940     {
1941       /* create a new remote SA ID to keep the old SA for a bit longer
1942        * so the peer has some time to swap their SAs */
1943
1944       /* use most significat bit of child index part in id */
1945       u32 mask = 0x800;
1946       if (sa->current_remote_id_mask)
1947         {
1948           sa->old_remote_id = a.old_remote_sa_id = remote_sa_id | mask;
1949           sa->current_remote_id_mask = 0;
1950         }
1951       else
1952         {
1953           sa->old_remote_id = a.old_remote_sa_id = remote_sa_id;
1954           sa->current_remote_id_mask = mask;
1955           remote_sa_id |= mask;
1956         }
1957       sa->old_id_expiration = 3.0;
1958       sa->old_remote_id_present = 1;
1959     }
1960
1961   child->remote_sa_id = a.remote_sa_id = remote_sa_id;
1962
1963   a.sw_if_index = (sa->is_tun_itf_set ? sa->tun_itf : ~0);
1964   a.ipsec_over_udp_port = sa->ipsec_over_udp_port;
1965
1966   vl_api_rpc_call_main_thread (ikev2_add_tunnel_from_main,
1967                                (u8 *) & a, sizeof (a));
1968   return 0;
1969 }
1970
1971 typedef struct
1972 {
1973   ip46_address_t local_ip;
1974   ip46_address_t remote_ip;
1975   u32 remote_sa_id;
1976   u32 local_sa_id;
1977   u32 sw_if_index;
1978 } ikev2_del_ipsec_tunnel_args_t;
1979
1980 static_always_inline u32
1981 ikev2_flip_alternate_sa_bit (u32 id)
1982 {
1983   u32 mask = 0x800;
1984   if (mask & id)
1985     return id & ~mask;
1986   return id | mask;
1987 }
1988
1989 static void
1990 ikev2_del_tunnel_from_main (ikev2_del_ipsec_tunnel_args_t * a)
1991 {
1992   ikev2_main_t *km = &ikev2_main;
1993   ipip_tunnel_t *ipip = NULL;
1994   u32 sw_if_index;
1995
1996   if (~0 == a->sw_if_index)
1997     {
1998     /* *INDENT-OFF* */
1999     ipip_tunnel_key_t key = {
2000       .src = a->local_ip,
2001       .dst = a->remote_ip,
2002       .transport = IPIP_TRANSPORT_IP4,
2003       .fib_index = 0,
2004     };
2005     /* *INDENT-ON* */
2006
2007       ipip = ipip_tunnel_db_find (&key);
2008
2009       if (ipip)
2010         {
2011           sw_if_index = ipip->sw_if_index;
2012           hash_unset (km->sw_if_indices, ipip->sw_if_index);
2013         }
2014       else
2015         sw_if_index = ~0;
2016     }
2017   else
2018     {
2019       sw_if_index = a->sw_if_index;
2020       vnet_sw_interface_admin_down (vnet_get_main (), sw_if_index);
2021     }
2022
2023   if (~0 != sw_if_index)
2024     ipsec_tun_protect_del (sw_if_index, NULL);
2025
2026   ipsec_sa_unlock_id (a->remote_sa_id);
2027   ipsec_sa_unlock_id (a->local_sa_id);
2028   ipsec_sa_unlock_id (ikev2_flip_alternate_sa_bit (a->remote_sa_id));
2029
2030   if (ipip)
2031     ipip_del_tunnel (ipip->sw_if_index);
2032 }
2033
2034 static int
2035 ikev2_delete_tunnel_interface (vnet_main_t * vnm, ikev2_sa_t * sa,
2036                                ikev2_child_sa_t * child)
2037 {
2038   ikev2_del_ipsec_tunnel_args_t a;
2039
2040   clib_memset (&a, 0, sizeof (a));
2041
2042   if (sa->is_initiator)
2043     {
2044       ip46_address_set_ip4 (&a.local_ip, &sa->iaddr);
2045       ip46_address_set_ip4 (&a.remote_ip, &sa->raddr);
2046     }
2047   else
2048     {
2049       ip46_address_set_ip4 (&a.local_ip, &sa->raddr);
2050       ip46_address_set_ip4 (&a.remote_ip, &sa->iaddr);
2051     }
2052
2053   a.remote_sa_id = child->remote_sa_id;
2054   a.local_sa_id = child->local_sa_id;
2055   a.sw_if_index = (sa->is_tun_itf_set ? sa->tun_itf : ~0);
2056
2057   vl_api_rpc_call_main_thread (ikev2_del_tunnel_from_main, (u8 *) & a,
2058                                sizeof (a));
2059   return 0;
2060 }
2061
2062 static u32
2063 ikev2_generate_message (ikev2_sa_t * sa, ike_header_t * ike, void *user,
2064                         udp_header_t * udp)
2065 {
2066   v8 *integ = 0;
2067   ike_payload_header_t *ph;
2068   u16 plen;
2069   u32 tlen = 0;
2070
2071   ikev2_sa_transform_t *tr_encr, *tr_integ;
2072   tr_encr =
2073     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_ENCR);
2074   tr_integ =
2075     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_INTEG);
2076
2077   ikev2_payload_chain_t *chain = 0;
2078   ikev2_payload_new_chain (chain);
2079
2080   if (ike->exchange == IKEV2_EXCHANGE_SA_INIT)
2081     {
2082       if (sa->r_proposals == 0)
2083         {
2084           ikev2_payload_add_notify (chain,
2085                                     IKEV2_NOTIFY_MSG_NO_PROPOSAL_CHOSEN, 0);
2086           ikev2_set_state (sa, IKEV2_STATE_NOTIFY_AND_DELETE);
2087         }
2088       else if (sa->dh_group == IKEV2_TRANSFORM_DH_TYPE_NONE)
2089         {
2090           u8 *data = vec_new (u8, 2);
2091           ikev2_sa_transform_t *tr_dh;
2092           tr_dh =
2093             ikev2_sa_get_td_for_type (sa->r_proposals,
2094                                       IKEV2_TRANSFORM_TYPE_DH);
2095           ASSERT (tr_dh && tr_dh->dh_type);
2096
2097           data[0] = (tr_dh->dh_type >> 8) & 0xff;
2098           data[1] = (tr_dh->dh_type) & 0xff;
2099
2100           ikev2_payload_add_notify (chain,
2101                                     IKEV2_NOTIFY_MSG_INVALID_KE_PAYLOAD,
2102                                     data);
2103           vec_free (data);
2104           ikev2_set_state (sa, IKEV2_STATE_NOTIFY_AND_DELETE);
2105         }
2106       else if (sa->state == IKEV2_STATE_NOTIFY_AND_DELETE)
2107         {
2108           u8 *data = vec_new (u8, 1);
2109
2110           data[0] = sa->unsupported_cp;
2111           ikev2_payload_add_notify (chain,
2112                                     IKEV2_NOTIFY_MSG_UNSUPPORTED_CRITICAL_PAYLOAD,
2113                                     data);
2114           vec_free (data);
2115         }
2116       else
2117         {
2118           ASSERT (udp);
2119
2120           ike->rspi = clib_host_to_net_u64 (sa->rspi);
2121           ikev2_payload_add_sa (chain, sa->r_proposals);
2122           ikev2_payload_add_ke (chain, sa->dh_group, sa->r_dh_data);
2123           ikev2_payload_add_nonce (chain, sa->r_nonce);
2124
2125           u8 *nat_detection_sha1 =
2126             ikev2_compute_nat_sha1 (clib_host_to_net_u64 (sa->ispi),
2127                                     clib_host_to_net_u64 (sa->rspi),
2128                                     clib_host_to_net_u32 (sa->raddr.as_u32),
2129                                     udp->dst_port);
2130           ikev2_payload_add_notify (chain,
2131                                     IKEV2_NOTIFY_MSG_NAT_DETECTION_SOURCE_IP,
2132                                     nat_detection_sha1);
2133           vec_free (nat_detection_sha1);
2134           nat_detection_sha1 =
2135             ikev2_compute_nat_sha1 (clib_host_to_net_u64 (sa->ispi),
2136                                     clib_host_to_net_u64 (sa->rspi),
2137                                     sa->iaddr.as_u32, udp->src_port);
2138           ikev2_payload_add_notify (chain,
2139                                     IKEV2_NOTIFY_MSG_NAT_DETECTION_DESTINATION_IP,
2140                                     nat_detection_sha1);
2141           vec_free (nat_detection_sha1);
2142         }
2143     }
2144   else if (ike->exchange == IKEV2_EXCHANGE_IKE_AUTH)
2145     {
2146       if (sa->state == IKEV2_STATE_AUTHENTICATED)
2147         {
2148           ikev2_payload_add_id (chain, &sa->r_id, IKEV2_PAYLOAD_IDR);
2149           ikev2_payload_add_id (chain, &sa->i_id, IKEV2_PAYLOAD_IDI);
2150           ikev2_payload_add_auth (chain, &sa->r_auth);
2151           ikev2_payload_add_sa (chain, sa->childs[0].r_proposals);
2152           ikev2_payload_add_ts (chain, sa->childs[0].tsi, IKEV2_PAYLOAD_TSI);
2153           ikev2_payload_add_ts (chain, sa->childs[0].tsr, IKEV2_PAYLOAD_TSR);
2154         }
2155       else if (sa->state == IKEV2_STATE_AUTH_FAILED)
2156         {
2157           ikev2_payload_add_notify (chain,
2158                                     IKEV2_NOTIFY_MSG_AUTHENTICATION_FAILED,
2159                                     0);
2160           ikev2_set_state (sa, IKEV2_STATE_NOTIFY_AND_DELETE);
2161         }
2162       else if (sa->state == IKEV2_STATE_TS_UNACCEPTABLE)
2163         {
2164           ikev2_payload_add_notify (chain, IKEV2_NOTIFY_MSG_TS_UNACCEPTABLE,
2165                                     0);
2166           ikev2_payload_add_id (chain, &sa->r_id, IKEV2_PAYLOAD_IDR);
2167           ikev2_payload_add_auth (chain, &sa->r_auth);
2168         }
2169       else if (sa->state == IKEV2_STATE_NO_PROPOSAL_CHOSEN)
2170         {
2171           ikev2_payload_add_notify (chain,
2172                                     IKEV2_NOTIFY_MSG_NO_PROPOSAL_CHOSEN, 0);
2173           ikev2_payload_add_id (chain, &sa->r_id, IKEV2_PAYLOAD_IDR);
2174           ikev2_payload_add_auth (chain, &sa->r_auth);
2175           ikev2_payload_add_ts (chain, sa->childs[0].tsi, IKEV2_PAYLOAD_TSI);
2176           ikev2_payload_add_ts (chain, sa->childs[0].tsr, IKEV2_PAYLOAD_TSR);
2177         }
2178       else if (sa->state == IKEV2_STATE_NOTIFY_AND_DELETE)
2179         {
2180           u8 *data = vec_new (u8, 1);
2181
2182           data[0] = sa->unsupported_cp;
2183           ikev2_payload_add_notify (chain,
2184                                     IKEV2_NOTIFY_MSG_UNSUPPORTED_CRITICAL_PAYLOAD,
2185                                     data);
2186           vec_free (data);
2187         }
2188       else if (sa->state == IKEV2_STATE_SA_INIT)
2189         {
2190           ikev2_payload_add_id (chain, &sa->i_id, IKEV2_PAYLOAD_IDI);
2191           ikev2_payload_add_id (chain, &sa->r_id, IKEV2_PAYLOAD_IDR);
2192           ikev2_payload_add_auth (chain, &sa->i_auth);
2193           ikev2_payload_add_sa (chain, sa->childs[0].i_proposals);
2194           ikev2_payload_add_ts (chain, sa->childs[0].tsi, IKEV2_PAYLOAD_TSI);
2195           ikev2_payload_add_ts (chain, sa->childs[0].tsr, IKEV2_PAYLOAD_TSR);
2196           ikev2_payload_add_notify (chain, IKEV2_NOTIFY_MSG_INITIAL_CONTACT,
2197                                     0);
2198         }
2199       else
2200         {
2201           ikev2_set_state (sa, IKEV2_STATE_DELETED);
2202           goto done;
2203         }
2204     }
2205   else if (ike->exchange == IKEV2_EXCHANGE_INFORMATIONAL)
2206     {
2207       /* if pending delete */
2208       if (sa->del)
2209         {
2210           if (sa->del[0].protocol_id == IKEV2_PROTOCOL_IKE)
2211             {
2212               if (sa->is_initiator)
2213                 ikev2_payload_add_delete (chain, sa->del);
2214
2215               /* The response to a request that deletes the IKE SA is an empty
2216                  INFORMATIONAL response. */
2217               ikev2_set_state (sa, IKEV2_STATE_NOTIFY_AND_DELETE);
2218             }
2219           /* The response to a request that deletes ESP or AH SAs will contain
2220              delete payloads for the paired SAs going in the other direction. */
2221           else
2222             {
2223               ikev2_payload_add_delete (chain, sa->del);
2224             }
2225           vec_free (sa->del);
2226           sa->del = 0;
2227         }
2228       /* received N(AUTHENTICATION_FAILED) */
2229       else if (sa->state == IKEV2_STATE_AUTH_FAILED)
2230         {
2231           ikev2_set_state (sa, IKEV2_STATE_DELETED);
2232           goto done;
2233         }
2234       /* received unsupported critical payload */
2235       else if (sa->unsupported_cp)
2236         {
2237           u8 *data = vec_new (u8, 1);
2238
2239           data[0] = sa->unsupported_cp;
2240           ikev2_payload_add_notify (chain,
2241                                     IKEV2_NOTIFY_MSG_UNSUPPORTED_CRITICAL_PAYLOAD,
2242                                     data);
2243           vec_free (data);
2244           sa->unsupported_cp = 0;
2245         }
2246       /* else send empty response */
2247     }
2248   else if (ike->exchange == IKEV2_EXCHANGE_CREATE_CHILD_SA)
2249     {
2250       if (sa->is_initiator)
2251         {
2252
2253           ikev2_sa_proposal_t *proposals = (ikev2_sa_proposal_t *) user;
2254           ikev2_notify_t notify;
2255           u8 *data = vec_new (u8, 4);
2256           clib_memset (&notify, 0, sizeof (notify));
2257           notify.protocol_id = IKEV2_PROTOCOL_ESP;
2258           notify.spi = sa->childs[0].i_proposals->spi;
2259           *(u32 *) data = clib_host_to_net_u32 (notify.spi);
2260
2261           ikev2_payload_add_sa (chain, proposals);
2262           ikev2_payload_add_nonce (chain, sa->i_nonce);
2263           ikev2_payload_add_ts (chain, sa->childs[0].tsi, IKEV2_PAYLOAD_TSI);
2264           ikev2_payload_add_ts (chain, sa->childs[0].tsr, IKEV2_PAYLOAD_TSR);
2265           ikev2_payload_add_notify_2 (chain, IKEV2_NOTIFY_MSG_REKEY_SA, data,
2266                                       &notify);
2267
2268           vec_free (data);
2269         }
2270       else
2271         {
2272           if (vec_len (sa->rekey) > 0)
2273             {
2274               ikev2_payload_add_sa (chain, sa->rekey[0].r_proposal);
2275               ikev2_payload_add_nonce (chain, sa->r_nonce);
2276               ikev2_payload_add_ts (chain, sa->rekey[0].tsi,
2277                                     IKEV2_PAYLOAD_TSI);
2278               ikev2_payload_add_ts (chain, sa->rekey[0].tsr,
2279                                     IKEV2_PAYLOAD_TSR);
2280               vec_del1 (sa->rekey, 0);
2281             }
2282           else if (sa->unsupported_cp)
2283             {
2284               u8 *data = vec_new (u8, 1);
2285
2286               data[0] = sa->unsupported_cp;
2287               ikev2_payload_add_notify (chain,
2288                                         IKEV2_NOTIFY_MSG_UNSUPPORTED_CRITICAL_PAYLOAD,
2289                                         data);
2290               vec_free (data);
2291               sa->unsupported_cp = 0;
2292             }
2293           else
2294             {
2295               ikev2_payload_add_notify (chain,
2296                                         IKEV2_NOTIFY_MSG_NO_ADDITIONAL_SAS,
2297                                         0);
2298             }
2299         }
2300     }
2301
2302   /* IKEv2 header */
2303   ike->version = IKE_VERSION_2;
2304   ike->nextpayload = IKEV2_PAYLOAD_SK;
2305   tlen = sizeof (*ike);
2306   if (sa->is_initiator)
2307     {
2308       ike->flags = IKEV2_HDR_FLAG_INITIATOR;
2309       sa->last_init_msg_id = clib_net_to_host_u32 (ike->msgid);
2310     }
2311   else
2312     {
2313       ike->flags = IKEV2_HDR_FLAG_RESPONSE;
2314     }
2315
2316
2317   if (ike->exchange == IKEV2_EXCHANGE_SA_INIT)
2318     {
2319       tlen += vec_len (chain->data);
2320       ike->nextpayload = chain->first_payload_type;
2321       ike->length = clib_host_to_net_u32 (tlen);
2322       clib_memcpy_fast (ike->payload, chain->data, vec_len (chain->data));
2323
2324       /* store whole IKE payload - needed for PSK auth */
2325       vec_free (sa->last_sa_init_res_packet_data);
2326       vec_add (sa->last_sa_init_res_packet_data, ike, tlen);
2327     }
2328   else
2329     {
2330       ikev2_main_per_thread_data_t *ptd = ikev2_get_per_thread_data ();
2331       ikev2_payload_chain_add_padding (chain, tr_encr->block_size);
2332
2333       /* SK payload */
2334       plen = sizeof (*ph);
2335       ph = (ike_payload_header_t *) & ike->payload[0];
2336       ph->nextpayload = chain->first_payload_type;
2337       ph->flags = 0;
2338       int is_aead =
2339         tr_encr->encr_type == IKEV2_TRANSFORM_ENCR_TYPE_AES_GCM_16;
2340       int iv_len = is_aead ? IKEV2_GCM_IV_SIZE : tr_encr->block_size;
2341       plen += vec_len (chain->data) + iv_len;
2342
2343       /* add space for hmac/tag */
2344       if (tr_integ)
2345         plen += tr_integ->key_trunc;
2346       else
2347         plen += IKEV2_GCM_ICV_SIZE;
2348       tlen += plen;
2349
2350       /* payload and total length */
2351       ph->length = clib_host_to_net_u16 (plen);
2352       ike->length = clib_host_to_net_u32 (tlen);
2353
2354       if (is_aead)
2355         {
2356           ikev2_encrypt_aead_data (ptd, sa, tr_encr, chain->data,
2357                                    ph->payload, (u8 *) ike,
2358                                    sizeof (*ike) + sizeof (*ph),
2359                                    ph->payload + plen - sizeof (*ph) -
2360                                    IKEV2_GCM_ICV_SIZE);
2361         }
2362       else
2363         {
2364           ikev2_encrypt_data (ptd, sa, tr_encr, chain->data, ph->payload);
2365           integ =
2366             ikev2_calc_integr (tr_integ,
2367                                sa->is_initiator ? sa->sk_ai : sa->sk_ar,
2368                                (u8 *) ike, tlen - tr_integ->key_trunc);
2369           clib_memcpy_fast (ike->payload + tlen - tr_integ->key_trunc -
2370                             sizeof (*ike), integ, tr_integ->key_trunc);
2371         }
2372
2373       /* store whole IKE payload - needed for retransmit */
2374       vec_free (sa->last_res_packet_data);
2375       vec_add (sa->last_res_packet_data, ike, tlen);
2376     }
2377
2378 done:
2379   ikev2_payload_destroy_chain (chain);
2380   vec_free (integ);
2381   return tlen;
2382 }
2383
2384 static int
2385 ikev2_retransmit_sa_init (ike_header_t * ike,
2386                           ip4_address_t iaddr, ip4_address_t raddr)
2387 {
2388   ikev2_main_t *km = &ikev2_main;
2389   ikev2_sa_t *sa;
2390   u32 thread_index = vlib_get_thread_index ();
2391
2392   /* *INDENT-OFF* */
2393   pool_foreach (sa, km->per_thread_data[thread_index].sas, ({
2394     if (sa->ispi == clib_net_to_host_u64(ike->ispi) &&
2395         sa->iaddr.as_u32 == iaddr.as_u32 &&
2396         sa->raddr.as_u32 == raddr.as_u32)
2397       {
2398         int p = 0;
2399         u32 len = clib_net_to_host_u32(ike->length);
2400         u8 payload = ike->nextpayload;
2401
2402         while (p < len && payload!= IKEV2_PAYLOAD_NONE) {
2403           ike_payload_header_t * ikep = (ike_payload_header_t *) &ike->payload[p];
2404           u32 plen = clib_net_to_host_u16(ikep->length);
2405
2406           if (plen < sizeof(ike_payload_header_t))
2407             return -1;
2408
2409           if (payload == IKEV2_PAYLOAD_NONCE)
2410             {
2411               if (!memcmp(sa->i_nonce, ikep->payload, plen - sizeof(*ikep)))
2412                 {
2413                   /* req is retransmit */
2414                   if (sa->state == IKEV2_STATE_SA_INIT)
2415                     {
2416                       ike_header_t * tmp;
2417                       tmp = (ike_header_t*)sa->last_sa_init_res_packet_data;
2418                       ike->ispi = tmp->ispi;
2419                       ike->rspi = tmp->rspi;
2420                       ike->nextpayload = tmp->nextpayload;
2421                       ike->version = tmp->version;
2422                       ike->exchange = tmp->exchange;
2423                       ike->flags = tmp->flags;
2424                       ike->msgid = tmp->msgid;
2425                       ike->length = tmp->length;
2426                       clib_memcpy_fast(ike->payload, tmp->payload,
2427                              clib_net_to_host_u32(tmp->length) - sizeof(*ike));
2428                       ikev2_elog_uint_peers (IKEV2_LOG_DEBUG,
2429                                              "ispi %lx IKE_SA_INIT retransmit "
2430                                              "from %d.%d.%d.%d to %d.%d.%d.%d",
2431                                              ike->ispi,
2432                                              raddr.as_u32, iaddr.as_u32);
2433                       return 1;
2434                     }
2435                   /* else ignore req */
2436                   else
2437                     {
2438                       ikev2_elog_uint_peers (IKEV2_LOG_DEBUG,
2439                                              "ispi %lx IKE_SA_INIT ignore "
2440                                              "from %d.%d.%d.%d to %d.%d.%d.%d",
2441                                              ike->ispi,
2442                                              raddr.as_u32, iaddr.as_u32);
2443                       return -1;
2444                     }
2445                 }
2446             }
2447           payload = ikep->nextpayload;
2448           p+=plen;
2449         }
2450       }
2451   }));
2452   /* *INDENT-ON* */
2453
2454   /* req is not retransmit */
2455   return 0;
2456 }
2457
2458 static int
2459 ikev2_retransmit_resp (ikev2_sa_t * sa, ike_header_t * ike)
2460 {
2461   u32 msg_id = clib_net_to_host_u32 (ike->msgid);
2462
2463   /* new req */
2464   if (msg_id > sa->last_msg_id)
2465     {
2466       sa->last_msg_id = msg_id;
2467       return 0;
2468     }
2469   /* retransmitted req */
2470   else if (msg_id == sa->last_msg_id)
2471     {
2472       ike_header_t *tmp;
2473       tmp = (ike_header_t *) sa->last_res_packet_data;
2474       ike->ispi = tmp->ispi;
2475       ike->rspi = tmp->rspi;
2476       ike->nextpayload = tmp->nextpayload;
2477       ike->version = tmp->version;
2478       ike->exchange = tmp->exchange;
2479       ike->flags = tmp->flags;
2480       ike->msgid = tmp->msgid;
2481       ike->length = tmp->length;
2482       clib_memcpy_fast (ike->payload, tmp->payload,
2483                         clib_net_to_host_u32 (tmp->length) - sizeof (*ike));
2484       ikev2_elog_uint_peers (IKEV2_LOG_DEBUG, "IKE retransmit msgid %d",
2485                              msg_id, sa->raddr.as_u32, sa->iaddr.as_u32);
2486       return 1;
2487     }
2488   /* old req ignore */
2489   else
2490     {
2491       ikev2_elog_uint_peers (IKEV2_LOG_DEBUG, "IKE req ignore msgid %d",
2492                              msg_id, sa->raddr.as_u32, sa->iaddr.as_u32);
2493     }
2494   return -1;
2495 }
2496
2497 static void
2498 ikev2_init_sa (vlib_main_t * vm, ikev2_sa_t * sa)
2499 {
2500   ikev2_main_t *km = &ikev2_main;
2501   sa->liveness_period_check = vlib_time_now (vm) + km->liveness_period;
2502   sa->profile_index = ~0;
2503 }
2504
2505 static void
2506 ikev2_del_sa_init_from_main (u64 * ispi)
2507 {
2508   ikev2_main_t *km = &ikev2_main;
2509   uword *p = hash_get (km->sa_by_ispi, *ispi);
2510   if (p)
2511     {
2512       ikev2_sa_t *sai = pool_elt_at_index (km->sais, p[0]);
2513       hash_unset (km->sa_by_ispi, sai->ispi);
2514       ikev2_sa_free_all_vec (sai);
2515       pool_put (km->sais, sai);
2516     }
2517 }
2518
2519 static void
2520 ikev2_del_sa_init (u64 ispi)
2521 {
2522   vl_api_rpc_call_main_thread (ikev2_del_sa_init_from_main, (u8 *) & ispi,
2523                                sizeof (ispi));
2524 }
2525
2526 static uword
2527 ikev2_node_fn (vlib_main_t * vm,
2528                vlib_node_runtime_t * node, vlib_frame_t * frame)
2529 {
2530   u32 n_left_from, *from, *to_next;
2531   ikev2_next_t next_index;
2532   ikev2_main_t *km = &ikev2_main;
2533   u32 thread_index = vlib_get_thread_index ();
2534
2535   from = vlib_frame_vector_args (frame);
2536   n_left_from = frame->n_vectors;
2537   next_index = node->cached_next_index;
2538
2539   while (n_left_from > 0)
2540     {
2541       u32 n_left_to_next;
2542
2543       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
2544
2545       while (n_left_from > 0 && n_left_to_next > 0)
2546         {
2547           u32 bi0;
2548           vlib_buffer_t *b0;
2549           u32 next0 = IKEV2_NEXT_ERROR_DROP;
2550           u32 sw_if_index0;
2551           ip4_header_t *ip40;
2552           udp_header_t *udp0;
2553           ike_header_t *ike0;
2554           ikev2_sa_t *sa0 = 0;
2555           ikev2_sa_t sa;        /* temporary store for SA */
2556           int len = 0;
2557           int r, is_req = 0, has_non_esp_marker = 0;
2558
2559           /* speculatively enqueue b0 to the current next frame */
2560           bi0 = from[0];
2561           to_next[0] = bi0;
2562           from += 1;
2563           to_next += 1;
2564           n_left_from -= 1;
2565           n_left_to_next -= 1;
2566
2567           b0 = vlib_get_buffer (vm, bi0);
2568
2569           if (b0->punt_reason == ipsec_punt_reason[IPSEC_PUNT_IP4_SPI_UDP_0])
2570             {
2571               u8 *ptr = vlib_buffer_get_current (b0);
2572               ip40 = (ip4_header_t *) ptr;
2573               ptr += sizeof (*ip40);
2574               udp0 = (udp_header_t *) ptr;
2575               ptr += sizeof (*udp0);
2576               ike0 = (ike_header_t *) ptr;
2577             }
2578           else
2579             {
2580               ike0 = vlib_buffer_get_current (b0);
2581               vlib_buffer_advance (b0, -sizeof (*udp0));
2582               udp0 = vlib_buffer_get_current (b0);
2583               vlib_buffer_advance (b0, -sizeof (*ip40));
2584               ip40 = vlib_buffer_get_current (b0);
2585             }
2586
2587           /* check for non-esp marker */
2588           if (*((u32 *) ike0) == 0)
2589             {
2590               ike0 = (ike_header_t *) ((u8 *) ike0 + sizeof (u32));
2591               has_non_esp_marker = 1;
2592             }
2593
2594           if (ike0->version != IKE_VERSION_2)
2595             {
2596               vlib_node_increment_counter (vm, ikev2_node.index,
2597                                            IKEV2_ERROR_NOT_IKEV2, 1);
2598               goto dispatch0;
2599             }
2600
2601           if (ike0->exchange == IKEV2_EXCHANGE_SA_INIT)
2602             {
2603               sa0 = &sa;
2604               clib_memset (sa0, 0, sizeof (*sa0));
2605
2606               if (ike0->flags & IKEV2_HDR_FLAG_INITIATOR)
2607                 {
2608                   if (ike0->rspi == 0)
2609                     {
2610                       sa0->raddr.as_u32 = ip40->dst_address.as_u32;
2611                       sa0->iaddr.as_u32 = ip40->src_address.as_u32;
2612                       sa0->dst_port = clib_net_to_host_u16 (udp0->src_port);
2613
2614                       r = ikev2_retransmit_sa_init (ike0, sa0->iaddr,
2615                                                     sa0->raddr);
2616                       if (r == 1)
2617                         {
2618                           vlib_node_increment_counter (vm, ikev2_node.index,
2619                                                        IKEV2_ERROR_IKE_SA_INIT_RETRANSMIT,
2620                                                        1);
2621                           len = clib_net_to_host_u32 (ike0->length);
2622                           goto dispatch0;
2623                         }
2624                       else if (r == -1)
2625                         {
2626                           vlib_node_increment_counter (vm, ikev2_node.index,
2627                                                        IKEV2_ERROR_IKE_SA_INIT_IGNORE,
2628                                                        1);
2629                           goto dispatch0;
2630                         }
2631
2632                       ikev2_process_sa_init_req (vm, sa0, ike0, udp0);
2633
2634                       if (sa0->state == IKEV2_STATE_SA_INIT)
2635                         {
2636                           ikev2_sa_free_proposal_vector (&sa0->r_proposals);
2637                           sa0->r_proposals =
2638                             ikev2_select_proposal (sa0->i_proposals,
2639                                                    IKEV2_PROTOCOL_IKE);
2640                           ikev2_generate_sa_init_data (sa0);
2641                         }
2642
2643                       if (sa0->state == IKEV2_STATE_SA_INIT
2644                           || sa0->state == IKEV2_STATE_NOTIFY_AND_DELETE)
2645                         {
2646                           len = ikev2_generate_message (sa0, ike0, 0, udp0);
2647                         }
2648
2649                       if (sa0->state == IKEV2_STATE_SA_INIT)
2650                         {
2651                           /* add SA to the pool */
2652                           pool_get (km->per_thread_data[thread_index].sas,
2653                                     sa0);
2654                           clib_memcpy_fast (sa0, &sa, sizeof (*sa0));
2655                           ikev2_init_sa (vm, sa0);
2656                           hash_set (km->
2657                                     per_thread_data[thread_index].sa_by_rspi,
2658                                     sa0->rspi,
2659                                     sa0 -
2660                                     km->per_thread_data[thread_index].sas);
2661                         }
2662                       else
2663                         {
2664                           ikev2_sa_free_all_vec (sa0);
2665                         }
2666                     }
2667                 }
2668               else              //received sa_init without initiator flag
2669                 {
2670                   sa0->raddr.as_u32 = ip40->src_address.as_u32;
2671                   sa0->iaddr.as_u32 = ip40->dst_address.as_u32;
2672                   ikev2_process_sa_init_resp (vm, sa0, ike0, udp0);
2673
2674                   if (sa0->state == IKEV2_STATE_SA_INIT)
2675                     {
2676                       is_req = 1;
2677                       ike0->exchange = IKEV2_EXCHANGE_IKE_AUTH;
2678                       uword *p = hash_get (km->sa_by_ispi, ike0->ispi);
2679                       if (p)
2680                         {
2681                           ikev2_sa_t *sai =
2682                             pool_elt_at_index (km->sais, p[0]);
2683
2684                           if (clib_atomic_bool_cmp_and_swap
2685                               (&sai->init_response_received, 0, 1))
2686                             {
2687                               ikev2_complete_sa_data (sa0, sai);
2688                               ikev2_calc_keys (sa0);
2689                               ikev2_sa_auth_init (sa0);
2690                               len =
2691                                 ikev2_generate_message (sa0, ike0, 0, udp0);
2692                             }
2693                           else
2694                             {
2695                               /* we've already processed sa-init response */
2696                               sa0->state = IKEV2_STATE_UNKNOWN;
2697                             }
2698                         }
2699                     }
2700
2701                   if (sa0->state == IKEV2_STATE_SA_INIT)
2702                     {
2703                       /* add SA to the pool */
2704                       pool_get (km->per_thread_data[thread_index].sas, sa0);
2705                       clib_memcpy_fast (sa0, &sa, sizeof (*sa0));
2706                       hash_set (km->per_thread_data[thread_index].sa_by_rspi,
2707                                 sa0->rspi,
2708                                 sa0 - km->per_thread_data[thread_index].sas);
2709                     }
2710                   else
2711                     {
2712                       ikev2_sa_free_all_vec (sa0);
2713                     }
2714                 }
2715             }
2716           else if (ike0->exchange == IKEV2_EXCHANGE_IKE_AUTH)
2717             {
2718               uword *p;
2719               p = hash_get (km->per_thread_data[thread_index].sa_by_rspi,
2720                             clib_net_to_host_u64 (ike0->rspi));
2721               if (p)
2722                 {
2723                   sa0 =
2724                     pool_elt_at_index (km->per_thread_data[thread_index].sas,
2725                                        p[0]);
2726
2727                   r = ikev2_retransmit_resp (sa0, ike0);
2728                   if (r == 1)
2729                     {
2730                       vlib_node_increment_counter (vm, ikev2_node.index,
2731                                                    IKEV2_ERROR_IKE_REQ_RETRANSMIT,
2732                                                    1);
2733                       len = clib_net_to_host_u32 (ike0->length);
2734                       goto dispatch0;
2735                     }
2736                   else if (r == -1)
2737                     {
2738                       vlib_node_increment_counter (vm, ikev2_node.index,
2739                                                    IKEV2_ERROR_IKE_REQ_IGNORE,
2740                                                    1);
2741                       goto dispatch0;
2742                     }
2743
2744                   sa0->dst_port = clib_net_to_host_u16 (udp0->src_port);
2745                   ikev2_process_auth_req (vm, sa0, ike0);
2746                   ikev2_sa_auth (sa0);
2747                   if (sa0->state == IKEV2_STATE_AUTHENTICATED)
2748                     {
2749                       ikev2_initial_contact_cleanup (sa0);
2750                       ikev2_sa_match_ts (sa0);
2751                       if (sa0->state != IKEV2_STATE_TS_UNACCEPTABLE)
2752                         ikev2_create_tunnel_interface (vm, thread_index, sa0,
2753                                                        &sa0->childs[0],
2754                                                        p[0], 0, 0);
2755                     }
2756
2757                   if (sa0->is_initiator)
2758                     {
2759                       ikev2_del_sa_init (ike0->ispi);
2760                     }
2761                   else
2762                     {
2763                       len = ikev2_generate_message (sa0, ike0, 0, udp0);
2764                     }
2765                 }
2766             }
2767           else if (ike0->exchange == IKEV2_EXCHANGE_INFORMATIONAL)
2768             {
2769               uword *p;
2770               p = hash_get (km->per_thread_data[thread_index].sa_by_rspi,
2771                             clib_net_to_host_u64 (ike0->rspi));
2772               if (p)
2773                 {
2774                   sa0 =
2775                     pool_elt_at_index (km->per_thread_data[thread_index].sas,
2776                                        p[0]);
2777
2778                   r = ikev2_retransmit_resp (sa0, ike0);
2779                   if (r == 1)
2780                     {
2781                       vlib_node_increment_counter (vm, ikev2_node.index,
2782                                                    IKEV2_ERROR_IKE_REQ_RETRANSMIT,
2783                                                    1);
2784                       len = clib_net_to_host_u32 (ike0->length);
2785                       goto dispatch0;
2786                     }
2787                   else if (r == -1)
2788                     {
2789                       vlib_node_increment_counter (vm, ikev2_node.index,
2790                                                    IKEV2_ERROR_IKE_REQ_IGNORE,
2791                                                    1);
2792                       goto dispatch0;
2793                     }
2794
2795                   ikev2_process_informational_req (vm, sa0, ike0);
2796                   if (sa0->del)
2797                     {
2798                       if (sa0->del[0].protocol_id != IKEV2_PROTOCOL_IKE)
2799                         {
2800                           ikev2_delete_t *d, *tmp, *resp = 0;
2801                           vec_foreach (d, sa0->del)
2802                           {
2803                             ikev2_child_sa_t *ch_sa;
2804                             ch_sa = ikev2_sa_get_child (sa0, d->spi,
2805                                                         d->protocol_id,
2806                                                         !sa0->is_initiator);
2807                             if (ch_sa)
2808                               {
2809                                 ikev2_delete_tunnel_interface (km->vnet_main,
2810                                                                sa0, ch_sa);
2811                                 if (!sa0->is_initiator)
2812                                   {
2813                                     vec_add2 (resp, tmp, 1);
2814                                     tmp->protocol_id = d->protocol_id;
2815                                     tmp->spi = ch_sa->r_proposals[0].spi;
2816                                   }
2817                                 ikev2_sa_del_child_sa (sa0, ch_sa);
2818                               }
2819                           }
2820                           if (!sa0->is_initiator)
2821                             {
2822                               vec_free (sa0->del);
2823                               sa0->del = resp;
2824                             }
2825                         }
2826                     }
2827                   if (!(ike0->flags & IKEV2_HDR_FLAG_RESPONSE))
2828                     {
2829                       ike0->flags |= IKEV2_HDR_FLAG_RESPONSE;
2830                       len = ikev2_generate_message (sa0, ike0, 0, udp0);
2831                     }
2832                 }
2833             }
2834           else if (ike0->exchange == IKEV2_EXCHANGE_CREATE_CHILD_SA)
2835             {
2836               uword *p;
2837               p = hash_get (km->per_thread_data[thread_index].sa_by_rspi,
2838                             clib_net_to_host_u64 (ike0->rspi));
2839               if (p)
2840                 {
2841                   sa0 =
2842                     pool_elt_at_index (km->per_thread_data[thread_index].sas,
2843                                        p[0]);
2844
2845                   r = ikev2_retransmit_resp (sa0, ike0);
2846                   if (r == 1)
2847                     {
2848                       vlib_node_increment_counter (vm, ikev2_node.index,
2849                                                    IKEV2_ERROR_IKE_REQ_RETRANSMIT,
2850                                                    1);
2851                       len = clib_net_to_host_u32 (ike0->length);
2852                       goto dispatch0;
2853                     }
2854                   else if (r == -1)
2855                     {
2856                       vlib_node_increment_counter (vm, ikev2_node.index,
2857                                                    IKEV2_ERROR_IKE_REQ_IGNORE,
2858                                                    1);
2859                       goto dispatch0;
2860                     }
2861
2862                   ikev2_process_create_child_sa_req (vm, sa0, ike0);
2863                   if (sa0->rekey)
2864                     {
2865                       if (sa0->rekey[0].protocol_id != IKEV2_PROTOCOL_IKE)
2866                         {
2867                           if (sa0->childs)
2868                             ikev2_sa_free_all_child_sa (&sa0->childs);
2869                           ikev2_child_sa_t *child;
2870                           vec_add2 (sa0->childs, child, 1);
2871                           clib_memset (child, 0, sizeof (*child));
2872                           child->r_proposals = sa0->rekey[0].r_proposal;
2873                           child->i_proposals = sa0->rekey[0].i_proposal;
2874                           child->tsi = sa0->rekey[0].tsi;
2875                           child->tsr = sa0->rekey[0].tsr;
2876                           ikev2_create_tunnel_interface (vm, thread_index,
2877                                                          sa0, child, p[0],
2878                                                          child - sa0->childs,
2879                                                          1);
2880                         }
2881                       if (sa0->is_initiator)
2882                         {
2883                           vec_free (sa0->rekey);
2884                         }
2885                       else
2886                         {
2887                           len = ikev2_generate_message (sa0, ike0, 0, udp0);
2888                         }
2889                     }
2890                 }
2891             }
2892           else
2893             {
2894               ikev2_elog_uint_peers (IKEV2_LOG_WARNING, "IKEv2 exchange %d "
2895                                      "received from %d.%d.%d.%d to %d.%d.%d.%d",
2896                                      ike0->exchange,
2897                                      ip40->src_address.as_u32,
2898                                      ip40->dst_address.as_u32);
2899             }
2900
2901         dispatch0:
2902           /* if we are sending packet back, rewrite headers */
2903           if (len)
2904             {
2905               next0 = IKEV2_NEXT_IP4_LOOKUP;
2906               if (sa0->is_initiator)
2907                 {
2908                   ip40->dst_address.as_u32 = sa0->raddr.as_u32;
2909                   ip40->src_address.as_u32 = sa0->iaddr.as_u32;
2910                 }
2911               else
2912                 {
2913                   ip40->dst_address.as_u32 = sa0->iaddr.as_u32;
2914                   ip40->src_address.as_u32 = sa0->raddr.as_u32;
2915                 }
2916
2917               if (is_req)
2918                 {
2919                   udp0->dst_port = udp0->src_port =
2920                     clib_net_to_host_u16 (ikev2_get_port (sa0));
2921
2922                   if (udp0->dst_port == clib_net_to_host_u16 (IKEV2_PORT_NATT)
2923                       && sa0->natt)
2924                     {
2925                       if (!has_non_esp_marker)
2926                         len = ikev2_insert_non_esp_marker (ike0, len);
2927                     }
2928                 }
2929               else
2930                 {
2931                   if (has_non_esp_marker)
2932                     len += sizeof (ikev2_non_esp_marker);
2933
2934                   u16 tp = udp0->dst_port;
2935                   udp0->dst_port = udp0->src_port;
2936                   udp0->src_port = tp;
2937                 }
2938
2939               udp0->length =
2940                 clib_host_to_net_u16 (len + sizeof (udp_header_t));
2941               udp0->checksum = 0;
2942               b0->current_length =
2943                 len + sizeof (ip4_header_t) + sizeof (udp_header_t);
2944               ip40->length = clib_host_to_net_u16 (b0->current_length);
2945               ip40->checksum = ip4_header_checksum (ip40);
2946             }
2947           /* delete sa */
2948           if (sa0 && (sa0->state == IKEV2_STATE_DELETED ||
2949                       sa0->state == IKEV2_STATE_NOTIFY_AND_DELETE))
2950             {
2951               ikev2_child_sa_t *c;
2952
2953               vec_foreach (c, sa0->childs)
2954                 ikev2_delete_tunnel_interface (km->vnet_main, sa0, c);
2955
2956               ikev2_delete_sa (sa0);
2957             }
2958           sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
2959
2960           if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)
2961                              && (b0->flags & VLIB_BUFFER_IS_TRACED)))
2962             {
2963               ikev2_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t));
2964               t->sw_if_index = sw_if_index0;
2965               t->next_index = next0;
2966             }
2967
2968           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
2969                                            n_left_to_next, bi0, next0);
2970         }
2971
2972       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2973     }
2974
2975   vlib_node_increment_counter (vm, ikev2_node.index,
2976                                IKEV2_ERROR_PROCESSED, frame->n_vectors);
2977   return frame->n_vectors;
2978 }
2979
2980 /* *INDENT-OFF* */
2981 VLIB_REGISTER_NODE (ikev2_node,static) = {
2982   .function = ikev2_node_fn,
2983   .name = "ikev2",
2984   .vector_size = sizeof (u32),
2985   .format_trace = format_ikev2_trace,
2986   .type = VLIB_NODE_TYPE_INTERNAL,
2987
2988   .n_errors = ARRAY_LEN(ikev2_error_strings),
2989   .error_strings = ikev2_error_strings,
2990
2991   .n_next_nodes = IKEV2_N_NEXT,
2992
2993   .next_nodes = {
2994     [IKEV2_NEXT_IP4_LOOKUP] = "ip4-lookup",
2995         [IKEV2_NEXT_ERROR_DROP] = "error-drop",
2996   },
2997 };
2998 /* *INDENT-ON* */
2999
3000 // set ikev2 proposals when vpp is used as initiator
3001 static clib_error_t *
3002 ikev2_set_initiator_proposals (vlib_main_t * vm, ikev2_sa_t * sa,
3003                                ikev2_transforms_set * ts,
3004                                ikev2_sa_proposal_t ** proposals, int is_ike)
3005 {
3006   clib_error_t *r;
3007   ikev2_main_t *km = &ikev2_main;
3008   ikev2_sa_proposal_t *proposal;
3009   vec_add2 (*proposals, proposal, 1);
3010   ikev2_sa_transform_t *td;
3011   int error;
3012
3013   /* Encryption */
3014   error = 1;
3015   vec_foreach (td, km->supported_transforms)
3016   {
3017     if (td->type == IKEV2_TRANSFORM_TYPE_ENCR
3018         && td->encr_type == ts->crypto_alg
3019         && td->key_len == ts->crypto_key_size / 8)
3020       {
3021         u16 attr[2];
3022         attr[0] = clib_host_to_net_u16 (14 | (1 << 15));
3023         attr[1] = clib_host_to_net_u16 (td->key_len << 3);
3024         vec_add (td->attrs, (u8 *) attr, 4);
3025         vec_add1 (proposal->transforms, *td);
3026         td->attrs = 0;
3027
3028         error = 0;
3029         break;
3030       }
3031   }
3032   if (error)
3033     {
3034       r = clib_error_return (0, "Unsupported algorithm");
3035       return r;
3036     }
3037
3038   if (IKEV2_TRANSFORM_INTEG_TYPE_NONE != ts->integ_alg)
3039     {
3040       /* Integrity */
3041       error = 1;
3042       vec_foreach (td, km->supported_transforms)
3043       {
3044         if (td->type == IKEV2_TRANSFORM_TYPE_INTEG
3045             && td->integ_type == ts->integ_alg)
3046           {
3047             vec_add1 (proposal->transforms, *td);
3048             error = 0;
3049             break;
3050           }
3051       }
3052       if (error)
3053         {
3054           ikev2_elog_error
3055             ("Didn't find any supported algorithm for IKEV2_TRANSFORM_TYPE_INTEG");
3056           r = clib_error_return (0, "Unsupported algorithm");
3057           return r;
3058         }
3059     }
3060
3061   /* PRF */
3062   if (is_ike)
3063     {
3064       error = 1;
3065       vec_foreach (td, km->supported_transforms)
3066       {
3067         if (td->type == IKEV2_TRANSFORM_TYPE_PRF
3068             && td->prf_type == IKEV2_TRANSFORM_PRF_TYPE_PRF_HMAC_SHA2_256)
3069           {
3070             vec_add1 (proposal->transforms, *td);
3071             error = 0;
3072             break;
3073           }
3074       }
3075       if (error)
3076         {
3077           r = clib_error_return (0, "Unsupported algorithm");
3078           return r;
3079         }
3080     }
3081
3082   /* DH */
3083   if (is_ike)
3084     {
3085       error = 1;
3086       vec_foreach (td, km->supported_transforms)
3087       {
3088         if (td->type == IKEV2_TRANSFORM_TYPE_DH && td->dh_type == ts->dh_type)
3089           {
3090             vec_add1 (proposal->transforms, *td);
3091             if (is_ike)
3092               {
3093                 sa->dh_group = td->dh_type;
3094               }
3095             error = 0;
3096             break;
3097           }
3098       }
3099       if (error)
3100         {
3101           r = clib_error_return (0, "Unsupported algorithm");
3102           return r;
3103         }
3104     }
3105
3106   if (!is_ike)
3107     {
3108       error = 1;
3109       vec_foreach (td, km->supported_transforms)
3110       {
3111         if (td->type == IKEV2_TRANSFORM_TYPE_ESN)
3112           {
3113             vec_add1 (proposal->transforms, *td);
3114             error = 0;
3115           }
3116       }
3117       if (error)
3118         {
3119           r = clib_error_return (0, "Unsupported algorithm");
3120           return r;
3121         }
3122     }
3123
3124
3125   return 0;
3126 }
3127
3128 static ikev2_profile_t *
3129 ikev2_profile_index_by_name (u8 * name)
3130 {
3131   ikev2_main_t *km = &ikev2_main;
3132   uword *p;
3133
3134   p = mhash_get (&km->profile_index_by_name, name);
3135   if (!p)
3136     return 0;
3137
3138   return pool_elt_at_index (km->profiles, p[0]);
3139 }
3140
3141
3142 static void
3143 ikev2_send_ike (vlib_main_t * vm, ip4_address_t * src, ip4_address_t * dst,
3144                 u32 bi0, u32 len, u16 src_port, u16 dst_port, u32 sw_if_index)
3145 {
3146   ip4_header_t *ip40;
3147   udp_header_t *udp0;
3148   vlib_buffer_t *b0;
3149   vlib_frame_t *f;
3150   u32 *to_next;
3151
3152   b0 = vlib_get_buffer (vm, bi0);
3153   vlib_buffer_advance (b0, -sizeof (udp_header_t));
3154   udp0 = vlib_buffer_get_current (b0);
3155   vlib_buffer_advance (b0, -sizeof (ip4_header_t));
3156   ip40 = vlib_buffer_get_current (b0);
3157
3158
3159   ip40->ip_version_and_header_length = 0x45;
3160   ip40->tos = 0;
3161   ip40->fragment_id = 0;
3162   ip40->flags_and_fragment_offset = 0;
3163   ip40->ttl = 0xff;
3164   ip40->protocol = IP_PROTOCOL_UDP;
3165   ip40->dst_address.as_u32 = dst->as_u32;
3166   ip40->src_address.as_u32 = src->as_u32;
3167   udp0->dst_port = clib_host_to_net_u16 (dst_port);
3168   udp0->src_port = clib_host_to_net_u16 (src_port);
3169   udp0->length = clib_host_to_net_u16 (len + sizeof (udp_header_t));
3170   udp0->checksum = 0;
3171   b0->current_length = len + sizeof (ip4_header_t) + sizeof (udp_header_t);
3172   ip40->length = clib_host_to_net_u16 (b0->current_length);
3173   ip40->checksum = ip4_header_checksum (ip40);
3174
3175   vnet_buffer (b0)->sw_if_index[VLIB_RX] = sw_if_index;
3176   vnet_buffer (b0)->sw_if_index[VLIB_TX] = ~0;
3177
3178   /* send the request */
3179   f = vlib_get_frame_to_node (vm, ip4_lookup_node.index);
3180   to_next = vlib_frame_vector_args (f);
3181   to_next[0] = bi0;
3182   f->n_vectors = 1;
3183   vlib_put_frame_to_node (vm, ip4_lookup_node.index, f);
3184
3185 }
3186
3187 static u32
3188 ikev2_get_new_ike_header_buff (vlib_main_t * vm, ike_header_t ** ike)
3189 {
3190   u32 bi0;
3191   if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
3192     {
3193       *ike = 0;
3194       return 0;
3195     }
3196   vlib_buffer_t *b0 = vlib_get_buffer (vm, bi0);
3197   *ike = vlib_buffer_get_current (b0);
3198   return bi0;
3199 }
3200
3201 clib_error_t *
3202 ikev2_set_local_key (vlib_main_t * vm, u8 * file)
3203 {
3204   ikev2_main_t *km = &ikev2_main;
3205
3206   km->pkey = ikev2_load_key_file (file);
3207   if (km->pkey == NULL)
3208     return clib_error_return (0, "load key '%s' failed", file);
3209
3210   return 0;
3211 }
3212
3213 static_always_inline vnet_api_error_t
3214 ikev2_register_udp_port (ikev2_profile_t * p, u16 port)
3215 {
3216   ikev2_main_t *km = &ikev2_main;
3217   udp_dst_port_info_t *pi;
3218
3219   uword *v = hash_get (km->udp_ports, port);
3220   pi = udp_get_dst_port_info (&udp_main, port, UDP_IP4);
3221
3222   if (v)
3223     {
3224       /* IKE already uses this port, only increment reference counter */
3225       ASSERT (pi);
3226       v[0]++;
3227     }
3228   else
3229     {
3230       if (pi)
3231         return VNET_API_ERROR_UDP_PORT_TAKEN;
3232
3233       udp_register_dst_port (km->vlib_main, port,
3234                              ipsec4_tun_input_node.index, 1);
3235       hash_set (km->udp_ports, port, 1);
3236     }
3237   p->ipsec_over_udp_port = port;
3238   return 0;
3239 }
3240
3241 static_always_inline void
3242 ikev2_unregister_udp_port (ikev2_profile_t * p)
3243 {
3244   ikev2_main_t *km = &ikev2_main;
3245   uword *v;
3246
3247   if (p->ipsec_over_udp_port == IPSEC_UDP_PORT_NONE)
3248     return;
3249
3250   v = hash_get (km->udp_ports, p->ipsec_over_udp_port);
3251   if (!v)
3252     return;
3253
3254   v[0]--;
3255
3256   if (v[0] == 0)
3257     {
3258       udp_unregister_dst_port (km->vlib_main, p->ipsec_over_udp_port, 1);
3259       hash_unset (km->udp_ports, p->ipsec_over_udp_port);
3260     }
3261
3262   p->ipsec_over_udp_port = IPSEC_UDP_PORT_NONE;
3263 }
3264
3265 static void
3266 ikev2_initiate_delete_ike_sa_internal (vlib_main_t * vm,
3267                                        ikev2_main_per_thread_data_t * tkm,
3268                                        ikev2_sa_t * sa)
3269 {
3270   ikev2_main_t *km = &ikev2_main;
3271   ip4_address_t *src, *dst;
3272
3273   /* Create the Initiator notification for IKE SA removal */
3274   ike_header_t *ike0;
3275   u32 bi0 = 0;
3276   int len;
3277
3278   bi0 = ikev2_get_new_ike_header_buff (vm, &ike0);
3279   if (!bi0)
3280     {
3281       ikev2_log_error ("buffer alloc failure");
3282       return;
3283     }
3284
3285   ike0->exchange = IKEV2_EXCHANGE_INFORMATIONAL;
3286   ike0->ispi = clib_host_to_net_u64 (sa->ispi);
3287   ike0->rspi = clib_host_to_net_u64 (sa->rspi);
3288   vec_resize (sa->del, 1);
3289   sa->del->protocol_id = IKEV2_PROTOCOL_IKE;
3290   sa->del->spi = sa->ispi;
3291   ike0->msgid = clib_host_to_net_u32 (sa->last_init_msg_id + 1);
3292   sa->last_init_msg_id = clib_net_to_host_u32 (ike0->msgid);
3293   len = ikev2_generate_message (sa, ike0, 0, 0);
3294
3295   if (sa->is_initiator)
3296     {
3297       src = &sa->iaddr;
3298       dst = &sa->raddr;
3299     }
3300   else
3301     {
3302       dst = &sa->iaddr;
3303       src = &sa->raddr;
3304     }
3305
3306   ikev2_send_ike (vm, src, dst, bi0, len,
3307                   ikev2_get_port (sa), sa->dst_port, 0);
3308
3309   /* delete local SA */
3310   ikev2_child_sa_t *c;
3311   vec_foreach (c, sa->childs)
3312     ikev2_delete_tunnel_interface (km->vnet_main, sa, c);
3313
3314   u64 rspi = sa->rspi;
3315   ikev2_sa_free_all_vec (sa);
3316   uword *p = hash_get (tkm->sa_by_rspi, rspi);
3317   if (p)
3318     {
3319       hash_unset (tkm->sa_by_rspi, rspi);
3320       pool_put (tkm->sas, sa);
3321     }
3322 }
3323
3324 static void
3325 ikev2_cleanup_profile_sessions (ikev2_main_t * km, ikev2_profile_t * p)
3326 {
3327   ikev2_main_per_thread_data_t *tkm;
3328   ikev2_sa_t *sa;
3329   u32 pi = p - km->profiles;
3330   u32 *sai;
3331   u32 *del_sai = 0;
3332
3333   vec_foreach (tkm, km->per_thread_data)
3334   {
3335     /* *INDENT-OFF* */
3336     pool_foreach (sa, tkm->sas, ({
3337       if (sa->profile_index != ~0 && pi == sa->profile_index)
3338         vec_add1 (del_sai, sa - tkm->sas);
3339     }));
3340     /* *INDENT-ON* */
3341
3342     vec_foreach (sai, del_sai)
3343     {
3344       sa = pool_elt_at_index (tkm->sas, sai[0]);
3345       ikev2_initiate_delete_ike_sa_internal (km->vlib_main, tkm, sa);
3346     }
3347
3348     vec_reset_length (del_sai);
3349   }
3350
3351   vec_free (del_sai);
3352 }
3353
3354 clib_error_t *
3355 ikev2_add_del_profile (vlib_main_t * vm, u8 * name, int is_add)
3356 {
3357   ikev2_main_t *km = &ikev2_main;
3358   ikev2_profile_t *p;
3359
3360   if (is_add)
3361     {
3362       if (ikev2_profile_index_by_name (name))
3363         return clib_error_return (0, "policy %v already exists", name);
3364
3365       pool_get (km->profiles, p);
3366       clib_memset (p, 0, sizeof (*p));
3367       p->name = vec_dup (name);
3368       p->ipsec_over_udp_port = IPSEC_UDP_PORT_NONE;
3369       p->responder.sw_if_index = ~0;
3370       p->tun_itf = ~0;
3371       uword index = p - km->profiles;
3372       mhash_set_mem (&km->profile_index_by_name, name, &index, 0);
3373     }
3374   else
3375     {
3376       p = ikev2_profile_index_by_name (name);
3377       if (!p)
3378         return clib_error_return (0, "policy %v does not exists", name);
3379
3380       ikev2_unregister_udp_port (p);
3381       ikev2_cleanup_profile_sessions (km, p);
3382
3383       vec_free (p->name);
3384       pool_put (km->profiles, p);
3385       mhash_unset (&km->profile_index_by_name, name, 0);
3386     }
3387   return 0;
3388 }
3389
3390 clib_error_t *
3391 ikev2_set_profile_auth (vlib_main_t * vm, u8 * name, u8 auth_method,
3392                         u8 * auth_data, u8 data_hex_format)
3393 {
3394   ikev2_profile_t *p;
3395   clib_error_t *r;
3396
3397   p = ikev2_profile_index_by_name (name);
3398
3399   if (!p)
3400     {
3401       r = clib_error_return (0, "unknown profile %v", name);
3402       return r;
3403     }
3404   vec_free (p->auth.data);
3405   p->auth.method = auth_method;
3406   p->auth.data = vec_dup (auth_data);
3407   p->auth.hex = data_hex_format;
3408
3409   if (auth_method == IKEV2_AUTH_METHOD_RSA_SIG)
3410     {
3411       vec_add1 (p->auth.data, 0);
3412       if (p->auth.key)
3413         EVP_PKEY_free (p->auth.key);
3414       p->auth.key = ikev2_load_cert_file (p->auth.data);
3415       if (p->auth.key == NULL)
3416         return clib_error_return (0, "load cert '%s' failed", p->auth.data);
3417     }
3418
3419   return 0;
3420 }
3421
3422 clib_error_t *
3423 ikev2_set_profile_id (vlib_main_t * vm, u8 * name, u8 id_type, u8 * data,
3424                       int is_local)
3425 {
3426   ikev2_profile_t *p;
3427   clib_error_t *r;
3428
3429   if (id_type > IKEV2_ID_TYPE_ID_RFC822_ADDR
3430       && id_type < IKEV2_ID_TYPE_ID_KEY_ID)
3431     {
3432       r = clib_error_return (0, "unsupported identity type %U",
3433                              format_ikev2_id_type, id_type);
3434       return r;
3435     }
3436
3437   p = ikev2_profile_index_by_name (name);
3438
3439   if (!p)
3440     {
3441       r = clib_error_return (0, "unknown profile %v", name);
3442       return r;
3443     }
3444
3445   if (is_local)
3446     {
3447       vec_free (p->loc_id.data);
3448       p->loc_id.type = id_type;
3449       p->loc_id.data = vec_dup (data);
3450     }
3451   else
3452     {
3453       vec_free (p->rem_id.data);
3454       p->rem_id.type = id_type;
3455       p->rem_id.data = vec_dup (data);
3456     }
3457
3458   return 0;
3459 }
3460
3461 clib_error_t *
3462 ikev2_set_profile_ts (vlib_main_t * vm, u8 * name, u8 protocol_id,
3463                       u16 start_port, u16 end_port, ip4_address_t start_addr,
3464                       ip4_address_t end_addr, int is_local)
3465 {
3466   ikev2_profile_t *p;
3467   clib_error_t *r;
3468
3469   p = ikev2_profile_index_by_name (name);
3470
3471   if (!p)
3472     {
3473       r = clib_error_return (0, "unknown profile %v", name);
3474       return r;
3475     }
3476
3477   if (is_local)
3478     {
3479       p->loc_ts.start_addr.as_u32 = start_addr.as_u32;
3480       p->loc_ts.end_addr.as_u32 = end_addr.as_u32;
3481       p->loc_ts.start_port = start_port;
3482       p->loc_ts.end_port = end_port;
3483       p->loc_ts.protocol_id = protocol_id;
3484       p->loc_ts.ts_type = 7;
3485     }
3486   else
3487     {
3488       p->rem_ts.start_addr.as_u32 = start_addr.as_u32;
3489       p->rem_ts.end_addr.as_u32 = end_addr.as_u32;
3490       p->rem_ts.start_port = start_port;
3491       p->rem_ts.end_port = end_port;
3492       p->rem_ts.protocol_id = protocol_id;
3493       p->rem_ts.ts_type = 7;
3494     }
3495
3496   return 0;
3497 }
3498
3499
3500 clib_error_t *
3501 ikev2_set_profile_responder (vlib_main_t * vm, u8 * name,
3502                              u32 sw_if_index, ip4_address_t ip4)
3503 {
3504   ikev2_profile_t *p;
3505   clib_error_t *r;
3506
3507   p = ikev2_profile_index_by_name (name);
3508
3509   if (!p)
3510     {
3511       r = clib_error_return (0, "unknown profile %v", name);
3512       return r;
3513     }
3514
3515   p->responder.sw_if_index = sw_if_index;
3516   p->responder.ip4 = ip4;
3517
3518   return 0;
3519 }
3520
3521 clib_error_t *
3522 ikev2_set_profile_ike_transforms (vlib_main_t * vm, u8 * name,
3523                                   ikev2_transform_encr_type_t crypto_alg,
3524                                   ikev2_transform_integ_type_t integ_alg,
3525                                   ikev2_transform_dh_type_t dh_type,
3526                                   u32 crypto_key_size)
3527 {
3528   ikev2_profile_t *p;
3529   clib_error_t *r;
3530
3531   p = ikev2_profile_index_by_name (name);
3532
3533   if (!p)
3534     {
3535       r = clib_error_return (0, "unknown profile %v", name);
3536       return r;
3537     }
3538
3539   p->ike_ts.crypto_alg = crypto_alg;
3540   p->ike_ts.integ_alg = integ_alg;
3541   p->ike_ts.dh_type = dh_type;
3542   p->ike_ts.crypto_key_size = crypto_key_size;
3543   return 0;
3544 }
3545
3546 clib_error_t *
3547 ikev2_set_profile_esp_transforms (vlib_main_t * vm, u8 * name,
3548                                   ikev2_transform_encr_type_t crypto_alg,
3549                                   ikev2_transform_integ_type_t integ_alg,
3550                                   u32 crypto_key_size)
3551 {
3552   ikev2_profile_t *p;
3553   clib_error_t *r;
3554
3555   p = ikev2_profile_index_by_name (name);
3556
3557   if (!p)
3558     {
3559       r = clib_error_return (0, "unknown profile %v", name);
3560       return r;
3561     }
3562
3563   p->esp_ts.crypto_alg = crypto_alg;
3564   p->esp_ts.integ_alg = integ_alg;
3565   p->esp_ts.crypto_key_size = crypto_key_size;
3566   return 0;
3567 }
3568
3569 clib_error_t *
3570 ikev2_set_profile_tunnel_interface (vlib_main_t * vm,
3571                                     u8 * name, u32 sw_if_index)
3572 {
3573   ikev2_profile_t *p;
3574   clib_error_t *r;
3575
3576   p = ikev2_profile_index_by_name (name);
3577
3578   if (!p)
3579     {
3580       r = clib_error_return (0, "unknown profile %v", name);
3581       return r;
3582     }
3583
3584   p->tun_itf = sw_if_index;
3585
3586   return 0;
3587 }
3588
3589 vnet_api_error_t
3590 ikev2_set_profile_ipsec_udp_port (vlib_main_t * vm, u8 * name, u16 port,
3591                                   u8 is_set)
3592 {
3593   ikev2_profile_t *p = ikev2_profile_index_by_name (name);
3594   ikev2_main_t *km = &ikev2_main;
3595   vnet_api_error_t rv = 0;
3596   uword *v;
3597
3598   if (!p)
3599     return VNET_API_ERROR_INVALID_VALUE;
3600
3601   if (is_set)
3602     {
3603       if (p->ipsec_over_udp_port != IPSEC_UDP_PORT_NONE)
3604         return VNET_API_ERROR_VALUE_EXIST;
3605
3606       rv = ikev2_register_udp_port (p, port);
3607     }
3608   else
3609     {
3610       v = hash_get (km->udp_ports, port);
3611       if (!v)
3612         return VNET_API_ERROR_IKE_NO_PORT;
3613
3614       if (p->ipsec_over_udp_port == IPSEC_UDP_PORT_NONE)
3615         return VNET_API_ERROR_INVALID_VALUE;
3616
3617       ikev2_unregister_udp_port (p);
3618     }
3619   return rv;
3620 }
3621
3622 clib_error_t *
3623 ikev2_set_profile_udp_encap (vlib_main_t * vm, u8 * name)
3624 {
3625   ikev2_profile_t *p = ikev2_profile_index_by_name (name);
3626   clib_error_t *r;
3627
3628   if (!p)
3629     {
3630       r = clib_error_return (0, "unknown profile %v", name);
3631       return r;
3632     }
3633
3634   p->udp_encap = 1;
3635   return 0;
3636 }
3637
3638 clib_error_t *
3639 ikev2_set_profile_sa_lifetime (vlib_main_t * vm, u8 * name,
3640                                u64 lifetime, u32 jitter, u32 handover,
3641                                u64 maxdata)
3642 {
3643   ikev2_profile_t *p;
3644   clib_error_t *r;
3645
3646   p = ikev2_profile_index_by_name (name);
3647
3648   if (!p)
3649     {
3650       r = clib_error_return (0, "unknown profile %v", name);
3651       return r;
3652     }
3653
3654   p->lifetime = lifetime;
3655   p->lifetime_jitter = jitter;
3656   p->handover = handover;
3657   p->lifetime_maxdata = maxdata;
3658   return 0;
3659 }
3660
3661 clib_error_t *
3662 ikev2_initiate_sa_init (vlib_main_t * vm, u8 * name)
3663 {
3664   ikev2_profile_t *p;
3665   clib_error_t *r;
3666   ip4_main_t *im = &ip4_main;
3667   ikev2_main_t *km = &ikev2_main;
3668
3669   p = ikev2_profile_index_by_name (name);
3670
3671   if (!p)
3672     {
3673       r = clib_error_return (0, "unknown profile %v", name);
3674       return r;
3675     }
3676
3677   if (p->responder.sw_if_index == ~0 || p->responder.ip4.data_u32 == 0)
3678     {
3679       r = clib_error_return (0, "responder not set for profile %v", name);
3680       return r;
3681     }
3682
3683
3684   /* Create the Initiator Request */
3685   {
3686     ike_header_t *ike0;
3687     u32 bi0 = 0;
3688     ip_lookup_main_t *lm = &im->lookup_main;
3689     u32 if_add_index0;
3690     int len = sizeof (ike_header_t);
3691
3692     /* Get own iface IP */
3693     if_add_index0 =
3694       lm->if_address_pool_index_by_sw_if_index[p->responder.sw_if_index];
3695     ip_interface_address_t *if_add =
3696       pool_elt_at_index (lm->if_address_pool, if_add_index0);
3697     ip4_address_t *if_ip = ip_interface_address_get_address (lm, if_add);
3698
3699     bi0 = ikev2_get_new_ike_header_buff (vm, &ike0);
3700     if (!bi0)
3701       {
3702         char *errmsg = "buffer alloc failure";
3703         ikev2_log_error (errmsg);
3704         return clib_error_return (0, errmsg);
3705       }
3706
3707     /* Prepare the SA and the IKE payload */
3708     ikev2_sa_t sa;
3709     clib_memset (&sa, 0, sizeof (ikev2_sa_t));
3710     ikev2_payload_chain_t *chain = 0;
3711     ikev2_payload_new_chain (chain);
3712
3713     /* Build the IKE proposal payload */
3714     ikev2_sa_proposal_t *proposals = 0;
3715     ikev2_set_initiator_proposals (vm, &sa, &p->ike_ts, &proposals, 1);
3716     proposals[0].proposal_num = 1;
3717     proposals[0].protocol_id = IKEV2_PROTOCOL_IKE;
3718
3719     /* Add and then cleanup proposal data */
3720     ikev2_payload_add_sa (chain, proposals);
3721     ikev2_sa_free_proposal_vector (&proposals);
3722
3723     sa.is_initiator = 1;
3724     sa.profile_index = p - km->profiles;
3725     sa.state = IKEV2_STATE_SA_INIT;
3726     sa.tun_itf = p->tun_itf;
3727     sa.udp_encap = p->udp_encap;
3728     sa.ipsec_over_udp_port = p->ipsec_over_udp_port;
3729     sa.is_tun_itf_set = 1;
3730     sa.initial_contact = 1;
3731     sa.dst_port = IKEV2_PORT;
3732     ikev2_generate_sa_init_data (&sa);
3733     ikev2_payload_add_ke (chain, sa.dh_group, sa.i_dh_data);
3734     ikev2_payload_add_nonce (chain, sa.i_nonce);
3735
3736     /* Build the child SA proposal */
3737     vec_resize (sa.childs, 1);
3738     ikev2_set_initiator_proposals (vm, &sa, &p->esp_ts,
3739                                    &sa.childs[0].i_proposals, 0);
3740     sa.childs[0].i_proposals[0].proposal_num = 1;
3741     sa.childs[0].i_proposals[0].protocol_id = IKEV2_PROTOCOL_ESP;
3742     RAND_bytes ((u8 *) & sa.childs[0].i_proposals[0].spi,
3743                 sizeof (sa.childs[0].i_proposals[0].spi));
3744
3745     /* Add NAT detection notification messages (mandatory) */
3746     u8 *nat_detection_sha1 =
3747       ikev2_compute_nat_sha1 (clib_host_to_net_u64 (sa.ispi),
3748                               clib_host_to_net_u64 (sa.rspi),
3749                               clib_host_to_net_u32 (if_ip->as_u32),
3750                               clib_host_to_net_u16 (IKEV2_PORT));
3751
3752     ikev2_payload_add_notify (chain, IKEV2_NOTIFY_MSG_NAT_DETECTION_SOURCE_IP,
3753                               nat_detection_sha1);
3754     vec_free (nat_detection_sha1);
3755     nat_detection_sha1 =
3756       ikev2_compute_nat_sha1 (clib_host_to_net_u64 (sa.ispi),
3757                               clib_host_to_net_u64 (sa.rspi),
3758                               clib_host_to_net_u32 (p->responder.ip4.as_u32),
3759                               clib_host_to_net_u16 (sa.dst_port));
3760     ikev2_payload_add_notify (chain,
3761                               IKEV2_NOTIFY_MSG_NAT_DETECTION_DESTINATION_IP,
3762                               nat_detection_sha1);
3763     vec_free (nat_detection_sha1);
3764
3765     u8 *sig_hash_algo = vec_new (u8, 8);
3766     u64 tmpsig = clib_host_to_net_u64 (0x0001000200030004);
3767     clib_memcpy_fast (sig_hash_algo, &tmpsig, sizeof (tmpsig));
3768     ikev2_payload_add_notify (chain,
3769                               IKEV2_NOTIFY_MSG_SIGNATURE_HASH_ALGORITHMS,
3770                               sig_hash_algo);
3771     vec_free (sig_hash_algo);
3772
3773
3774     /* Buffer update and boilerplate */
3775     len += vec_len (chain->data);
3776     ike0->nextpayload = chain->first_payload_type;
3777     ike0->length = clib_host_to_net_u32 (len);
3778     clib_memcpy_fast (ike0->payload, chain->data, vec_len (chain->data));
3779     ikev2_payload_destroy_chain (chain);
3780
3781     ike0->version = IKE_VERSION_2;
3782     ike0->flags = IKEV2_HDR_FLAG_INITIATOR;
3783     ike0->exchange = IKEV2_EXCHANGE_SA_INIT;
3784     ike0->ispi = sa.ispi;
3785     ike0->rspi = 0;
3786     ike0->msgid = 0;
3787
3788     /* store whole IKE payload - needed for PSK auth */
3789     vec_free (sa.last_sa_init_req_packet_data);
3790     vec_add (sa.last_sa_init_req_packet_data, ike0, len);
3791
3792     /* add data to the SA then add it to the pool */
3793     sa.iaddr.as_u32 = if_ip->as_u32;
3794     sa.raddr.as_u32 = p->responder.ip4.as_u32;
3795     sa.i_id.type = p->loc_id.type;
3796     sa.i_id.data = vec_dup (p->loc_id.data);
3797     sa.r_id.type = p->rem_id.type;
3798     sa.r_id.data = vec_dup (p->rem_id.data);
3799     sa.i_auth.method = p->auth.method;
3800     sa.i_auth.hex = p->auth.hex;
3801     sa.i_auth.data = vec_dup (p->auth.data);
3802     sa.sw_if_index = p->responder.sw_if_index;
3803     vec_add (sa.childs[0].tsi, &p->loc_ts, 1);
3804     vec_add (sa.childs[0].tsr, &p->rem_ts, 1);
3805
3806     ikev2_initial_contact_cleanup (&sa);
3807
3808     /* add SA to the pool */
3809     ikev2_sa_t *sa0 = 0;
3810     pool_get (km->sais, sa0);
3811     clib_memcpy_fast (sa0, &sa, sizeof (*sa0));
3812     hash_set (km->sa_by_ispi, sa0->ispi, sa0 - km->sais);
3813
3814     ikev2_send_ike (vm, if_ip, &p->responder.ip4, bi0, len,
3815                     IKEV2_PORT, sa.dst_port, sa.sw_if_index);
3816
3817     ikev2_elog_exchange ("ispi %lx rspi %lx IKEV2_EXCHANGE_SA_INIT sent to "
3818                          "%d.%d.%d.%d", clib_host_to_net_u64 (sa0->ispi), 0,
3819                          p->responder.ip4.as_u32);
3820   }
3821
3822   return 0;
3823 }
3824
3825 static void
3826 ikev2_delete_child_sa_internal (vlib_main_t * vm, ikev2_sa_t * sa,
3827                                 ikev2_child_sa_t * csa)
3828 {
3829   /* Create the Initiator notification for child SA removal */
3830   ikev2_main_t *km = &ikev2_main;
3831   ike_header_t *ike0;
3832   u32 bi0 = 0;
3833   int len;
3834
3835   bi0 = ikev2_get_new_ike_header_buff (vm, &ike0);
3836   if (!bi0)
3837     {
3838       ikev2_log_error ("buffer alloc failure");
3839       return;
3840     }
3841
3842   ike0->exchange = IKEV2_EXCHANGE_INFORMATIONAL;
3843   ike0->ispi = clib_host_to_net_u64 (sa->ispi);
3844   ike0->rspi = clib_host_to_net_u64 (sa->rspi);
3845   vec_resize (sa->del, 1);
3846   sa->del->protocol_id = IKEV2_PROTOCOL_ESP;
3847   sa->del->spi = csa->i_proposals->spi;
3848   ike0->msgid = clib_host_to_net_u32 (sa->last_init_msg_id + 1);
3849   sa->last_init_msg_id = clib_net_to_host_u32 (ike0->msgid);
3850   len = ikev2_generate_message (sa, ike0, 0, 0);
3851   if (sa->natt)
3852     len = ikev2_insert_non_esp_marker (ike0, len);
3853   ikev2_send_ike (vm, &sa->iaddr, &sa->raddr, bi0, len,
3854                   ikev2_get_port (sa), sa->dst_port, sa->sw_if_index);
3855
3856   /* delete local child SA */
3857   ikev2_delete_tunnel_interface (km->vnet_main, sa, csa);
3858   ikev2_sa_del_child_sa (sa, csa);
3859 }
3860
3861 clib_error_t *
3862 ikev2_initiate_delete_child_sa (vlib_main_t * vm, u32 ispi)
3863 {
3864   clib_error_t *r;
3865   ikev2_main_t *km = &ikev2_main;
3866   ikev2_main_per_thread_data_t *tkm;
3867   ikev2_sa_t *fsa = 0;
3868   ikev2_child_sa_t *fchild = 0;
3869
3870   /* Search for the child SA */
3871   vec_foreach (tkm, km->per_thread_data)
3872   {
3873     ikev2_sa_t *sa;
3874     if (fchild)
3875       break;
3876     /* *INDENT-OFF* */
3877     pool_foreach (sa, tkm->sas, ({
3878       fchild = ikev2_sa_get_child(sa, ispi, IKEV2_PROTOCOL_ESP, 1);
3879       if (fchild)
3880         {
3881           fsa = sa;
3882           break;
3883         }
3884     }));
3885     /* *INDENT-ON* */
3886   }
3887
3888   if (!fchild || !fsa)
3889     {
3890       r = clib_error_return (0, "Child SA not found");
3891       return r;
3892     }
3893   else
3894     {
3895       ikev2_delete_child_sa_internal (vm, fsa, fchild);
3896     }
3897
3898   return 0;
3899 }
3900
3901 clib_error_t *
3902 ikev2_initiate_delete_ike_sa (vlib_main_t * vm, u64 ispi)
3903 {
3904   clib_error_t *r;
3905   ikev2_main_t *km = &ikev2_main;
3906   ikev2_main_per_thread_data_t *tkm;
3907   ikev2_sa_t *fsa = 0;
3908   ikev2_main_per_thread_data_t *ftkm = 0;
3909
3910   /* Search for the IKE SA */
3911   vec_foreach (tkm, km->per_thread_data)
3912   {
3913     ikev2_sa_t *sa;
3914     if (fsa)
3915       break;
3916     /* *INDENT-OFF* */
3917     pool_foreach (sa, tkm->sas, ({
3918       if (sa->ispi == ispi)
3919         {
3920           fsa = sa;
3921           ftkm = tkm;
3922           break;
3923         }
3924     }));
3925     /* *INDENT-ON* */
3926   }
3927
3928   if (!fsa)
3929     {
3930       r = clib_error_return (0, "IKE SA not found");
3931       return r;
3932     }
3933
3934   ikev2_initiate_delete_ike_sa_internal (vm, ftkm, fsa);
3935   return 0;
3936 }
3937
3938 static void
3939 ikev2_rekey_child_sa_internal (vlib_main_t * vm, ikev2_sa_t * sa,
3940                                ikev2_child_sa_t * csa)
3941 {
3942   /* Create the Initiator request for create child SA */
3943   ike_header_t *ike0;
3944   u32 bi0 = 0;
3945   int len;
3946
3947   bi0 = ikev2_get_new_ike_header_buff (vm, &ike0);
3948   if (!bi0)
3949     {
3950       ikev2_log_error ("buffer alloc failure");
3951       return;
3952     }
3953
3954   ike0->version = IKE_VERSION_2;
3955   ike0->flags = IKEV2_HDR_FLAG_INITIATOR;
3956   ike0->exchange = IKEV2_EXCHANGE_CREATE_CHILD_SA;
3957   ike0->ispi = clib_host_to_net_u64 (sa->ispi);
3958   ike0->rspi = clib_host_to_net_u64 (sa->rspi);
3959   ike0->msgid = clib_host_to_net_u32 (sa->last_init_msg_id + 1);
3960   sa->last_init_msg_id = clib_net_to_host_u32 (ike0->msgid);
3961
3962   ikev2_rekey_t *rekey;
3963   vec_add2 (sa->rekey, rekey, 1);
3964   ikev2_sa_proposal_t *proposals = vec_dup (csa->i_proposals);
3965
3966   /*need new ispi */
3967   RAND_bytes ((u8 *) & proposals[0].spi, sizeof (proposals[0].spi));
3968   rekey->spi = proposals[0].spi;
3969   rekey->ispi = csa->i_proposals->spi;
3970   len = ikev2_generate_message (sa, ike0, proposals, 0);
3971   if (sa->natt)
3972     len = ikev2_insert_non_esp_marker (ike0, len);
3973   ikev2_send_ike (vm, &sa->iaddr, &sa->raddr, bi0, len,
3974                   ikev2_get_port (sa), ikev2_get_port (sa), sa->sw_if_index);
3975   vec_free (proposals);
3976 }
3977
3978 clib_error_t *
3979 ikev2_initiate_rekey_child_sa (vlib_main_t * vm, u32 ispi)
3980 {
3981   clib_error_t *r;
3982   ikev2_main_t *km = &ikev2_main;
3983   ikev2_main_per_thread_data_t *tkm;
3984   ikev2_sa_t *fsa = 0;
3985   ikev2_child_sa_t *fchild = 0;
3986
3987   /* Search for the child SA */
3988   vec_foreach (tkm, km->per_thread_data)
3989   {
3990     ikev2_sa_t *sa;
3991     if (fchild)
3992       break;
3993     /* *INDENT-OFF* */
3994     pool_foreach (sa, tkm->sas, ({
3995       fchild = ikev2_sa_get_child(sa, ispi, IKEV2_PROTOCOL_ESP, 1);
3996       if (fchild)
3997         {
3998           fsa = sa;
3999           break;
4000         }
4001     }));
4002     /* *INDENT-ON* */
4003   }
4004
4005   if (!fchild || !fsa)
4006     {
4007       r = clib_error_return (0, "Child SA not found");
4008       return r;
4009     }
4010   else
4011     {
4012       ikev2_rekey_child_sa_internal (vm, fsa, fchild);
4013     }
4014
4015   return 0;
4016 }
4017
4018 clib_error_t *
4019 ikev2_init (vlib_main_t * vm)
4020 {
4021   ikev2_main_t *km = &ikev2_main;
4022   vlib_thread_main_t *tm = vlib_get_thread_main ();
4023   int thread_id;
4024
4025   clib_memset (km, 0, sizeof (ikev2_main_t));
4026   km->vnet_main = vnet_get_main ();
4027   km->vlib_main = vm;
4028
4029   km->liveness_period = IKEV2_LIVENESS_PERIOD_CHECK;
4030   km->liveness_max_retries = IKEV2_LIVENESS_RETRIES;
4031   ikev2_crypto_init (km);
4032
4033   mhash_init_vec_string (&km->profile_index_by_name, sizeof (uword));
4034
4035   vec_validate_aligned (km->per_thread_data, tm->n_vlib_mains - 1,
4036                         CLIB_CACHE_LINE_BYTES);
4037   for (thread_id = 0; thread_id < tm->n_vlib_mains; thread_id++)
4038     {
4039       ikev2_main_per_thread_data_t *ptd =
4040         vec_elt_at_index (km->per_thread_data, thread_id);
4041
4042       ptd->sa_by_rspi = hash_create (0, sizeof (uword));
4043
4044 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
4045       ptd->evp_ctx = EVP_CIPHER_CTX_new ();
4046       ptd->hmac_ctx = HMAC_CTX_new ();
4047 #else
4048       EVP_CIPHER_CTX_init (&ptd->_evp_ctx);
4049       ptd->evp_ctx = &ptd->_evp_ctx;
4050       HMAC_CTX_init (&(ptd->_hmac_ctx));
4051       ptd->hmac_ctx = &ptd->_hmac_ctx;
4052 #endif
4053     }
4054
4055   km->sa_by_ispi = hash_create (0, sizeof (uword));
4056   km->sw_if_indices = hash_create (0, 0);
4057   km->udp_ports = hash_create (0, sizeof (uword));
4058
4059   udp_register_dst_port (vm, IKEV2_PORT, ikev2_node.index, 1);
4060   udp_register_dst_port (vm, IKEV2_PORT_NATT, ikev2_node.index, 1);
4061
4062   vlib_punt_hdl_t punt_hdl = vlib_punt_client_register ("ikev2");
4063   vlib_punt_register (punt_hdl, ipsec_punt_reason[IPSEC_PUNT_IP4_SPI_UDP_0],
4064                       "ikev2");
4065   ikev2_cli_reference ();
4066
4067   km->log_level = IKEV2_LOG_ERROR;
4068   km->log_class = vlib_log_register_class ("ikev2", 0);
4069   return 0;
4070 }
4071
4072 /* *INDENT-OFF* */
4073 VLIB_INIT_FUNCTION (ikev2_init) =
4074 {
4075   .runs_after = VLIB_INITS("ipsec_init", "ipsec_punt_init"),
4076 };
4077 /* *INDENT-ON* */
4078
4079 static u8
4080 ikev2_mngr_process_child_sa (ikev2_sa_t * sa, ikev2_child_sa_t * csa,
4081                              u8 del_old_ids)
4082 {
4083   ikev2_main_t *km = &ikev2_main;
4084   ikev2_profile_t *p = 0;
4085   vlib_main_t *vm = km->vlib_main;
4086   f64 now = vlib_time_now (vm);
4087   u8 res = 0;
4088
4089   if (sa->profile_index != ~0)
4090     p = pool_elt_at_index (km->profiles, sa->profile_index);
4091
4092   if (sa->is_initiator && p && csa->time_to_expiration
4093       && now > csa->time_to_expiration)
4094     {
4095       if (!csa->is_expired || csa->rekey_retries > 0)
4096         {
4097           ikev2_rekey_child_sa_internal (vm, sa, csa);
4098           csa->time_to_expiration = now + p->handover;
4099           csa->is_expired = 1;
4100           if (csa->rekey_retries == 0)
4101             {
4102               csa->rekey_retries = 5;
4103             }
4104           else if (csa->rekey_retries > 0)
4105             {
4106               csa->rekey_retries--;
4107               ikev2_log_debug ("Rekeying Child SA 0x%x, retries left %d",
4108                                csa->i_proposals->spi, csa->rekey_retries);
4109               if (csa->rekey_retries == 0)
4110                 {
4111                   csa->rekey_retries = -1;
4112                 }
4113             }
4114           res |= 1;
4115         }
4116       else
4117         {
4118           csa->time_to_expiration = 0;
4119           ikev2_delete_child_sa_internal (vm, sa, csa);
4120           res |= 1;
4121           return res;
4122         }
4123     }
4124
4125   if (del_old_ids)
4126     {
4127       ipip_tunnel_t *ipip = NULL;
4128       u32 sw_if_index = sa->is_tun_itf_set ? sa->tun_itf : ~0;
4129       if (~0 == sw_if_index)
4130         {
4131           ip46_address_t local_ip;
4132           ip46_address_t remote_ip;
4133           if (sa->is_initiator)
4134             {
4135               ip46_address_set_ip4 (&local_ip, &sa->iaddr);
4136               ip46_address_set_ip4 (&remote_ip, &sa->raddr);
4137             }
4138           else
4139             {
4140               ip46_address_set_ip4 (&local_ip, &sa->raddr);
4141               ip46_address_set_ip4 (&remote_ip, &sa->iaddr);
4142             }
4143
4144        /* *INDENT-OFF* */
4145        ipip_tunnel_key_t key = {
4146          .src = local_ip,
4147          .dst = remote_ip,
4148          .transport = IPIP_TRANSPORT_IP4,
4149          .fib_index = 0,
4150        };
4151        /* *INDENT-ON* */
4152
4153           ipip = ipip_tunnel_db_find (&key);
4154
4155           if (ipip)
4156             sw_if_index = ipip->sw_if_index;
4157           else
4158             return res;
4159         }
4160
4161       u32 *sas_in = NULL;
4162       vec_add1 (sas_in, csa->remote_sa_id);
4163       vlib_worker_thread_barrier_sync (vm);
4164       ipsec_tun_protect_update (sw_if_index, NULL, csa->local_sa_id, sas_in);
4165       ipsec_sa_unlock_id (ikev2_flip_alternate_sa_bit (csa->remote_sa_id));
4166       vlib_worker_thread_barrier_release (vm);
4167     }
4168
4169   return res;
4170 }
4171
4172 int
4173 ikev2_set_log_level (ikev2_log_level_t log_level)
4174 {
4175   ikev2_main_t *km = &ikev2_main;
4176
4177   if (log_level >= IKEV2_LOG_MAX)
4178     {
4179       ikev2_log_error ("unknown logging level %d", log_level);
4180       return -1;
4181     }
4182
4183   km->log_level = log_level;
4184   return 0;
4185 }
4186
4187 clib_error_t *
4188 ikev2_set_liveness_params (u32 period, u32 max_retries)
4189 {
4190   ikev2_main_t *km = &ikev2_main;
4191
4192   if (period == 0 || max_retries == 0)
4193     return clib_error_return (0, "invalid args");
4194
4195   km->liveness_period = period;
4196   km->liveness_max_retries = max_retries;
4197   return 0;
4198 }
4199
4200 static void
4201 ikev2_mngr_process_ipsec_sa (ipsec_sa_t * ipsec_sa)
4202 {
4203   ikev2_main_t *km = &ikev2_main;
4204   vlib_main_t *vm = km->vlib_main;
4205   ikev2_main_per_thread_data_t *tkm;
4206   ikev2_sa_t *fsa = 0;
4207   ikev2_profile_t *p = 0;
4208   ikev2_child_sa_t *fchild = 0;
4209   f64 now = vlib_time_now (vm);
4210   vlib_counter_t counts;
4211
4212   /* Search for the SA and child SA */
4213   vec_foreach (tkm, km->per_thread_data)
4214   {
4215     ikev2_sa_t *sa;
4216     if (fchild)
4217       break;
4218     /* *INDENT-OFF* */
4219     pool_foreach (sa, tkm->sas, ({
4220       fchild = ikev2_sa_get_child(sa, ipsec_sa->spi, IKEV2_PROTOCOL_ESP, 1);
4221       if (fchild)
4222         {
4223           fsa = sa;
4224           break;
4225         }
4226     }));
4227     /* *INDENT-ON* */
4228   }
4229   vlib_get_combined_counter (&ipsec_sa_counters,
4230                              ipsec_sa->stat_index, &counts);
4231
4232   if (fsa && fsa->profile_index != ~0 && fsa->is_initiator)
4233     p = pool_elt_at_index (km->profiles, fsa->profile_index);
4234
4235   if (fchild && p && p->lifetime_maxdata)
4236     {
4237       if (!fchild->is_expired && counts.bytes > p->lifetime_maxdata)
4238         {
4239           fchild->time_to_expiration = now;
4240         }
4241     }
4242 }
4243
4244 static void
4245 ikev2_process_pending_sa_init (ikev2_main_t * km)
4246 {
4247   u32 sai;
4248   u64 ispi;
4249   ikev2_sa_t *sa;
4250
4251   /* *INDENT-OFF* */
4252   hash_foreach (ispi, sai, km->sa_by_ispi,
4253   ({
4254     sa = pool_elt_at_index (km->sais, sai);
4255     if (sa->init_response_received)
4256       continue;
4257
4258     u32 bi0;
4259     if (vlib_buffer_alloc (km->vlib_main, &bi0, 1) != 1)
4260       return;
4261
4262     vlib_buffer_t * b = vlib_get_buffer (km->vlib_main, bi0);
4263     clib_memcpy_fast (vlib_buffer_get_current (b),
4264         sa->last_sa_init_req_packet_data,
4265         vec_len (sa->last_sa_init_req_packet_data));
4266     ikev2_send_ike (km->vlib_main, &sa->iaddr, &sa->raddr, bi0,
4267         vec_len (sa->last_sa_init_req_packet_data),
4268         ikev2_get_port (sa), IKEV2_PORT, sa->sw_if_index);
4269   }));
4270   /* *INDENT-ON* */
4271 }
4272
4273 static vlib_node_registration_t ikev2_mngr_process_node;
4274
4275 static void
4276 ikev2_send_informational_request (ikev2_sa_t * sa)
4277 {
4278   ikev2_main_t *km = &ikev2_main;
4279   ip4_address_t *src, *dst;
4280   ike_header_t *ike0;
4281   u32 bi0 = 0;
4282   u16 dp;
4283   int len;
4284
4285   bi0 = ikev2_get_new_ike_header_buff (km->vlib_main, &ike0);
4286   if (!bi0)
4287     {
4288       ikev2_log_error ("buffer alloc failure");
4289       return;
4290     }
4291
4292   ike0->exchange = IKEV2_EXCHANGE_INFORMATIONAL;
4293   ike0->ispi = clib_host_to_net_u64 (sa->ispi);
4294   ike0->rspi = clib_host_to_net_u64 (sa->rspi);
4295   ike0->msgid = clib_host_to_net_u32 (sa->last_init_msg_id + 1);
4296   sa->last_init_msg_id = clib_net_to_host_u32 (ike0->msgid);
4297   len = ikev2_generate_message (sa, ike0, 0, 0);
4298   if (sa->natt)
4299     len = ikev2_insert_non_esp_marker (ike0, len);
4300
4301   if (sa->is_initiator)
4302     {
4303       src = &sa->iaddr;
4304       dst = &sa->raddr;
4305     }
4306   else
4307     {
4308       dst = &sa->iaddr;
4309       src = &sa->raddr;
4310     }
4311
4312   dp = sa->dst_port ? sa->dst_port : ikev2_get_port (sa);
4313   ikev2_send_ike (km->vlib_main, src, dst, bi0, len, ikev2_get_port (sa), dp,
4314                   sa->sw_if_index);
4315 }
4316
4317 static_always_inline int
4318 ikev2_mngr_process_responder_sas (ikev2_sa_t * sa)
4319 {
4320   ikev2_main_t *km = &ikev2_main;
4321   vlib_main_t *vm = km->vlib_main;
4322
4323   if (!sa->sk_ai || !sa->sk_ar)
4324     return 0;
4325
4326   if (sa->liveness_retries >= km->liveness_max_retries)
4327     return 1;
4328
4329   f64 now = vlib_time_now (vm);
4330
4331   if (sa->liveness_period_check < now)
4332     {
4333       sa->liveness_retries++;
4334       sa->liveness_period_check = now + km->liveness_period;
4335       ikev2_send_informational_request (sa);
4336     }
4337   return 0;
4338 }
4339
4340 static uword
4341 ikev2_mngr_process_fn (vlib_main_t * vm, vlib_node_runtime_t * rt,
4342                        vlib_frame_t * f)
4343 {
4344   ikev2_main_t *km = &ikev2_main;
4345   ipsec_main_t *im = &ipsec_main;
4346   ikev2_profile_t *p;
4347   ikev2_child_sa_t *c;
4348   u32 *sai;
4349
4350   while (1)
4351     {
4352       u8 req_sent = 0;
4353       vlib_process_wait_for_event_or_clock (vm, 1);
4354       vlib_process_get_events (vm, NULL);
4355
4356       /* process ike child sas */
4357       ikev2_main_per_thread_data_t *tkm;
4358       vec_foreach (tkm, km->per_thread_data)
4359       {
4360         ikev2_sa_t *sa;
4361         u32 *to_be_deleted = 0;
4362
4363         /* *INDENT-OFF* */
4364         pool_foreach (sa, tkm->sas, ({
4365           ikev2_child_sa_t *c;
4366           u8 del_old_ids = 0;
4367           if (sa->old_remote_id_present && 0 > sa->old_id_expiration)
4368             {
4369               sa->old_remote_id_present = 0;
4370               del_old_ids = 1;
4371             }
4372           else
4373             sa->old_id_expiration -= 1;
4374
4375           vec_foreach (c, sa->childs)
4376             {
4377             req_sent |= ikev2_mngr_process_child_sa(sa, c, del_old_ids);
4378             }
4379
4380           if (ikev2_mngr_process_responder_sas (sa))
4381             vec_add1 (to_be_deleted, sa - tkm->sas);
4382         }));
4383         /* *INDENT-ON* */
4384
4385         vec_foreach (sai, to_be_deleted)
4386         {
4387           sa = pool_elt_at_index (tkm->sas, sai[0]);
4388           u8 reinitiate = (sa->is_initiator && sa->profile_index != ~0);
4389           vec_foreach (c, sa->childs)
4390           {
4391             ikev2_delete_tunnel_interface (km->vnet_main, sa, c);
4392             ikev2_sa_del_child_sa (sa, c);
4393           }
4394           ikev2_sa_free_all_vec (sa);
4395           hash_unset (tkm->sa_by_rspi, sa->rspi);
4396           pool_put (tkm->sas, sa);
4397
4398           if (reinitiate)
4399             {
4400               p = pool_elt_at_index (km->profiles, sa->profile_index);
4401               if (p)
4402                 {
4403                   ikev2_initiate_sa_init (vm, p->name);
4404                 }
4405             }
4406         }
4407         vec_free (to_be_deleted);
4408       }
4409
4410       /* process ipsec sas */
4411       ipsec_sa_t *sa;
4412       /* *INDENT-OFF* */
4413       pool_foreach (sa, im->sad, ({
4414         ikev2_mngr_process_ipsec_sa(sa);
4415       }));
4416       /* *INDENT-ON* */
4417
4418       ikev2_process_pending_sa_init (km);
4419
4420       if (req_sent)
4421         {
4422           vlib_process_wait_for_event_or_clock (vm, 5);
4423           vlib_process_get_events (vm, NULL);
4424           req_sent = 0;
4425         }
4426
4427     }
4428   return 0;
4429 }
4430
4431 /* *INDENT-OFF* */
4432 VLIB_REGISTER_NODE (ikev2_mngr_process_node, static) = {
4433     .function = ikev2_mngr_process_fn,
4434     .type = VLIB_NODE_TYPE_PROCESS,
4435     .name =
4436     "ikev2-manager-process",
4437 };
4438
4439 VLIB_PLUGIN_REGISTER () = {
4440     .version = VPP_BUILD_VER,
4441     .description = "Internet Key Exchange (IKEv2) Protocol",
4442 };
4443 /* *INDENT-ON* */
4444
4445 /*
4446  * fd.io coding-style-patch-verification: ON
4447  *
4448  * Local Variables:
4449  * eval: (c-set-style "gnu")
4450  * End:
4451  */