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