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