src/plugins/ikev2/ikev2.c

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