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