src/vnet/ipsec/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 <vnet/vnet.h>
  18 #include <vnet/pg/pg.h>
  19 #include <vppinfra/error.h>
  20 #include <vppinfra/random.h>
  21 #include <vnet/udp/udp.h>
  22 #include <vnet/ipsec/ipsec.h>
  23 #include <vnet/ipsec/ikev2.h>
  24 #include <vnet/ipsec/ikev2_priv.h>
  25 #include <openssl/sha.h>
  26
  27 ikev2_main_t ikev2_main;
  28
  29 static int ikev2_delete_tunnel_interface (vnet_main_t * vnm,
  30                                           ikev2_sa_t * sa,
  31                                           ikev2_child_sa_t * child);
  32
  33 #define ikev2_set_state(sa, v) do { \
  34     (sa)->state = v; \
  35     clib_warning("sa state changed to " #v); \
  36   } while(0);
  37
  38 typedef struct
  39 {
  40   u32 next_index;
  41   u32 sw_if_index;
  42 } ikev2_trace_t;
  43
  44 static u8 *
  45 format_ikev2_trace (u8 * s, va_list * args)
  46 {
  47   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  48   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  49   ikev2_trace_t *t = va_arg (*args, ikev2_trace_t *);
  50
  51   s = format (s, "ikev2: sw_if_index %d, next index %d",
  52               t->sw_if_index, t->next_index);
  53   return s;
  54 }
  55
  56 static vlib_node_registration_t ikev2_node;
  57
  58 #define foreach_ikev2_error \
  59 _(PROCESSED, "IKEv2 packets processed") \
  60 _(IKE_SA_INIT_RETRANSMIT, "IKE_SA_INIT retransmit ") \
  61 _(IKE_SA_INIT_IGNORE, "IKE_SA_INIT ignore (IKE SA already auth)") \
  62 _(IKE_REQ_RETRANSMIT, "IKE request retransmit") \
  63 _(IKE_REQ_IGNORE, "IKE request ignore (old msgid)") \
  64 _(NOT_IKEV2, "Non IKEv2 packets received")
  65
  66 typedef enum
  67 {
  68 #define _(sym,str) IKEV2_ERROR_##sym,
  69   foreach_ikev2_error
  70 #undef _
  71     IKEV2_N_ERROR,
  72 } ikev2_error_t;
  73
  74 static char *ikev2_error_strings[] = {
  75 #define _(sym,string) string,
  76   foreach_ikev2_error
  77 #undef _
  78 };
  79
  80 typedef enum
  81 {
  82   IKEV2_NEXT_IP4_LOOKUP,
  83   IKEV2_NEXT_ERROR_DROP,
  84   IKEV2_N_NEXT,
  85 } ikev2_next_t;
  86
  87 static ikev2_sa_transform_t *
  88 ikev2_find_transform_data (ikev2_sa_transform_t * t)
  89 {
  90   ikev2_main_t *km = &ikev2_main;
  91   ikev2_sa_transform_t *td;
  92
  93   vec_foreach (td, km->supported_transforms)
  94   {
  95     if (td->type != t->type)
  96       continue;
  97
  98     if (td->transform_id != t->transform_id)
  99       continue;
 100
 101     if (td->type == IKEV2_TRANSFORM_TYPE_ENCR)
 102       {
 103         if (vec_len (t->attrs) != 4 || t->attrs[0] != 0x80
 104             || t->attrs[1] != 14)
 105           continue;
 106
 107         if (((t->attrs[2] << 8 | t->attrs[3]) / 8) != td->key_len)
 108           continue;
 109       }
 110     return td;
 111   }
 112   return 0;
 113 }
 114
 115 static ikev2_sa_proposal_t *
 116 ikev2_select_proposal (ikev2_sa_proposal_t * proposals,
 117                        ikev2_protocol_id_t prot_id)
 118 {
 119   ikev2_sa_proposal_t *rv = 0;
 120   ikev2_sa_proposal_t *proposal;
 121   ikev2_sa_transform_t *transform, *new_t;
 122   u8 mandatory_bitmap, optional_bitmap;
 123
 124   if (prot_id == IKEV2_PROTOCOL_IKE)
 125     {
 126       mandatory_bitmap = (1 << IKEV2_TRANSFORM_TYPE_ENCR) |
 127         (1 << IKEV2_TRANSFORM_TYPE_PRF) |
 128         (1 << IKEV2_TRANSFORM_TYPE_INTEG) | (1 << IKEV2_TRANSFORM_TYPE_DH);
 129       optional_bitmap = mandatory_bitmap;
 130     }
 131   else if (prot_id == IKEV2_PROTOCOL_ESP)
 132     {
 133       mandatory_bitmap = (1 << IKEV2_TRANSFORM_TYPE_ENCR) |
 134         (1 << IKEV2_TRANSFORM_TYPE_ESN);
 135       optional_bitmap = mandatory_bitmap |
 136         (1 << IKEV2_TRANSFORM_TYPE_INTEG) | (1 << IKEV2_TRANSFORM_TYPE_DH);
 137     }
 138   else if (prot_id == IKEV2_PROTOCOL_AH)
 139     {
 140       mandatory_bitmap = (1 << IKEV2_TRANSFORM_TYPE_INTEG) |
 141         (1 << IKEV2_TRANSFORM_TYPE_ESN);
 142       optional_bitmap = mandatory_bitmap | (1 << IKEV2_TRANSFORM_TYPE_DH);
 143     }
 144   else
 145     return 0;
 146
 147   vec_add2 (rv, proposal, 1);
 148
 149   vec_foreach (proposal, proposals)
 150   {
 151     u8 bitmap = 0;
 152     if (proposal->protocol_id != prot_id)
 153       continue;
 154
 155     vec_foreach (transform, proposal->transforms)
 156     {
 157       if ((1 << transform->type) & bitmap)
 158         continue;
 159
 160       if (ikev2_find_transform_data (transform))
 161         {
 162           bitmap |= 1 << transform->type;
 163           vec_add2 (rv->transforms, new_t, 1);
 164           clib_memcpy (new_t, transform, sizeof (*new_t));
 165           new_t->attrs = vec_dup (transform->attrs);
 166         }
 167     }
 168
 169     clib_warning ("bitmap is %x mandatory is %x optional is %x",
 170                   bitmap, mandatory_bitmap, optional_bitmap);
 171
 172     if ((bitmap & mandatory_bitmap) == mandatory_bitmap &&
 173         (bitmap & ~optional_bitmap) == 0)
 174       {
 175         rv->proposal_num = proposal->proposal_num;
 176         rv->protocol_id = proposal->protocol_id;
 177         RAND_bytes ((u8 *) & rv->spi, sizeof (rv->spi));
 178         goto done;
 179       }
 180     else
 181       {
 182         vec_free (rv->transforms);
 183       }
 184   }
 185
 186   vec_free (rv);
 187 done:
 188   return rv;
 189 }
 190
 191 ikev2_sa_transform_t *
 192 ikev2_sa_get_td_for_type (ikev2_sa_proposal_t * p,
 193                           ikev2_transform_type_t type)
 194 {
 195   ikev2_sa_transform_t *t;
 196
 197   if (!p)
 198     return 0;
 199
 200   vec_foreach (t, p->transforms)
 201   {
 202     if (t->type == type)
 203       return ikev2_find_transform_data (t);
 204   }
 205   return 0;
 206 }
 207
 208 ikev2_child_sa_t *
 209 ikev2_sa_get_child (ikev2_sa_t * sa, u32 spi, ikev2_protocol_id_t prot_id,
 210                     int by_initiator)
 211 {
 212   ikev2_child_sa_t *c;
 213   vec_foreach (c, sa->childs)
 214   {
 215     ikev2_sa_proposal_t *proposal =
 216       by_initiator ? &c->i_proposals[0] : &c->r_proposals[0];
 217     if (proposal && proposal->spi == spi && proposal->protocol_id == prot_id)
 218       return c;
 219   }
 220
 221   return 0;
 222 }
 223
 224 void
 225 ikev2_sa_free_proposal_vector (ikev2_sa_proposal_t ** v)
 226 {
 227   ikev2_sa_proposal_t *p;
 228   ikev2_sa_transform_t *t;
 229
 230   if (!*v)
 231     return;
 232
 233   vec_foreach (p, *v)
 234   {
 235     vec_foreach (t, p->transforms)
 236     {
 237       vec_free (t->attrs);
 238     }
 239     vec_free (p->transforms);
 240   }
 241   vec_free (*v);
 242 };
 243
 244 static void
 245 ikev2_sa_free_all_child_sa (ikev2_child_sa_t ** childs)
 246 {
 247   ikev2_child_sa_t *c;
 248   vec_foreach (c, *childs)
 249   {
 250     ikev2_sa_free_proposal_vector (&c->r_proposals);
 251     ikev2_sa_free_proposal_vector (&c->i_proposals);
 252     vec_free (c->sk_ai);
 253     vec_free (c->sk_ar);
 254     vec_free (c->sk_ei);
 255     vec_free (c->sk_er);
 256   }
 257
 258   vec_free (*childs);
 259 }
 260
 261 static void
 262 ikev2_sa_del_child_sa (ikev2_sa_t * sa, ikev2_child_sa_t * child)
 263 {
 264   ikev2_sa_free_proposal_vector (&child->r_proposals);
 265   ikev2_sa_free_proposal_vector (&child->i_proposals);
 266   vec_free (child->sk_ai);
 267   vec_free (child->sk_ar);
 268   vec_free (child->sk_ei);
 269   vec_free (child->sk_er);
 270
 271   vec_del1 (sa->childs, child - sa->childs);
 272 }
 273
 274 static void
 275 ikev2_sa_free_all_vec (ikev2_sa_t * sa)
 276 {
 277   vec_free (sa->i_nonce);
 278   vec_free (sa->i_dh_data);
 279   vec_free (sa->dh_shared_key);
 280   vec_free (sa->dh_private_key);
 281
 282   ikev2_sa_free_proposal_vector (&sa->r_proposals);
 283   ikev2_sa_free_proposal_vector (&sa->i_proposals);
 284
 285   vec_free (sa->sk_d);
 286   vec_free (sa->sk_ai);
 287   vec_free (sa->sk_ar);
 288   vec_free (sa->sk_ei);
 289   vec_free (sa->sk_er);
 290   vec_free (sa->sk_pi);
 291   vec_free (sa->sk_pr);
 292
 293   vec_free (sa->i_id.data);
 294   vec_free (sa->i_auth.data);
 295   vec_free (sa->r_id.data);
 296   vec_free (sa->r_auth.data);
 297   if (sa->r_auth.key)
 298     EVP_PKEY_free (sa->r_auth.key);
 299
 300   vec_free (sa->del);
 301
 302   ikev2_sa_free_all_child_sa (&sa->childs);
 303 }
 304
 305 static void
 306 ikev2_delete_sa (ikev2_sa_t * sa)
 307 {
 308   ikev2_main_t *km = &ikev2_main;
 309   u32 thread_index = vlib_get_thread_index ();
 310   uword *p;
 311
 312   ikev2_sa_free_all_vec (sa);
 313
 314   p = hash_get (km->per_thread_data[thread_index].sa_by_rspi, sa->rspi);
 315   if (p)
 316     {
 317       hash_unset (km->per_thread_data[thread_index].sa_by_rspi, sa->rspi);
 318       pool_put (km->per_thread_data[thread_index].sas, sa);
 319     }
 320 }
 321
 322 static void
 323 ikev2_generate_sa_init_data (ikev2_sa_t * sa)
 324 {
 325   ikev2_sa_transform_t *t = 0, *t2;
 326   ikev2_main_t *km = &ikev2_main;
 327
 328   if (sa->dh_group == IKEV2_TRANSFORM_DH_TYPE_NONE)
 329     {
 330       return;
 331     }
 332
 333   /* check if received DH group is on our list of supported groups */
 334   vec_foreach (t2, km->supported_transforms)
 335   {
 336     if (t2->type == IKEV2_TRANSFORM_TYPE_DH && sa->dh_group == t2->dh_type)
 337       {
 338         t = t2;
 339         break;
 340       }
 341   }
 342
 343   if (!t)
 344     {
 345       clib_warning ("unknown dh data group %u (data len %u)", sa->dh_group,
 346                     vec_len (sa->i_dh_data));
 347       sa->dh_group = IKEV2_TRANSFORM_DH_TYPE_NONE;
 348       return;
 349     }
 350
 351   if (sa->is_initiator)
 352     {
 353       /* generate rspi */
 354       RAND_bytes ((u8 *) & sa->ispi, 8);
 355
 356       /* generate nonce */
 357       sa->i_nonce = vec_new (u8, IKEV2_NONCE_SIZE);
 358       RAND_bytes ((u8 *) sa->i_nonce, IKEV2_NONCE_SIZE);
 359     }
 360   else
 361     {
 362       /* generate rspi */
 363       RAND_bytes ((u8 *) & sa->rspi, 8);
 364
 365       /* generate nonce */
 366       sa->r_nonce = vec_new (u8, IKEV2_NONCE_SIZE);
 367       RAND_bytes ((u8 *) sa->r_nonce, IKEV2_NONCE_SIZE);
 368     }
 369
 370   /* generate dh keys */
 371   ikev2_generate_dh (sa, t);
 372
 373 }
 374
 375 static void
 376 ikev2_complete_sa_data (ikev2_sa_t * sa, ikev2_sa_t * sai)
 377 {
 378   ikev2_sa_transform_t *t = 0, *t2;
 379   ikev2_main_t *km = &ikev2_main;
 380
 381
 382   /*move some data to the new SA */
 383 #define _(A) ({void* __tmp__ = (A); (A) = 0; __tmp__;})
 384   sa->i_nonce = _(sai->i_nonce);
 385   sa->i_dh_data = _(sai->i_dh_data);
 386   sa->dh_private_key = _(sai->dh_private_key);
 387   sa->iaddr.as_u32 = sai->iaddr.as_u32;
 388   sa->raddr.as_u32 = sai->raddr.as_u32;
 389   sa->is_initiator = sai->is_initiator;
 390   sa->profile = sai->profile;
 391   sa->i_id.type = sai->i_id.type;
 392   sa->i_id.data = _(sai->i_id.data);
 393   sa->i_auth.method = sai->i_auth.method;
 394   sa->i_auth.hex = sai->i_auth.hex;
 395   sa->i_auth.data = _(sai->i_auth.data);
 396   sa->i_auth.key = _(sai->i_auth.key);
 397   sa->last_sa_init_req_packet_data = _(sai->last_sa_init_req_packet_data);
 398   sa->childs = _(sai->childs);
 399 #undef _
 400
 401
 402   if (sa->dh_group == IKEV2_TRANSFORM_DH_TYPE_NONE)
 403     {
 404       return;
 405     }
 406
 407   /* check if received DH group is on our list of supported groups */
 408   vec_foreach (t2, km->supported_transforms)
 409   {
 410     if (t2->type == IKEV2_TRANSFORM_TYPE_DH && sa->dh_group == t2->dh_type)
 411       {
 412         t = t2;
 413         break;
 414       }
 415   }
 416
 417   if (!t)
 418     {
 419       clib_warning ("unknown dh data group %u (data len %u)", sa->dh_group,
 420                     vec_len (sa->i_dh_data));
 421       sa->dh_group = IKEV2_TRANSFORM_DH_TYPE_NONE;
 422       return;
 423     }
 424
 425
 426   /* generate dh keys */
 427   ikev2_complete_dh (sa, t);
 428
 429 }
 430
 431 static void
 432 ikev2_calc_keys (ikev2_sa_t * sa)
 433 {
 434   u8 *tmp;
 435   /* calculate SKEYSEED = prf(Ni | Nr, g^ir) */
 436   u8 *skeyseed = 0;
 437   u8 *s = 0;
 438   ikev2_sa_transform_t *tr_encr, *tr_prf, *tr_integ;
 439   tr_encr =
 440     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_ENCR);
 441   tr_prf =
 442     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_PRF);
 443   tr_integ =
 444     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_INTEG);
 445
 446   vec_append (s, sa->i_nonce);
 447   vec_append (s, sa->r_nonce);
 448   skeyseed = ikev2_calc_prf (tr_prf, s, sa->dh_shared_key);
 449
 450   /* Calculate S = Ni | Nr | SPIi | SPIr */
 451   u64 *spi;
 452   vec_add2 (s, tmp, 2 * sizeof (*spi));
 453   spi = (u64 *) tmp;
 454   spi[0] = clib_host_to_net_u64 (sa->ispi);
 455   spi[1] = clib_host_to_net_u64 (sa->rspi);
 456
 457   /* calculate PRFplus */
 458   u8 *keymat;
 459   int len = tr_prf->key_trunc + /* SK_d */
 460     tr_integ->key_len * 2 +     /* SK_ai, SK_ar */
 461     tr_encr->key_len * 2 +      /* SK_ei, SK_er */
 462     tr_prf->key_len * 2;        /* SK_pi, SK_pr */
 463
 464   keymat = ikev2_calc_prfplus (tr_prf, skeyseed, s, len);
 465   vec_free (skeyseed);
 466   vec_free (s);
 467
 468   int pos = 0;
 469
 470   /* SK_d */
 471   sa->sk_d = vec_new (u8, tr_prf->key_trunc);
 472   clib_memcpy (sa->sk_d, keymat + pos, tr_prf->key_trunc);
 473   pos += tr_prf->key_trunc;
 474
 475   /* SK_ai */
 476   sa->sk_ai = vec_new (u8, tr_integ->key_len);
 477   clib_memcpy (sa->sk_ai, keymat + pos, tr_integ->key_len);
 478   pos += tr_integ->key_len;
 479
 480   /* SK_ar */
 481   sa->sk_ar = vec_new (u8, tr_integ->key_len);
 482   clib_memcpy (sa->sk_ar, keymat + pos, tr_integ->key_len);
 483   pos += tr_integ->key_len;
 484
 485   /* SK_ei */
 486   sa->sk_ei = vec_new (u8, tr_encr->key_len);
 487   clib_memcpy (sa->sk_ei, keymat + pos, tr_encr->key_len);
 488   pos += tr_encr->key_len;
 489
 490   /* SK_er */
 491   sa->sk_er = vec_new (u8, tr_encr->key_len);
 492   clib_memcpy (sa->sk_er, keymat + pos, tr_encr->key_len);
 493   pos += tr_encr->key_len;
 494
 495   /* SK_pi */
 496   sa->sk_pi = vec_new (u8, tr_prf->key_len);
 497   clib_memcpy (sa->sk_pi, keymat + pos, tr_prf->key_len);
 498   pos += tr_prf->key_len;
 499
 500   /* SK_pr */
 501   sa->sk_pr = vec_new (u8, tr_prf->key_len);
 502   clib_memcpy (sa->sk_pr, keymat + pos, tr_prf->key_len);
 503   pos += tr_prf->key_len;
 504
 505   vec_free (keymat);
 506 }
 507
 508 static void
 509 ikev2_calc_child_keys (ikev2_sa_t * sa, ikev2_child_sa_t * child)
 510 {
 511   u8 *s = 0;
 512   ikev2_sa_transform_t *tr_prf, *ctr_encr, *ctr_integ;
 513   tr_prf =
 514     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_PRF);
 515   ctr_encr =
 516     ikev2_sa_get_td_for_type (child->r_proposals, IKEV2_TRANSFORM_TYPE_ENCR);
 517   ctr_integ =
 518     ikev2_sa_get_td_for_type (child->r_proposals, IKEV2_TRANSFORM_TYPE_INTEG);
 519
 520   vec_append (s, sa->i_nonce);
 521   vec_append (s, sa->r_nonce);
 522   /* calculate PRFplus */
 523   u8 *keymat;
 524   int len = ctr_encr->key_len * 2 + ctr_integ->key_len * 2;
 525
 526   keymat = ikev2_calc_prfplus (tr_prf, sa->sk_d, s, len);
 527
 528   int pos = 0;
 529
 530   /* SK_ei */
 531   child->sk_ei = vec_new (u8, ctr_encr->key_len);
 532   clib_memcpy (child->sk_ei, keymat + pos, ctr_encr->key_len);
 533   pos += ctr_encr->key_len;
 534
 535   /* SK_ai */
 536   child->sk_ai = vec_new (u8, ctr_integ->key_len);
 537   clib_memcpy (child->sk_ai, keymat + pos, ctr_integ->key_len);
 538   pos += ctr_integ->key_len;
 539
 540   /* SK_er */
 541   child->sk_er = vec_new (u8, ctr_encr->key_len);
 542   clib_memcpy (child->sk_er, keymat + pos, ctr_encr->key_len);
 543   pos += ctr_encr->key_len;
 544
 545   /* SK_ar */
 546   child->sk_ar = vec_new (u8, ctr_integ->key_len);
 547   clib_memcpy (child->sk_ar, keymat + pos, ctr_integ->key_len);
 548   pos += ctr_integ->key_len;
 549
 550   ASSERT (pos == len);
 551
 552   vec_free (keymat);
 553 }
 554
 555 static void
 556 ikev2_process_sa_init_req (vlib_main_t * vm, ikev2_sa_t * sa,
 557                            ike_header_t * ike)
 558 {
 559   int p = 0;
 560   u32 len = clib_net_to_host_u32 (ike->length);
 561   u8 payload = ike->nextpayload;
 562
 563   clib_warning ("ispi %lx rspi %lx nextpayload %x version %x "
 564                 "exchange %x flags %x msgid %x length %u",
 565                 clib_net_to_host_u64 (ike->ispi),
 566                 clib_net_to_host_u64 (ike->rspi),
 567                 payload, ike->version,
 568                 ike->exchange, ike->flags,
 569                 clib_net_to_host_u32 (ike->msgid), len);
 570
 571   sa->ispi = clib_net_to_host_u64 (ike->ispi);
 572
 573   /* store whole IKE payload - needed for PSK auth */
 574   vec_free (sa->last_sa_init_req_packet_data);
 575   vec_add (sa->last_sa_init_req_packet_data, ike, len);
 576
 577   while (p < len && payload != IKEV2_PAYLOAD_NONE)
 578     {
 579       ike_payload_header_t *ikep = (ike_payload_header_t *) & ike->payload[p];
 580       u32 plen = clib_net_to_host_u16 (ikep->length);
 581
 582       if (plen < sizeof (ike_payload_header_t))
 583         return;
 584
 585       if (payload == IKEV2_PAYLOAD_SA)
 586         {
 587           ikev2_sa_free_proposal_vector (&sa->i_proposals);
 588           sa->i_proposals = ikev2_parse_sa_payload (ikep);
 589         }
 590       else if (payload == IKEV2_PAYLOAD_KE)
 591         {
 592           ike_ke_payload_header_t *ke = (ike_ke_payload_header_t *) ikep;
 593           sa->dh_group = clib_net_to_host_u16 (ke->dh_group);
 594           vec_free (sa->i_dh_data);
 595           vec_add (sa->i_dh_data, ke->payload, plen - sizeof (*ke));
 596         }
 597       else if (payload == IKEV2_PAYLOAD_NONCE)
 598         {
 599           vec_free (sa->i_nonce);
 600           vec_add (sa->i_nonce, ikep->payload, plen - sizeof (*ikep));
 601         }
 602       else if (payload == IKEV2_PAYLOAD_NOTIFY)
 603         {
 604           ikev2_notify_t *n = ikev2_parse_notify_payload (ikep);
 605           vec_free (n);
 606         }
 607       else if (payload == IKEV2_PAYLOAD_VENDOR)
 608         {
 609           ikev2_parse_vendor_payload (ikep);
 610         }
 611       else
 612         {
 613           clib_warning ("unknown payload %u flags %x length %u", payload,
 614                         ikep->flags, plen);
 615           if (ikep->flags & IKEV2_PAYLOAD_FLAG_CRITICAL)
 616             {
 617               ikev2_set_state (sa, IKEV2_STATE_NOTIFY_AND_DELETE);
 618               sa->unsupported_cp = payload;
 619               return;
 620             }
 621         }
 622
 623       payload = ikep->nextpayload;
 624       p += plen;
 625     }
 626
 627   ikev2_set_state (sa, IKEV2_STATE_SA_INIT);
 628 }
 629
 630 static void
 631 ikev2_process_sa_init_resp (vlib_main_t * vm, ikev2_sa_t * sa,
 632                             ike_header_t * ike)
 633 {
 634   int p = 0;
 635   u32 len = clib_net_to_host_u32 (ike->length);
 636   u8 payload = ike->nextpayload;
 637
 638   clib_warning ("ispi %lx rspi %lx nextpayload %x version %x "
 639                 "exchange %x flags %x msgid %x length %u",
 640                 clib_net_to_host_u64 (ike->ispi),
 641                 clib_net_to_host_u64 (ike->rspi),
 642                 payload, ike->version,
 643                 ike->exchange, ike->flags,
 644                 clib_net_to_host_u32 (ike->msgid), len);
 645
 646   sa->ispi = clib_net_to_host_u64 (ike->ispi);
 647   sa->rspi = clib_net_to_host_u64 (ike->rspi);
 648
 649   /* store whole IKE payload - needed for PSK auth */
 650   vec_free (sa->last_sa_init_res_packet_data);
 651   vec_add (sa->last_sa_init_res_packet_data, ike, len);
 652
 653   while (p < len && payload != IKEV2_PAYLOAD_NONE)
 654     {
 655       ike_payload_header_t *ikep = (ike_payload_header_t *) & ike->payload[p];
 656       u32 plen = clib_net_to_host_u16 (ikep->length);
 657
 658       if (plen < sizeof (ike_payload_header_t))
 659         return;
 660
 661       if (payload == IKEV2_PAYLOAD_SA)
 662         {
 663           ikev2_sa_free_proposal_vector (&sa->r_proposals);
 664           sa->r_proposals = ikev2_parse_sa_payload (ikep);
 665           if (sa->r_proposals)
 666             {
 667               ikev2_set_state (sa, IKEV2_STATE_SA_INIT);
 668               ike->msgid =
 669                 clib_host_to_net_u32 (clib_net_to_host_u32 (ike->msgid) + 1);
 670             }
 671         }
 672       else if (payload == IKEV2_PAYLOAD_KE)
 673         {
 674           ike_ke_payload_header_t *ke = (ike_ke_payload_header_t *) ikep;
 675           sa->dh_group = clib_net_to_host_u16 (ke->dh_group);
 676           vec_free (sa->r_dh_data);
 677           vec_add (sa->r_dh_data, ke->payload, plen - sizeof (*ke));
 678         }
 679       else if (payload == IKEV2_PAYLOAD_NONCE)
 680         {
 681           vec_free (sa->r_nonce);
 682           vec_add (sa->r_nonce, ikep->payload, plen - sizeof (*ikep));
 683         }
 684       else if (payload == IKEV2_PAYLOAD_NOTIFY)
 685         {
 686           ikev2_notify_t *n = ikev2_parse_notify_payload (ikep);
 687           vec_free (n);
 688         }
 689       else if (payload == IKEV2_PAYLOAD_VENDOR)
 690         {
 691           ikev2_parse_vendor_payload (ikep);
 692         }
 693       else
 694         {
 695           clib_warning ("unknown payload %u flags %x length %u", payload,
 696                         ikep->flags, plen);
 697           if (ikep->flags & IKEV2_PAYLOAD_FLAG_CRITICAL)
 698             {
 699               ikev2_set_state (sa, IKEV2_STATE_NOTIFY_AND_DELETE);
 700               sa->unsupported_cp = payload;
 701               return;
 702             }
 703         }
 704
 705       payload = ikep->nextpayload;
 706       p += plen;
 707     }
 708 }
 709
 710 static u8 *
 711 ikev2_decrypt_sk_payload (ikev2_sa_t * sa, ike_header_t * ike, u8 * payload)
 712 {
 713   int p = 0;
 714   u8 last_payload = 0;
 715   u8 *hmac = 0;
 716   u32 len = clib_net_to_host_u32 (ike->length);
 717   ike_payload_header_t *ikep = 0;
 718   u32 plen = 0;
 719   ikev2_sa_transform_t *tr_integ;
 720   tr_integ =
 721     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_INTEG);
 722
 723   while (p < len &&
 724          *payload != IKEV2_PAYLOAD_NONE && last_payload != IKEV2_PAYLOAD_SK)
 725     {
 726       ikep = (ike_payload_header_t *) & ike->payload[p];
 727       plen = clib_net_to_host_u16 (ikep->length);
 728
 729       if (plen < sizeof (*ikep))
 730         return 0;
 731
 732       if (*payload == IKEV2_PAYLOAD_SK)
 733         {
 734           clib_warning ("received IKEv2 payload SK, len %u", plen - 4);
 735           last_payload = *payload;
 736         }
 737       else
 738         {
 739           clib_warning ("unknown payload %u flags %x length %u", payload,
 740                         ikep->flags, plen);
 741           if (ikep->flags & IKEV2_PAYLOAD_FLAG_CRITICAL)
 742             {
 743               sa->unsupported_cp = *payload;
 744               return 0;
 745             }
 746         }
 747
 748       *payload = ikep->nextpayload;
 749       p += plen;
 750     }
 751
 752   if (last_payload != IKEV2_PAYLOAD_SK)
 753     {
 754       clib_warning ("Last payload must be SK");
 755       return 0;
 756     }
 757
 758   hmac =
 759     ikev2_calc_integr (tr_integ, sa->is_initiator ? sa->sk_ar : sa->sk_ai,
 760                        (u8 *) ike, len - tr_integ->key_trunc);
 761
 762   plen = plen - sizeof (*ikep) - tr_integ->key_trunc;
 763
 764   if (memcmp (hmac, &ikep->payload[plen], tr_integ->key_trunc))
 765     {
 766       clib_warning ("message integrity check failed");
 767       vec_free (hmac);
 768       return 0;
 769     }
 770   vec_free (hmac);
 771
 772   return ikev2_decrypt_data (sa, ikep->payload, plen);
 773 }
 774
 775 static void
 776 ikev2_initial_contact_cleanup (ikev2_sa_t * sa)
 777 {
 778   ikev2_main_t *km = &ikev2_main;
 779   ikev2_sa_t *tmp;
 780   u32 i, *delete = 0;
 781   ikev2_child_sa_t *c;
 782   u32 thread_index = vlib_get_thread_index ();
 783
 784   if (!sa->initial_contact)
 785     return;
 786
 787   /* find old IKE SAs with the same authenticated identity */
 788   /* *INDENT-OFF* */
 789   pool_foreach (tmp, km->per_thread_data[thread_index].sas, ({
 790         if (tmp->i_id.type != sa->i_id.type ||
 791             vec_len(tmp->i_id.data) != vec_len(sa->i_id.data) ||
 792             memcmp(sa->i_id.data, tmp->i_id.data, vec_len(sa->i_id.data)))
 793           continue;
 794
 795         if (sa->rspi != tmp->rspi)
 796           vec_add1(delete, tmp - km->per_thread_data[thread_index].sas);
 797   }));
 798   /* *INDENT-ON* */
 799
 800   for (i = 0; i < vec_len (delete); i++)
 801     {
 802       tmp =
 803         pool_elt_at_index (km->per_thread_data[thread_index].sas, delete[i]);
 804       vec_foreach (c,
 805                    tmp->childs) ikev2_delete_tunnel_interface (km->vnet_main,
 806                                                                tmp, c);
 807       ikev2_delete_sa (tmp);
 808     }
 809
 810   vec_free (delete);
 811   sa->initial_contact = 0;
 812 }
 813
 814 static void
 815 ikev2_process_auth_req (vlib_main_t * vm, ikev2_sa_t * sa, ike_header_t * ike)
 816 {
 817   ikev2_child_sa_t *first_child_sa;
 818   int p = 0;
 819   u32 len = clib_net_to_host_u32 (ike->length);
 820   u8 payload = ike->nextpayload;
 821   u8 *plaintext = 0;
 822
 823   ike_payload_header_t *ikep;
 824   u32 plen;
 825
 826   clib_warning ("ispi %lx rspi %lx nextpayload %x version %x "
 827                 "exchange %x flags %x msgid %x length %u",
 828                 clib_net_to_host_u64 (ike->ispi),
 829                 clib_net_to_host_u64 (ike->rspi),
 830                 payload, ike->version,
 831                 ike->exchange, ike->flags,
 832                 clib_net_to_host_u32 (ike->msgid), len);
 833
 834   ikev2_calc_keys (sa);
 835
 836   plaintext = ikev2_decrypt_sk_payload (sa, ike, &payload);
 837
 838   if (!plaintext)
 839     {
 840       if (sa->unsupported_cp)
 841         ikev2_set_state (sa, IKEV2_STATE_NOTIFY_AND_DELETE);
 842       goto cleanup_and_exit;
 843     }
 844
 845   /* select or create 1st child SA */
 846   if (sa->is_initiator)
 847     {
 848       first_child_sa = &sa->childs[0];
 849     }
 850   else
 851     {
 852       ikev2_sa_free_all_child_sa (&sa->childs);
 853       vec_add2 (sa->childs, first_child_sa, 1);
 854     }
 855
 856
 857   /* process encrypted payload */
 858   p = 0;
 859   while (p < vec_len (plaintext) && payload != IKEV2_PAYLOAD_NONE)
 860     {
 861       ikep = (ike_payload_header_t *) & plaintext[p];
 862       plen = clib_net_to_host_u16 (ikep->length);
 863
 864       if (plen < sizeof (ike_payload_header_t))
 865         goto cleanup_and_exit;
 866
 867       if (payload == IKEV2_PAYLOAD_SA)  /* 33 */
 868         {
 869           clib_warning ("received payload SA, len %u", plen - sizeof (*ikep));
 870           if (sa->is_initiator)
 871             {
 872               ikev2_sa_free_proposal_vector (&first_child_sa->r_proposals);
 873               first_child_sa->r_proposals = ikev2_parse_sa_payload (ikep);
 874             }
 875           else
 876             {
 877               ikev2_sa_free_proposal_vector (&first_child_sa->i_proposals);
 878               first_child_sa->i_proposals = ikev2_parse_sa_payload (ikep);
 879             }
 880         }
 881       else if (payload == IKEV2_PAYLOAD_IDI)    /* 35 */
 882         {
 883           ike_id_payload_header_t *id = (ike_id_payload_header_t *) ikep;
 884
 885           sa->i_id.type = id->id_type;
 886           vec_free (sa->i_id.data);
 887           vec_add (sa->i_id.data, id->payload, plen - sizeof (*id));
 888
 889           clib_warning ("received payload IDi, len %u id_type %u",
 890                         plen - sizeof (*id), id->id_type);
 891         }
 892       else if (payload == IKEV2_PAYLOAD_IDR)    /* 36 */
 893         {
 894           ike_id_payload_header_t *id = (ike_id_payload_header_t *) ikep;
 895
 896           sa->r_id.type = id->id_type;
 897           vec_free (sa->r_id.data);
 898           vec_add (sa->r_id.data, id->payload, plen - sizeof (*id));
 899
 900           clib_warning ("received payload IDr len %u id_type %u",
 901                         plen - sizeof (*id), id->id_type);
 902         }
 903       else if (payload == IKEV2_PAYLOAD_AUTH)   /* 39 */
 904         {
 905           ike_auth_payload_header_t *a = (ike_auth_payload_header_t *) ikep;
 906
 907           if (sa->is_initiator)
 908             {
 909               sa->r_auth.method = a->auth_method;
 910               vec_free (sa->r_auth.data);
 911               vec_add (sa->r_auth.data, a->payload, plen - sizeof (*a));
 912             }
 913           else
 914             {
 915               sa->i_auth.method = a->auth_method;
 916               vec_free (sa->i_auth.data);
 917               vec_add (sa->i_auth.data, a->payload, plen - sizeof (*a));
 918             }
 919
 920           clib_warning ("received payload AUTH, len %u auth_type %u",
 921                         plen - sizeof (*a), a->auth_method);
 922         }
 923       else if (payload == IKEV2_PAYLOAD_NOTIFY) /* 41 */
 924         {
 925           ikev2_notify_t *n = ikev2_parse_notify_payload (ikep);
 926           if (n->msg_type == IKEV2_NOTIFY_MSG_INITIAL_CONTACT)
 927             {
 928               sa->initial_contact = 1;
 929             }
 930           vec_free (n);
 931         }
 932       else if (payload == IKEV2_PAYLOAD_VENDOR) /* 43 */
 933         {
 934           ikev2_parse_vendor_payload (ikep);
 935         }
 936       else if (payload == IKEV2_PAYLOAD_TSI)    /* 44 */
 937         {
 938           clib_warning ("received payload TSi, len %u",
 939                         plen - sizeof (*ikep));
 940
 941           vec_free (first_child_sa->tsi);
 942           first_child_sa->tsi = ikev2_parse_ts_payload (ikep);
 943         }
 944       else if (payload == IKEV2_PAYLOAD_TSR)    /* 45 */
 945         {
 946           clib_warning ("received payload TSr, len %u",
 947                         plen - sizeof (*ikep));
 948
 949           vec_free (first_child_sa->tsr);
 950           first_child_sa->tsr = ikev2_parse_ts_payload (ikep);
 951         }
 952       else
 953         {
 954           clib_warning ("unknown payload %u flags %x length %u data %u",
 955                         payload, ikep->flags, plen - 4,
 956                         format_hex_bytes, ikep->payload, plen - 4);
 957
 958           if (ikep->flags & IKEV2_PAYLOAD_FLAG_CRITICAL)
 959             {
 960               ikev2_set_state (sa, IKEV2_STATE_NOTIFY_AND_DELETE);
 961               sa->unsupported_cp = payload;
 962               return;
 963             }
 964         }
 965
 966       payload = ikep->nextpayload;
 967       p += plen;
 968     }
 969
 970 cleanup_and_exit:
 971   vec_free (plaintext);
 972 }
 973
 974 static void
 975 ikev2_process_informational_req (vlib_main_t * vm, ikev2_sa_t * sa,
 976                                  ike_header_t * ike)
 977 {
 978   int p = 0;
 979   u32 len = clib_net_to_host_u32 (ike->length);
 980   u8 payload = ike->nextpayload;
 981   u8 *plaintext = 0;
 982
 983   ike_payload_header_t *ikep;
 984   u32 plen;
 985
 986   clib_warning ("ispi %lx rspi %lx nextpayload %x version %x "
 987                 "exchange %x flags %x msgid %x length %u",
 988                 clib_net_to_host_u64 (ike->ispi),
 989                 clib_net_to_host_u64 (ike->rspi),
 990                 payload, ike->version,
 991                 ike->exchange, ike->flags,
 992                 clib_net_to_host_u32 (ike->msgid), len);
 993
 994   plaintext = ikev2_decrypt_sk_payload (sa, ike, &payload);
 995
 996   if (!plaintext)
 997     goto cleanup_and_exit;
 998
 999   /* process encrypted payload */
1000   p = 0;
1001   while (p < vec_len (plaintext) && payload != IKEV2_PAYLOAD_NONE)
1002     {
1003       ikep = (ike_payload_header_t *) & plaintext[p];
1004       plen = clib_net_to_host_u16 (ikep->length);
1005
1006       if (plen < sizeof (ike_payload_header_t))
1007         goto cleanup_and_exit;
1008
1009       if (payload == IKEV2_PAYLOAD_NOTIFY)      /* 41 */
1010         {
1011           ikev2_notify_t *n = ikev2_parse_notify_payload (ikep);
1012           if (n->msg_type == IKEV2_NOTIFY_MSG_AUTHENTICATION_FAILED)
1013             ikev2_set_state (sa, IKEV2_STATE_AUTH_FAILED);
1014           vec_free (n);
1015         }
1016       else if (payload == IKEV2_PAYLOAD_DELETE) /* 42 */
1017         {
1018           sa->del = ikev2_parse_delete_payload (ikep);
1019         }
1020       else if (payload == IKEV2_PAYLOAD_VENDOR) /* 43 */
1021         {
1022           ikev2_parse_vendor_payload (ikep);
1023         }
1024       else
1025         {
1026           clib_warning ("unknown payload %u flags %x length %u data %u",
1027                         payload, ikep->flags, plen - 4,
1028                         format_hex_bytes, ikep->payload, plen - 4);
1029
1030           if (ikep->flags & IKEV2_PAYLOAD_FLAG_CRITICAL)
1031             {
1032               sa->unsupported_cp = payload;
1033               return;
1034             }
1035         }
1036
1037       payload = ikep->nextpayload;
1038       p += plen;
1039     }
1040
1041 cleanup_and_exit:
1042   vec_free (plaintext);
1043 }
1044
1045 static void
1046 ikev2_process_create_child_sa_req (vlib_main_t * vm, ikev2_sa_t * sa,
1047                                    ike_header_t * ike)
1048 {
1049   int p = 0;
1050   u32 len = clib_net_to_host_u32 (ike->length);
1051   u8 payload = ike->nextpayload;
1052   u8 *plaintext = 0;
1053   u8 rekeying = 0;
1054   u8 nonce[IKEV2_NONCE_SIZE];
1055
1056   ike_payload_header_t *ikep;
1057   u32 plen;
1058   ikev2_notify_t *n = 0;
1059   ikev2_ts_t *tsi = 0;
1060   ikev2_ts_t *tsr = 0;
1061   ikev2_sa_proposal_t *proposal = 0;
1062   ikev2_child_sa_t *child_sa;
1063
1064   clib_warning ("ispi %lx rspi %lx nextpayload %x version %x "
1065                 "exchange %x flags %x msgid %x length %u",
1066                 clib_net_to_host_u64 (ike->ispi),
1067                 clib_net_to_host_u64 (ike->rspi),
1068                 payload, ike->version,
1069                 ike->exchange, ike->flags,
1070                 clib_net_to_host_u32 (ike->msgid), len);
1071
1072   plaintext = ikev2_decrypt_sk_payload (sa, ike, &payload);
1073
1074   if (!plaintext)
1075     goto cleanup_and_exit;
1076
1077   /* process encrypted payload */
1078   p = 0;
1079   while (p < vec_len (plaintext) && payload != IKEV2_PAYLOAD_NONE)
1080     {
1081       ikep = (ike_payload_header_t *) & plaintext[p];
1082       plen = clib_net_to_host_u16 (ikep->length);
1083
1084       if (plen < sizeof (ike_payload_header_t))
1085         goto cleanup_and_exit;
1086
1087       else if (payload == IKEV2_PAYLOAD_SA)
1088         {
1089           proposal = ikev2_parse_sa_payload (ikep);
1090         }
1091       else if (payload == IKEV2_PAYLOAD_NOTIFY)
1092         {
1093           n = ikev2_parse_notify_payload (ikep);
1094           if (n->msg_type == IKEV2_NOTIFY_MSG_REKEY_SA)
1095             {
1096               rekeying = 1;
1097             }
1098         }
1099       else if (payload == IKEV2_PAYLOAD_DELETE)
1100         {
1101           sa->del = ikev2_parse_delete_payload (ikep);
1102         }
1103       else if (payload == IKEV2_PAYLOAD_VENDOR)
1104         {
1105           ikev2_parse_vendor_payload (ikep);
1106         }
1107       else if (payload == IKEV2_PAYLOAD_NONCE)
1108         {
1109           clib_memcpy (nonce, ikep->payload, plen - sizeof (*ikep));
1110         }
1111       else if (payload == IKEV2_PAYLOAD_TSI)
1112         {
1113           tsi = ikev2_parse_ts_payload (ikep);
1114         }
1115       else if (payload == IKEV2_PAYLOAD_TSR)
1116         {
1117           tsr = ikev2_parse_ts_payload (ikep);
1118         }
1119       else
1120         {
1121           clib_warning ("unknown payload %u flags %x length %u data %u",
1122                         payload, ikep->flags, plen - 4,
1123                         format_hex_bytes, ikep->payload, plen - 4);
1124
1125           if (ikep->flags & IKEV2_PAYLOAD_FLAG_CRITICAL)
1126             {
1127               sa->unsupported_cp = payload;
1128               return;
1129             }
1130         }
1131
1132       payload = ikep->nextpayload;
1133       p += plen;
1134     }
1135
1136   if (sa->is_initiator && proposal->protocol_id == IKEV2_PROTOCOL_ESP)
1137     {
1138       ikev2_rekey_t *rekey = &sa->rekey[0];
1139       rekey->protocol_id = proposal->protocol_id;
1140       rekey->i_proposal =
1141         ikev2_select_proposal (proposal, IKEV2_PROTOCOL_ESP);
1142       rekey->i_proposal->spi = rekey->spi;
1143       rekey->r_proposal = proposal;
1144       rekey->tsi = tsi;
1145       rekey->tsr = tsr;
1146       /* update Nr */
1147       vec_free (sa->r_nonce);
1148       vec_add (sa->r_nonce, nonce, IKEV2_NONCE_SIZE);
1149       child_sa = ikev2_sa_get_child (sa, rekey->ispi, IKEV2_PROTOCOL_ESP, 1);
1150       if (child_sa)
1151         {
1152           child_sa->rekey_retries = 0;
1153         }
1154     }
1155   else if (rekeying)
1156     {
1157       ikev2_rekey_t *rekey;
1158       child_sa = ikev2_sa_get_child (sa, n->spi, n->protocol_id, 1);
1159       if (!child_sa)
1160         {
1161           clib_warning ("child SA spi %lx not found", n->spi);
1162           goto cleanup_and_exit;
1163         }
1164       vec_add2 (sa->rekey, rekey, 1);
1165       rekey->protocol_id = n->protocol_id;
1166       rekey->spi = n->spi;
1167       rekey->i_proposal = proposal;
1168       rekey->r_proposal =
1169         ikev2_select_proposal (proposal, IKEV2_PROTOCOL_ESP);
1170       rekey->tsi = tsi;
1171       rekey->tsr = tsr;
1172       /* update Ni */
1173       vec_free (sa->i_nonce);
1174       vec_add (sa->i_nonce, nonce, IKEV2_NONCE_SIZE);
1175       /* generate new Nr */
1176       vec_free (sa->r_nonce);
1177       sa->r_nonce = vec_new (u8, IKEV2_NONCE_SIZE);
1178       RAND_bytes ((u8 *) sa->r_nonce, IKEV2_NONCE_SIZE);
1179     }
1180
1181 cleanup_and_exit:
1182   vec_free (plaintext);
1183   vec_free (n);
1184 }
1185
1186 static u8 *
1187 ikev2_sa_generate_authmsg (ikev2_sa_t * sa, int is_responder)
1188 {
1189   u8 *authmsg = 0;
1190   u8 *data;
1191   u8 *nonce;
1192   ikev2_id_t *id;
1193   u8 *key;
1194   u8 *packet_data;
1195   ikev2_sa_transform_t *tr_prf;
1196
1197   tr_prf =
1198     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_PRF);
1199
1200   if (is_responder)
1201     {
1202       id = &sa->r_id;
1203       key = sa->sk_pr;
1204       nonce = sa->i_nonce;
1205       packet_data = sa->last_sa_init_res_packet_data;
1206     }
1207   else
1208     {
1209       id = &sa->i_id;
1210       key = sa->sk_pi;
1211       nonce = sa->r_nonce;
1212       packet_data = sa->last_sa_init_req_packet_data;
1213     }
1214
1215   data = vec_new (u8, 4);
1216   data[0] = id->type;
1217   vec_append (data, id->data);
1218
1219   u8 *id_hash = ikev2_calc_prf (tr_prf, key, data);
1220   vec_append (authmsg, packet_data);
1221   vec_append (authmsg, nonce);
1222   vec_append (authmsg, id_hash);
1223   vec_free (id_hash);
1224   vec_free (data);
1225
1226   return authmsg;
1227 }
1228
1229 static int
1230 ikev2_ts_cmp (ikev2_ts_t * ts1, ikev2_ts_t * ts2)
1231 {
1232   if (ts1->ts_type == ts2->ts_type && ts1->protocol_id == ts2->protocol_id &&
1233       ts1->start_port == ts2->start_port && ts1->end_port == ts2->end_port &&
1234       ts1->start_addr.as_u32 == ts2->start_addr.as_u32 &&
1235       ts1->end_addr.as_u32 == ts2->end_addr.as_u32)
1236     return 1;
1237
1238   return 0;
1239 }
1240
1241 static void
1242 ikev2_sa_match_ts (ikev2_sa_t * sa)
1243 {
1244   ikev2_main_t *km = &ikev2_main;
1245   ikev2_profile_t *p;
1246   ikev2_ts_t *ts, *p_tsi, *p_tsr, *tsi = 0, *tsr = 0;
1247   ikev2_id_t *id;
1248
1249   /* *INDENT-OFF* */
1250   pool_foreach (p, km->profiles, ({
1251
1252     if (sa->is_initiator)
1253       {
1254         p_tsi = &p->loc_ts;
1255         p_tsr = &p->rem_ts;
1256         id = &sa->r_id;
1257       }
1258     else
1259       {
1260         p_tsi = &p->rem_ts;
1261         p_tsr = &p->loc_ts;
1262         id = &sa->i_id;
1263       }
1264
1265     /* check id */
1266     if (p->rem_id.type != id->type ||
1267         vec_len(p->rem_id.data) != vec_len(id->data) ||
1268         memcmp(p->rem_id.data, id->data, vec_len(p->rem_id.data)))
1269       continue;
1270
1271     vec_foreach(ts, sa->childs[0].tsi)
1272       {
1273         if (ikev2_ts_cmp(p_tsi, ts))
1274           {
1275             tsi = vec_dup(ts);
1276             break;
1277           }
1278       }
1279
1280     vec_foreach(ts, sa->childs[0].tsr)
1281       {
1282         if (ikev2_ts_cmp(p_tsr, ts))
1283           {
1284             tsr = vec_dup(ts);
1285             break;
1286           }
1287       }
1288
1289     break;
1290   }));
1291   /* *INDENT-ON* */
1292
1293   if (tsi && tsr)
1294     {
1295       vec_free (sa->childs[0].tsi);
1296       vec_free (sa->childs[0].tsr);
1297       sa->childs[0].tsi = tsi;
1298       sa->childs[0].tsr = tsr;
1299     }
1300   else
1301     {
1302       vec_free (tsi);
1303       vec_free (tsr);
1304       ikev2_set_state (sa, IKEV2_STATE_TS_UNACCEPTABLE);
1305     }
1306 }
1307
1308 static void
1309 ikev2_sa_auth (ikev2_sa_t * sa)
1310 {
1311   ikev2_main_t *km = &ikev2_main;
1312   ikev2_profile_t *p, *sel_p = 0;
1313   u8 *authmsg, *key_pad, *psk = 0, *auth = 0;
1314   ikev2_sa_transform_t *tr_prf;
1315
1316   tr_prf =
1317     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_PRF);
1318
1319   /* only shared key and rsa signature */
1320   if (!(sa->i_auth.method == IKEV2_AUTH_METHOD_SHARED_KEY_MIC ||
1321         sa->i_auth.method == IKEV2_AUTH_METHOD_RSA_SIG))
1322     {
1323       clib_warning ("unsupported authentication method %u",
1324                     sa->i_auth.method);
1325       ikev2_set_state (sa, IKEV2_STATE_AUTH_FAILED);
1326       return;
1327     }
1328
1329   key_pad = format (0, "%s", IKEV2_KEY_PAD);
1330   authmsg = ikev2_sa_generate_authmsg (sa, sa->is_initiator);
1331
1332   ikev2_id_t *sa_id;
1333   ikev2_auth_t *sa_auth;
1334
1335   if (sa->is_initiator)
1336     {
1337       sa_id = &sa->r_id;
1338       sa_auth = &sa->r_auth;
1339     }
1340   else
1341     {
1342       sa_id = &sa->i_id;
1343       sa_auth = &sa->i_auth;
1344     }
1345
1346   /* *INDENT-OFF* */
1347   pool_foreach (p, km->profiles, ({
1348
1349     /* check id */
1350     if (p->rem_id.type != sa_id->type ||
1351         vec_len(p->rem_id.data) != vec_len(sa_id->data) ||
1352         memcmp(p->rem_id.data, sa_id->data, vec_len(p->rem_id.data)))
1353       continue;
1354
1355     if (sa_auth->method == IKEV2_AUTH_METHOD_SHARED_KEY_MIC)
1356       {
1357         if (!p->auth.data ||
1358              p->auth.method != IKEV2_AUTH_METHOD_SHARED_KEY_MIC)
1359           continue;
1360
1361         psk = ikev2_calc_prf(tr_prf, p->auth.data, key_pad);
1362         auth = ikev2_calc_prf(tr_prf, psk, authmsg);
1363
1364         if (!memcmp(auth, sa_auth->data, vec_len(sa_auth->data)))
1365           {
1366             ikev2_set_state(sa, IKEV2_STATE_AUTHENTICATED);
1367             vec_free(auth);
1368             sel_p = p;
1369             break;
1370           }
1371
1372       }
1373     else if (sa_auth->method == IKEV2_AUTH_METHOD_RSA_SIG)
1374       {
1375         if (p->auth.method != IKEV2_AUTH_METHOD_RSA_SIG)
1376           continue;
1377
1378         if (ikev2_verify_sign(p->auth.key, sa_auth->data, authmsg) == 1)
1379           {
1380             ikev2_set_state(sa, IKEV2_STATE_AUTHENTICATED);
1381             sel_p = p;
1382             break;
1383           }
1384       }
1385
1386     vec_free(auth);
1387     vec_free(psk);
1388   }));
1389   /* *INDENT-ON* */
1390
1391   vec_free (authmsg);
1392
1393   if (sa->state == IKEV2_STATE_AUTHENTICATED)
1394     {
1395       if (!sa->is_initiator)
1396         {
1397           vec_free (sa->r_id.data);
1398           sa->r_id.data = vec_dup (sel_p->loc_id.data);
1399           sa->r_id.type = sel_p->loc_id.type;
1400
1401           /* generate our auth data */
1402           authmsg = ikev2_sa_generate_authmsg (sa, 1);
1403           if (sel_p->auth.method == IKEV2_AUTH_METHOD_SHARED_KEY_MIC)
1404             {
1405               sa->r_auth.data = ikev2_calc_prf (tr_prf, psk, authmsg);
1406               sa->r_auth.method = IKEV2_AUTH_METHOD_SHARED_KEY_MIC;
1407             }
1408           else if (sel_p->auth.method == IKEV2_AUTH_METHOD_RSA_SIG)
1409             {
1410               sa->r_auth.data = ikev2_calc_sign (km->pkey, authmsg);
1411               sa->r_auth.method = IKEV2_AUTH_METHOD_RSA_SIG;
1412             }
1413           vec_free (authmsg);
1414
1415           /* select transforms for 1st child sa */
1416           ikev2_sa_free_proposal_vector (&sa->childs[0].r_proposals);
1417           sa->childs[0].r_proposals =
1418             ikev2_select_proposal (sa->childs[0].i_proposals,
1419                                    IKEV2_PROTOCOL_ESP);
1420         }
1421     }
1422   else
1423     {
1424       ikev2_set_state (sa, IKEV2_STATE_AUTH_FAILED);
1425     }
1426   vec_free (psk);
1427   vec_free (key_pad);
1428 }
1429
1430
1431 static void
1432 ikev2_sa_auth_init (ikev2_sa_t * sa)
1433 {
1434   ikev2_main_t *km = &ikev2_main;
1435   u8 *authmsg, *key_pad, *psk = 0, *auth = 0;
1436   ikev2_sa_transform_t *tr_prf;
1437
1438   tr_prf =
1439     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_PRF);
1440
1441   /* only shared key and rsa signature */
1442   if (!(sa->i_auth.method == IKEV2_AUTH_METHOD_SHARED_KEY_MIC ||
1443         sa->i_auth.method == IKEV2_AUTH_METHOD_RSA_SIG))
1444     {
1445       clib_warning ("unsupported authentication method %u",
1446                     sa->i_auth.method);
1447       ikev2_set_state (sa, IKEV2_STATE_AUTH_FAILED);
1448       return;
1449     }
1450
1451   key_pad = format (0, "%s", IKEV2_KEY_PAD);
1452   authmsg = ikev2_sa_generate_authmsg (sa, 0);
1453   psk = ikev2_calc_prf (tr_prf, sa->i_auth.data, key_pad);
1454   auth = ikev2_calc_prf (tr_prf, psk, authmsg);
1455
1456
1457   if (sa->i_auth.method == IKEV2_AUTH_METHOD_SHARED_KEY_MIC)
1458     {
1459       sa->i_auth.data = ikev2_calc_prf (tr_prf, psk, authmsg);
1460       sa->i_auth.method = IKEV2_AUTH_METHOD_SHARED_KEY_MIC;
1461     }
1462   else if (sa->i_auth.method == IKEV2_AUTH_METHOD_RSA_SIG)
1463     {
1464       sa->i_auth.data = ikev2_calc_sign (km->pkey, authmsg);
1465       sa->i_auth.method = IKEV2_AUTH_METHOD_RSA_SIG;
1466     }
1467
1468   vec_free (psk);
1469   vec_free (key_pad);
1470   vec_free (auth);
1471   vec_free (authmsg);
1472 }
1473
1474
1475 static int
1476 ikev2_create_tunnel_interface (vnet_main_t * vnm, ikev2_sa_t * sa,
1477                                ikev2_child_sa_t * child)
1478 {
1479   ipsec_add_del_tunnel_args_t a;
1480   ikev2_sa_transform_t *tr;
1481   ikev2_sa_proposal_t *proposals;
1482   u8 encr_type = 0;
1483
1484   if (!child->r_proposals)
1485     {
1486       ikev2_set_state (sa, IKEV2_STATE_NO_PROPOSAL_CHOSEN);
1487       return 1;
1488     }
1489
1490   memset (&a, 0, sizeof (a));
1491   a.is_add = 1;
1492   if (sa->is_initiator)
1493     {
1494       a.local_ip.as_u32 = sa->iaddr.as_u32;
1495       a.remote_ip.as_u32 = sa->raddr.as_u32;
1496       proposals = child->i_proposals;
1497       a.local_spi = child->r_proposals[0].spi;
1498       a.remote_spi = child->i_proposals[0].spi;
1499     }
1500   else
1501     {
1502       a.local_ip.as_u32 = sa->raddr.as_u32;
1503       a.remote_ip.as_u32 = sa->iaddr.as_u32;
1504       proposals = child->r_proposals;
1505       a.local_spi = child->i_proposals[0].spi;
1506       a.remote_spi = child->r_proposals[0].spi;
1507     }
1508   a.anti_replay = 1;
1509
1510   tr = ikev2_sa_get_td_for_type (proposals, IKEV2_TRANSFORM_TYPE_ESN);
1511   if (tr)
1512     a.esn = tr->esn_type;
1513   else
1514     a.esn = 0;
1515
1516   tr = ikev2_sa_get_td_for_type (proposals, IKEV2_TRANSFORM_TYPE_ENCR);
1517   if (tr)
1518     {
1519       if (tr->encr_type == IKEV2_TRANSFORM_ENCR_TYPE_AES_CBC && tr->key_len)
1520         {
1521           switch (tr->key_len)
1522             {
1523             case 16:
1524               encr_type = IPSEC_CRYPTO_ALG_AES_CBC_128;
1525               break;
1526             case 24:
1527               encr_type = IPSEC_CRYPTO_ALG_AES_CBC_192;
1528               break;
1529             case 32:
1530               encr_type = IPSEC_CRYPTO_ALG_AES_CBC_256;
1531               break;
1532             default:
1533               ikev2_set_state (sa, IKEV2_STATE_NO_PROPOSAL_CHOSEN);
1534               return 1;
1535               break;
1536             }
1537         }
1538       else
1539         {
1540           ikev2_set_state (sa, IKEV2_STATE_NO_PROPOSAL_CHOSEN);
1541           return 1;
1542         }
1543     }
1544   else
1545     {
1546       ikev2_set_state (sa, IKEV2_STATE_NO_PROPOSAL_CHOSEN);
1547       return 1;
1548     }
1549
1550   tr = ikev2_sa_get_td_for_type (proposals, IKEV2_TRANSFORM_TYPE_INTEG);
1551   if (tr)
1552     {
1553       if (tr->integ_type != IKEV2_TRANSFORM_INTEG_TYPE_AUTH_HMAC_SHA1_96)
1554         {
1555           ikev2_set_state (sa, IKEV2_STATE_NO_PROPOSAL_CHOSEN);
1556           return 1;
1557         }
1558     }
1559   else
1560     {
1561       ikev2_set_state (sa, IKEV2_STATE_NO_PROPOSAL_CHOSEN);
1562       return 1;
1563     }
1564
1565   ikev2_calc_child_keys (sa, child);
1566
1567   u8 *loc_ckey, *rem_ckey, *loc_ikey, *rem_ikey;
1568   if (sa->is_initiator)
1569     {
1570       loc_ikey = child->sk_ai;
1571       rem_ikey = child->sk_ar;
1572       loc_ckey = child->sk_ei;
1573       rem_ckey = child->sk_er;
1574     }
1575   else
1576     {
1577       loc_ikey = child->sk_ar;
1578       rem_ikey = child->sk_ai;
1579       loc_ckey = child->sk_er;
1580       rem_ckey = child->sk_ei;
1581     }
1582
1583   a.integ_alg = IPSEC_INTEG_ALG_SHA1_96;
1584   a.local_integ_key_len = vec_len (loc_ikey);
1585   clib_memcpy (a.local_integ_key, loc_ikey, a.local_integ_key_len);
1586   a.remote_integ_key_len = vec_len (rem_ikey);
1587   clib_memcpy (a.remote_integ_key, rem_ikey, a.remote_integ_key_len);
1588
1589   a.crypto_alg = encr_type;
1590   a.local_crypto_key_len = vec_len (loc_ckey);
1591   clib_memcpy (a.local_crypto_key, loc_ckey, a.local_crypto_key_len);
1592   a.remote_crypto_key_len = vec_len (rem_ckey);
1593   clib_memcpy (a.remote_crypto_key, rem_ckey, a.remote_crypto_key_len);
1594
1595   if (sa->profile && sa->profile->lifetime)
1596     {
1597       child->time_to_expiration = vlib_time_now (vnm->vlib_main)
1598         + sa->profile->lifetime;
1599       if (sa->profile->lifetime_jitter)
1600         {
1601           // This is not much better than rand(3), which Coverity warns
1602           // is unsuitable for security applications; random_u32 is
1603           // however fast. If this perturbance to the expiration time
1604           // needs to use a better RNG then we may need to use something
1605           // like /dev/urandom which has significant overhead.
1606           u32 rnd = (u32) (vlib_time_now (vnm->vlib_main) * 1e6);
1607           rnd = random_u32 (&rnd);
1608
1609           child->time_to_expiration +=
1610             1 + (rnd % sa->profile->lifetime_jitter);
1611         }
1612     }
1613
1614   ipsec_add_del_tunnel_if (&a);
1615
1616   return 0;
1617 }
1618
1619 static int
1620 ikev2_delete_tunnel_interface (vnet_main_t * vnm, ikev2_sa_t * sa,
1621                                ikev2_child_sa_t * child)
1622 {
1623   ipsec_add_del_tunnel_args_t a;
1624
1625   if (sa->is_initiator)
1626     {
1627       if (!vec_len (child->i_proposals))
1628         return 0;
1629
1630       a.is_add = 0;
1631       a.local_ip.as_u32 = sa->iaddr.as_u32;
1632       a.remote_ip.as_u32 = sa->raddr.as_u32;
1633       a.local_spi = child->r_proposals[0].spi;
1634       a.remote_spi = child->i_proposals[0].spi;
1635     }
1636   else
1637     {
1638       if (!vec_len (child->r_proposals))
1639         return 0;
1640
1641       a.is_add = 0;
1642       a.local_ip.as_u32 = sa->raddr.as_u32;
1643       a.remote_ip.as_u32 = sa->iaddr.as_u32;
1644       a.local_spi = child->i_proposals[0].spi;
1645       a.remote_spi = child->r_proposals[0].spi;
1646     }
1647
1648   ipsec_add_del_tunnel_if (&a);
1649   return 0;
1650 }
1651
1652 static u32
1653 ikev2_generate_message (ikev2_sa_t * sa, ike_header_t * ike, void *user)
1654 {
1655   v8 *integ = 0;
1656   ike_payload_header_t *ph;
1657   u16 plen;
1658   u32 tlen = 0;
1659
1660   ikev2_sa_transform_t *tr_encr, *tr_integ;
1661   tr_encr =
1662     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_ENCR);
1663   tr_integ =
1664     ikev2_sa_get_td_for_type (sa->r_proposals, IKEV2_TRANSFORM_TYPE_INTEG);
1665
1666   ikev2_payload_chain_t *chain = 0;
1667   ikev2_payload_new_chain (chain);
1668
1669   if (ike->exchange == IKEV2_EXCHANGE_SA_INIT)
1670     {
1671       if (sa->r_proposals == 0)
1672         {
1673           ikev2_payload_add_notify (chain,
1674                                     IKEV2_NOTIFY_MSG_NO_PROPOSAL_CHOSEN, 0);
1675           ikev2_set_state (sa, IKEV2_STATE_NOTIFY_AND_DELETE);
1676         }
1677       else if (sa->dh_group == IKEV2_TRANSFORM_DH_TYPE_NONE)
1678         {
1679           u8 *data = vec_new (u8, 2);
1680           ikev2_sa_transform_t *tr_dh;
1681           tr_dh =
1682             ikev2_sa_get_td_for_type (sa->r_proposals,
1683                                       IKEV2_TRANSFORM_TYPE_DH);
1684           ASSERT (tr_dh && tr_dh->dh_type);
1685
1686           data[0] = (tr_dh->dh_type >> 8) & 0xff;
1687           data[1] = (tr_dh->dh_type) & 0xff;
1688
1689           ikev2_payload_add_notify (chain,
1690                                     IKEV2_NOTIFY_MSG_INVALID_KE_PAYLOAD,
1691                                     data);
1692           vec_free (data);
1693           ikev2_set_state (sa, IKEV2_STATE_NOTIFY_AND_DELETE);
1694         }
1695       else if (sa->state == IKEV2_STATE_NOTIFY_AND_DELETE)
1696         {
1697           u8 *data = vec_new (u8, 1);
1698
1699           data[0] = sa->unsupported_cp;
1700           ikev2_payload_add_notify (chain,
1701                                     IKEV2_NOTIFY_MSG_UNSUPPORTED_CRITICAL_PAYLOAD,
1702                                     data);
1703           vec_free (data);
1704         }
1705       else
1706         {
1707           ike->rspi = clib_host_to_net_u64 (sa->rspi);
1708           ikev2_payload_add_sa (chain, sa->r_proposals);
1709           ikev2_payload_add_ke (chain, sa->dh_group, sa->r_dh_data);
1710           ikev2_payload_add_nonce (chain, sa->r_nonce);
1711         }
1712     }
1713   else if (ike->exchange == IKEV2_EXCHANGE_IKE_AUTH)
1714     {
1715       if (sa->state == IKEV2_STATE_AUTHENTICATED)
1716         {
1717           ikev2_payload_add_id (chain, &sa->r_id, IKEV2_PAYLOAD_IDR);
1718           ikev2_payload_add_auth (chain, &sa->r_auth);
1719           ikev2_payload_add_sa (chain, sa->childs[0].r_proposals);
1720           ikev2_payload_add_ts (chain, sa->childs[0].tsi, IKEV2_PAYLOAD_TSI);
1721           ikev2_payload_add_ts (chain, sa->childs[0].tsr, IKEV2_PAYLOAD_TSR);
1722         }
1723       else if (sa->state == IKEV2_STATE_AUTH_FAILED)
1724         {
1725           ikev2_payload_add_notify (chain,
1726                                     IKEV2_NOTIFY_MSG_AUTHENTICATION_FAILED,
1727                                     0);
1728           ikev2_set_state (sa, IKEV2_STATE_NOTIFY_AND_DELETE);
1729         }
1730       else if (sa->state == IKEV2_STATE_TS_UNACCEPTABLE)
1731         {
1732           ikev2_payload_add_notify (chain, IKEV2_NOTIFY_MSG_TS_UNACCEPTABLE,
1733                                     0);
1734           ikev2_payload_add_id (chain, &sa->r_id, IKEV2_PAYLOAD_IDR);
1735           ikev2_payload_add_auth (chain, &sa->r_auth);
1736         }
1737       else if (sa->state == IKEV2_STATE_NO_PROPOSAL_CHOSEN)
1738         {
1739           ikev2_payload_add_notify (chain,
1740                                     IKEV2_NOTIFY_MSG_NO_PROPOSAL_CHOSEN, 0);
1741           ikev2_payload_add_id (chain, &sa->r_id, IKEV2_PAYLOAD_IDR);
1742           ikev2_payload_add_auth (chain, &sa->r_auth);
1743           ikev2_payload_add_ts (chain, sa->childs[0].tsi, IKEV2_PAYLOAD_TSI);
1744           ikev2_payload_add_ts (chain, sa->childs[0].tsr, IKEV2_PAYLOAD_TSR);
1745         }
1746       else if (sa->state == IKEV2_STATE_NOTIFY_AND_DELETE)
1747         {
1748           u8 *data = vec_new (u8, 1);
1749
1750           data[0] = sa->unsupported_cp;
1751           ikev2_payload_add_notify (chain,
1752                                     IKEV2_NOTIFY_MSG_UNSUPPORTED_CRITICAL_PAYLOAD,
1753                                     data);
1754           vec_free (data);
1755         }
1756       else if (sa->state == IKEV2_STATE_SA_INIT)
1757         {
1758           ikev2_payload_add_id (chain, &sa->i_id, IKEV2_PAYLOAD_IDI);
1759           ikev2_payload_add_auth (chain, &sa->i_auth);
1760           ikev2_payload_add_sa (chain, sa->childs[0].i_proposals);
1761           ikev2_payload_add_ts (chain, sa->childs[0].tsi, IKEV2_PAYLOAD_TSI);
1762           ikev2_payload_add_ts (chain, sa->childs[0].tsr, IKEV2_PAYLOAD_TSR);
1763         }
1764       else
1765         {
1766           ikev2_set_state (sa, IKEV2_STATE_DELETED);
1767           goto done;
1768         }
1769     }
1770   else if (ike->exchange == IKEV2_EXCHANGE_INFORMATIONAL)
1771     {
1772       /* if pending delete */
1773       if (sa->del)
1774         {
1775           if (sa->del[0].protocol_id == IKEV2_PROTOCOL_IKE)
1776             {
1777               if (sa->is_initiator)
1778                 ikev2_payload_add_delete (chain, sa->del);
1779
1780               /* The response to a request that deletes the IKE SA is an empty
1781                  INFORMATIONAL response. */
1782               ikev2_set_state (sa, IKEV2_STATE_NOTIFY_AND_DELETE);
1783             }
1784           /* The response to a request that deletes ESP or AH SAs will contain
1785              delete payloads for the paired SAs going in the other direction. */
1786           else
1787             {
1788               ikev2_payload_add_delete (chain, sa->del);
1789             }
1790           vec_free (sa->del);
1791           sa->del = 0;
1792         }
1793       /* received N(AUTHENTICATION_FAILED) */
1794       else if (sa->state == IKEV2_STATE_AUTH_FAILED)
1795         {
1796           ikev2_set_state (sa, IKEV2_STATE_DELETED);
1797           goto done;
1798         }
1799       /* received unsupported critical payload */
1800       else if (sa->unsupported_cp)
1801         {
1802           u8 *data = vec_new (u8, 1);
1803
1804           data[0] = sa->unsupported_cp;
1805           ikev2_payload_add_notify (chain,
1806                                     IKEV2_NOTIFY_MSG_UNSUPPORTED_CRITICAL_PAYLOAD,
1807                                     data);
1808           vec_free (data);
1809           sa->unsupported_cp = 0;
1810         }
1811       /* else send empty response */
1812     }
1813   else if (ike->exchange == IKEV2_EXCHANGE_CREATE_CHILD_SA)
1814     {
1815       if (sa->is_initiator)
1816         {
1817
1818           ikev2_sa_proposal_t *proposals = (ikev2_sa_proposal_t *) user;
1819           ikev2_notify_t notify;
1820           u8 *data = vec_new (u8, 4);
1821           memset (&notify, 0, sizeof (notify));
1822           notify.protocol_id = IKEV2_PROTOCOL_ESP;
1823           notify.spi = sa->childs[0].i_proposals->spi;
1824           *(u32 *) data = clib_host_to_net_u32 (notify.spi);
1825
1826           ikev2_payload_add_sa (chain, proposals);
1827           ikev2_payload_add_nonce (chain, sa->i_nonce);
1828           ikev2_payload_add_ts (chain, sa->childs[0].tsi, IKEV2_PAYLOAD_TSI);
1829           ikev2_payload_add_ts (chain, sa->childs[0].tsr, IKEV2_PAYLOAD_TSR);
1830           ikev2_payload_add_notify_2 (chain, IKEV2_NOTIFY_MSG_REKEY_SA, data,
1831                                       &notify);
1832
1833           vec_free (data);
1834         }
1835       else
1836         {
1837           if (sa->rekey)
1838             {
1839               ikev2_payload_add_sa (chain, sa->rekey[0].r_proposal);
1840               ikev2_payload_add_nonce (chain, sa->r_nonce);
1841               ikev2_payload_add_ts (chain, sa->rekey[0].tsi,
1842                                     IKEV2_PAYLOAD_TSI);
1843               ikev2_payload_add_ts (chain, sa->rekey[0].tsr,
1844                                     IKEV2_PAYLOAD_TSR);
1845               vec_del1 (sa->rekey, 0);
1846             }
1847           else if (sa->unsupported_cp)
1848             {
1849               u8 *data = vec_new (u8, 1);
1850
1851               data[0] = sa->unsupported_cp;
1852               ikev2_payload_add_notify (chain,
1853                                         IKEV2_NOTIFY_MSG_UNSUPPORTED_CRITICAL_PAYLOAD,
1854                                         data);
1855               vec_free (data);
1856               sa->unsupported_cp = 0;
1857             }
1858           else
1859             {
1860               ikev2_payload_add_notify (chain,
1861                                         IKEV2_NOTIFY_MSG_NO_ADDITIONAL_SAS,
1862                                         0);
1863             }
1864         }
1865     }
1866
1867   /* IKEv2 header */
1868   ike->version = IKE_VERSION_2;
1869   ike->nextpayload = IKEV2_PAYLOAD_SK;
1870   tlen = sizeof (*ike);
1871   if (sa->is_initiator)
1872     {
1873       ike->flags = IKEV2_HDR_FLAG_INITIATOR;
1874       sa->last_init_msg_id = clib_net_to_host_u32 (ike->msgid);
1875     }
1876   else
1877     {
1878       ike->flags = IKEV2_HDR_FLAG_RESPONSE;
1879     }
1880
1881
1882   if (ike->exchange == IKEV2_EXCHANGE_SA_INIT)
1883     {
1884       tlen += vec_len (chain->data);
1885       ike->nextpayload = chain->first_payload_type;
1886       ike->length = clib_host_to_net_u32 (tlen);
1887       clib_memcpy (ike->payload, chain->data, vec_len (chain->data));
1888
1889       /* store whole IKE payload - needed for PSK auth */
1890       vec_free (sa->last_sa_init_res_packet_data);
1891       vec_add (sa->last_sa_init_res_packet_data, ike, tlen);
1892     }
1893   else
1894     {
1895
1896       ikev2_payload_chain_add_padding (chain, tr_encr->block_size);
1897
1898       /* SK payload */
1899       plen = sizeof (*ph);
1900       ph = (ike_payload_header_t *) & ike->payload[0];
1901       ph->nextpayload = chain->first_payload_type;
1902       ph->flags = 0;
1903       int enc_len = ikev2_encrypt_data (sa, chain->data, ph->payload);
1904       plen += enc_len;
1905
1906       /* add space for hmac */
1907       plen += tr_integ->key_trunc;
1908       tlen += plen;
1909
1910       /* payload and total length */
1911       ph->length = clib_host_to_net_u16 (plen);
1912       ike->length = clib_host_to_net_u32 (tlen);
1913
1914       /* calc integrity data for whole packet except hash itself */
1915       integ =
1916         ikev2_calc_integr (tr_integ, sa->is_initiator ? sa->sk_ai : sa->sk_ar,
1917                            (u8 *) ike, tlen - tr_integ->key_trunc);
1918
1919       clib_memcpy (ike->payload + tlen - tr_integ->key_trunc - sizeof (*ike),
1920                    integ, tr_integ->key_trunc);
1921
1922       /* store whole IKE payload - needed for retransmit */
1923       vec_free (sa->last_res_packet_data);
1924       vec_add (sa->last_res_packet_data, ike, tlen);
1925     }
1926
1927 done:
1928   ikev2_payload_destroy_chain (chain);
1929   vec_free (integ);
1930   return tlen;
1931 }
1932
1933 static int
1934 ikev2_retransmit_sa_init (ike_header_t * ike,
1935                           ip4_address_t iaddr, ip4_address_t raddr)
1936 {
1937   ikev2_main_t *km = &ikev2_main;
1938   ikev2_sa_t *sa;
1939   u32 thread_index = vlib_get_thread_index ();
1940
1941   /* *INDENT-OFF* */
1942   pool_foreach (sa, km->per_thread_data[thread_index].sas, ({
1943     if (sa->ispi == clib_net_to_host_u64(ike->ispi) &&
1944         sa->iaddr.as_u32 == iaddr.as_u32 &&
1945         sa->raddr.as_u32 == raddr.as_u32)
1946       {
1947         int p = 0;
1948         u32 len = clib_net_to_host_u32(ike->length);
1949         u8 payload = ike->nextpayload;
1950
1951         while (p < len && payload!= IKEV2_PAYLOAD_NONE) {
1952           ike_payload_header_t * ikep = (ike_payload_header_t *) &ike->payload[p];
1953           u32 plen = clib_net_to_host_u16(ikep->length);
1954
1955           if (plen < sizeof(ike_payload_header_t))
1956             return -1;
1957
1958           if (payload == IKEV2_PAYLOAD_NONCE)
1959             {
1960               if (!memcmp(sa->i_nonce, ikep->payload, plen - sizeof(*ikep)))
1961                 {
1962                   /* req is retransmit */
1963                   if (sa->state == IKEV2_STATE_SA_INIT)
1964                     {
1965                       ike_header_t * tmp;
1966                       tmp = (ike_header_t*)sa->last_sa_init_res_packet_data;
1967                       ike->ispi = tmp->ispi;
1968                       ike->rspi = tmp->rspi;
1969                       ike->nextpayload = tmp->nextpayload;
1970                       ike->version = tmp->version;
1971                       ike->exchange = tmp->exchange;
1972                       ike->flags = tmp->flags;
1973                       ike->msgid = tmp->msgid;
1974                       ike->length = tmp->length;
1975                       clib_memcpy(ike->payload, tmp->payload,
1976                              clib_net_to_host_u32(tmp->length) - sizeof(*ike));
1977                       clib_warning("IKE_SA_INIT retransmit from %U to %U",
1978                                    format_ip4_address, &raddr,
1979                                    format_ip4_address, &iaddr);
1980                       return 1;
1981                     }
1982                   /* else ignore req */
1983                   else
1984                     {
1985                       clib_warning("IKE_SA_INIT ignore from %U to %U",
1986                                    format_ip4_address, &raddr,
1987                                    format_ip4_address, &iaddr);
1988                       return -1;
1989                     }
1990                 }
1991             }
1992           payload = ikep->nextpayload;
1993           p+=plen;
1994         }
1995       }
1996   }));
1997   /* *INDENT-ON* */
1998
1999   /* req is not retransmit */
2000   return 0;
2001 }
2002
2003 static int
2004 ikev2_retransmit_resp (ikev2_sa_t * sa, ike_header_t * ike)
2005 {
2006   u32 msg_id = clib_net_to_host_u32 (ike->msgid);
2007
2008   /* new req */
2009   if (msg_id > sa->last_msg_id)
2010     {
2011       sa->last_msg_id = msg_id;
2012       return 0;
2013     }
2014   /* retransmitted req */
2015   else if (msg_id == sa->last_msg_id)
2016     {
2017       ike_header_t *tmp;
2018       tmp = (ike_header_t *) sa->last_res_packet_data;
2019       ike->ispi = tmp->ispi;
2020       ike->rspi = tmp->rspi;
2021       ike->nextpayload = tmp->nextpayload;
2022       ike->version = tmp->version;
2023       ike->exchange = tmp->exchange;
2024       ike->flags = tmp->flags;
2025       ike->msgid = tmp->msgid;
2026       ike->length = tmp->length;
2027       clib_memcpy (ike->payload, tmp->payload,
2028                    clib_net_to_host_u32 (tmp->length) - sizeof (*ike));
2029       clib_warning ("IKE msgid %u retransmit from %U to %U",
2030                     msg_id,
2031                     format_ip4_address, &sa->raddr,
2032                     format_ip4_address, &sa->iaddr);
2033       return 1;
2034     }
2035   /* old req ignore */
2036   else
2037     {
2038       clib_warning ("IKE msgid %u req ignore from %U to %U",
2039                     msg_id,
2040                     format_ip4_address, &sa->raddr,
2041                     format_ip4_address, &sa->iaddr);
2042       return -1;
2043     }
2044 }
2045
2046 static uword
2047 ikev2_node_fn (vlib_main_t * vm,
2048                vlib_node_runtime_t * node, vlib_frame_t * frame)
2049 {
2050   u32 n_left_from, *from, *to_next;
2051   ikev2_next_t next_index;
2052   ikev2_main_t *km = &ikev2_main;
2053   u32 thread_index = vlib_get_thread_index ();
2054
2055   from = vlib_frame_vector_args (frame);
2056   n_left_from = frame->n_vectors;
2057   next_index = node->cached_next_index;
2058
2059   while (n_left_from > 0)
2060     {
2061       u32 n_left_to_next;
2062
2063       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
2064
2065       while (n_left_from > 0 && n_left_to_next > 0)
2066         {
2067           u32 bi0;
2068           vlib_buffer_t *b0;
2069           u32 next0 = IKEV2_NEXT_ERROR_DROP;
2070           u32 sw_if_index0;
2071           ip4_header_t *ip40;
2072           udp_header_t *udp0;
2073           ike_header_t *ike0;
2074           ikev2_sa_t *sa0 = 0;
2075           ikev2_sa_t sa;        /* temporary store for SA */
2076           int len = 0;
2077           int r;
2078
2079           /* speculatively enqueue b0 to the current next frame */
2080           bi0 = from[0];
2081           to_next[0] = bi0;
2082           from += 1;
2083           to_next += 1;
2084           n_left_from -= 1;
2085           n_left_to_next -= 1;
2086
2087           b0 = vlib_get_buffer (vm, bi0);
2088           ike0 = vlib_buffer_get_current (b0);
2089           vlib_buffer_advance (b0, -sizeof (*udp0));
2090           udp0 = vlib_buffer_get_current (b0);
2091           vlib_buffer_advance (b0, -sizeof (*ip40));
2092           ip40 = vlib_buffer_get_current (b0);
2093
2094           if (ike0->version != IKE_VERSION_2)
2095             {
2096               vlib_node_increment_counter (vm, ikev2_node.index,
2097                                            IKEV2_ERROR_NOT_IKEV2, 1);
2098               goto dispatch0;
2099             }
2100
2101           if (ike0->exchange == IKEV2_EXCHANGE_SA_INIT)
2102             {
2103               sa0 = &sa;
2104               memset (sa0, 0, sizeof (*sa0));
2105
2106               if (ike0->flags & IKEV2_HDR_FLAG_INITIATOR)
2107                 {
2108                   if (ike0->rspi == 0)
2109                     {
2110                       sa0->raddr.as_u32 = ip40->dst_address.as_u32;
2111                       sa0->iaddr.as_u32 = ip40->src_address.as_u32;
2112
2113                       r = ikev2_retransmit_sa_init (ike0, sa0->iaddr,
2114                                                     sa0->raddr);
2115                       if (r == 1)
2116                         {
2117                           vlib_node_increment_counter (vm, ikev2_node.index,
2118                                                        IKEV2_ERROR_IKE_SA_INIT_RETRANSMIT,
2119                                                        1);
2120                           len = clib_net_to_host_u32 (ike0->length);
2121                           goto dispatch0;
2122                         }
2123                       else if (r == -1)
2124                         {
2125                           vlib_node_increment_counter (vm, ikev2_node.index,
2126                                                        IKEV2_ERROR_IKE_SA_INIT_IGNORE,
2127                                                        1);
2128                           goto dispatch0;
2129                         }
2130
2131                       ikev2_process_sa_init_req (vm, sa0, ike0);
2132
2133                       if (sa0->state == IKEV2_STATE_SA_INIT)
2134                         {
2135                           ikev2_sa_free_proposal_vector (&sa0->r_proposals);
2136                           sa0->r_proposals =
2137                             ikev2_select_proposal (sa0->i_proposals,
2138                                                    IKEV2_PROTOCOL_IKE);
2139                           ikev2_generate_sa_init_data (sa0);
2140                         }
2141
2142                       if (sa0->state == IKEV2_STATE_SA_INIT
2143                           || sa0->state == IKEV2_STATE_NOTIFY_AND_DELETE)
2144                         {
2145                           len = ikev2_generate_message (sa0, ike0, 0);
2146                         }
2147
2148                       if (sa0->state == IKEV2_STATE_SA_INIT)
2149                         {
2150                           /* add SA to the pool */
2151                           pool_get (km->per_thread_data[thread_index].sas,
2152                                     sa0);
2153                           clib_memcpy (sa0, &sa, sizeof (*sa0));
2154                           hash_set (km->
2155                                     per_thread_data[thread_index].sa_by_rspi,
2156                                     sa0->rspi,
2157                                     sa0 -
2158                                     km->per_thread_data[thread_index].sas);
2159                         }
2160                       else
2161                         {
2162                           ikev2_sa_free_all_vec (sa0);
2163                         }
2164                     }
2165                 }
2166               else
2167                 {
2168                   ikev2_process_sa_init_resp (vm, sa0, ike0);
2169
2170                   if (sa0->state == IKEV2_STATE_SA_INIT)
2171                     {
2172                       ike0->exchange = IKEV2_EXCHANGE_IKE_AUTH;
2173                       uword *p = hash_get (km->sa_by_ispi, ike0->ispi);
2174                       if (p)
2175                         {
2176                           ikev2_sa_t *sai =
2177                             pool_elt_at_index (km->sais, p[0]);
2178
2179                           ikev2_complete_sa_data (sa0, sai);
2180                           ikev2_calc_keys (sa0);
2181                           ikev2_sa_auth_init (sa0);
2182                           len = ikev2_generate_message (sa0, ike0, 0);
2183                         }
2184                     }
2185
2186                   if (sa0->state == IKEV2_STATE_SA_INIT)
2187                     {
2188                       /* add SA to the pool */
2189                       pool_get (km->per_thread_data[thread_index].sas, sa0);
2190                       clib_memcpy (sa0, &sa, sizeof (*sa0));
2191                       hash_set (km->per_thread_data[thread_index].sa_by_rspi,
2192                                 sa0->rspi,
2193                                 sa0 - km->per_thread_data[thread_index].sas);
2194                     }
2195                   else
2196                     {
2197                       ikev2_sa_free_all_vec (sa0);
2198                     }
2199                 }
2200             }
2201           else if (ike0->exchange == IKEV2_EXCHANGE_IKE_AUTH)
2202             {
2203               uword *p;
2204               p = hash_get (km->per_thread_data[thread_index].sa_by_rspi,
2205                             clib_net_to_host_u64 (ike0->rspi));
2206               if (p)
2207                 {
2208                   sa0 =
2209                     pool_elt_at_index (km->per_thread_data[thread_index].sas,
2210                                        p[0]);
2211
2212                   r = ikev2_retransmit_resp (sa0, ike0);
2213                   if (r == 1)
2214                     {
2215                       vlib_node_increment_counter (vm, ikev2_node.index,
2216                                                    IKEV2_ERROR_IKE_REQ_RETRANSMIT,
2217                                                    1);
2218                       len = clib_net_to_host_u32 (ike0->length);
2219                       goto dispatch0;
2220                     }
2221                   else if (r == -1)
2222                     {
2223                       vlib_node_increment_counter (vm, ikev2_node.index,
2224                                                    IKEV2_ERROR_IKE_REQ_IGNORE,
2225                                                    1);
2226                       goto dispatch0;
2227                     }
2228
2229                   ikev2_process_auth_req (vm, sa0, ike0);
2230                   ikev2_sa_auth (sa0);
2231                   if (sa0->state == IKEV2_STATE_AUTHENTICATED)
2232                     {
2233                       ikev2_initial_contact_cleanup (sa0);
2234                       ikev2_sa_match_ts (sa0);
2235                       if (sa0->state != IKEV2_STATE_TS_UNACCEPTABLE)
2236                         ikev2_create_tunnel_interface (km->vnet_main, sa0,
2237                                                        &sa0->childs[0]);
2238                     }
2239
2240                   if (sa0->is_initiator)
2241                     {
2242                       uword *p = hash_get (km->sa_by_ispi, ike0->ispi);
2243                       if (p)
2244                         {
2245                           ikev2_sa_t *sai =
2246                             pool_elt_at_index (km->sais, p[0]);
2247                           hash_unset (km->sa_by_ispi, sai->ispi);
2248                           ikev2_sa_free_all_vec (sai);
2249                           pool_put (km->sais, sai);
2250                         }
2251                     }
2252                   else
2253                     {
2254                       len = ikev2_generate_message (sa0, ike0, 0);
2255                     }
2256                 }
2257             }
2258           else if (ike0->exchange == IKEV2_EXCHANGE_INFORMATIONAL)
2259             {
2260               uword *p;
2261               p = hash_get (km->per_thread_data[thread_index].sa_by_rspi,
2262                             clib_net_to_host_u64 (ike0->rspi));
2263               if (p)
2264                 {
2265                   sa0 =
2266                     pool_elt_at_index (km->per_thread_data[thread_index].sas,
2267                                        p[0]);
2268
2269                   r = ikev2_retransmit_resp (sa0, ike0);
2270                   if (r == 1)
2271                     {
2272                       vlib_node_increment_counter (vm, ikev2_node.index,
2273                                                    IKEV2_ERROR_IKE_REQ_RETRANSMIT,
2274                                                    1);
2275                       len = clib_net_to_host_u32 (ike0->length);
2276                       goto dispatch0;
2277                     }
2278                   else if (r == -1)
2279                     {
2280                       vlib_node_increment_counter (vm, ikev2_node.index,
2281                                                    IKEV2_ERROR_IKE_REQ_IGNORE,
2282                                                    1);
2283                       goto dispatch0;
2284                     }
2285
2286                   ikev2_process_informational_req (vm, sa0, ike0);
2287                   if (sa0->del)
2288                     {
2289                       if (sa0->del[0].protocol_id != IKEV2_PROTOCOL_IKE)
2290                         {
2291                           ikev2_delete_t *d, *tmp, *resp = 0;
2292                           vec_foreach (d, sa0->del)
2293                           {
2294                             ikev2_child_sa_t *ch_sa;
2295                             ch_sa = ikev2_sa_get_child (sa0, d->spi,
2296                                                         d->protocol_id,
2297                                                         !sa0->is_initiator);
2298                             if (ch_sa)
2299                               {
2300                                 ikev2_delete_tunnel_interface (km->vnet_main,
2301                                                                sa0, ch_sa);
2302                                 if (!sa0->is_initiator)
2303                                   {
2304                                     vec_add2 (resp, tmp, 1);
2305                                     tmp->protocol_id = d->protocol_id;
2306                                     tmp->spi = ch_sa->r_proposals[0].spi;
2307                                   }
2308                                 ikev2_sa_del_child_sa (sa0, ch_sa);
2309                               }
2310                           }
2311                           if (!sa0->is_initiator)
2312                             {
2313                               vec_free (sa0->del);
2314                               sa0->del = resp;
2315                             }
2316                         }
2317                     }
2318                   if (!sa0->is_initiator)
2319                     {
2320                       len = ikev2_generate_message (sa0, ike0, 0);
2321                     }
2322                 }
2323             }
2324           else if (ike0->exchange == IKEV2_EXCHANGE_CREATE_CHILD_SA)
2325             {
2326               uword *p;
2327               p = hash_get (km->per_thread_data[thread_index].sa_by_rspi,
2328                             clib_net_to_host_u64 (ike0->rspi));
2329               if (p)
2330                 {
2331                   sa0 =
2332                     pool_elt_at_index (km->per_thread_data[thread_index].sas,
2333                                        p[0]);
2334
2335                   r = ikev2_retransmit_resp (sa0, ike0);
2336                   if (r == 1)
2337                     {
2338                       vlib_node_increment_counter (vm, ikev2_node.index,
2339                                                    IKEV2_ERROR_IKE_REQ_RETRANSMIT,
2340                                                    1);
2341                       len = clib_net_to_host_u32 (ike0->length);
2342                       goto dispatch0;
2343                     }
2344                   else if (r == -1)
2345                     {
2346                       vlib_node_increment_counter (vm, ikev2_node.index,
2347                                                    IKEV2_ERROR_IKE_REQ_IGNORE,
2348                                                    1);
2349                       goto dispatch0;
2350                     }
2351
2352                   ikev2_process_create_child_sa_req (vm, sa0, ike0);
2353                   if (sa0->rekey)
2354                     {
2355                       if (sa0->rekey[0].protocol_id != IKEV2_PROTOCOL_IKE)
2356                         {
2357                           ikev2_child_sa_t *child;
2358                           vec_add2 (sa0->childs, child, 1);
2359                           child->r_proposals = sa0->rekey[0].r_proposal;
2360                           child->i_proposals = sa0->rekey[0].i_proposal;
2361                           child->tsi = sa0->rekey[0].tsi;
2362                           child->tsr = sa0->rekey[0].tsr;
2363                           ikev2_create_tunnel_interface (km->vnet_main, sa0,
2364                                                          child);
2365                         }
2366                       if (sa0->is_initiator)
2367                         {
2368                           vec_del1 (sa0->rekey, 0);
2369                         }
2370                       else
2371                         {
2372                           len = ikev2_generate_message (sa0, ike0, 0);
2373                         }
2374                     }
2375                 }
2376             }
2377           else
2378             {
2379               clib_warning ("IKEv2 exchange %u packet received from %U to %U",
2380                             ike0->exchange,
2381                             format_ip4_address, ip40->src_address.as_u8,
2382                             format_ip4_address, ip40->dst_address.as_u8);
2383             }
2384
2385         dispatch0:
2386           /* if we are sending packet back, rewrite headers */
2387           if (len)
2388             {
2389               next0 = IKEV2_NEXT_IP4_LOOKUP;
2390               if (sa0->is_initiator)
2391                 {
2392                   ip40->dst_address.as_u32 = sa0->raddr.as_u32;
2393                   ip40->src_address.as_u32 = sa0->iaddr.as_u32;
2394                 }
2395               else
2396                 {
2397                   ip40->dst_address.as_u32 = sa0->iaddr.as_u32;
2398                   ip40->src_address.as_u32 = sa0->raddr.as_u32;
2399                 }
2400               udp0->length =
2401                 clib_host_to_net_u16 (len + sizeof (udp_header_t));
2402               udp0->checksum = 0;
2403               b0->current_length =
2404                 len + sizeof (ip4_header_t) + sizeof (udp_header_t);
2405               ip40->length = clib_host_to_net_u16 (b0->current_length);
2406               ip40->checksum = ip4_header_checksum (ip40);
2407             }
2408           /* delete sa */
2409           if (sa0 && (sa0->state == IKEV2_STATE_DELETED ||
2410                       sa0->state == IKEV2_STATE_NOTIFY_AND_DELETE))
2411             {
2412               ikev2_child_sa_t *c;
2413
2414               vec_foreach (c, sa0->childs)
2415                 ikev2_delete_tunnel_interface (km->vnet_main, sa0, c);
2416
2417               ikev2_delete_sa (sa0);
2418             }
2419           sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
2420
2421           if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)
2422                              && (b0->flags & VLIB_BUFFER_IS_TRACED)))
2423             {
2424               ikev2_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t));
2425               t->sw_if_index = sw_if_index0;
2426               t->next_index = next0;
2427             }
2428
2429           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
2430                                            n_left_to_next, bi0, next0);
2431         }
2432
2433       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2434     }
2435
2436   vlib_node_increment_counter (vm, ikev2_node.index,
2437                                IKEV2_ERROR_PROCESSED, frame->n_vectors);
2438   return frame->n_vectors;
2439 }
2440
2441 /* *INDENT-OFF* */
2442 VLIB_REGISTER_NODE (ikev2_node,static) = {
2443   .function = ikev2_node_fn,
2444   .name = "ikev2",
2445   .vector_size = sizeof (u32),
2446   .format_trace = format_ikev2_trace,
2447   .type = VLIB_NODE_TYPE_INTERNAL,
2448
2449   .n_errors = ARRAY_LEN(ikev2_error_strings),
2450   .error_strings = ikev2_error_strings,
2451
2452   .n_next_nodes = IKEV2_N_NEXT,
2453
2454   .next_nodes = {
2455     [IKEV2_NEXT_IP4_LOOKUP] = "ip4-lookup",
2456         [IKEV2_NEXT_ERROR_DROP] = "error-drop",
2457   },
2458 };
2459 /* *INDENT-ON* */
2460
2461
2462 static clib_error_t *
2463 ikev2_set_initiator_proposals (vlib_main_t * vm, ikev2_sa_t * sa,
2464                                ikev2_transforms_set * ts,
2465                                ikev2_sa_proposal_t ** proposals, int is_ike)
2466 {
2467   clib_error_t *r;
2468   ikev2_main_t *km = &ikev2_main;
2469   ikev2_sa_proposal_t *proposal;
2470   vec_add2 (*proposals, proposal, 1);
2471   ikev2_sa_transform_t *td;
2472   int error;
2473
2474   /* Encryption */
2475   error = 1;
2476   vec_foreach (td, km->supported_transforms)
2477   {
2478     if (td->type == IKEV2_TRANSFORM_TYPE_ENCR
2479         && td->encr_type == IKEV2_TRANSFORM_ENCR_TYPE_AES_CBC
2480         && td->key_len == ts->crypto_key_size / 8)
2481       {
2482         u16 attr[2];
2483         attr[0] = clib_host_to_net_u16 (14 | (1 << 15));
2484         attr[1] = clib_host_to_net_u16 (td->key_len << 3);
2485         vec_add (td->attrs, (u8 *) attr, 4);
2486         vec_add1 (proposal->transforms, *td);
2487         td->attrs = 0;
2488
2489         error = 0;
2490         break;
2491       }
2492   }
2493   if (error)
2494     {
2495       r = clib_error_return (0, "Unsupported algorithm");
2496       return r;
2497     }
2498
2499   /* Integrity */
2500   error = 1;
2501   vec_foreach (td, km->supported_transforms)
2502   {
2503     if (td->type == IKEV2_TRANSFORM_TYPE_INTEG
2504         && td->integ_type == IKEV2_TRANSFORM_INTEG_TYPE_AUTH_HMAC_SHA1_96)
2505       {
2506         vec_add1 (proposal->transforms, *td);
2507         error = 0;
2508         break;
2509       }
2510   }
2511   if (error)
2512     {
2513       r = clib_error_return (0, "Unsupported algorithm");
2514       return r;
2515     }
2516
2517   /* PRF */
2518   if (is_ike)
2519     {
2520       error = 1;
2521       vec_foreach (td, km->supported_transforms)
2522       {
2523         if (td->type == IKEV2_TRANSFORM_TYPE_PRF
2524             && td->prf_type == IKEV2_TRANSFORM_PRF_TYPE_PRF_HMAC_SHA1)
2525           {
2526             vec_add1 (proposal->transforms, *td);
2527             error = 0;
2528             break;
2529           }
2530       }
2531       if (error)
2532         {
2533           r = clib_error_return (0, "Unsupported algorithm");
2534           return r;
2535         }
2536     }
2537
2538   /* DH */
2539   error = 1;
2540   vec_foreach (td, km->supported_transforms)
2541   {
2542     if (td->type == IKEV2_TRANSFORM_TYPE_DH && td->dh_type == ts->dh_type)
2543       {
2544         vec_add1 (proposal->transforms, *td);
2545         if (is_ike)
2546           {
2547             sa->dh_group = td->dh_type;
2548           }
2549         error = 0;
2550         break;
2551       }
2552   }
2553   if (error)
2554     {
2555       r = clib_error_return (0, "Unsupported algorithm");
2556       return r;
2557     }
2558
2559   if (!is_ike)
2560     {
2561       error = 1;
2562       vec_foreach (td, km->supported_transforms)
2563       {
2564         if (td->type == IKEV2_TRANSFORM_TYPE_ESN)
2565           {
2566             vec_add1 (proposal->transforms, *td);
2567             error = 0;
2568             break;
2569           }
2570       }
2571       if (error)
2572         {
2573           r = clib_error_return (0, "Unsupported algorithm");
2574           return r;
2575         }
2576     }
2577
2578
2579   return 0;
2580 }
2581
2582 static ikev2_profile_t *
2583 ikev2_profile_index_by_name (u8 * name)
2584 {
2585   ikev2_main_t *km = &ikev2_main;
2586   uword *p;
2587
2588   p = mhash_get (&km->profile_index_by_name, name);
2589   if (!p)
2590     return 0;
2591
2592   return pool_elt_at_index (km->profiles, p[0]);
2593 }
2594
2595
2596 static void
2597 ikev2_send_ike (vlib_main_t * vm, ip4_address_t * src, ip4_address_t * dst,
2598                 u32 bi0, u32 len)
2599 {
2600   ip4_header_t *ip40;
2601   udp_header_t *udp0;
2602   vlib_buffer_t *b0;
2603   vlib_frame_t *f;
2604   u32 *to_next;
2605
2606   b0 = vlib_get_buffer (vm, bi0);
2607   vlib_buffer_advance (b0, -sizeof (udp_header_t));
2608   udp0 = vlib_buffer_get_current (b0);
2609   vlib_buffer_advance (b0, -sizeof (ip4_header_t));
2610   ip40 = vlib_buffer_get_current (b0);
2611
2612
2613   ip40->ip_version_and_header_length = 0x45;
2614   ip40->tos = 0;
2615   ip40->fragment_id = 0;
2616   ip40->flags_and_fragment_offset = 0;
2617   ip40->ttl = 0xff;
2618   ip40->protocol = IP_PROTOCOL_UDP;
2619   ip40->dst_address.as_u32 = dst->as_u32;
2620   ip40->src_address.as_u32 = src->as_u32;
2621   udp0->dst_port = clib_host_to_net_u16 (500);
2622   udp0->src_port = clib_host_to_net_u16 (500);
2623   udp0->length = clib_host_to_net_u16 (len + sizeof (udp_header_t));
2624   udp0->checksum = 0;
2625   b0->current_length = len + sizeof (ip4_header_t) + sizeof (udp_header_t);
2626   ip40->length = clib_host_to_net_u16 (b0->current_length);
2627   ip40->checksum = ip4_header_checksum (ip40);
2628
2629
2630   /* send the request */
2631   f = vlib_get_frame_to_node (vm, ip4_lookup_node.index);
2632   to_next = vlib_frame_vector_args (f);
2633   to_next[0] = bi0;
2634   f->n_vectors = 1;
2635   vlib_put_frame_to_node (vm, ip4_lookup_node.index, f);
2636
2637 }
2638
2639 static u32
2640 ikev2_get_new_ike_header_buff (vlib_main_t * vm, ike_header_t ** ike)
2641 {
2642   u32 bi0;
2643   if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
2644     {
2645       *ike = 0;
2646       return 0;
2647     }
2648   vlib_buffer_t *b0 = vlib_get_buffer (vm, bi0);
2649   *ike = vlib_buffer_get_current (b0);
2650   return bi0;
2651 }
2652
2653 clib_error_t *
2654 ikev2_set_local_key (vlib_main_t * vm, u8 * file)
2655 {
2656   ikev2_main_t *km = &ikev2_main;
2657
2658   km->pkey = ikev2_load_key_file (file);
2659   if (km->pkey == NULL)
2660     return clib_error_return (0, "load key '%s' failed", file);
2661
2662   return 0;
2663 }
2664
2665 clib_error_t *
2666 ikev2_add_del_profile (vlib_main_t * vm, u8 * name, int is_add)
2667 {
2668   ikev2_main_t *km = &ikev2_main;
2669   ikev2_profile_t *p;
2670
2671   if (is_add)
2672     {
2673       if (ikev2_profile_index_by_name (name))
2674         return clib_error_return (0, "policy %v already exists", name);
2675
2676       pool_get (km->profiles, p);
2677       memset (p, 0, sizeof (*p));
2678       p->name = vec_dup (name);
2679       p->responder.sw_if_index = ~0;
2680       uword index = p - km->profiles;
2681       mhash_set_mem (&km->profile_index_by_name, name, &index, 0);
2682     }
2683   else
2684     {
2685       p = ikev2_profile_index_by_name (name);
2686       if (!p)
2687         return clib_error_return (0, "policy %v does not exists", name);
2688
2689       vec_free (p->name);
2690       pool_put (km->profiles, p);
2691       mhash_unset (&km->profile_index_by_name, name, 0);
2692     }
2693   return 0;
2694 }
2695
2696 clib_error_t *
2697 ikev2_set_profile_auth (vlib_main_t * vm, u8 * name, u8 auth_method,
2698                         u8 * auth_data, u8 data_hex_format)
2699 {
2700   ikev2_profile_t *p;
2701   clib_error_t *r;
2702
2703   p = ikev2_profile_index_by_name (name);
2704
2705   if (!p)
2706     {
2707       r = clib_error_return (0, "unknown profile %v", name);
2708       return r;
2709     }
2710   vec_free (p->auth.data);
2711   p->auth.method = auth_method;
2712   p->auth.data = vec_dup (auth_data);
2713   p->auth.hex = data_hex_format;
2714
2715   if (auth_method == IKEV2_AUTH_METHOD_RSA_SIG)
2716     {
2717       vec_add1 (p->auth.data, 0);
2718       if (p->auth.key)
2719         EVP_PKEY_free (p->auth.key);
2720       p->auth.key = ikev2_load_cert_file (auth_data);
2721       if (p->auth.key == NULL)
2722         return clib_error_return (0, "load cert '%s' failed", auth_data);
2723     }
2724
2725   return 0;
2726 }
2727
2728 clib_error_t *
2729 ikev2_set_profile_id (vlib_main_t * vm, u8 * name, u8 id_type, u8 * data,
2730                       int is_local)
2731 {
2732   ikev2_profile_t *p;
2733   clib_error_t *r;
2734
2735   if (id_type > IKEV2_ID_TYPE_ID_RFC822_ADDR
2736       && id_type < IKEV2_ID_TYPE_ID_KEY_ID)
2737     {
2738       r = clib_error_return (0, "unsupported identity type %U",
2739                              format_ikev2_id_type, id_type);
2740       return r;
2741     }
2742
2743   p = ikev2_profile_index_by_name (name);
2744
2745   if (!p)
2746     {
2747       r = clib_error_return (0, "unknown profile %v", name);
2748       return r;
2749     }
2750
2751   if (is_local)
2752     {
2753       vec_free (p->loc_id.data);
2754       p->loc_id.type = id_type;
2755       p->loc_id.data = vec_dup (data);
2756     }
2757   else
2758     {
2759       vec_free (p->rem_id.data);
2760       p->rem_id.type = id_type;
2761       p->rem_id.data = vec_dup (data);
2762     }
2763
2764   return 0;
2765 }
2766
2767 clib_error_t *
2768 ikev2_set_profile_ts (vlib_main_t * vm, u8 * name, u8 protocol_id,
2769                       u16 start_port, u16 end_port, ip4_address_t start_addr,
2770                       ip4_address_t end_addr, int is_local)
2771 {
2772   ikev2_profile_t *p;
2773   clib_error_t *r;
2774
2775   p = ikev2_profile_index_by_name (name);
2776
2777   if (!p)
2778     {
2779       r = clib_error_return (0, "unknown profile %v", name);
2780       return r;
2781     }
2782
2783   if (is_local)
2784     {
2785       p->loc_ts.start_addr.as_u32 = start_addr.as_u32;
2786       p->loc_ts.end_addr.as_u32 = end_addr.as_u32;
2787       p->loc_ts.start_port = start_port;
2788       p->loc_ts.end_port = end_port;
2789       p->loc_ts.protocol_id = protocol_id;
2790       p->loc_ts.ts_type = 7;
2791     }
2792   else
2793     {
2794       p->rem_ts.start_addr.as_u32 = start_addr.as_u32;
2795       p->rem_ts.end_addr.as_u32 = end_addr.as_u32;
2796       p->rem_ts.start_port = start_port;
2797       p->rem_ts.end_port = end_port;
2798       p->rem_ts.protocol_id = protocol_id;
2799       p->rem_ts.ts_type = 7;
2800     }
2801
2802   return 0;
2803 }
2804
2805
2806 clib_error_t *
2807 ikev2_set_profile_responder (vlib_main_t * vm, u8 * name,
2808                              u32 sw_if_index, ip4_address_t ip4)
2809 {
2810   ikev2_profile_t *p;
2811   clib_error_t *r;
2812
2813   p = ikev2_profile_index_by_name (name);
2814
2815   if (!p)
2816     {
2817       r = clib_error_return (0, "unknown profile %v", name);
2818       return r;
2819     }
2820
2821   p->responder.sw_if_index = sw_if_index;
2822   p->responder.ip4 = ip4;
2823
2824   return 0;
2825 }
2826
2827 clib_error_t *
2828 ikev2_set_profile_ike_transforms (vlib_main_t * vm, u8 * name,
2829                                   ikev2_transform_encr_type_t crypto_alg,
2830                                   ikev2_transform_integ_type_t integ_alg,
2831                                   ikev2_transform_dh_type_t dh_type,
2832                                   u32 crypto_key_size)
2833 {
2834   ikev2_profile_t *p;
2835   clib_error_t *r;
2836
2837   p = ikev2_profile_index_by_name (name);
2838
2839   if (!p)
2840     {
2841       r = clib_error_return (0, "unknown profile %v", name);
2842       return r;
2843     }
2844
2845   p->ike_ts.crypto_alg = crypto_alg;
2846   p->ike_ts.integ_alg = integ_alg;
2847   p->ike_ts.dh_type = dh_type;
2848   p->ike_ts.crypto_key_size = crypto_key_size;
2849   return 0;
2850 }
2851
2852 clib_error_t *
2853 ikev2_set_profile_esp_transforms (vlib_main_t * vm, u8 * name,
2854                                   ikev2_transform_encr_type_t crypto_alg,
2855                                   ikev2_transform_integ_type_t integ_alg,
2856                                   ikev2_transform_dh_type_t dh_type,
2857                                   u32 crypto_key_size)
2858 {
2859   ikev2_profile_t *p;
2860   clib_error_t *r;
2861
2862   p = ikev2_profile_index_by_name (name);
2863
2864   if (!p)
2865     {
2866       r = clib_error_return (0, "unknown profile %v", name);
2867       return r;
2868     }
2869
2870   p->esp_ts.crypto_alg = crypto_alg;
2871   p->esp_ts.integ_alg = integ_alg;
2872   p->esp_ts.dh_type = dh_type;
2873   p->esp_ts.crypto_key_size = crypto_key_size;
2874   return 0;
2875 }
2876
2877 clib_error_t *
2878 ikev2_set_profile_sa_lifetime (vlib_main_t * vm, u8 * name,
2879                                u64 lifetime, u32 jitter, u32 handover,
2880                                u64 maxdata)
2881 {
2882   ikev2_profile_t *p;
2883   clib_error_t *r;
2884
2885   p = ikev2_profile_index_by_name (name);
2886
2887   if (!p)
2888     {
2889       r = clib_error_return (0, "unknown profile %v", name);
2890       return r;
2891     }
2892
2893   p->lifetime = lifetime;
2894   p->lifetime_jitter = jitter;
2895   p->handover = handover;
2896   p->lifetime_maxdata = maxdata;
2897   return 0;
2898 }
2899
2900 clib_error_t *
2901 ikev2_initiate_sa_init (vlib_main_t * vm, u8 * name)
2902 {
2903   ikev2_profile_t *p;
2904   clib_error_t *r;
2905   ip4_main_t *im = &ip4_main;
2906   ikev2_main_t *km = &ikev2_main;
2907
2908   p = ikev2_profile_index_by_name (name);
2909
2910   if (!p)
2911     {
2912       r = clib_error_return (0, "unknown profile %v", name);
2913       return r;
2914     }
2915
2916   if (p->responder.sw_if_index == ~0 || p->responder.ip4.data_u32 == 0)
2917     {
2918       r = clib_error_return (0, "responder not set for profile %v", name);
2919       return r;
2920     }
2921
2922
2923   /* Create the Initiator Request */
2924   {
2925     ike_header_t *ike0;
2926     u32 bi0 = 0;
2927     ip_lookup_main_t *lm = &im->lookup_main;
2928     u32 if_add_index0;
2929     int len = sizeof (ike_header_t);
2930
2931     /* Get own iface IP */
2932     if_add_index0 =
2933       lm->if_address_pool_index_by_sw_if_index[p->responder.sw_if_index];
2934     ip_interface_address_t *if_add =
2935       pool_elt_at_index (lm->if_address_pool, if_add_index0);
2936     ip4_address_t *if_ip = ip_interface_address_get_address (lm, if_add);
2937
2938     bi0 = ikev2_get_new_ike_header_buff (vm, &ike0);
2939
2940     /* Prepare the SA and the IKE payload */
2941     ikev2_sa_t sa;
2942     memset (&sa, 0, sizeof (ikev2_sa_t));
2943     ikev2_payload_chain_t *chain = 0;
2944     ikev2_payload_new_chain (chain);
2945
2946     /* Build the IKE proposal payload */
2947     ikev2_sa_proposal_t *proposals = 0;
2948     ikev2_set_initiator_proposals (vm, &sa, &p->ike_ts, &proposals, 1);
2949     proposals[0].proposal_num = 1;
2950     proposals[0].protocol_id = IKEV2_PROTOCOL_IKE;
2951
2952     /* Add and then cleanup proposal data */
2953     ikev2_payload_add_sa (chain, proposals);
2954     ikev2_sa_free_proposal_vector (&proposals);
2955
2956     sa.is_initiator = 1;
2957     sa.profile = p;
2958     sa.state = IKEV2_STATE_SA_INIT;
2959     ikev2_generate_sa_init_data (&sa);
2960     ikev2_payload_add_ke (chain, sa.dh_group, sa.i_dh_data);
2961     ikev2_payload_add_nonce (chain, sa.i_nonce);
2962
2963     /* Build the child SA proposal */
2964     vec_resize (sa.childs, 1);
2965     ikev2_set_initiator_proposals (vm, &sa, &p->esp_ts,
2966                                    &sa.childs[0].i_proposals, 0);
2967     sa.childs[0].i_proposals[0].proposal_num = 1;
2968     sa.childs[0].i_proposals[0].protocol_id = IKEV2_PROTOCOL_ESP;
2969     RAND_bytes ((u8 *) & sa.childs[0].i_proposals[0].spi,
2970                 sizeof (sa.childs[0].i_proposals[0].spi));
2971
2972
2973
2974     /* Add NAT detection notification messages (mandatory) */
2975     u8 nat_detection_source[8 + 8 + 4 + 2];
2976     u8 *nat_detection_sha1 = vec_new (u8, 20);
2977
2978     u64 tmpspi = clib_host_to_net_u64 (sa.ispi);
2979     clib_memcpy (&nat_detection_source[0], &tmpspi, sizeof (tmpspi));
2980     tmpspi = clib_host_to_net_u64 (sa.rspi);
2981     clib_memcpy (&nat_detection_source[8], &tmpspi, sizeof (tmpspi));
2982     u16 tmpport = clib_host_to_net_u16 (500);
2983     clib_memcpy (&nat_detection_source[8 + 8 + 4], &tmpport,
2984                  sizeof (tmpport));
2985     u32 tmpip = clib_host_to_net_u32 (if_ip->as_u32);
2986     clib_memcpy (&nat_detection_source[8 + 8], &tmpip, sizeof (tmpip));
2987     SHA1 (nat_detection_source, sizeof (nat_detection_source),
2988           nat_detection_sha1);
2989     ikev2_payload_add_notify (chain, IKEV2_NOTIFY_MSG_NAT_DETECTION_SOURCE_IP,
2990                               nat_detection_sha1);
2991     tmpip = clib_host_to_net_u32 (p->responder.ip4.as_u32);
2992     clib_memcpy (&nat_detection_source[8 + 8], &tmpip, sizeof (tmpip));
2993     SHA1 (nat_detection_source, sizeof (nat_detection_source),
2994           nat_detection_sha1);
2995     ikev2_payload_add_notify (chain,
2996                               IKEV2_NOTIFY_MSG_NAT_DETECTION_DESTINATION_IP,
2997                               nat_detection_sha1);
2998     vec_free (nat_detection_sha1);
2999
3000     u8 *sig_hash_algo = vec_new (u8, 8);
3001     u64 tmpsig = clib_host_to_net_u64 (0x0001000200030004);
3002     clib_memcpy (sig_hash_algo, &tmpsig, sizeof (tmpsig));
3003     ikev2_payload_add_notify (chain,
3004                               IKEV2_NOTIFY_MSG_SIGNATURE_HASH_ALGORITHMS,
3005                               sig_hash_algo);
3006     vec_free (sig_hash_algo);
3007
3008
3009     /* Buffer update and bolierplate */
3010     len += vec_len (chain->data);
3011     ike0->nextpayload = chain->first_payload_type;
3012     ike0->length = clib_host_to_net_u32 (len);
3013     clib_memcpy (ike0->payload, chain->data, vec_len (chain->data));
3014     ikev2_payload_destroy_chain (chain);
3015
3016     ike0->version = IKE_VERSION_2;
3017     ike0->flags = IKEV2_HDR_FLAG_INITIATOR;
3018     ike0->exchange = IKEV2_EXCHANGE_SA_INIT;
3019     ike0->ispi = sa.ispi;
3020
3021     /* store whole IKE payload - needed for PSK auth */
3022     vec_free (sa.last_sa_init_req_packet_data);
3023     vec_add (sa.last_sa_init_req_packet_data, ike0, len);
3024
3025     /* add data to the SA then add it to the pool */
3026     sa.iaddr.as_u32 = if_ip->as_u32;
3027     sa.raddr.as_u32 = p->responder.ip4.as_u32;
3028     sa.i_id.type = p->loc_id.type;
3029     sa.i_id.data = vec_dup (p->loc_id.data);
3030     sa.i_auth.method = p->auth.method;
3031     sa.i_auth.hex = p->auth.hex;
3032     sa.i_auth.data = vec_dup (p->auth.data);
3033     sa.i_auth.key = vec_dup (p->auth.key);
3034     vec_add (sa.childs[0].tsi, &p->loc_ts, 1);
3035     vec_add (sa.childs[0].tsr, &p->rem_ts, 1);
3036
3037     /* add SA to the pool */
3038     ikev2_sa_t *sa0 = 0;
3039     pool_get (km->sais, sa0);
3040     clib_memcpy (sa0, &sa, sizeof (*sa0));
3041     hash_set (km->sa_by_ispi, sa0->ispi, sa0 - km->sais);
3042
3043     ikev2_send_ike (vm, if_ip, &p->responder.ip4, bi0, len);
3044
3045   }
3046
3047   return 0;
3048 }
3049
3050 static void
3051 ikev2_delete_child_sa_internal (vlib_main_t * vm, ikev2_sa_t * sa,
3052                                 ikev2_child_sa_t * csa)
3053 {
3054   /* Create the Initiator notification for child SA removal */
3055   ikev2_main_t *km = &ikev2_main;
3056   ike_header_t *ike0;
3057   u32 bi0 = 0;
3058   int len;
3059
3060   bi0 = ikev2_get_new_ike_header_buff (vm, &ike0);
3061
3062
3063   ike0->exchange = IKEV2_EXCHANGE_INFORMATIONAL;
3064   ike0->ispi = clib_host_to_net_u64 (sa->ispi);
3065   ike0->rspi = clib_host_to_net_u64 (sa->rspi);
3066   vec_resize (sa->del, 1);
3067   sa->del->protocol_id = IKEV2_PROTOCOL_ESP;
3068   sa->del->spi = csa->i_proposals->spi;
3069   ike0->msgid = clib_host_to_net_u32 (sa->last_init_msg_id + 1);
3070   sa->last_init_msg_id = clib_net_to_host_u32 (ike0->msgid);
3071   len = ikev2_generate_message (sa, ike0, 0);
3072
3073   ikev2_send_ike (vm, &sa->iaddr, &sa->raddr, bi0, len);
3074
3075   /* delete local child SA */
3076   ikev2_delete_tunnel_interface (km->vnet_main, sa, csa);
3077   ikev2_sa_del_child_sa (sa, csa);
3078 }
3079
3080 clib_error_t *
3081 ikev2_initiate_delete_child_sa (vlib_main_t * vm, u32 ispi)
3082 {
3083   clib_error_t *r;
3084   ikev2_main_t *km = &ikev2_main;
3085   ikev2_main_per_thread_data_t *tkm;
3086   ikev2_sa_t *fsa = 0;
3087   ikev2_child_sa_t *fchild = 0;
3088
3089   /* Search for the child SA */
3090   vec_foreach (tkm, km->per_thread_data)
3091   {
3092     ikev2_sa_t *sa;
3093     if (fchild)
3094       break;
3095     /* *INDENT-OFF* */
3096     pool_foreach (sa, tkm->sas, ({
3097       fchild = ikev2_sa_get_child(sa, ispi, IKEV2_PROTOCOL_ESP, 1);
3098       if (fchild)
3099         {
3100           fsa = sa;
3101           break;
3102         }
3103     }));
3104     /* *INDENT-ON* */
3105   }
3106
3107   if (!fchild || !fsa)
3108     {
3109       r = clib_error_return (0, "Child SA not found");
3110       return r;
3111     }
3112   else
3113     {
3114       ikev2_delete_child_sa_internal (vm, fsa, fchild);
3115     }
3116
3117   return 0;
3118 }
3119
3120 clib_error_t *
3121 ikev2_initiate_delete_ike_sa (vlib_main_t * vm, u64 ispi)
3122 {
3123   clib_error_t *r;
3124   ikev2_main_t *km = &ikev2_main;
3125   ikev2_main_per_thread_data_t *tkm;
3126   ikev2_sa_t *fsa = 0;
3127   ikev2_main_per_thread_data_t *ftkm = 0;
3128
3129   /* Search for the IKE SA */
3130   vec_foreach (tkm, km->per_thread_data)
3131   {
3132     ikev2_sa_t *sa;
3133     if (fsa)
3134       break;
3135     /* *INDENT-OFF* */
3136     pool_foreach (sa, tkm->sas, ({
3137       if (sa->ispi == ispi)
3138         {
3139           fsa = sa;
3140           ftkm = tkm;
3141           break;
3142         }
3143     }));
3144     /* *INDENT-ON* */
3145   }
3146
3147   if (!fsa)
3148     {
3149       r = clib_error_return (0, "IKE SA not found");
3150       return r;
3151     }
3152
3153
3154   /* Create the Initiator notification for IKE SA removal */
3155   {
3156     ike_header_t *ike0;
3157     u32 bi0 = 0;
3158     int len;
3159
3160     bi0 = ikev2_get_new_ike_header_buff (vm, &ike0);
3161
3162
3163     ike0->exchange = IKEV2_EXCHANGE_INFORMATIONAL;
3164     ike0->ispi = clib_host_to_net_u64 (fsa->ispi);
3165     ike0->rspi = clib_host_to_net_u64 (fsa->rspi);
3166     vec_resize (fsa->del, 1);
3167     fsa->del->protocol_id = IKEV2_PROTOCOL_IKE;
3168     fsa->del->spi = ispi;
3169     ike0->msgid = clib_host_to_net_u32 (fsa->last_init_msg_id + 1);
3170     fsa->last_init_msg_id = clib_net_to_host_u32 (ike0->msgid);
3171     len = ikev2_generate_message (fsa, ike0, 0);
3172
3173     ikev2_send_ike (vm, &fsa->iaddr, &fsa->raddr, bi0, len);
3174   }
3175
3176
3177   /* delete local SA */
3178   ikev2_child_sa_t *c;
3179   vec_foreach (c, fsa->childs)
3180   {
3181     ikev2_delete_tunnel_interface (km->vnet_main, fsa, c);
3182     ikev2_sa_del_child_sa (fsa, c);
3183   }
3184   ikev2_sa_free_all_vec (fsa);
3185   uword *p = hash_get (ftkm->sa_by_rspi, fsa->rspi);
3186   if (p)
3187     {
3188       hash_unset (ftkm->sa_by_rspi, fsa->rspi);
3189       pool_put (ftkm->sas, fsa);
3190     }
3191
3192
3193   return 0;
3194 }
3195
3196 static void
3197 ikev2_rekey_child_sa_internal (vlib_main_t * vm, ikev2_sa_t * sa,
3198                                ikev2_child_sa_t * csa)
3199 {
3200   /* Create the Initiator request for create child SA */
3201   ike_header_t *ike0;
3202   u32 bi0 = 0;
3203   int len;
3204
3205
3206   bi0 = ikev2_get_new_ike_header_buff (vm, &ike0);
3207
3208
3209   ike0->version = IKE_VERSION_2;
3210   ike0->flags = IKEV2_HDR_FLAG_INITIATOR;
3211   ike0->exchange = IKEV2_EXCHANGE_CREATE_CHILD_SA;
3212   ike0->ispi = clib_host_to_net_u64 (sa->ispi);
3213   ike0->rspi = clib_host_to_net_u64 (sa->rspi);
3214   ike0->msgid = clib_host_to_net_u32 (sa->last_init_msg_id + 1);
3215   sa->last_init_msg_id = clib_net_to_host_u32 (ike0->msgid);
3216
3217   ikev2_rekey_t *rekey;
3218   vec_add2 (sa->rekey, rekey, 1);
3219   ikev2_sa_proposal_t *proposals = vec_dup (csa->i_proposals);
3220
3221   /*need new ispi */
3222   RAND_bytes ((u8 *) & proposals[0].spi, sizeof (proposals[0].spi));
3223   rekey->spi = proposals[0].spi;
3224   rekey->ispi = csa->i_proposals->spi;
3225   len = ikev2_generate_message (sa, ike0, proposals);
3226   ikev2_send_ike (vm, &sa->iaddr, &sa->raddr, bi0, len);
3227   vec_free (proposals);
3228 }
3229
3230 clib_error_t *
3231 ikev2_initiate_rekey_child_sa (vlib_main_t * vm, u32 ispi)
3232 {
3233   clib_error_t *r;
3234   ikev2_main_t *km = &ikev2_main;
3235   ikev2_main_per_thread_data_t *tkm;
3236   ikev2_sa_t *fsa = 0;
3237   ikev2_child_sa_t *fchild = 0;
3238
3239   /* Search for the child SA */
3240   vec_foreach (tkm, km->per_thread_data)
3241   {
3242     ikev2_sa_t *sa;
3243     if (fchild)
3244       break;
3245     /* *INDENT-OFF* */
3246     pool_foreach (sa, tkm->sas, ({
3247       fchild = ikev2_sa_get_child(sa, ispi, IKEV2_PROTOCOL_ESP, 1);
3248       if (fchild)
3249         {
3250           fsa = sa;
3251           break;
3252         }
3253     }));
3254     /* *INDENT-ON* */
3255   }
3256
3257   if (!fchild || !fsa)
3258     {
3259       r = clib_error_return (0, "Child SA not found");
3260       return r;
3261     }
3262   else
3263     {
3264       ikev2_rekey_child_sa_internal (vm, fsa, fchild);
3265     }
3266
3267   return 0;
3268 }
3269
3270 clib_error_t *
3271 ikev2_init (vlib_main_t * vm)
3272 {
3273   ikev2_main_t *km = &ikev2_main;
3274   clib_error_t *error;
3275   vlib_thread_main_t *tm = vlib_get_thread_main ();
3276   int thread_id;
3277
3278   memset (km, 0, sizeof (ikev2_main_t));
3279   km->vnet_main = vnet_get_main ();
3280   km->vlib_main = vm;
3281
3282   ikev2_crypto_init (km);
3283
3284   mhash_init_vec_string (&km->profile_index_by_name, sizeof (uword));
3285
3286   vec_validate (km->per_thread_data, tm->n_vlib_mains - 1);
3287   for (thread_id = 0; thread_id < tm->n_vlib_mains - 1; thread_id++)
3288     {
3289       km->per_thread_data[thread_id].sa_by_rspi =
3290         hash_create (0, sizeof (uword));
3291     }
3292
3293   km->sa_by_ispi = hash_create (0, sizeof (uword));
3294
3295
3296   if ((error = vlib_call_init_function (vm, ikev2_cli_init)))
3297     return error;
3298
3299   udp_register_dst_port (vm, 500, ikev2_node.index, 1);
3300
3301   return 0;
3302 }
3303
3304
3305 static u8
3306 ikev2_mngr_process_child_sa (ikev2_sa_t * sa, ikev2_child_sa_t * csa)
3307 {
3308   ikev2_main_t *km = &ikev2_main;
3309   vlib_main_t *vm = km->vlib_main;
3310   f64 now = vlib_time_now (vm);
3311   u8 res = 0;
3312
3313   if (sa->is_initiator && sa->profile && csa->time_to_expiration
3314       && now > csa->time_to_expiration)
3315     {
3316       if (!csa->is_expired || csa->rekey_retries > 0)
3317         {
3318           ikev2_rekey_child_sa_internal (vm, sa, csa);
3319           csa->time_to_expiration = now + sa->profile->handover;
3320           csa->is_expired = 1;
3321           if (csa->rekey_retries == 0)
3322             {
3323               csa->rekey_retries = 5;
3324             }
3325           else if (csa->rekey_retries > 0)
3326             {
3327               csa->rekey_retries--;
3328               clib_warning ("Rekeing Child SA 0x%x, retries left %d",
3329                             csa->i_proposals->spi, csa->rekey_retries);
3330               if (csa->rekey_retries == 0)
3331                 {
3332                   csa->rekey_retries = -1;
3333                 }
3334             }
3335           res |= 1;
3336         }
3337       else
3338         {
3339           csa->time_to_expiration = 0;
3340           ikev2_delete_child_sa_internal (vm, sa, csa);
3341           res |= 1;
3342         }
3343     }
3344
3345   return res;
3346 }
3347
3348 static void
3349 ikev2_mngr_process_ipsec_sa (ipsec_sa_t * ipsec_sa)
3350 {
3351   ikev2_main_t *km = &ikev2_main;
3352   vlib_main_t *vm = km->vlib_main;
3353   ikev2_main_per_thread_data_t *tkm;
3354   ikev2_sa_t *fsa = 0;
3355   ikev2_child_sa_t *fchild = 0;
3356   f64 now = vlib_time_now (vm);
3357
3358   /* Search for the SA and child SA */
3359   vec_foreach (tkm, km->per_thread_data)
3360   {
3361     ikev2_sa_t *sa;
3362     if (fchild)
3363       break;
3364     /* *INDENT-OFF* */
3365     pool_foreach (sa, tkm->sas, ({
3366       fchild = ikev2_sa_get_child(sa, ipsec_sa->spi, IKEV2_PROTOCOL_ESP, 1);
3367       if (fchild)
3368         {
3369           fsa = sa;
3370           break;
3371         }
3372     }));
3373     /* *INDENT-ON* */
3374   }
3375
3376   if (fchild && fsa && fsa->profile && fsa->profile->lifetime_maxdata)
3377     {
3378       if (!fchild->is_expired
3379           && ipsec_sa->total_data_size > fsa->profile->lifetime_maxdata)
3380         {
3381           fchild->time_to_expiration = now;
3382         }
3383     }
3384 }
3385
3386 static vlib_node_registration_t ikev2_mngr_process_node;
3387
3388 static uword
3389 ikev2_mngr_process_fn (vlib_main_t * vm, vlib_node_runtime_t * rt,
3390                        vlib_frame_t * f)
3391 {
3392   ikev2_main_t *km = &ikev2_main;
3393   ipsec_main_t *im = &ipsec_main;
3394
3395   while (1)
3396     {
3397       u8 req_sent = 0;
3398       vlib_process_wait_for_event_or_clock (vm, 1);
3399       vlib_process_get_events (vm, NULL);
3400
3401       /* process ike child sas */
3402       ikev2_main_per_thread_data_t *tkm;
3403       vec_foreach (tkm, km->per_thread_data)
3404       {
3405         ikev2_sa_t *sa;
3406         /* *INDENT-OFF* */
3407         pool_foreach (sa, tkm->sas, ({
3408           ikev2_child_sa_t *c;
3409           vec_foreach (c, sa->childs)
3410             {
3411             req_sent |= ikev2_mngr_process_child_sa(sa, c);
3412             }
3413         }));
3414         /* *INDENT-ON* */
3415       }
3416
3417       /* process ipsec sas */
3418       ipsec_sa_t *sa;
3419       /* *INDENT-OFF* */
3420       pool_foreach (sa, im->sad, ({
3421         ikev2_mngr_process_ipsec_sa(sa);
3422       }));
3423       /* *INDENT-ON* */
3424
3425       if (req_sent)
3426         {
3427           vlib_process_wait_for_event_or_clock (vm, 5);
3428           vlib_process_get_events (vm, NULL);
3429           req_sent = 0;
3430         }
3431
3432     }
3433   return 0;
3434 }
3435
3436 /* *INDENT-OFF* */
3437 VLIB_REGISTER_NODE (ikev2_mngr_process_node, static) = {
3438     .function = ikev2_mngr_process_fn,
3439     .type = VLIB_NODE_TYPE_PROCESS,
3440     .name =
3441     "ikev2-manager-process",
3442 };
3443
3444 /* *INDENT-ON* */
3445
3446 /*
3447  * fd.io coding-style-patch-verification: ON
3448  *
3449  * Local Variables:
3450  * eval: (c-set-style "gnu")
3451  * End:
3452  */