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                                u32 thread_index,
1844                                ikev2_sa_t * sa,
1845                                ikev2_child_sa_t * child, u32 sa_index,
1846                                u32 child_index, u8 is_rekey)
1847 {
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_from, *from, *to_next;
2666   ikev2_next_t next_index;
2667   ikev2_main_t *km = &ikev2_main;
2668   u32 thread_index = vlib_get_thread_index ();
2669   int res;
2670
2671   from = vlib_frame_vector_args (frame);
2672   n_left_from = frame->n_vectors;
2673   next_index = node->cached_next_index;
2674
2675   while (n_left_from > 0)
2676     {
2677       u32 n_left_to_next;
2678
2679       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
2680
2681       while (n_left_from > 0 && n_left_to_next > 0)
2682         {
2683           u32 bi0;
2684           vlib_buffer_t *b0;
2685           u32 next0 = IKEV2_NEXT_ERROR_DROP;
2686           ip4_header_t *ip40;
2687           udp_header_t *udp0;
2688           ike_header_t *ike0;
2689           ikev2_sa_t *sa0 = 0;
2690           ikev2_sa_t sa;        /* temporary store for SA */
2691           u32 rlen, slen = 0;
2692           int is_req = 0, has_non_esp_marker = 0;
2693
2694           /* speculatively enqueue b0 to the current next frame */
2695           bi0 = from[0];
2696           to_next[0] = bi0;
2697           from += 1;
2698           to_next += 1;
2699           n_left_from -= 1;
2700           n_left_to_next -= 1;
2701
2702           b0 = vlib_get_buffer (vm, bi0);
2703
2704           if (b0->punt_reason == ipsec_punt_reason[IPSEC_PUNT_IP4_SPI_UDP_0])
2705             {
2706               u8 *ptr = vlib_buffer_get_current (b0);
2707               ip40 = (ip4_header_t *) ptr;
2708               ptr += sizeof (*ip40);
2709               udp0 = (udp_header_t *) ptr;
2710               ptr += sizeof (*udp0);
2711               ike0 = (ike_header_t *) ptr;
2712             }
2713           else
2714             {
2715               ike0 = vlib_buffer_get_current (b0);
2716               vlib_buffer_advance (b0, -sizeof (*udp0));
2717               udp0 = vlib_buffer_get_current (b0);
2718               vlib_buffer_advance (b0, -sizeof (*ip40));
2719               ip40 = vlib_buffer_get_current (b0);
2720             }
2721
2722           rlen = b0->current_length - sizeof (*ip40) - sizeof (*udp0);
2723
2724           /* check for non-esp marker */
2725           if (*((u32 *) ike0) == 0)
2726             {
2727               ike0 =
2728                 (ike_header_t *) ((u8 *) ike0 +
2729                                   sizeof (ikev2_non_esp_marker));
2730               rlen -= sizeof (ikev2_non_esp_marker);
2731               has_non_esp_marker = 1;
2732             }
2733
2734           if (clib_net_to_host_u32 (ike0->length) != rlen)
2735             {
2736               vlib_node_increment_counter (vm, ikev2_node.index,
2737                                            IKEV2_ERROR_BAD_LENGTH, 1);
2738               goto dispatch0;
2739             }
2740
2741           if (ike0->version != IKE_VERSION_2)
2742             {
2743               vlib_node_increment_counter (vm, ikev2_node.index,
2744                                            IKEV2_ERROR_NOT_IKEV2, 1);
2745               goto dispatch0;
2746             }
2747
2748           if (ike0->exchange == IKEV2_EXCHANGE_SA_INIT)
2749             {
2750               sa0 = &sa;
2751               clib_memset (sa0, 0, sizeof (*sa0));
2752
2753               if (ike0->flags & IKEV2_HDR_FLAG_INITIATOR)
2754                 {
2755                   if (ike0->rspi == 0)
2756                     {
2757                       sa0->raddr.as_u32 = ip40->dst_address.as_u32;
2758                       sa0->iaddr.as_u32 = ip40->src_address.as_u32;
2759                       sa0->dst_port = clib_net_to_host_u16 (udp0->src_port);
2760
2761                       slen =
2762                         ikev2_retransmit_sa_init (ike0, sa0->iaddr,
2763                                                   sa0->raddr, rlen);
2764                       if (slen)
2765                         {
2766                           vlib_node_increment_counter (vm, ikev2_node.index,
2767                                                        ~0 ==
2768                                                        slen ?
2769                                                        IKEV2_ERROR_IKE_SA_INIT_IGNORE
2770                                                        :
2771                                                        IKEV2_ERROR_IKE_SA_INIT_RETRANSMIT,
2772                                                        1);
2773                           goto dispatch0;
2774                         }
2775
2776                       res = ikev2_process_sa_init_req (vm, sa0,
2777                                                        ike0, udp0, rlen);
2778                       if (!res)
2779                         vlib_node_increment_counter (vm, ikev2_node.index,
2780                                                      IKEV2_ERROR_MALFORMED_PACKET,
2781                                                      1);
2782
2783                       if (sa0->state == IKEV2_STATE_SA_INIT)
2784                         {
2785                           ikev2_sa_free_proposal_vector (&sa0->r_proposals);
2786                           sa0->r_proposals =
2787                             ikev2_select_proposal (sa0->i_proposals,
2788                                                    IKEV2_PROTOCOL_IKE);
2789                           ikev2_generate_sa_init_data (sa0);
2790                         }
2791
2792                       if (sa0->state == IKEV2_STATE_SA_INIT
2793                           || sa0->state == IKEV2_STATE_NOTIFY_AND_DELETE)
2794                         {
2795                           slen =
2796                             ikev2_generate_message (b0, sa0, ike0, 0, udp0);
2797                           if (~0 == slen)
2798                             vlib_node_increment_counter (vm, ikev2_node.index,
2799                                                          IKEV2_ERROR_NO_BUFF_SPACE,
2800                                                          1);
2801                         }
2802
2803                       if (sa0->state == IKEV2_STATE_SA_INIT)
2804                         {
2805                           /* add SA to the pool */
2806                           pool_get (km->per_thread_data[thread_index].sas,
2807                                     sa0);
2808                           clib_memcpy_fast (sa0, &sa, sizeof (*sa0));
2809                           ikev2_init_sa (vm, sa0);
2810                           hash_set (km->
2811                                     per_thread_data[thread_index].sa_by_rspi,
2812                                     sa0->rspi,
2813                                     sa0 -
2814                                     km->per_thread_data[thread_index].sas);
2815                         }
2816                       else
2817                         {
2818                           ikev2_sa_free_all_vec (sa0);
2819                         }
2820                     }
2821                 }
2822               else              //received sa_init without initiator flag
2823                 {
2824                   sa0->raddr.as_u32 = ip40->src_address.as_u32;
2825                   sa0->iaddr.as_u32 = ip40->dst_address.as_u32;
2826                   ikev2_process_sa_init_resp (vm, sa0, ike0, udp0, rlen);
2827
2828                   if (sa0->state == IKEV2_STATE_SA_INIT)
2829                     {
2830                       is_req = 1;
2831                       ike0->exchange = IKEV2_EXCHANGE_IKE_AUTH;
2832                       uword *p = hash_get (km->sa_by_ispi, sa0->ispi);
2833                       if (p)
2834                         {
2835                           ikev2_sa_t *sai =
2836                             pool_elt_at_index (km->sais, p[0]);
2837
2838                           if (clib_atomic_bool_cmp_and_swap
2839                               (&sai->init_response_received, 0, 1))
2840                             {
2841                               ikev2_complete_sa_data (sa0, sai);
2842                               ikev2_calc_keys (sa0);
2843                               ikev2_sa_auth_init (sa0);
2844                               slen =
2845                                 ikev2_generate_message (b0, sa0, ike0, 0,
2846                                                         udp0);
2847                               if (~0 == slen)
2848                                 vlib_node_increment_counter (vm,
2849                                                              ikev2_node.index,
2850                                                              IKEV2_ERROR_NO_BUFF_SPACE,
2851                                                              1);
2852                             }
2853                           else
2854                             {
2855                               /* we've already processed sa-init response */
2856                               sa0->state = IKEV2_STATE_UNKNOWN;
2857                             }
2858                         }
2859                     }
2860
2861                   if (sa0->state == IKEV2_STATE_SA_INIT)
2862                     {
2863                       /* add SA to the pool */
2864                       pool_get (km->per_thread_data[thread_index].sas, sa0);
2865                       clib_memcpy_fast (sa0, &sa, sizeof (*sa0));
2866                       hash_set (km->per_thread_data[thread_index].sa_by_rspi,
2867                                 sa0->rspi,
2868                                 sa0 - km->per_thread_data[thread_index].sas);
2869                     }
2870                   else
2871                     {
2872                       ikev2_sa_free_all_vec (sa0);
2873                     }
2874                 }
2875             }
2876           else if (ike0->exchange == IKEV2_EXCHANGE_IKE_AUTH)
2877             {
2878               uword *p;
2879               p = hash_get (km->per_thread_data[thread_index].sa_by_rspi,
2880                             clib_net_to_host_u64 (ike0->rspi));
2881               if (p)
2882                 {
2883                   sa0 =
2884                     pool_elt_at_index (km->per_thread_data[thread_index].sas,
2885                                        p[0]);
2886
2887                   slen = ikev2_retransmit_resp (sa0, ike0);
2888                   if (slen)
2889                     {
2890                       vlib_node_increment_counter (vm, ikev2_node.index,
2891                                                    ~0 ==
2892                                                    slen ?
2893                                                    IKEV2_ERROR_IKE_REQ_IGNORE
2894                                                    :
2895                                                    IKEV2_ERROR_IKE_REQ_RETRANSMIT,
2896                                                    1);
2897                       goto dispatch0;
2898                     }
2899
2900                   sa0->dst_port = clib_net_to_host_u16 (udp0->src_port);
2901                   res = ikev2_process_auth_req (vm, sa0, ike0, rlen);
2902                   if (res)
2903                     ikev2_sa_auth (sa0);
2904                   else
2905                     vlib_node_increment_counter (vm, ikev2_node.index,
2906                                                  IKEV2_ERROR_MALFORMED_PACKET,
2907                                                  1);
2908                   if (sa0->state == IKEV2_STATE_AUTHENTICATED)
2909                     {
2910                       ikev2_initial_contact_cleanup (sa0);
2911                       ikev2_sa_match_ts (sa0);
2912                       if (sa0->state != IKEV2_STATE_TS_UNACCEPTABLE)
2913                         ikev2_create_tunnel_interface (vm, thread_index, sa0,
2914                                                        &sa0->childs[0],
2915                                                        p[0], 0, 0);
2916                     }
2917
2918                   if (sa0->is_initiator)
2919                     {
2920                       ikev2_del_sa_init (sa0->ispi);
2921                     }
2922                   else
2923                     {
2924                       slen = ikev2_generate_message (b0, sa0, ike0, 0, udp0);
2925                       if (~0 == slen)
2926                         vlib_node_increment_counter (vm, ikev2_node.index,
2927                                                      IKEV2_ERROR_NO_BUFF_SPACE,
2928                                                      1);
2929                     }
2930                 }
2931             }
2932           else if (ike0->exchange == IKEV2_EXCHANGE_INFORMATIONAL)
2933             {
2934               uword *p;
2935               p = hash_get (km->per_thread_data[thread_index].sa_by_rspi,
2936                             clib_net_to_host_u64 (ike0->rspi));
2937               if (p)
2938                 {
2939                   sa0 =
2940                     pool_elt_at_index (km->per_thread_data[thread_index].sas,
2941                                        p[0]);
2942
2943                   slen = ikev2_retransmit_resp (sa0, ike0);
2944                   if (slen)
2945                     {
2946                       vlib_node_increment_counter (vm, ikev2_node.index,
2947                                                    ~0 ==
2948                                                    slen ?
2949                                                    IKEV2_ERROR_IKE_REQ_IGNORE
2950                                                    :
2951                                                    IKEV2_ERROR_IKE_REQ_RETRANSMIT,
2952                                                    1);
2953                       goto dispatch0;
2954                     }
2955
2956                   res = ikev2_process_informational_req (vm, sa0, ike0, rlen);
2957                   if (!res)
2958                     {
2959                       vlib_node_increment_counter (vm, ikev2_node.index,
2960                                                    IKEV2_ERROR_MALFORMED_PACKET,
2961                                                    1);
2962                       slen = ~0;
2963                       goto dispatch0;
2964                     }
2965
2966                   if (sa0->del)
2967                     {
2968                       if (sa0->del[0].protocol_id != IKEV2_PROTOCOL_IKE)
2969                         {
2970                           ikev2_delete_t *d, *tmp, *resp = 0;
2971                           vec_foreach (d, sa0->del)
2972                           {
2973                             ikev2_child_sa_t *ch_sa;
2974                             ch_sa = ikev2_sa_get_child (sa0, d->spi,
2975                                                         d->protocol_id,
2976                                                         !sa0->is_initiator);
2977                             if (ch_sa)
2978                               {
2979                                 ikev2_delete_tunnel_interface (km->vnet_main,
2980                                                                sa0, ch_sa);
2981                                 if (!sa0->is_initiator)
2982                                   {
2983                                     vec_add2 (resp, tmp, 1);
2984                                     tmp->protocol_id = d->protocol_id;
2985                                     tmp->spi = ch_sa->r_proposals[0].spi;
2986                                   }
2987                                 ikev2_sa_del_child_sa (sa0, ch_sa);
2988                               }
2989                           }
2990                           if (!sa0->is_initiator)
2991                             {
2992                               vec_free (sa0->del);
2993                               sa0->del = resp;
2994                             }
2995                         }
2996                     }
2997                   if (!(ike0->flags & IKEV2_HDR_FLAG_RESPONSE))
2998                     {
2999                       ike0->flags |= IKEV2_HDR_FLAG_RESPONSE;
3000                       slen = ikev2_generate_message (b0, sa0, ike0, 0, udp0);
3001                       if (~0 == slen)
3002                         vlib_node_increment_counter (vm, ikev2_node.index,
3003                                                      IKEV2_ERROR_NO_BUFF_SPACE,
3004                                                      1);
3005                     }
3006                 }
3007             }
3008           else if (ike0->exchange == IKEV2_EXCHANGE_CREATE_CHILD_SA)
3009             {
3010               uword *p;
3011               p = hash_get (km->per_thread_data[thread_index].sa_by_rspi,
3012                             clib_net_to_host_u64 (ike0->rspi));
3013               if (p)
3014                 {
3015                   sa0 =
3016                     pool_elt_at_index (km->per_thread_data[thread_index].sas,
3017                                        p[0]);
3018
3019                   slen = ikev2_retransmit_resp (sa0, ike0);
3020                   if (slen)
3021                     {
3022                       vlib_node_increment_counter (vm, ikev2_node.index,
3023                                                    ~0 ==
3024                                                    slen ?
3025                                                    IKEV2_ERROR_IKE_REQ_IGNORE
3026                                                    :
3027                                                    IKEV2_ERROR_IKE_REQ_RETRANSMIT,
3028                                                    1);
3029                       goto dispatch0;
3030                     }
3031
3032                   res = ikev2_process_create_child_sa_req (vm, sa0,
3033                                                            ike0, rlen);
3034                   if (!res)
3035                     {
3036                       vlib_node_increment_counter (vm, ikev2_node.index,
3037                                                    IKEV2_ERROR_MALFORMED_PACKET,
3038                                                    1);
3039                       slen = ~0;
3040                       goto dispatch0;
3041                     }
3042
3043                   if (sa0->rekey)
3044                     {
3045                       if (sa0->rekey[0].protocol_id != IKEV2_PROTOCOL_IKE)
3046                         {
3047                           if (sa0->childs)
3048                             ikev2_sa_free_all_child_sa (&sa0->childs);
3049                           ikev2_child_sa_t *child;
3050                           vec_add2 (sa0->childs, child, 1);
3051                           clib_memset (child, 0, sizeof (*child));
3052                           child->r_proposals = sa0->rekey[0].r_proposal;
3053                           child->i_proposals = sa0->rekey[0].i_proposal;
3054                           child->tsi = sa0->rekey[0].tsi;
3055                           child->tsr = sa0->rekey[0].tsr;
3056                           ikev2_create_tunnel_interface (vm, thread_index,
3057                                                          sa0, child, p[0],
3058                                                          child - sa0->childs,
3059                                                          1);
3060                         }
3061                       if (sa0->is_initiator)
3062                         {
3063                           vec_free (sa0->rekey);
3064                         }
3065                       else
3066                         {
3067                           slen =
3068                             ikev2_generate_message (b0, sa0, ike0, 0, udp0);
3069                           if (~0 == slen)
3070                             vlib_node_increment_counter (vm, ikev2_node.index,
3071                                                          IKEV2_ERROR_NO_BUFF_SPACE,
3072                                                          1);
3073                         }
3074                     }
3075                 }
3076             }
3077           else
3078             {
3079               ikev2_elog_uint_peers (IKEV2_LOG_WARNING, "IKEv2 exchange %d "
3080                                      "received from %d.%d.%d.%d to %d.%d.%d.%d",
3081                                      ike0->exchange,
3082                                      ip40->src_address.as_u32,
3083                                      ip40->dst_address.as_u32);
3084             }
3085
3086         dispatch0:
3087           /* if we are sending packet back, rewrite headers */
3088           if (slen && ~0 != slen)
3089             {
3090               next0 = IKEV2_NEXT_IP4_LOOKUP;
3091               if (sa0->is_initiator)
3092                 {
3093                   ip40->dst_address.as_u32 = sa0->raddr.as_u32;
3094                   ip40->src_address.as_u32 = sa0->iaddr.as_u32;
3095                 }
3096               else
3097                 {
3098                   ip40->dst_address.as_u32 = sa0->iaddr.as_u32;
3099                   ip40->src_address.as_u32 = sa0->raddr.as_u32;
3100                 }
3101
3102               if (is_req)
3103                 {
3104                   udp0->dst_port = udp0->src_port =
3105                     clib_net_to_host_u16 (ikev2_get_port (sa0));
3106
3107                   if (udp0->dst_port == clib_net_to_host_u16 (IKEV2_PORT_NATT)
3108                       && sa0->natt)
3109                     {
3110                       if (!has_non_esp_marker)
3111                         slen = ikev2_insert_non_esp_marker (ike0, slen);
3112                     }
3113                 }
3114               else
3115                 {
3116                   if (has_non_esp_marker)
3117                     slen += sizeof (ikev2_non_esp_marker);
3118
3119                   u16 tp = udp0->dst_port;
3120                   udp0->dst_port = udp0->src_port;
3121                   udp0->src_port = tp;
3122                 }
3123
3124               udp0->length =
3125                 clib_host_to_net_u16 (slen + sizeof (udp_header_t));
3126               udp0->checksum = 0;
3127               b0->current_length =
3128                 slen + sizeof (ip4_header_t) + sizeof (udp_header_t);
3129               ip40->length = clib_host_to_net_u16 (b0->current_length);
3130               ip40->checksum = ip4_header_checksum (ip40);
3131             }
3132           /* delete sa */
3133           if (sa0 && (sa0->state == IKEV2_STATE_DELETED ||
3134                       sa0->state == IKEV2_STATE_NOTIFY_AND_DELETE))
3135             {
3136               ikev2_child_sa_t *c;
3137
3138               vec_foreach (c, sa0->childs)
3139                 ikev2_delete_tunnel_interface (km->vnet_main, sa0, c);
3140
3141               ikev2_delete_sa (sa0);
3142             }
3143           if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)
3144                              && (b0->flags & VLIB_BUFFER_IS_TRACED)))
3145             {
3146
3147               ikev2_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t));
3148               t->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];
3149               t->next_index = next0;
3150             }
3151
3152           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
3153                                            n_left_to_next, bi0, next0);
3154         }
3155
3156       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
3157     }
3158
3159   vlib_node_increment_counter (vm, ikev2_node.index,
3160                                IKEV2_ERROR_PROCESSED, frame->n_vectors);
3161   return frame->n_vectors;
3162 }
3163
3164 /* *INDENT-OFF* */
3165 VLIB_REGISTER_NODE (ikev2_node,static) = {
3166   .function = ikev2_node_fn,
3167   .name = "ikev2",
3168   .vector_size = sizeof (u32),
3169   .format_trace = format_ikev2_trace,
3170   .type = VLIB_NODE_TYPE_INTERNAL,
3171
3172   .n_errors = ARRAY_LEN(ikev2_error_strings),
3173   .error_strings = ikev2_error_strings,
3174
3175   .n_next_nodes = IKEV2_N_NEXT,
3176
3177   .next_nodes = {
3178     [IKEV2_NEXT_IP4_LOOKUP] = "ip4-lookup",
3179         [IKEV2_NEXT_ERROR_DROP] = "error-drop",
3180   },
3181 };
3182 /* *INDENT-ON* */
3183
3184 // set ikev2 proposals when vpp is used as initiator
3185 static clib_error_t *
3186 ikev2_set_initiator_proposals (vlib_main_t * vm, ikev2_sa_t * sa,
3187                                ikev2_transforms_set * ts,
3188                                ikev2_sa_proposal_t ** proposals, int is_ike)
3189 {
3190   clib_error_t *r;
3191   ikev2_main_t *km = &ikev2_main;
3192   ikev2_sa_proposal_t *proposal;
3193   vec_add2 (*proposals, proposal, 1);
3194   ikev2_sa_transform_t *td;
3195   int error;
3196
3197   /* Encryption */
3198   error = 1;
3199   vec_foreach (td, km->supported_transforms)
3200   {
3201     if (td->type == IKEV2_TRANSFORM_TYPE_ENCR
3202         && td->encr_type == ts->crypto_alg
3203         && td->key_len == ts->crypto_key_size / 8)
3204       {
3205         u16 attr[2];
3206         attr[0] = clib_host_to_net_u16 (14 | (1 << 15));
3207         attr[1] = clib_host_to_net_u16 (td->key_len << 3);
3208         vec_add (td->attrs, (u8 *) attr, 4);
3209         vec_add1 (proposal->transforms, *td);
3210         td->attrs = 0;
3211
3212         error = 0;
3213         break;
3214       }
3215   }
3216   if (error)
3217     {
3218       r = clib_error_return (0, "Unsupported algorithm");
3219       return r;
3220     }
3221
3222   if (IKEV2_TRANSFORM_INTEG_TYPE_NONE != ts->integ_alg)
3223     {
3224       /* Integrity */
3225       error = 1;
3226       vec_foreach (td, km->supported_transforms)
3227       {
3228         if (td->type == IKEV2_TRANSFORM_TYPE_INTEG
3229             && td->integ_type == ts->integ_alg)
3230           {
3231             vec_add1 (proposal->transforms, *td);
3232             error = 0;
3233             break;
3234           }
3235       }
3236       if (error)
3237         {
3238           ikev2_elog_error
3239             ("Didn't find any supported algorithm for IKEV2_TRANSFORM_TYPE_INTEG");
3240           r = clib_error_return (0, "Unsupported algorithm");
3241           return r;
3242         }
3243     }
3244
3245   /* PRF */
3246   if (is_ike)
3247     {
3248       error = 1;
3249       vec_foreach (td, km->supported_transforms)
3250       {
3251         if (td->type == IKEV2_TRANSFORM_TYPE_PRF
3252             && td->prf_type == IKEV2_TRANSFORM_PRF_TYPE_PRF_HMAC_SHA2_256)
3253           {
3254             vec_add1 (proposal->transforms, *td);
3255             error = 0;
3256             break;
3257           }
3258       }
3259       if (error)
3260         {
3261           r = clib_error_return (0, "Unsupported algorithm");
3262           return r;
3263         }
3264     }
3265
3266   /* DH */
3267   if (is_ike)
3268     {
3269       error = 1;
3270       vec_foreach (td, km->supported_transforms)
3271       {
3272         if (td->type == IKEV2_TRANSFORM_TYPE_DH && td->dh_type == ts->dh_type)
3273           {
3274             vec_add1 (proposal->transforms, *td);
3275             if (is_ike)
3276               {
3277                 sa->dh_group = td->dh_type;
3278               }
3279             error = 0;
3280             break;
3281           }
3282       }
3283       if (error)
3284         {
3285           r = clib_error_return (0, "Unsupported algorithm");
3286           return r;
3287         }
3288     }
3289
3290   if (!is_ike)
3291     {
3292       error = 1;
3293       vec_foreach (td, km->supported_transforms)
3294       {
3295         if (td->type == IKEV2_TRANSFORM_TYPE_ESN)
3296           {
3297             vec_add1 (proposal->transforms, *td);
3298             error = 0;
3299           }
3300       }
3301       if (error)
3302         {
3303           r = clib_error_return (0, "Unsupported algorithm");
3304           return r;
3305         }
3306     }
3307
3308
3309   return 0;
3310 }
3311
3312 static ikev2_profile_t *
3313 ikev2_profile_index_by_name (u8 * name)
3314 {
3315   ikev2_main_t *km = &ikev2_main;
3316   uword *p;
3317
3318   p = mhash_get (&km->profile_index_by_name, name);
3319   if (!p)
3320     return 0;
3321
3322   return pool_elt_at_index (km->profiles, p[0]);
3323 }
3324
3325
3326 static void
3327 ikev2_send_ike (vlib_main_t * vm, ip4_address_t * src, ip4_address_t * dst,
3328                 u32 bi0, u32 len, u16 src_port, u16 dst_port, u32 sw_if_index)
3329 {
3330   ip4_header_t *ip40;
3331   udp_header_t *udp0;
3332   vlib_buffer_t *b0;
3333   vlib_frame_t *f;
3334   u32 *to_next;
3335
3336   b0 = vlib_get_buffer (vm, bi0);
3337   vlib_buffer_advance (b0, -sizeof (udp_header_t));
3338   udp0 = vlib_buffer_get_current (b0);
3339   vlib_buffer_advance (b0, -sizeof (ip4_header_t));
3340   ip40 = vlib_buffer_get_current (b0);
3341
3342
3343   ip40->ip_version_and_header_length = 0x45;
3344   ip40->tos = 0;
3345   ip40->fragment_id = 0;
3346   ip40->flags_and_fragment_offset = 0;
3347   ip40->ttl = 0xff;
3348   ip40->protocol = IP_PROTOCOL_UDP;
3349   ip40->dst_address.as_u32 = dst->as_u32;
3350   ip40->src_address.as_u32 = src->as_u32;
3351   udp0->dst_port = clib_host_to_net_u16 (dst_port);
3352   udp0->src_port = clib_host_to_net_u16 (src_port);
3353   udp0->length = clib_host_to_net_u16 (len + sizeof (udp_header_t));
3354   udp0->checksum = 0;
3355   b0->current_length = len + sizeof (ip4_header_t) + sizeof (udp_header_t);
3356   ip40->length = clib_host_to_net_u16 (b0->current_length);
3357   ip40->checksum = ip4_header_checksum (ip40);
3358
3359   vnet_buffer (b0)->sw_if_index[VLIB_RX] = sw_if_index;
3360   vnet_buffer (b0)->sw_if_index[VLIB_TX] = ~0;
3361
3362   /* send the request */
3363   f = vlib_get_frame_to_node (vm, ip4_lookup_node.index);
3364   to_next = vlib_frame_vector_args (f);
3365   to_next[0] = bi0;
3366   f->n_vectors = 1;
3367   vlib_put_frame_to_node (vm, ip4_lookup_node.index, f);
3368
3369 }
3370
3371 static u32
3372 ikev2_get_new_ike_header_buff (vlib_main_t * vm, vlib_buffer_t ** b)
3373 {
3374   u32 bi0;
3375   if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
3376     {
3377       *b = 0;
3378       return 0;
3379     }
3380   *b = vlib_get_buffer (vm, bi0);
3381   return bi0;
3382 }
3383
3384 clib_error_t *
3385 ikev2_set_local_key (vlib_main_t * vm, u8 * file)
3386 {
3387   ikev2_main_t *km = &ikev2_main;
3388
3389   if (km->pkey)
3390     EVP_PKEY_free (km->pkey);
3391   km->pkey = ikev2_load_key_file (file);
3392   if (km->pkey == NULL)
3393     return clib_error_return (0, "load key '%s' failed", file);
3394
3395   return 0;
3396 }
3397
3398 static_always_inline vnet_api_error_t
3399 ikev2_register_udp_port (ikev2_profile_t * p, u16 port)
3400 {
3401   ikev2_main_t *km = &ikev2_main;
3402   udp_dst_port_info_t *pi;
3403
3404   uword *v = hash_get (km->udp_ports, port);
3405   pi = udp_get_dst_port_info (&udp_main, port, UDP_IP4);
3406
3407   if (v)
3408     {
3409       /* IKE already uses this port, only increment reference counter */
3410       ASSERT (pi);
3411       v[0]++;
3412     }
3413   else
3414     {
3415       if (pi)
3416         return VNET_API_ERROR_UDP_PORT_TAKEN;
3417
3418       udp_register_dst_port (km->vlib_main, port,
3419                              ipsec4_tun_input_node.index, 1);
3420       hash_set (km->udp_ports, port, 1);
3421     }
3422   p->ipsec_over_udp_port = port;
3423   return 0;
3424 }
3425
3426 static_always_inline void
3427 ikev2_unregister_udp_port (ikev2_profile_t * p)
3428 {
3429   ikev2_main_t *km = &ikev2_main;
3430   uword *v;
3431
3432   if (p->ipsec_over_udp_port == IPSEC_UDP_PORT_NONE)
3433     return;
3434
3435   v = hash_get (km->udp_ports, p->ipsec_over_udp_port);
3436   if (!v)
3437     return;
3438
3439   v[0]--;
3440
3441   if (v[0] == 0)
3442     {
3443       udp_unregister_dst_port (km->vlib_main, p->ipsec_over_udp_port, 1);
3444       hash_unset (km->udp_ports, p->ipsec_over_udp_port);
3445     }
3446
3447   p->ipsec_over_udp_port = IPSEC_UDP_PORT_NONE;
3448 }
3449
3450 static void
3451 ikev2_initiate_delete_ike_sa_internal (vlib_main_t * vm,
3452                                        ikev2_main_per_thread_data_t * tkm,
3453                                        ikev2_sa_t * sa)
3454 {
3455   ikev2_main_t *km = &ikev2_main;
3456   ip4_address_t *src, *dst;
3457   vlib_buffer_t *b0;
3458
3459   /* Create the Initiator notification for IKE SA removal */
3460   ike_header_t *ike0;
3461   u32 bi0 = 0;
3462   int len;
3463
3464   bi0 = ikev2_get_new_ike_header_buff (vm, &b0);
3465   if (!bi0)
3466     {
3467       ikev2_log_error ("buffer alloc failure");
3468       return;
3469     }
3470
3471   ike0 = vlib_buffer_get_current (b0);
3472   ike0->exchange = IKEV2_EXCHANGE_INFORMATIONAL;
3473   ike0->ispi = clib_host_to_net_u64 (sa->ispi);
3474   ike0->rspi = clib_host_to_net_u64 (sa->rspi);
3475   vec_resize (sa->del, 1);
3476   sa->del->protocol_id = IKEV2_PROTOCOL_IKE;
3477   sa->del->spi = sa->ispi;
3478   ike0->msgid = clib_host_to_net_u32 (sa->last_init_msg_id + 1);
3479   sa->last_init_msg_id = clib_net_to_host_u32 (ike0->msgid);
3480   len = ikev2_generate_message (b0, sa, ike0, 0, 0);
3481   if (~0 == len)
3482     return;
3483
3484   if (sa->is_initiator)
3485     {
3486       src = &sa->iaddr;
3487       dst = &sa->raddr;
3488     }
3489   else
3490     {
3491       dst = &sa->iaddr;
3492       src = &sa->raddr;
3493     }
3494
3495   ikev2_send_ike (vm, src, dst, bi0, len,
3496                   ikev2_get_port (sa), sa->dst_port, 0);
3497
3498   /* delete local SA */
3499   ikev2_child_sa_t *c;
3500   vec_foreach (c, sa->childs)
3501     ikev2_delete_tunnel_interface (km->vnet_main, sa, c);
3502
3503   u64 rspi = sa->rspi;
3504   ikev2_sa_free_all_vec (sa);
3505   uword *p = hash_get (tkm->sa_by_rspi, rspi);
3506   if (p)
3507     {
3508       hash_unset (tkm->sa_by_rspi, rspi);
3509       pool_put (tkm->sas, sa);
3510     }
3511 }
3512
3513 static void
3514 ikev2_cleanup_profile_sessions (ikev2_main_t * km, ikev2_profile_t * p)
3515 {
3516   ikev2_main_per_thread_data_t *tkm;
3517   ikev2_sa_t *sa;
3518   u32 pi = p - km->profiles;
3519   u32 *sai;
3520   u32 *del_sai = 0;
3521
3522   vec_foreach (tkm, km->per_thread_data)
3523   {
3524     /* *INDENT-OFF* */
3525     pool_foreach (sa, tkm->sas, ({
3526       if (sa->profile_index != ~0 && pi == sa->profile_index)
3527         vec_add1 (del_sai, sa - tkm->sas);
3528     }));
3529     /* *INDENT-ON* */
3530
3531     vec_foreach (sai, del_sai)
3532     {
3533       sa = pool_elt_at_index (tkm->sas, sai[0]);
3534       ikev2_initiate_delete_ike_sa_internal (km->vlib_main, tkm, sa);
3535     }
3536
3537     vec_reset_length (del_sai);
3538   }
3539
3540   vec_free (del_sai);
3541 }
3542
3543 static void
3544 ikev2_profile_free (ikev2_profile_t * p)
3545 {
3546   vec_free (p->name);
3547
3548   vec_free (p->auth.data);
3549   if (p->auth.key)
3550     EVP_PKEY_free (p->auth.key);
3551
3552   vec_free (p->loc_id.data);
3553   vec_free (p->rem_id.data);
3554 }
3555
3556 clib_error_t *
3557 ikev2_add_del_profile (vlib_main_t * vm, u8 * name, int is_add)
3558 {
3559   ikev2_main_t *km = &ikev2_main;
3560   ikev2_profile_t *p;
3561
3562   if (is_add)
3563     {
3564       if (ikev2_profile_index_by_name (name))
3565         return clib_error_return (0, "policy %v already exists", name);
3566
3567       pool_get (km->profiles, p);
3568       clib_memset (p, 0, sizeof (*p));
3569       p->name = vec_dup (name);
3570       p->ipsec_over_udp_port = IPSEC_UDP_PORT_NONE;
3571       p->responder.sw_if_index = ~0;
3572       p->tun_itf = ~0;
3573       uword index = p - km->profiles;
3574       mhash_set_mem (&km->profile_index_by_name, name, &index, 0);
3575     }
3576   else
3577     {
3578       p = ikev2_profile_index_by_name (name);
3579       if (!p)
3580         return clib_error_return (0, "policy %v does not exists", name);
3581
3582       ikev2_unregister_udp_port (p);
3583       ikev2_cleanup_profile_sessions (km, p);
3584
3585       ikev2_profile_free (p);
3586       pool_put (km->profiles, p);
3587       mhash_unset (&km->profile_index_by_name, name, 0);
3588     }
3589   return 0;
3590 }
3591
3592 clib_error_t *
3593 ikev2_set_profile_auth (vlib_main_t * vm, u8 * name, u8 auth_method,
3594                         u8 * auth_data, u8 data_hex_format)
3595 {
3596   ikev2_profile_t *p;
3597   clib_error_t *r;
3598
3599   p = ikev2_profile_index_by_name (name);
3600
3601   if (!p)
3602     {
3603       r = clib_error_return (0, "unknown profile %v", name);
3604       return r;
3605     }
3606
3607   if (p->auth.key)
3608     EVP_PKEY_free (p->auth.key);
3609   vec_free (p->auth.data);
3610
3611   p->auth.method = auth_method;
3612   p->auth.data = vec_dup (auth_data);
3613   p->auth.hex = data_hex_format;
3614
3615   if (auth_method == IKEV2_AUTH_METHOD_RSA_SIG)
3616     {
3617       vec_add1 (p->auth.data, 0);
3618       p->auth.key = ikev2_load_cert_file (p->auth.data);
3619       if (p->auth.key == NULL)
3620         return clib_error_return (0, "load cert '%s' failed", p->auth.data);
3621     }
3622
3623   return 0;
3624 }
3625
3626 clib_error_t *
3627 ikev2_set_profile_id (vlib_main_t * vm, u8 * name, u8 id_type, u8 * data,
3628                       int is_local)
3629 {
3630   ikev2_profile_t *p;
3631   clib_error_t *r;
3632
3633   if (id_type > IKEV2_ID_TYPE_ID_RFC822_ADDR
3634       && id_type < IKEV2_ID_TYPE_ID_KEY_ID)
3635     {
3636       r = clib_error_return (0, "unsupported identity type %U",
3637                              format_ikev2_id_type, id_type);
3638       return r;
3639     }
3640
3641   p = ikev2_profile_index_by_name (name);
3642
3643   if (!p)
3644     {
3645       r = clib_error_return (0, "unknown profile %v", name);
3646       return r;
3647     }
3648
3649   if (is_local)
3650     {
3651       vec_free (p->loc_id.data);
3652       p->loc_id.type = id_type;
3653       p->loc_id.data = vec_dup (data);
3654     }
3655   else
3656     {
3657       vec_free (p->rem_id.data);
3658       p->rem_id.type = id_type;
3659       p->rem_id.data = vec_dup (data);
3660     }
3661
3662   return 0;
3663 }
3664
3665 clib_error_t *
3666 ikev2_set_profile_ts (vlib_main_t * vm, u8 * name, u8 protocol_id,
3667                       u16 start_port, u16 end_port, ip4_address_t start_addr,
3668                       ip4_address_t end_addr, int is_local)
3669 {
3670   ikev2_profile_t *p;
3671   clib_error_t *r;
3672
3673   p = ikev2_profile_index_by_name (name);
3674
3675   if (!p)
3676     {
3677       r = clib_error_return (0, "unknown profile %v", name);
3678       return r;
3679     }
3680
3681   if (is_local)
3682     {
3683       p->loc_ts.start_addr.as_u32 = start_addr.as_u32;
3684       p->loc_ts.end_addr.as_u32 = end_addr.as_u32;
3685       p->loc_ts.start_port = start_port;
3686       p->loc_ts.end_port = end_port;
3687       p->loc_ts.protocol_id = protocol_id;
3688       p->loc_ts.ts_type = 7;
3689     }
3690   else
3691     {
3692       p->rem_ts.start_addr.as_u32 = start_addr.as_u32;
3693       p->rem_ts.end_addr.as_u32 = end_addr.as_u32;
3694       p->rem_ts.start_port = start_port;
3695       p->rem_ts.end_port = end_port;
3696       p->rem_ts.protocol_id = protocol_id;
3697       p->rem_ts.ts_type = 7;
3698     }
3699
3700   return 0;
3701 }
3702
3703
3704 clib_error_t *
3705 ikev2_set_profile_responder (vlib_main_t * vm, u8 * name,
3706                              u32 sw_if_index, ip4_address_t ip4)
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->responder.sw_if_index = sw_if_index;
3720   p->responder.ip4 = ip4;
3721
3722   return 0;
3723 }
3724
3725 clib_error_t *
3726 ikev2_set_profile_ike_transforms (vlib_main_t * vm, u8 * name,
3727                                   ikev2_transform_encr_type_t crypto_alg,
3728                                   ikev2_transform_integ_type_t integ_alg,
3729                                   ikev2_transform_dh_type_t dh_type,
3730                                   u32 crypto_key_size)
3731 {
3732   ikev2_profile_t *p;
3733   clib_error_t *r;
3734
3735   p = ikev2_profile_index_by_name (name);
3736
3737   if (!p)
3738     {
3739       r = clib_error_return (0, "unknown profile %v", name);
3740       return r;
3741     }
3742
3743   p->ike_ts.crypto_alg = crypto_alg;
3744   p->ike_ts.integ_alg = integ_alg;
3745   p->ike_ts.dh_type = dh_type;
3746   p->ike_ts.crypto_key_size = crypto_key_size;
3747   return 0;
3748 }
3749
3750 clib_error_t *
3751 ikev2_set_profile_esp_transforms (vlib_main_t * vm, u8 * name,
3752                                   ikev2_transform_encr_type_t crypto_alg,
3753                                   ikev2_transform_integ_type_t integ_alg,
3754                                   u32 crypto_key_size)
3755 {
3756   ikev2_profile_t *p;
3757   clib_error_t *r;
3758
3759   p = ikev2_profile_index_by_name (name);
3760
3761   if (!p)
3762     {
3763       r = clib_error_return (0, "unknown profile %v", name);
3764       return r;
3765     }
3766
3767   p->esp_ts.crypto_alg = crypto_alg;
3768   p->esp_ts.integ_alg = integ_alg;
3769   p->esp_ts.crypto_key_size = crypto_key_size;
3770   return 0;
3771 }
3772
3773 clib_error_t *
3774 ikev2_set_profile_tunnel_interface (vlib_main_t * vm,
3775                                     u8 * name, u32 sw_if_index)
3776 {
3777   ikev2_profile_t *p;
3778   clib_error_t *r;
3779
3780   p = ikev2_profile_index_by_name (name);
3781
3782   if (!p)
3783     {
3784       r = clib_error_return (0, "unknown profile %v", name);
3785       return r;
3786     }
3787
3788   p->tun_itf = sw_if_index;
3789
3790   return 0;
3791 }
3792
3793 vnet_api_error_t
3794 ikev2_set_profile_ipsec_udp_port (vlib_main_t * vm, u8 * name, u16 port,
3795                                   u8 is_set)
3796 {
3797   ikev2_profile_t *p = ikev2_profile_index_by_name (name);
3798   ikev2_main_t *km = &ikev2_main;
3799   vnet_api_error_t rv = 0;
3800   uword *v;
3801
3802   if (!p)
3803     return VNET_API_ERROR_INVALID_VALUE;
3804
3805   if (is_set)
3806     {
3807       if (p->ipsec_over_udp_port != IPSEC_UDP_PORT_NONE)
3808         return VNET_API_ERROR_VALUE_EXIST;
3809
3810       rv = ikev2_register_udp_port (p, port);
3811     }
3812   else
3813     {
3814       v = hash_get (km->udp_ports, port);
3815       if (!v)
3816         return VNET_API_ERROR_IKE_NO_PORT;
3817
3818       if (p->ipsec_over_udp_port == IPSEC_UDP_PORT_NONE)
3819         return VNET_API_ERROR_INVALID_VALUE;
3820
3821       ikev2_unregister_udp_port (p);
3822     }
3823   return rv;
3824 }
3825
3826 clib_error_t *
3827 ikev2_set_profile_udp_encap (vlib_main_t * vm, u8 * name)
3828 {
3829   ikev2_profile_t *p = ikev2_profile_index_by_name (name);
3830   clib_error_t *r;
3831
3832   if (!p)
3833     {
3834       r = clib_error_return (0, "unknown profile %v", name);
3835       return r;
3836     }
3837
3838   p->udp_encap = 1;
3839   return 0;
3840 }
3841
3842 clib_error_t *
3843 ikev2_set_profile_sa_lifetime (vlib_main_t * vm, u8 * name,
3844                                u64 lifetime, u32 jitter, u32 handover,
3845                                u64 maxdata)
3846 {
3847   ikev2_profile_t *p;
3848   clib_error_t *r;
3849
3850   p = ikev2_profile_index_by_name (name);
3851
3852   if (!p)
3853     {
3854       r = clib_error_return (0, "unknown profile %v", name);
3855       return r;
3856     }
3857
3858   p->lifetime = lifetime;
3859   p->lifetime_jitter = jitter;
3860   p->handover = handover;
3861   p->lifetime_maxdata = maxdata;
3862   return 0;
3863 }
3864
3865 clib_error_t *
3866 ikev2_initiate_sa_init (vlib_main_t * vm, u8 * name)
3867 {
3868   ikev2_profile_t *p;
3869   clib_error_t *r;
3870   ip4_main_t *im = &ip4_main;
3871   ikev2_main_t *km = &ikev2_main;
3872
3873   p = ikev2_profile_index_by_name (name);
3874
3875   if (!p)
3876     {
3877       r = clib_error_return (0, "unknown profile %v", name);
3878       return r;
3879     }
3880
3881   if (p->responder.sw_if_index == ~0 || p->responder.ip4.data_u32 == 0)
3882     {
3883       r = clib_error_return (0, "responder not set for profile %v", name);
3884       return r;
3885     }
3886
3887
3888   /* Create the Initiator Request */
3889   {
3890     vlib_buffer_t *b0;
3891     ike_header_t *ike0;
3892     u32 bi0 = 0;
3893     ip_lookup_main_t *lm = &im->lookup_main;
3894     u32 if_add_index0;
3895     int len = sizeof (ike_header_t);
3896
3897     /* Get own iface IP */
3898     if_add_index0 =
3899       lm->if_address_pool_index_by_sw_if_index[p->responder.sw_if_index];
3900     ip_interface_address_t *if_add =
3901       pool_elt_at_index (lm->if_address_pool, if_add_index0);
3902     ip4_address_t *if_ip = ip_interface_address_get_address (lm, if_add);
3903
3904     bi0 = ikev2_get_new_ike_header_buff (vm, &b0);
3905     if (!bi0)
3906       {
3907         char *errmsg = "buffer alloc failure";
3908         ikev2_log_error (errmsg);
3909         return clib_error_return (0, errmsg);
3910       }
3911     ike0 = vlib_buffer_get_current (b0);
3912
3913     /* Prepare the SA and the IKE payload */
3914     ikev2_sa_t sa;
3915     clib_memset (&sa, 0, sizeof (ikev2_sa_t));
3916     ikev2_payload_chain_t *chain = 0;
3917     ikev2_payload_new_chain (chain);
3918
3919     /* Build the IKE proposal payload */
3920     ikev2_sa_proposal_t *proposals = 0;
3921     ikev2_set_initiator_proposals (vm, &sa, &p->ike_ts, &proposals, 1);
3922     proposals[0].proposal_num = 1;
3923     proposals[0].protocol_id = IKEV2_PROTOCOL_IKE;
3924
3925     /* Add and then cleanup proposal data */
3926     ikev2_payload_add_sa (chain, proposals);
3927     ikev2_sa_free_proposal_vector (&proposals);
3928
3929     sa.is_initiator = 1;
3930     sa.profile_index = p - km->profiles;
3931     sa.state = IKEV2_STATE_SA_INIT;
3932     sa.tun_itf = p->tun_itf;
3933     sa.udp_encap = p->udp_encap;
3934     sa.ipsec_over_udp_port = p->ipsec_over_udp_port;
3935     sa.is_tun_itf_set = 1;
3936     sa.initial_contact = 1;
3937     sa.dst_port = IKEV2_PORT;
3938     ikev2_generate_sa_init_data (&sa);
3939     ikev2_payload_add_ke (chain, sa.dh_group, sa.i_dh_data);
3940     ikev2_payload_add_nonce (chain, sa.i_nonce);
3941
3942     /* Build the child SA proposal */
3943     vec_resize (sa.childs, 1);
3944     ikev2_set_initiator_proposals (vm, &sa, &p->esp_ts,
3945                                    &sa.childs[0].i_proposals, 0);
3946     sa.childs[0].i_proposals[0].proposal_num = 1;
3947     sa.childs[0].i_proposals[0].protocol_id = IKEV2_PROTOCOL_ESP;
3948     RAND_bytes ((u8 *) & sa.childs[0].i_proposals[0].spi,
3949                 sizeof (sa.childs[0].i_proposals[0].spi));
3950
3951     /* Add NAT detection notification messages (mandatory) */
3952     u8 *nat_detection_sha1 =
3953       ikev2_compute_nat_sha1 (clib_host_to_net_u64 (sa.ispi),
3954                               clib_host_to_net_u64 (sa.rspi),
3955                               if_ip->as_u32,
3956                               clib_host_to_net_u16 (IKEV2_PORT));
3957
3958     ikev2_payload_add_notify (chain, IKEV2_NOTIFY_MSG_NAT_DETECTION_SOURCE_IP,
3959                               nat_detection_sha1);
3960     vec_free (nat_detection_sha1);
3961     nat_detection_sha1 =
3962       ikev2_compute_nat_sha1 (clib_host_to_net_u64 (sa.ispi),
3963                               clib_host_to_net_u64 (sa.rspi),
3964                               p->responder.ip4.as_u32,
3965                               clib_host_to_net_u16 (sa.dst_port));
3966     ikev2_payload_add_notify (chain,
3967                               IKEV2_NOTIFY_MSG_NAT_DETECTION_DESTINATION_IP,
3968                               nat_detection_sha1);
3969     vec_free (nat_detection_sha1);
3970
3971     u8 *sig_hash_algo = vec_new (u8, 8);
3972     u64 tmpsig = clib_host_to_net_u64 (0x0001000200030004);
3973     clib_memcpy_fast (sig_hash_algo, &tmpsig, sizeof (tmpsig));
3974     ikev2_payload_add_notify (chain,
3975                               IKEV2_NOTIFY_MSG_SIGNATURE_HASH_ALGORITHMS,
3976                               sig_hash_algo);
3977     vec_free (sig_hash_algo);
3978
3979
3980     /* Buffer update and boilerplate */
3981     len += vec_len (chain->data);
3982     ike0->nextpayload = chain->first_payload_type;
3983     ike0->length = clib_host_to_net_u32 (len);
3984     clib_memcpy_fast (ike0->payload, chain->data, vec_len (chain->data));
3985     ikev2_payload_destroy_chain (chain);
3986
3987     ike0->version = IKE_VERSION_2;
3988     ike0->flags = IKEV2_HDR_FLAG_INITIATOR;
3989     ike0->exchange = IKEV2_EXCHANGE_SA_INIT;
3990     ike0->ispi = clib_host_to_net_u64 (sa.ispi);
3991     ike0->rspi = 0;
3992     ike0->msgid = 0;
3993
3994     /* store whole IKE payload - needed for PSK auth */
3995     vec_reset_length (sa.last_sa_init_req_packet_data);
3996     vec_add (sa.last_sa_init_req_packet_data, ike0, len);
3997
3998     /* add data to the SA then add it to the pool */
3999     sa.iaddr.as_u32 = if_ip->as_u32;
4000     sa.raddr.as_u32 = p->responder.ip4.as_u32;
4001     sa.i_id.type = p->loc_id.type;
4002     sa.i_id.data = vec_dup (p->loc_id.data);
4003     sa.r_id.type = p->rem_id.type;
4004     sa.r_id.data = vec_dup (p->rem_id.data);
4005     sa.i_auth.method = p->auth.method;
4006     sa.i_auth.hex = p->auth.hex;
4007     sa.i_auth.data = vec_dup (p->auth.data);
4008     sa.sw_if_index = p->responder.sw_if_index;
4009     vec_add (sa.childs[0].tsi, &p->loc_ts, 1);
4010     vec_add (sa.childs[0].tsr, &p->rem_ts, 1);
4011
4012     ikev2_initial_contact_cleanup (&sa);
4013
4014     /* add SA to the pool */
4015     ikev2_sa_t *sa0 = 0;
4016     pool_get (km->sais, sa0);
4017     clib_memcpy_fast (sa0, &sa, sizeof (*sa0));
4018     hash_set (km->sa_by_ispi, sa0->ispi, sa0 - km->sais);
4019
4020     ikev2_send_ike (vm, if_ip, &p->responder.ip4, bi0, len,
4021                     IKEV2_PORT, sa.dst_port, sa.sw_if_index);
4022
4023     ikev2_elog_exchange ("ispi %lx rspi %lx IKEV2_EXCHANGE_SA_INIT sent to "
4024                          "%d.%d.%d.%d", clib_host_to_net_u64 (sa0->ispi), 0,
4025                          p->responder.ip4.as_u32);
4026   }
4027
4028   return 0;
4029 }
4030
4031 static void
4032 ikev2_delete_child_sa_internal (vlib_main_t * vm, ikev2_sa_t * sa,
4033                                 ikev2_child_sa_t * csa)
4034 {
4035   /* Create the Initiator notification for child SA removal */
4036   ikev2_main_t *km = &ikev2_main;
4037   ike_header_t *ike0;
4038   u32 bi0 = 0;
4039   vlib_buffer_t *b0;
4040   int len;
4041
4042   bi0 = ikev2_get_new_ike_header_buff (vm, &b0);
4043   if (!bi0)
4044     {
4045       ikev2_log_error ("buffer alloc failure");
4046       return;
4047     }
4048
4049   ike0 = vlib_buffer_get_current (b0);
4050   ike0->exchange = IKEV2_EXCHANGE_INFORMATIONAL;
4051   ike0->ispi = clib_host_to_net_u64 (sa->ispi);
4052   ike0->rspi = clib_host_to_net_u64 (sa->rspi);
4053   vec_resize (sa->del, 1);
4054   sa->del->protocol_id = IKEV2_PROTOCOL_ESP;
4055   sa->del->spi = csa->i_proposals->spi;
4056   ike0->msgid = clib_host_to_net_u32 (sa->last_init_msg_id + 1);
4057   sa->last_init_msg_id = clib_net_to_host_u32 (ike0->msgid);
4058   len = ikev2_generate_message (b0, sa, ike0, 0, 0);
4059   if (~0 == len)
4060     return;
4061
4062   if (sa->natt)
4063     len = ikev2_insert_non_esp_marker (ike0, len);
4064   ikev2_send_ike (vm, &sa->iaddr, &sa->raddr, bi0, len,
4065                   ikev2_get_port (sa), sa->dst_port, sa->sw_if_index);
4066
4067   /* delete local child SA */
4068   ikev2_delete_tunnel_interface (km->vnet_main, sa, csa);
4069   ikev2_sa_del_child_sa (sa, csa);
4070 }
4071
4072 clib_error_t *
4073 ikev2_initiate_delete_child_sa (vlib_main_t * vm, u32 ispi)
4074 {
4075   clib_error_t *r;
4076   ikev2_main_t *km = &ikev2_main;
4077   ikev2_main_per_thread_data_t *tkm;
4078   ikev2_sa_t *fsa = 0;
4079   ikev2_child_sa_t *fchild = 0;
4080
4081   /* Search for the child SA */
4082   vec_foreach (tkm, km->per_thread_data)
4083   {
4084     ikev2_sa_t *sa;
4085     if (fchild)
4086       break;
4087     /* *INDENT-OFF* */
4088     pool_foreach (sa, tkm->sas, ({
4089       fchild = ikev2_sa_get_child(sa, ispi, IKEV2_PROTOCOL_ESP, 1);
4090       if (fchild)
4091         {
4092           fsa = sa;
4093           break;
4094         }
4095     }));
4096     /* *INDENT-ON* */
4097   }
4098
4099   if (!fchild || !fsa)
4100     {
4101       r = clib_error_return (0, "Child SA not found");
4102       return r;
4103     }
4104   else
4105     {
4106       ikev2_delete_child_sa_internal (vm, fsa, fchild);
4107     }
4108
4109   return 0;
4110 }
4111
4112 clib_error_t *
4113 ikev2_initiate_delete_ike_sa (vlib_main_t * vm, u64 ispi)
4114 {
4115   clib_error_t *r;
4116   ikev2_main_t *km = &ikev2_main;
4117   ikev2_main_per_thread_data_t *tkm;
4118   ikev2_sa_t *fsa = 0;
4119   ikev2_main_per_thread_data_t *ftkm = 0;
4120
4121   /* Search for the IKE SA */
4122   vec_foreach (tkm, km->per_thread_data)
4123   {
4124     ikev2_sa_t *sa;
4125     if (fsa)
4126       break;
4127     /* *INDENT-OFF* */
4128     pool_foreach (sa, tkm->sas, ({
4129       if (sa->ispi == ispi)
4130         {
4131           fsa = sa;
4132           ftkm = tkm;
4133           break;
4134         }
4135     }));
4136     /* *INDENT-ON* */
4137   }
4138
4139   if (!fsa)
4140     {
4141       r = clib_error_return (0, "IKE SA not found");
4142       return r;
4143     }
4144
4145   ikev2_initiate_delete_ike_sa_internal (vm, ftkm, fsa);
4146   return 0;
4147 }
4148
4149 static void
4150 ikev2_rekey_child_sa_internal (vlib_main_t * vm, ikev2_sa_t * sa,
4151                                ikev2_child_sa_t * csa)
4152 {
4153   /* Create the Initiator request for create child SA */
4154   ike_header_t *ike0;
4155   vlib_buffer_t *b0;
4156   u32 bi0 = 0;
4157   int len;
4158
4159   bi0 = ikev2_get_new_ike_header_buff (vm, &b0);
4160   if (!bi0)
4161     {
4162       ikev2_log_error ("buffer alloc failure");
4163       return;
4164     }
4165
4166   ike0 = vlib_buffer_get_current (b0);
4167   ike0->version = IKE_VERSION_2;
4168   ike0->flags = IKEV2_HDR_FLAG_INITIATOR;
4169   ike0->exchange = IKEV2_EXCHANGE_CREATE_CHILD_SA;
4170   ike0->ispi = clib_host_to_net_u64 (sa->ispi);
4171   ike0->rspi = clib_host_to_net_u64 (sa->rspi);
4172   ike0->msgid = clib_host_to_net_u32 (sa->last_init_msg_id + 1);
4173   sa->last_init_msg_id = clib_net_to_host_u32 (ike0->msgid);
4174
4175   ikev2_rekey_t *rekey;
4176   vec_add2 (sa->rekey, rekey, 1);
4177   ikev2_sa_proposal_t *proposals = vec_dup (csa->i_proposals);
4178
4179   /*need new ispi */
4180   RAND_bytes ((u8 *) & proposals[0].spi, sizeof (proposals[0].spi));
4181   rekey->spi = proposals[0].spi;
4182   rekey->ispi = csa->i_proposals->spi;
4183   len = ikev2_generate_message (b0, sa, ike0, proposals, 0);
4184   if (~0 == len)
4185     return;
4186
4187   if (sa->natt)
4188     len = ikev2_insert_non_esp_marker (ike0, len);
4189   ikev2_send_ike (vm, &sa->iaddr, &sa->raddr, bi0, len,
4190                   ikev2_get_port (sa), ikev2_get_port (sa), sa->sw_if_index);
4191   vec_free (proposals);
4192 }
4193
4194 clib_error_t *
4195 ikev2_initiate_rekey_child_sa (vlib_main_t * vm, u32 ispi)
4196 {
4197   clib_error_t *r;
4198   ikev2_main_t *km = &ikev2_main;
4199   ikev2_main_per_thread_data_t *tkm;
4200   ikev2_sa_t *fsa = 0;
4201   ikev2_child_sa_t *fchild = 0;
4202
4203   /* Search for the child SA */
4204   vec_foreach (tkm, km->per_thread_data)
4205   {
4206     ikev2_sa_t *sa;
4207     if (fchild)
4208       break;
4209     /* *INDENT-OFF* */
4210     pool_foreach (sa, tkm->sas, ({
4211       fchild = ikev2_sa_get_child(sa, ispi, IKEV2_PROTOCOL_ESP, 1);
4212       if (fchild)
4213         {
4214           fsa = sa;
4215           break;
4216         }
4217     }));
4218     /* *INDENT-ON* */
4219   }
4220
4221   if (!fchild || !fsa)
4222     {
4223       r = clib_error_return (0, "Child SA not found");
4224       return r;
4225     }
4226   else
4227     {
4228       ikev2_rekey_child_sa_internal (vm, fsa, fchild);
4229     }
4230
4231   return 0;
4232 }
4233
4234 clib_error_t *
4235 ikev2_init (vlib_main_t * vm)
4236 {
4237   ikev2_main_t *km = &ikev2_main;
4238   vlib_thread_main_t *tm = vlib_get_thread_main ();
4239   int thread_id;
4240
4241   clib_memset (km, 0, sizeof (ikev2_main_t));
4242   km->vnet_main = vnet_get_main ();
4243   km->vlib_main = vm;
4244
4245   km->liveness_period = IKEV2_LIVENESS_PERIOD_CHECK;
4246   km->liveness_max_retries = IKEV2_LIVENESS_RETRIES;
4247   ikev2_crypto_init (km);
4248
4249   mhash_init_vec_string (&km->profile_index_by_name, sizeof (uword));
4250
4251   vec_validate_aligned (km->per_thread_data, tm->n_vlib_mains - 1,
4252                         CLIB_CACHE_LINE_BYTES);
4253   for (thread_id = 0; thread_id < tm->n_vlib_mains; thread_id++)
4254     {
4255       ikev2_main_per_thread_data_t *ptd =
4256         vec_elt_at_index (km->per_thread_data, thread_id);
4257
4258       ptd->sa_by_rspi = hash_create (0, sizeof (uword));
4259
4260 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
4261       ptd->evp_ctx = EVP_CIPHER_CTX_new ();
4262       ptd->hmac_ctx = HMAC_CTX_new ();
4263 #else
4264       EVP_CIPHER_CTX_init (&ptd->_evp_ctx);
4265       ptd->evp_ctx = &ptd->_evp_ctx;
4266       HMAC_CTX_init (&(ptd->_hmac_ctx));
4267       ptd->hmac_ctx = &ptd->_hmac_ctx;
4268 #endif
4269     }
4270
4271   km->sa_by_ispi = hash_create (0, sizeof (uword));
4272   km->sw_if_indices = hash_create (0, 0);
4273   km->udp_ports = hash_create (0, sizeof (uword));
4274
4275   udp_register_dst_port (vm, IKEV2_PORT, ikev2_node.index, 1);
4276   udp_register_dst_port (vm, IKEV2_PORT_NATT, ikev2_node.index, 1);
4277
4278   vlib_punt_hdl_t punt_hdl = vlib_punt_client_register ("ikev2");
4279   vlib_punt_register (punt_hdl, ipsec_punt_reason[IPSEC_PUNT_IP4_SPI_UDP_0],
4280                       "ikev2");
4281   ikev2_cli_reference ();
4282
4283   km->log_level = IKEV2_LOG_ERROR;
4284   km->log_class = vlib_log_register_class ("ikev2", 0);
4285   return 0;
4286 }
4287
4288 /* *INDENT-OFF* */
4289 VLIB_INIT_FUNCTION (ikev2_init) =
4290 {
4291   .runs_after = VLIB_INITS("ipsec_init", "ipsec_punt_init"),
4292 };
4293 /* *INDENT-ON* */
4294
4295 static u8
4296 ikev2_mngr_process_child_sa (ikev2_sa_t * sa, ikev2_child_sa_t * csa,
4297                              u8 del_old_ids)
4298 {
4299   ikev2_main_t *km = &ikev2_main;
4300   ikev2_profile_t *p = 0;
4301   vlib_main_t *vm = km->vlib_main;
4302   f64 now = vlib_time_now (vm);
4303   u8 res = 0;
4304
4305   if (sa->profile_index != ~0)
4306     p = pool_elt_at_index (km->profiles, sa->profile_index);
4307
4308   if (sa->is_initiator && p && csa->time_to_expiration
4309       && now > csa->time_to_expiration)
4310     {
4311       if (!csa->is_expired || csa->rekey_retries > 0)
4312         {
4313           ikev2_rekey_child_sa_internal (vm, sa, csa);
4314           csa->time_to_expiration = now + p->handover;
4315           csa->is_expired = 1;
4316           if (csa->rekey_retries == 0)
4317             {
4318               csa->rekey_retries = 5;
4319             }
4320           else if (csa->rekey_retries > 0)
4321             {
4322               csa->rekey_retries--;
4323               ikev2_log_debug ("Rekeying Child SA 0x%x, retries left %d",
4324                                csa->i_proposals->spi, csa->rekey_retries);
4325               if (csa->rekey_retries == 0)
4326                 {
4327                   csa->rekey_retries = -1;
4328                 }
4329             }
4330           res |= 1;
4331         }
4332       else
4333         {
4334           csa->time_to_expiration = 0;
4335           ikev2_delete_child_sa_internal (vm, sa, csa);
4336           res |= 1;
4337           return res;
4338         }
4339     }
4340
4341   if (del_old_ids)
4342     {
4343       ipip_tunnel_t *ipip = NULL;
4344       u32 sw_if_index = sa->is_tun_itf_set ? sa->tun_itf : ~0;
4345       if (~0 == sw_if_index)
4346         {
4347           ip46_address_t local_ip;
4348           ip46_address_t remote_ip;
4349           if (sa->is_initiator)
4350             {
4351               ip46_address_set_ip4 (&local_ip, &sa->iaddr);
4352               ip46_address_set_ip4 (&remote_ip, &sa->raddr);
4353             }
4354           else
4355             {
4356               ip46_address_set_ip4 (&local_ip, &sa->raddr);
4357               ip46_address_set_ip4 (&remote_ip, &sa->iaddr);
4358             }
4359
4360        /* *INDENT-OFF* */
4361        ipip_tunnel_key_t key = {
4362          .src = local_ip,
4363          .dst = remote_ip,
4364          .transport = IPIP_TRANSPORT_IP4,
4365          .fib_index = 0,
4366        };
4367        /* *INDENT-ON* */
4368
4369           ipip = ipip_tunnel_db_find (&key);
4370
4371           if (ipip)
4372             sw_if_index = ipip->sw_if_index;
4373           else
4374             return res;
4375         }
4376
4377       u32 *sas_in = NULL;
4378       vec_add1 (sas_in, csa->remote_sa_id);
4379       vlib_worker_thread_barrier_sync (vm);
4380       ipsec_tun_protect_update (sw_if_index, NULL, csa->local_sa_id, sas_in);
4381       ipsec_sa_unlock_id (ikev2_flip_alternate_sa_bit (csa->remote_sa_id));
4382       vlib_worker_thread_barrier_release (vm);
4383     }
4384
4385   return res;
4386 }
4387
4388 int
4389 ikev2_set_log_level (ikev2_log_level_t log_level)
4390 {
4391   ikev2_main_t *km = &ikev2_main;
4392
4393   if (log_level >= IKEV2_LOG_MAX)
4394     {
4395       ikev2_log_error ("unknown logging level %d", log_level);
4396       return -1;
4397     }
4398
4399   km->log_level = log_level;
4400   return 0;
4401 }
4402
4403 clib_error_t *
4404 ikev2_set_liveness_params (u32 period, u32 max_retries)
4405 {
4406   ikev2_main_t *km = &ikev2_main;
4407
4408   if (period == 0 || max_retries == 0)
4409     return clib_error_return (0, "invalid args");
4410
4411   km->liveness_period = period;
4412   km->liveness_max_retries = max_retries;
4413   return 0;
4414 }
4415
4416 static void
4417 ikev2_mngr_process_ipsec_sa (ipsec_sa_t * ipsec_sa)
4418 {
4419   ikev2_main_t *km = &ikev2_main;
4420   vlib_main_t *vm = km->vlib_main;
4421   ikev2_main_per_thread_data_t *tkm;
4422   ikev2_sa_t *fsa = 0;
4423   ikev2_profile_t *p = 0;
4424   ikev2_child_sa_t *fchild = 0;
4425   f64 now = vlib_time_now (vm);
4426   vlib_counter_t counts;
4427
4428   /* Search for the SA and child SA */
4429   vec_foreach (tkm, km->per_thread_data)
4430   {
4431     ikev2_sa_t *sa;
4432     if (fchild)
4433       break;
4434     /* *INDENT-OFF* */
4435     pool_foreach (sa, tkm->sas, ({
4436       fchild = ikev2_sa_get_child(sa, ipsec_sa->spi, IKEV2_PROTOCOL_ESP, 1);
4437       if (fchild)
4438         {
4439           fsa = sa;
4440           break;
4441         }
4442     }));
4443     /* *INDENT-ON* */
4444   }
4445   vlib_get_combined_counter (&ipsec_sa_counters,
4446                              ipsec_sa->stat_index, &counts);
4447
4448   if (fsa && fsa->profile_index != ~0 && fsa->is_initiator)
4449     p = pool_elt_at_index (km->profiles, fsa->profile_index);
4450
4451   if (fchild && p && p->lifetime_maxdata)
4452     {
4453       if (!fchild->is_expired && counts.bytes > p->lifetime_maxdata)
4454         {
4455           fchild->time_to_expiration = now;
4456         }
4457     }
4458 }
4459
4460 static void
4461 ikev2_process_pending_sa_init (ikev2_main_t * km)
4462 {
4463   u32 sai;
4464   u64 ispi;
4465   ikev2_sa_t *sa;
4466
4467   /* *INDENT-OFF* */
4468   hash_foreach (ispi, sai, km->sa_by_ispi,
4469   ({
4470     sa = pool_elt_at_index (km->sais, sai);
4471     if (sa->init_response_received)
4472       continue;
4473
4474     u32 bi0;
4475     if (vlib_buffer_alloc (km->vlib_main, &bi0, 1) != 1)
4476       return;
4477
4478     vlib_buffer_t * b = vlib_get_buffer (km->vlib_main, bi0);
4479     clib_memcpy_fast (vlib_buffer_get_current (b),
4480         sa->last_sa_init_req_packet_data,
4481         vec_len (sa->last_sa_init_req_packet_data));
4482     ikev2_send_ike (km->vlib_main, &sa->iaddr, &sa->raddr, bi0,
4483         vec_len (sa->last_sa_init_req_packet_data),
4484         ikev2_get_port (sa), IKEV2_PORT, sa->sw_if_index);
4485   }));
4486   /* *INDENT-ON* */
4487 }
4488
4489 static vlib_node_registration_t ikev2_mngr_process_node;
4490
4491 static void
4492 ikev2_send_informational_request (ikev2_sa_t * sa)
4493 {
4494   ikev2_main_t *km = &ikev2_main;
4495   ip4_address_t *src, *dst;
4496   ike_header_t *ike0;
4497   vlib_buffer_t *b0;
4498   u32 bi0 = 0;
4499   u16 dp;
4500   int len;
4501
4502   bi0 = ikev2_get_new_ike_header_buff (km->vlib_main, &b0);
4503   if (!bi0)
4504     {
4505       ikev2_log_error ("buffer alloc failure");
4506       return;
4507     }
4508
4509   ike0 = vlib_buffer_get_current (b0);
4510   ike0->exchange = IKEV2_EXCHANGE_INFORMATIONAL;
4511   ike0->ispi = clib_host_to_net_u64 (sa->ispi);
4512   ike0->rspi = clib_host_to_net_u64 (sa->rspi);
4513   ike0->msgid = clib_host_to_net_u32 (sa->last_init_msg_id + 1);
4514   sa->last_init_msg_id = clib_net_to_host_u32 (ike0->msgid);
4515   len = ikev2_generate_message (b0, sa, ike0, 0, 0);
4516   if (~0 == len)
4517     return;
4518
4519   if (sa->natt)
4520     len = ikev2_insert_non_esp_marker (ike0, len);
4521
4522   if (sa->is_initiator)
4523     {
4524       src = &sa->iaddr;
4525       dst = &sa->raddr;
4526     }
4527   else
4528     {
4529       dst = &sa->iaddr;
4530       src = &sa->raddr;
4531     }
4532
4533   dp = sa->dst_port ? sa->dst_port : ikev2_get_port (sa);
4534   ikev2_send_ike (km->vlib_main, src, dst, bi0, len, ikev2_get_port (sa), dp,
4535                   sa->sw_if_index);
4536 }
4537
4538 static_always_inline int
4539 ikev2_mngr_process_responder_sas (ikev2_sa_t * sa)
4540 {
4541   ikev2_main_t *km = &ikev2_main;
4542   vlib_main_t *vm = km->vlib_main;
4543
4544   if (!sa->keys_generated)
4545     return 0;
4546
4547   if (sa->liveness_retries >= km->liveness_max_retries)
4548     return 1;
4549
4550   f64 now = vlib_time_now (vm);
4551
4552   if (sa->liveness_period_check < now)
4553     {
4554       sa->liveness_retries++;
4555       sa->liveness_period_check = now + km->liveness_period;
4556       ikev2_send_informational_request (sa);
4557     }
4558   return 0;
4559 }
4560
4561 static uword
4562 ikev2_mngr_process_fn (vlib_main_t * vm, vlib_node_runtime_t * rt,
4563                        vlib_frame_t * f)
4564 {
4565   ikev2_main_t *km = &ikev2_main;
4566   ipsec_main_t *im = &ipsec_main;
4567   ikev2_profile_t *p;
4568   ikev2_child_sa_t *c;
4569   u32 *sai;
4570
4571   while (1)
4572     {
4573       u8 req_sent = 0;
4574       vlib_process_wait_for_event_or_clock (vm, 1);
4575       vlib_process_get_events (vm, NULL);
4576
4577       /* process ike child sas */
4578       ikev2_main_per_thread_data_t *tkm;
4579       vec_foreach (tkm, km->per_thread_data)
4580       {
4581         ikev2_sa_t *sa;
4582         u32 *to_be_deleted = 0;
4583
4584         /* *INDENT-OFF* */
4585         pool_foreach (sa, tkm->sas, ({
4586           ikev2_child_sa_t *c;
4587           u8 del_old_ids = 0;
4588           if (sa->old_remote_id_present && 0 > sa->old_id_expiration)
4589             {
4590               sa->old_remote_id_present = 0;
4591               del_old_ids = 1;
4592             }
4593           else
4594             sa->old_id_expiration -= 1;
4595
4596           vec_foreach (c, sa->childs)
4597             {
4598             req_sent |= ikev2_mngr_process_child_sa(sa, c, del_old_ids);
4599             }
4600
4601           if (ikev2_mngr_process_responder_sas (sa))
4602             vec_add1 (to_be_deleted, sa - tkm->sas);
4603         }));
4604         /* *INDENT-ON* */
4605
4606         vec_foreach (sai, to_be_deleted)
4607         {
4608           sa = pool_elt_at_index (tkm->sas, sai[0]);
4609           u8 reinitiate = (sa->is_initiator && sa->profile_index != ~0);
4610           vec_foreach (c, sa->childs)
4611           {
4612             ikev2_delete_tunnel_interface (km->vnet_main, sa, c);
4613             ikev2_sa_del_child_sa (sa, c);
4614           }
4615           ikev2_sa_free_all_vec (sa);
4616           hash_unset (tkm->sa_by_rspi, sa->rspi);
4617           pool_put (tkm->sas, sa);
4618
4619           if (reinitiate)
4620             {
4621               p = pool_elt_at_index (km->profiles, sa->profile_index);
4622               if (p)
4623                 {
4624                   ikev2_initiate_sa_init (vm, p->name);
4625                 }
4626             }
4627         }
4628         vec_free (to_be_deleted);
4629       }
4630
4631       /* process ipsec sas */
4632       ipsec_sa_t *sa;
4633       /* *INDENT-OFF* */
4634       pool_foreach (sa, im->sad, ({
4635         ikev2_mngr_process_ipsec_sa(sa);
4636       }));
4637       /* *INDENT-ON* */
4638
4639       ikev2_process_pending_sa_init (km);
4640
4641       if (req_sent)
4642         {
4643           vlib_process_wait_for_event_or_clock (vm, 5);
4644           vlib_process_get_events (vm, NULL);
4645           req_sent = 0;
4646         }
4647
4648     }
4649   return 0;
4650 }
4651
4652 /* *INDENT-OFF* */
4653 VLIB_REGISTER_NODE (ikev2_mngr_process_node, static) = {
4654     .function = ikev2_mngr_process_fn,
4655     .type = VLIB_NODE_TYPE_PROCESS,
4656     .name =
4657     "ikev2-manager-process",
4658 };
4659
4660 VLIB_PLUGIN_REGISTER () = {
4661     .version = VPP_BUILD_VER,
4662     .description = "Internet Key Exchange (IKEv2) Protocol",
4663 };
4664 /* *INDENT-ON* */
4665
4666 /*
4667  * fd.io coding-style-patch-verification: ON
4668  *
4669  * Local Variables:
4670  * eval: (c-set-style "gnu")
4671  * End:
4672  */