vnet/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 <vnet/ip/udp.h>
  21 #include <vnet/ipsec/ipsec.h>
  22 #include <vnet/ipsec/ikev2.h>
  23 #include <vnet/ipsec/ikev2_priv.h>
  24
  25 static int ikev2_delete_tunnel_interface(vnet_main_t * vnm,
  26                                          ikev2_sa_t *sa,
  27                                          ikev2_child_sa_t * child);
  28
  29 static void hexdump(u8 buffer[], int len)
  30 {
  31 #define HEXDUMP_LINE_LEN  16
  32   int i;
  33   char s[HEXDUMP_LINE_LEN+1];
  34   bzero(s, HEXDUMP_LINE_LEN+1);
  35
  36   for(i=0; i < len; i++) {
  37     if (!(i%HEXDUMP_LINE_LEN)) {
  38       if (s[0])
  39         printf("[%s]",s);
  40       printf("\n%05x: ", i);
  41       bzero(s, HEXDUMP_LINE_LEN);
  42     }
  43     s[i%HEXDUMP_LINE_LEN]=isprint(buffer[i])?buffer[i]:'.';
  44     printf("%02x ", buffer[i]);
  45   }
  46   while(i++%HEXDUMP_LINE_LEN)
  47     printf("   ");
  48
  49   printf("[%s]\n", s);
  50 }
  51
  52 #define ikev2_set_state(sa, v) do { \
  53     (sa)->state = v; \
  54     clib_warning("sa state changed to " #v); \
  55   } while(0);
  56
  57 typedef struct {
  58   u32 next_index;
  59   u32 sw_if_index;
  60 } ikev2_trace_t;
  61
  62 static u8 * format_ikev2_trace (u8 * s, va_list * args)
  63 {
  64   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  65   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  66   ikev2_trace_t * t = va_arg (*args, ikev2_trace_t *);
  67
  68   s = format (s, "ikev2: sw_if_index %d, next index %d",
  69               t->sw_if_index, t->next_index);
  70   return s;
  71 }
  72
  73 vlib_node_registration_t ikev2_node;
  74
  75 #define foreach_ikev2_error \
  76 _(PROCESSED, "IKEv2 packets processed") \
  77 _(IKE_SA_INIT_RETRANSMIT, "IKE_SA_INIT retransmit ") \
  78 _(IKE_SA_INIT_IGNORE, "IKE_SA_INIT ignore (IKE SA already auth)") \
  79 _(IKE_REQ_RETRANSMIT, "IKE request retransmit") \
  80 _(IKE_REQ_IGNORE, "IKE request ignore (old msgid)") \
  81 _(NOT_IKEV2, "Non IKEv2 packets received")
  82
  83 typedef enum {
  84 #define _(sym,str) IKEV2_ERROR_##sym,
  85   foreach_ikev2_error
  86 #undef _
  87   IKEV2_N_ERROR,
  88 } ikev2_error_t;
  89
  90 static char * ikev2_error_strings[] = {
  91 #define _(sym,string) string,
  92   foreach_ikev2_error
  93 #undef _
  94 };
  95
  96 typedef enum {
  97   IKEV2_NEXT_IP4_LOOKUP,
  98   IKEV2_NEXT_ERROR_DROP,
  99   IKEV2_N_NEXT,
 100 } ikev2_next_t;
 101
 102 static ikev2_sa_transform_t *
 103 ikev2_find_transform_data(ikev2_sa_transform_t * t)
 104 {
 105   ikev2_main_t * km = &ikev2_main;
 106   ikev2_sa_transform_t * td;
 107
 108   vec_foreach(td, km->supported_transforms)
 109     {
 110       if (td->type != t->type)
 111         continue;
 112
 113       if (td->transform_id != t->transform_id)
 114         continue;
 115
 116       if (td->type == IKEV2_TRANSFORM_TYPE_ENCR)
 117         {
 118           if (vec_len(t->attrs) != 4 || t->attrs[0] != 0x80 || t->attrs[1] != 14)
 119             continue;
 120
 121           if (((t->attrs[2] << 8 | t->attrs[3]) / 8) != td->key_len)
 122             continue;
 123         }
 124       return td;
 125     }
 126   return 0;
 127 }
 128
 129 static ikev2_sa_proposal_t *
 130 ikev2_select_proposal(ikev2_sa_proposal_t *proposals, ikev2_protocol_id_t prot_id)
 131 {
 132   ikev2_sa_proposal_t * rv = 0;
 133   ikev2_sa_proposal_t * proposal;
 134   ikev2_sa_transform_t * transform, * new_t;
 135   u8 mandatory_bitmap, optional_bitmap;
 136
 137   if (prot_id == IKEV2_PROTOCOL_IKE)
 138     {
 139       mandatory_bitmap = (1 << IKEV2_TRANSFORM_TYPE_ENCR)  |
 140                          (1 << IKEV2_TRANSFORM_TYPE_PRF)   |
 141                          (1 << IKEV2_TRANSFORM_TYPE_INTEG) |
 142                          (1 << IKEV2_TRANSFORM_TYPE_DH);
 143       optional_bitmap  = mandatory_bitmap;
 144     }
 145   else if (prot_id == IKEV2_PROTOCOL_ESP)
 146     {
 147       mandatory_bitmap = (1 << IKEV2_TRANSFORM_TYPE_ENCR) |
 148                          (1 << IKEV2_TRANSFORM_TYPE_ESN);
 149       optional_bitmap =  mandatory_bitmap |
 150                          (1 << IKEV2_TRANSFORM_TYPE_INTEG) |
 151                          (1 << IKEV2_TRANSFORM_TYPE_DH);
 152     }
 153   else if (prot_id == IKEV2_PROTOCOL_AH)
 154     {
 155       mandatory_bitmap = (1 << IKEV2_TRANSFORM_TYPE_INTEG) |
 156                          (1 << IKEV2_TRANSFORM_TYPE_ESN);
 157       optional_bitmap =  mandatory_bitmap |
 158                          (1 << IKEV2_TRANSFORM_TYPE_DH);
 159     }
 160   else
 161     return 0;
 162
 163   vec_add2(rv, proposal, 1);
 164
 165   vec_foreach(proposal, proposals)
 166     {
 167       u8 bitmap = 0;
 168       if (proposal->protocol_id != prot_id)
 169         continue;
 170
 171       vec_foreach(transform, proposal->transforms)
 172         {
 173           if ((1 << transform->type) & bitmap)
 174             continue;
 175
 176           if (ikev2_find_transform_data(transform))
 177             {
 178               bitmap |= 1 << transform->type;
 179               vec_add2(rv->transforms, new_t, 1);
 180               memcpy(new_t, transform, sizeof(*new_t));
 181               new_t->attrs = vec_dup(transform->attrs);
 182             }
 183         }
 184
 185       clib_warning("bitmap is %x mandatory is %x optional is %x",
 186                    bitmap, mandatory_bitmap, optional_bitmap);
 187
 188       if ((bitmap & mandatory_bitmap) == mandatory_bitmap &&
 189           (bitmap & ~optional_bitmap) == 0)
 190         {
 191           rv->proposal_num = proposal->proposal_num;
 192           rv->protocol_id = proposal->protocol_id;
 193           RAND_bytes((u8 *) &rv->spi, sizeof(rv->spi));
 194           goto done;
 195         }
 196       else
 197         {
 198           vec_free(rv->transforms);
 199         }
 200     }
 201
 202   vec_free(rv);
 203 done:
 204   return rv;
 205 }
 206
 207 ikev2_sa_transform_t *
 208 ikev2_sa_get_td_for_type(ikev2_sa_proposal_t * p, ikev2_transform_type_t type)
 209 {
 210   ikev2_sa_transform_t * t;
 211
 212   if (!p)
 213     return 0;
 214
 215   vec_foreach(t, p->transforms)
 216     {
 217       if (t->type == type)
 218         return ikev2_find_transform_data(t);
 219     }
 220   return 0;
 221 }
 222
 223 ikev2_child_sa_t *
 224 ikev2_sa_get_child(ikev2_sa_t * sa, u32 spi, ikev2_protocol_id_t prot_id)
 225 {
 226   ikev2_child_sa_t * c;
 227   vec_foreach(c, sa->childs)
 228     {
 229       if (c->i_proposals[0].spi == spi && c->i_proposals[0].protocol_id == prot_id)
 230         return c;
 231     }
 232
 233   return 0;
 234 }
 235
 236 void
 237 ikev2_sa_free_proposal_vector(ikev2_sa_proposal_t ** v)
 238 {
 239   ikev2_sa_proposal_t * p;
 240   ikev2_sa_transform_t * t;
 241
 242   if (!*v)
 243         return;
 244
 245   vec_foreach(p, *v) {
 246     vec_foreach(t, p->transforms) {
 247         vec_free(t->attrs);
 248     }
 249     vec_free(p->transforms);
 250   }
 251   vec_free(*v);
 252 };
 253
 254 static void
 255 ikev2_sa_free_all_child_sa(ikev2_child_sa_t ** childs)
 256 {
 257   ikev2_child_sa_t * c;
 258   vec_foreach(c, *childs)
 259     {
 260       ikev2_sa_free_proposal_vector(&c->r_proposals);
 261       ikev2_sa_free_proposal_vector(&c->i_proposals);
 262       vec_free(c->sk_ai);
 263       vec_free(c->sk_ar);
 264       vec_free(c->sk_ei);
 265       vec_free(c->sk_er);
 266     }
 267
 268   vec_free(*childs);
 269 }
 270
 271 static void
 272 ikev2_sa_del_child_sa(ikev2_sa_t * sa, ikev2_child_sa_t * child)
 273 {
 274   ikev2_sa_free_proposal_vector(&child->r_proposals);
 275   ikev2_sa_free_proposal_vector(&child->i_proposals);
 276   vec_free(child->sk_ai);
 277   vec_free(child->sk_ar);
 278   vec_free(child->sk_ei);
 279   vec_free(child->sk_er);
 280
 281   vec_del1(sa->childs, child - sa->childs);
 282 }
 283
 284 static void
 285 ikev2_sa_free_all_vec(ikev2_sa_t *sa)
 286 {
 287   vec_free(sa->i_nonce);
 288   vec_free(sa->i_dh_data);
 289   vec_free(sa->dh_shared_key);
 290
 291   ikev2_sa_free_proposal_vector(&sa->r_proposals);
 292   ikev2_sa_free_proposal_vector(&sa->i_proposals);
 293
 294   vec_free(sa->sk_d);
 295   vec_free(sa->sk_ai);
 296   vec_free(sa->sk_ar);
 297   vec_free(sa->sk_ei);
 298   vec_free(sa->sk_er);
 299   vec_free(sa->sk_pi);
 300   vec_free(sa->sk_pr);
 301
 302   vec_free(sa->i_id.data);
 303   vec_free(sa->i_auth.data);
 304   vec_free(sa->r_id.data);
 305   vec_free(sa->r_auth.data);
 306   if (sa->r_auth.key)
 307     EVP_PKEY_free(sa->r_auth.key);
 308
 309   vec_free(sa->del);
 310
 311   ikev2_sa_free_all_child_sa(&sa->childs);
 312 }
 313
 314 static void
 315 ikev2_delete_sa(ikev2_sa_t *sa)
 316 {
 317   ikev2_main_t * km = &ikev2_main;
 318   uword * p;
 319
 320   ikev2_sa_free_all_vec(sa);
 321
 322   p = hash_get(km->sa_by_rspi, sa->rspi);
 323   if (p)
 324     {
 325       hash_unset(km->sa_by_rspi, sa->rspi);
 326       pool_put(km->sas, sa);
 327     }
 328 }
 329
 330 static void
 331 ikev2_generate_sa_init_data(ikev2_sa_t *sa)
 332 {
 333   ikev2_sa_transform_t * t = 0, * t2;
 334   ikev2_main_t * km = &ikev2_main;
 335
 336   if (sa->dh_group == IKEV2_TRANSFORM_DH_TYPE_NONE)
 337     {
 338       return;
 339     }
 340
 341   /* check if received DH group is on our list of supported groups */
 342   vec_foreach(t2, km->supported_transforms)
 343     {
 344        if (t2->type == IKEV2_TRANSFORM_TYPE_DH &&
 345            sa->dh_group == t2->dh_type)
 346          {
 347             t = t2;
 348             break;
 349          }
 350     }
 351
 352   if (!t)
 353     {
 354       clib_warning("unknown dh data group %u (data len %u)", sa->dh_group,
 355                  vec_len(sa->i_dh_data));
 356       sa->dh_group = IKEV2_TRANSFORM_DH_TYPE_NONE;
 357       return;
 358     }
 359
 360   /* generate rspi */
 361   RAND_bytes((u8 *) &sa->rspi, 8);
 362
 363   /* generate nonce */
 364   sa->r_nonce = vec_new(u8, IKEV2_NONCE_SIZE);
 365   RAND_bytes((u8 *) sa->r_nonce, IKEV2_NONCE_SIZE);
 366
 367   /* generate dh keys */
 368   ikev2_generate_dh(sa, t);
 369 }
 370
 371 static void
 372 ikev2_calc_keys(ikev2_sa_t *sa)
 373 {
 374   u8 * tmp;
 375   /* calculate SKEYSEED = prf(Ni | Nr, g^ir) */
 376   u8 * skeyseed = 0;
 377   u8 * s = 0;
 378   ikev2_sa_transform_t * tr_encr, * tr_prf, * tr_integ;
 379   tr_encr = ikev2_sa_get_td_for_type(sa->r_proposals, IKEV2_TRANSFORM_TYPE_ENCR);
 380   tr_prf = ikev2_sa_get_td_for_type(sa->r_proposals, IKEV2_TRANSFORM_TYPE_PRF);
 381   tr_integ = ikev2_sa_get_td_for_type(sa->r_proposals, IKEV2_TRANSFORM_TYPE_INTEG);
 382
 383   vec_append(s, sa->i_nonce);
 384   vec_append(s, sa->r_nonce);
 385   skeyseed = ikev2_calc_prf(tr_prf, s, sa->dh_shared_key);
 386
 387   /* Calculate S = Ni | Nr | SPIi | SPIr*/
 388   u64 * spi;
 389   vec_add2(s, tmp, 2 * sizeof(*spi));
 390   spi = (u64 *) tmp;
 391   spi[0] = clib_host_to_net_u64(sa->ispi);
 392   spi[1] = clib_host_to_net_u64(sa->rspi);
 393
 394   /* calculate PRFplus */
 395   u8 * keymat;
 396   int len = tr_prf->key_trunc     + /* SK_d */
 397             tr_integ->key_len * 2 + /* SK_ai, SK_ar */
 398             tr_encr->key_len * 2  + /* SK_ei, SK_er */
 399             tr_prf->key_len * 2   ; /* SK_pi, SK_pr */
 400
 401   keymat = ikev2_calc_prfplus(tr_prf, skeyseed, s, len);
 402   vec_free(skeyseed);
 403   vec_free(s);
 404
 405   int pos = 0;
 406
 407   /* SK_d */
 408   sa->sk_d = vec_new(u8, tr_prf->key_trunc);
 409   memcpy(sa->sk_d, keymat + pos, tr_prf->key_trunc);
 410   pos += tr_prf->key_trunc;
 411
 412   /* SK_ai */
 413   sa->sk_ai = vec_new(u8, tr_integ->key_len);
 414   memcpy(sa->sk_ai, keymat + pos, tr_integ->key_len);
 415   pos += tr_integ->key_len;
 416
 417   /* SK_ar */
 418   sa->sk_ar = vec_new(u8, tr_integ->key_len);
 419   memcpy(sa->sk_ar, keymat + pos, tr_integ->key_len);
 420   pos += tr_integ->key_len;
 421
 422   /* SK_ei */
 423   sa->sk_ei = vec_new(u8, tr_encr->key_len);
 424   memcpy(sa->sk_ei, keymat + pos, tr_encr->key_len);
 425   pos += tr_encr->key_len;
 426
 427   /* SK_er */
 428   sa->sk_er = vec_new(u8, tr_encr->key_len);
 429   memcpy(sa->sk_er, keymat + pos, tr_encr->key_len);
 430   pos += tr_encr->key_len;
 431
 432   /* SK_pi */
 433   sa->sk_pi = vec_new(u8, tr_prf->key_len);
 434   memcpy(sa->sk_pi, keymat + pos, tr_prf->key_len);
 435   pos += tr_prf->key_len;
 436
 437   /* SK_pr */
 438   sa->sk_pr = vec_new(u8, tr_prf->key_len);
 439   memcpy(sa->sk_pr, keymat + pos, tr_prf->key_len);
 440   pos += tr_prf->key_len;
 441
 442   vec_free(keymat);
 443 }
 444
 445 static void
 446 ikev2_calc_child_keys(ikev2_sa_t *sa, ikev2_child_sa_t * child)
 447 {
 448   u8 * s = 0;
 449   ikev2_sa_transform_t * tr_prf, * ctr_encr, * ctr_integ;
 450   tr_prf = ikev2_sa_get_td_for_type(sa->r_proposals, IKEV2_TRANSFORM_TYPE_PRF);
 451   ctr_encr = ikev2_sa_get_td_for_type(child->r_proposals, IKEV2_TRANSFORM_TYPE_ENCR);
 452   ctr_integ = ikev2_sa_get_td_for_type(child->r_proposals, IKEV2_TRANSFORM_TYPE_INTEG);
 453
 454   vec_append(s, sa->i_nonce);
 455   vec_append(s, sa->r_nonce);
 456   /* calculate PRFplus */
 457   u8 * keymat;
 458   int len = ctr_encr->key_len * 2 + ctr_integ->key_len * 2;
 459
 460   keymat = ikev2_calc_prfplus(tr_prf, sa->sk_d, s, len);
 461   hexdump(keymat, vec_len(keymat));
 462
 463   int pos = 0;
 464
 465   /* SK_ei */
 466   child->sk_ei = vec_new(u8, ctr_encr->key_len);
 467   memcpy(child->sk_ei, keymat + pos, ctr_encr->key_len);
 468   pos += ctr_encr->key_len;
 469
 470   /* SK_ai */
 471   child->sk_ai = vec_new(u8, ctr_integ->key_len);
 472   memcpy(child->sk_ai, keymat + pos, ctr_integ->key_len);
 473   pos += ctr_integ->key_len;
 474
 475   /* SK_er */
 476   child->sk_er = vec_new(u8, ctr_encr->key_len);
 477   memcpy(child->sk_er, keymat + pos, ctr_encr->key_len);
 478   pos += ctr_encr->key_len;
 479
 480   /* SK_ar */
 481   child->sk_ar = vec_new(u8, ctr_integ->key_len);
 482   memcpy(child->sk_ar, keymat + pos, ctr_integ->key_len);
 483   pos += ctr_integ->key_len;
 484
 485   ASSERT(pos == len);
 486
 487   vec_free(keymat);
 488 }
 489
 490 static void
 491 ikev2_process_sa_init_req(vlib_main_t * vm, ikev2_sa_t *sa, ike_header_t * ike)
 492 {
 493   int p = 0;
 494   u32 len = clib_net_to_host_u32(ike->length);
 495   u8 payload = ike->nextpayload;
 496
 497   clib_warning("ispi %lx rspi %lx nextpayload %x version %x "
 498                "exchange %x flags %x msgid %x length %u",
 499                clib_net_to_host_u64(ike->ispi),
 500                clib_net_to_host_u64(ike->rspi),
 501                payload, ike->version,
 502                ike->exchange, ike->flags,
 503                clib_net_to_host_u32(ike->msgid),
 504                len);
 505
 506   sa->ispi = clib_net_to_host_u64(ike->ispi);
 507
 508   /* store whole IKE payload - needed for PSK auth */
 509   vec_free(sa->last_sa_init_req_packet_data);
 510   vec_add(sa->last_sa_init_req_packet_data, ike, len);
 511
 512   while (p < len && payload!= IKEV2_PAYLOAD_NONE) {
 513     ike_payload_header_t * ikep = (ike_payload_header_t *) &ike->payload[p];
 514     u32 plen = clib_net_to_host_u16(ikep->length);
 515
 516     if (plen < sizeof(ike_payload_header_t))
 517       return;
 518
 519     if (payload == IKEV2_PAYLOAD_SA)
 520       {
 521         ikev2_sa_free_proposal_vector(&sa->i_proposals);
 522         sa->i_proposals = ikev2_parse_sa_payload(ikep);
 523       }
 524     else if (payload == IKEV2_PAYLOAD_KE)
 525       {
 526         ike_ke_payload_header_t * ke = (ike_ke_payload_header_t *) ikep;
 527         sa->dh_group = clib_net_to_host_u16(ke->dh_group);
 528         vec_free(sa->i_dh_data);
 529         vec_add(sa->i_dh_data, ke->payload, plen - sizeof(*ke));
 530       }
 531     else if (payload == IKEV2_PAYLOAD_NONCE)
 532       {
 533         vec_free(sa->i_nonce);
 534         vec_add(sa->i_nonce, ikep->payload, plen - sizeof(*ikep));
 535       }
 536     else if (payload == IKEV2_PAYLOAD_NOTIFY)
 537       {
 538         ikev2_notify_t * n = ikev2_parse_notify_payload(ikep);
 539         vec_free(n);
 540       }
 541     else if (payload == IKEV2_PAYLOAD_VENDOR)
 542       {
 543         ikev2_parse_vendor_payload(ikep);
 544       }
 545     else
 546       {
 547         clib_warning("unknown payload %u flags %x length %u", payload, ikep->flags, plen);
 548         if (ikep->flags & IKEV2_PAYLOAD_FLAG_CRITICAL) {
 549           ikev2_set_state(sa, IKEV2_STATE_NOTIFY_AND_DELETE);
 550           sa->unsupported_cp = payload;
 551           return;
 552         }
 553       }
 554
 555     payload = ikep->nextpayload;
 556     p+=plen;
 557   }
 558
 559   ikev2_set_state(sa, IKEV2_STATE_SA_INIT);
 560 }
 561
 562 static u8 *
 563 ikev2_decrypt_sk_payload(ikev2_sa_t * sa, ike_header_t * ike, u8 * payload)
 564 {
 565   int p = 0;
 566   u8 last_payload = 0;
 567   u8 * hmac = 0;
 568   u32 len = clib_net_to_host_u32(ike->length);
 569   ike_payload_header_t * ikep;
 570   u32 plen;
 571   ikev2_sa_transform_t * tr_integ;
 572   tr_integ = ikev2_sa_get_td_for_type(sa->r_proposals, IKEV2_TRANSFORM_TYPE_INTEG);
 573
 574   while (p < len &&
 575          *payload != IKEV2_PAYLOAD_NONE && last_payload != IKEV2_PAYLOAD_SK)
 576     {
 577       ikep = (ike_payload_header_t *) &ike->payload[p];
 578       plen = clib_net_to_host_u16(ikep->length);
 579
 580       if (plen < sizeof(*ikep))
 581         return 0;
 582
 583       if (*payload == IKEV2_PAYLOAD_SK)
 584         {
 585           clib_warning("received IKEv2 payload SK, len %u", plen - 4);
 586           last_payload = *payload;
 587         }
 588       else
 589         {
 590           clib_warning("unknown payload %u flags %x length %u", payload, ikep->flags, plen);
 591           if (ikep->flags & IKEV2_PAYLOAD_FLAG_CRITICAL)
 592             {
 593               sa->unsupported_cp = *payload;
 594               return 0;
 595             }
 596         }
 597
 598     *payload = ikep->nextpayload;
 599     p+=plen;
 600   }
 601
 602   if (last_payload != IKEV2_PAYLOAD_SK) {
 603     clib_warning("Last payload must be SK");
 604     return 0;
 605   }
 606
 607   hmac = ikev2_calc_integr(tr_integ, sa->sk_ai,  (u8 *) ike,
 608                            len - tr_integ->key_trunc);
 609
 610   plen = plen - sizeof(*ikep) - tr_integ->key_trunc;
 611
 612   if (memcmp(hmac, &ikep->payload[plen], tr_integ->key_trunc))
 613     {
 614       clib_warning("message integrity check failed");
 615       vec_free(hmac);
 616       return 0;
 617     }
 618   vec_free(hmac);
 619
 620   return ikev2_decrypt_data(sa, ikep->payload, plen);
 621 }
 622
 623 static void
 624 ikev2_initial_contact_cleanup (ikev2_sa_t * sa)
 625 {
 626   ikev2_main_t * km = &ikev2_main;
 627   ikev2_sa_t * tmp;
 628   u32 i, * delete = 0;
 629   ikev2_child_sa_t * c;
 630
 631   if (!sa->initial_contact)
 632     return;
 633
 634   /* find old IKE SAs with the same authenticated identity */
 635   pool_foreach (tmp, km->sas, ({
 636         if (tmp->i_id.type != sa->i_id.type ||
 637             vec_len(tmp->i_id.data) != vec_len(sa->i_id.data) ||
 638             memcmp(sa->i_id.data, tmp->i_id.data, vec_len(sa->i_id.data)))
 639           continue;
 640
 641         if (sa->rspi != tmp->rspi)
 642           vec_add1(delete, tmp - km->sas);
 643   }));
 644
 645   for (i = 0; i < vec_len(delete); i++)
 646     {
 647       tmp = pool_elt_at_index(km->sas, delete[i]);
 648       vec_foreach(c, tmp->childs)
 649         ikev2_delete_tunnel_interface(km->vnet_main, tmp, c);
 650       ikev2_delete_sa(tmp);
 651     }
 652
 653   vec_free(delete);
 654   sa->initial_contact = 0;
 655 }
 656
 657 static void
 658 ikev2_process_auth_req(vlib_main_t * vm, ikev2_sa_t *sa, ike_header_t * ike)
 659 {
 660   ikev2_child_sa_t * first_child_sa;
 661   int p = 0;
 662   u32 len = clib_net_to_host_u32(ike->length);
 663   u8 payload = ike->nextpayload;
 664   u8 * plaintext = 0;
 665
 666   ike_payload_header_t * ikep;
 667   u32 plen;
 668
 669   clib_warning("ispi %lx rspi %lx nextpayload %x version %x "
 670                "exchange %x flags %x msgid %x length %u",
 671                clib_net_to_host_u64(ike->ispi),
 672                clib_net_to_host_u64(ike->rspi),
 673                payload, ike->version,
 674                ike->exchange, ike->flags,
 675                clib_net_to_host_u32(ike->msgid),
 676                len);
 677
 678   ikev2_calc_keys(sa);
 679
 680   plaintext = ikev2_decrypt_sk_payload(sa, ike, &payload);
 681
 682   if (!plaintext)
 683     {
 684       if (sa->unsupported_cp)
 685         ikev2_set_state(sa, IKEV2_STATE_NOTIFY_AND_DELETE);
 686       goto cleanup_and_exit;
 687     }
 688
 689   /* create 1st child SA */
 690   ikev2_sa_free_all_child_sa(&sa->childs);
 691   vec_add2(sa->childs, first_child_sa, 1);
 692
 693
 694   /* process encrypted payload */
 695   p = 0;
 696   while (p < vec_len(plaintext) && payload != IKEV2_PAYLOAD_NONE)
 697     {
 698       ikep = (ike_payload_header_t *) &plaintext[p];
 699       plen = clib_net_to_host_u16(ikep->length);
 700
 701       if (plen < sizeof(ike_payload_header_t))
 702         goto cleanup_and_exit;
 703
 704       if (payload == IKEV2_PAYLOAD_SA) /* 33 */
 705         {
 706           clib_warning("received payload SA, len %u", plen - sizeof(*ikep));
 707           ikev2_sa_free_proposal_vector(&first_child_sa->i_proposals);
 708           first_child_sa->i_proposals = ikev2_parse_sa_payload(ikep);
 709         }
 710       else if (payload == IKEV2_PAYLOAD_IDI) /* 35 */
 711         {
 712           ike_id_payload_header_t * id = (ike_id_payload_header_t *) ikep;
 713
 714           sa->i_id.type = id->id_type;
 715           vec_free(sa->i_id.data);
 716           vec_add(sa->i_id.data, id->payload, plen - sizeof(*id));
 717
 718           clib_warning("received payload IDi, len %u id_type %u",
 719                        plen - sizeof(*id), id->id_type);
 720         }
 721       else if (payload == IKEV2_PAYLOAD_AUTH) /* 39 */
 722         {
 723           ike_auth_payload_header_t * a = (ike_auth_payload_header_t *) ikep;
 724
 725           sa->i_auth.method = a->auth_method;
 726           vec_free(sa->i_auth.data);
 727           vec_add(sa->i_auth.data, a->payload, plen - sizeof(*a));
 728
 729           clib_warning("received payload AUTH, len %u auth_type %u",
 730                        plen - sizeof(*a), a->auth_method);
 731         }
 732       else if (payload == IKEV2_PAYLOAD_NOTIFY) /* 41 */
 733         {
 734           ikev2_notify_t * n = ikev2_parse_notify_payload(ikep);
 735           if (n->msg_type == IKEV2_NOTIFY_MSG_INITIAL_CONTACT)
 736             {
 737               sa->initial_contact = 1;
 738             }
 739           vec_free(n);
 740         }
 741       else if (payload == IKEV2_PAYLOAD_VENDOR) /* 43 */
 742         {
 743           ikev2_parse_vendor_payload(ikep);
 744         }
 745       else if (payload == IKEV2_PAYLOAD_TSI) /* 44 */
 746         {
 747           clib_warning("received payload TSi, len %u", plen - sizeof(*ikep));
 748
 749           vec_free(first_child_sa->tsi);
 750           first_child_sa->tsi = ikev2_parse_ts_payload(ikep);
 751         }
 752       else if (payload == IKEV2_PAYLOAD_TSR) /* 45 */
 753         {
 754           clib_warning("received payload TSr, len %u", plen - sizeof(*ikep));
 755
 756           vec_free(first_child_sa->tsr);
 757           first_child_sa->tsr = ikev2_parse_ts_payload(ikep);
 758         }
 759       else
 760         {
 761           clib_warning("unknown payload %u flags %x length %u data %u",
 762                        payload, ikep->flags, plen - 4,
 763                        format_hex_bytes, ikep->payload, plen - 4);
 764
 765           if (ikep->flags & IKEV2_PAYLOAD_FLAG_CRITICAL) {
 766             ikev2_set_state(sa, IKEV2_STATE_NOTIFY_AND_DELETE);
 767             sa->unsupported_cp = payload;
 768             return;
 769           }
 770         }
 771
 772       payload = ikep->nextpayload;
 773       p += plen;
 774     }
 775
 776 cleanup_and_exit:
 777   vec_free(plaintext);
 778 }
 779
 780 static void
 781 ikev2_process_informational_req(vlib_main_t * vm, ikev2_sa_t *sa, ike_header_t * ike)
 782 {
 783   int p = 0;
 784   u32 len = clib_net_to_host_u32(ike->length);
 785   u8 payload = ike->nextpayload;
 786   u8 * plaintext = 0;
 787
 788   ike_payload_header_t * ikep;
 789   u32 plen;
 790
 791   clib_warning("ispi %lx rspi %lx nextpayload %x version %x "
 792                "exchange %x flags %x msgid %x length %u",
 793                clib_net_to_host_u64(ike->ispi),
 794                clib_net_to_host_u64(ike->rspi),
 795                payload, ike->version,
 796                ike->exchange, ike->flags,
 797                clib_net_to_host_u32(ike->msgid),
 798                len);
 799
 800   plaintext = ikev2_decrypt_sk_payload(sa, ike, &payload);
 801
 802   if (!plaintext)
 803     goto cleanup_and_exit;
 804
 805   /* process encrypted payload */
 806   p = 0;
 807   while (p < vec_len(plaintext) && payload != IKEV2_PAYLOAD_NONE)
 808     {
 809       ikep = (ike_payload_header_t *) &plaintext[p];
 810       plen = clib_net_to_host_u16(ikep->length);
 811
 812       if (plen < sizeof(ike_payload_header_t))
 813         goto cleanup_and_exit;
 814
 815       if (payload == IKEV2_PAYLOAD_NOTIFY) /* 41 */
 816         {
 817           ikev2_notify_t * n = ikev2_parse_notify_payload(ikep);
 818           if (n->msg_type == IKEV2_NOTIFY_MSG_AUTHENTICATION_FAILED)
 819             ikev2_set_state(sa, IKEV2_STATE_AUTH_FAILED);
 820           vec_free(n);
 821         }
 822       else if (payload == IKEV2_PAYLOAD_DELETE) /* 42 */
 823         {
 824           sa->del = ikev2_parse_delete_payload(ikep);
 825         }
 826       else if (payload == IKEV2_PAYLOAD_VENDOR) /* 43 */
 827         {
 828           ikev2_parse_vendor_payload(ikep);
 829         }
 830       else
 831         {
 832           clib_warning("unknown payload %u flags %x length %u data %u",
 833                        payload, ikep->flags, plen - 4,
 834                        format_hex_bytes, ikep->payload, plen - 4);
 835
 836           if (ikep->flags & IKEV2_PAYLOAD_FLAG_CRITICAL) {
 837             sa->unsupported_cp = payload;
 838             return;
 839           }
 840         }
 841
 842       payload = ikep->nextpayload;
 843       p += plen;
 844     }
 845
 846 cleanup_and_exit:
 847   vec_free(plaintext);
 848 }
 849
 850 static void
 851 ikev2_process_create_child_sa_req(vlib_main_t * vm, ikev2_sa_t *sa, ike_header_t * ike)
 852 {
 853   int p = 0;
 854   u32 len = clib_net_to_host_u32(ike->length);
 855   u8 payload = ike->nextpayload;
 856   u8 * plaintext = 0;
 857   u8 rekeying = 0;
 858   u8 i_nonce[IKEV2_NONCE_SIZE];
 859
 860   ike_payload_header_t * ikep;
 861   u32 plen;
 862   ikev2_notify_t * n = 0;
 863   ikev2_ts_t * tsi = 0;
 864   ikev2_ts_t * tsr = 0;
 865   ikev2_sa_proposal_t * proposal = 0;
 866   ikev2_child_sa_t * child_sa;
 867
 868   clib_warning("ispi %lx rspi %lx nextpayload %x version %x "
 869                "exchange %x flags %x msgid %x length %u",
 870                clib_net_to_host_u64(ike->ispi),
 871                clib_net_to_host_u64(ike->rspi),
 872                payload, ike->version,
 873                ike->exchange, ike->flags,
 874                clib_net_to_host_u32(ike->msgid),
 875                len);
 876
 877   plaintext = ikev2_decrypt_sk_payload(sa, ike, &payload);
 878
 879   if (!plaintext)
 880     goto cleanup_and_exit;
 881
 882   /* process encrypted payload */
 883   p = 0;
 884   while (p < vec_len(plaintext) && payload != IKEV2_PAYLOAD_NONE)
 885     {
 886       ikep = (ike_payload_header_t *) &plaintext[p];
 887       plen = clib_net_to_host_u16(ikep->length);
 888
 889       if (plen < sizeof(ike_payload_header_t))
 890         goto cleanup_and_exit;
 891
 892       else if (payload == IKEV2_PAYLOAD_SA)
 893         {
 894           proposal = ikev2_parse_sa_payload(ikep);
 895         }
 896       else if (payload == IKEV2_PAYLOAD_NOTIFY)
 897         {
 898           n = ikev2_parse_notify_payload(ikep);
 899           if (n->msg_type == IKEV2_NOTIFY_MSG_REKEY_SA)
 900             {
 901               rekeying = 1;
 902             }
 903         }
 904       else if (payload == IKEV2_PAYLOAD_DELETE)
 905         {
 906           sa->del = ikev2_parse_delete_payload(ikep);
 907         }
 908       else if (payload == IKEV2_PAYLOAD_VENDOR)
 909         {
 910           ikev2_parse_vendor_payload(ikep);
 911         }
 912       else if (payload == IKEV2_PAYLOAD_NONCE)
 913         {
 914           memcpy(i_nonce, ikep->payload, plen - sizeof(*ikep));
 915         }
 916       else if (payload == IKEV2_PAYLOAD_TSI)
 917         {
 918           tsi = ikev2_parse_ts_payload(ikep);
 919         }
 920       else if (payload == IKEV2_PAYLOAD_TSR)
 921         {
 922           tsr = ikev2_parse_ts_payload(ikep);
 923         }
 924       else
 925         {
 926           clib_warning("unknown payload %u flags %x length %u data %u",
 927                        payload, ikep->flags, plen - 4,
 928                        format_hex_bytes, ikep->payload, plen - 4);
 929
 930           if (ikep->flags & IKEV2_PAYLOAD_FLAG_CRITICAL) {
 931             sa->unsupported_cp = payload;
 932             return;
 933           }
 934         }
 935
 936       payload = ikep->nextpayload;
 937       p += plen;
 938     }
 939
 940   if (rekeying)
 941     {
 942       ikev2_rekey_t * rekey;
 943       child_sa = ikev2_sa_get_child(sa, n->spi, n->protocol_id);
 944       if (!child_sa)
 945         {
 946           clib_warning("child SA spi %lx not found", n->spi);
 947           goto cleanup_and_exit;
 948         }
 949       vec_add2(sa->rekey, rekey, 1);
 950       rekey->protocol_id = n->protocol_id;
 951       rekey->spi = n->spi;
 952       rekey->i_proposal = proposal;
 953       rekey->r_proposal = ikev2_select_proposal(proposal, IKEV2_PROTOCOL_ESP);
 954       rekey->tsi = tsi;
 955       rekey->tsr = tsr;
 956       /* update Ni */
 957       vec_free(sa->i_nonce);
 958       vec_add(sa->i_nonce, i_nonce, IKEV2_NONCE_SIZE);
 959       /* generate new Nr */
 960       vec_free(sa->r_nonce);
 961       sa->r_nonce = vec_new(u8, IKEV2_NONCE_SIZE);
 962       RAND_bytes((u8 *) sa->r_nonce, IKEV2_NONCE_SIZE);
 963     }
 964
 965 cleanup_and_exit:
 966   vec_free(plaintext);
 967   vec_free(n);
 968 }
 969
 970 static u8 *
 971 ikev2_sa_generate_authmsg(ikev2_sa_t *sa, int is_responder)
 972 {
 973   u8 * authmsg = 0;
 974   u8 * data;
 975   u8 * nonce;
 976   ikev2_id_t * id;
 977   u8 * key;
 978   u8 * packet_data;
 979   ikev2_sa_transform_t * tr_prf;
 980
 981   tr_prf = ikev2_sa_get_td_for_type(sa->r_proposals, IKEV2_TRANSFORM_TYPE_PRF);
 982
 983   if (is_responder)
 984     {
 985       id = &sa->r_id;
 986       key = sa->sk_pr;
 987       nonce = sa->i_nonce;
 988       packet_data = sa->last_sa_init_res_packet_data;
 989     }
 990   else
 991     {
 992       id = &sa->i_id;
 993       key = sa->sk_pi;
 994       nonce = sa->r_nonce;
 995       packet_data = sa->last_sa_init_req_packet_data;
 996     }
 997
 998   data = vec_new(u8, 4);
 999   data[0] = id->type;
1000   vec_append(data, id->data);
1001
1002   u8 * id_hash = ikev2_calc_prf(tr_prf, key, data);
1003   vec_append(authmsg, packet_data);
1004   vec_append(authmsg, nonce);
1005   vec_append(authmsg, id_hash);
1006   vec_free(id_hash);
1007   vec_free(data);
1008
1009   return authmsg;
1010 }
1011
1012 static int
1013 ikev2_ts_cmp(ikev2_ts_t * ts1, ikev2_ts_t * ts2)
1014 {
1015   if (ts1->ts_type == ts2->ts_type && ts1->protocol_id == ts2->protocol_id &&
1016       ts1->start_port == ts2->start_port && ts1->end_port == ts2->end_port &&
1017       ts1->start_addr.as_u32 == ts2->start_addr.as_u32 &&
1018       ts1->end_addr.as_u32 == ts2->end_addr.as_u32)
1019     return 1;
1020
1021   return 0;
1022 }
1023
1024 static void
1025 ikev2_sa_match_ts(ikev2_sa_t *sa)
1026 {
1027   ikev2_main_t * km = &ikev2_main;
1028   ikev2_profile_t * p;
1029   ikev2_ts_t * ts, * tsi = 0, * tsr = 0;
1030
1031   pool_foreach (p, km->profiles, ({
1032
1033     /* check id */
1034     if (p->rem_id.type != sa->i_id.type ||
1035         vec_len(p->rem_id.data) != vec_len(sa->i_id.data) ||
1036         memcmp(p->rem_id.data, sa->i_id.data, vec_len(p->rem_id.data)))
1037       continue;
1038
1039     vec_foreach(ts, sa->childs[0].tsi)
1040       {
1041         if (ikev2_ts_cmp(&p->rem_ts, ts))
1042           {
1043             tsi = vec_dup(ts);
1044             break;
1045           }
1046       }
1047
1048     vec_foreach(ts, sa->childs[0].tsr)
1049       {
1050         if (ikev2_ts_cmp(&p->loc_ts, ts))
1051           {
1052             tsr = vec_dup(ts);
1053             break;
1054           }
1055       }
1056
1057     break;
1058   }));
1059
1060   if (tsi && tsr)
1061     {
1062       vec_free(sa->childs[0].tsi);
1063       vec_free(sa->childs[0].tsr);
1064       sa->childs[0].tsi = tsi;
1065       sa->childs[0].tsr = tsr;
1066     }
1067   else
1068     {
1069       vec_free(tsi);
1070       vec_free(tsr);
1071       ikev2_set_state(sa, IKEV2_STATE_TS_UNACCEPTABLE);
1072     }
1073 }
1074
1075 static void
1076 ikev2_sa_auth(ikev2_sa_t *sa)
1077 {
1078   ikev2_main_t * km = &ikev2_main;
1079   ikev2_profile_t * p, * sel_p = 0;
1080   u8 * authmsg, * key_pad, * psk = 0, * auth = 0;
1081   ikev2_sa_transform_t * tr_prf;
1082
1083   tr_prf = ikev2_sa_get_td_for_type(sa->r_proposals, IKEV2_TRANSFORM_TYPE_PRF);
1084
1085   /* only shared key and rsa signature */
1086   if (!(sa->i_auth.method == IKEV2_AUTH_METHOD_SHARED_KEY_MIC ||
1087         sa->i_auth.method == IKEV2_AUTH_METHOD_RSA_SIG))
1088     {
1089       clib_warning("unsupported authentication method %u", sa->i_auth.method);
1090       ikev2_set_state(sa, IKEV2_STATE_AUTH_FAILED);
1091       return;
1092     }
1093
1094   key_pad = format(0, "%s", IKEV2_KEY_PAD);
1095   authmsg = ikev2_sa_generate_authmsg(sa, 0);
1096
1097   pool_foreach (p, km->profiles, ({
1098
1099     /* check id */
1100     if (p->rem_id.type != sa->i_id.type ||
1101         vec_len(p->rem_id.data) != vec_len(sa->i_id.data) ||
1102         memcmp(p->rem_id.data, sa->i_id.data, vec_len(p->rem_id.data)))
1103       continue;
1104
1105     if (sa->i_auth.method == IKEV2_AUTH_METHOD_SHARED_KEY_MIC)
1106       {
1107         if (!p->auth.data ||
1108              p->auth.method != IKEV2_AUTH_METHOD_SHARED_KEY_MIC)
1109           continue;
1110
1111         psk = ikev2_calc_prf(tr_prf, p->auth.data, key_pad);
1112         auth = ikev2_calc_prf(tr_prf, psk, authmsg);
1113
1114         if (!memcmp(auth, sa->i_auth.data, vec_len(sa->i_auth.data)))
1115           {
1116             ikev2_set_state(sa, IKEV2_STATE_AUTHENTICATED);
1117             vec_free(auth);
1118             sel_p = p;
1119             break;
1120           }
1121
1122       }
1123     else if (sa->i_auth.method == IKEV2_AUTH_METHOD_RSA_SIG)
1124       {
1125         if (p->auth.method != IKEV2_AUTH_METHOD_RSA_SIG)
1126           continue;
1127
1128         if (ikev2_verify_sign(p->auth.key, sa->i_auth.data, authmsg) == 1)
1129           {
1130             ikev2_set_state(sa, IKEV2_STATE_AUTHENTICATED);
1131             sel_p = p;
1132             break;
1133           }
1134       }
1135
1136     vec_free(auth);
1137     vec_free(psk);
1138   }));
1139
1140   vec_free(authmsg);
1141
1142   if (sa->state == IKEV2_STATE_AUTHENTICATED)
1143     {
1144       vec_free(sa->r_id.data);
1145       sa->r_id.data = vec_dup(sel_p->loc_id.data);
1146       sa->r_id.type = sel_p->loc_id.type;
1147
1148       /* generate our auth data */
1149       authmsg = ikev2_sa_generate_authmsg(sa, 1);
1150       if (sel_p->auth.method == IKEV2_AUTH_METHOD_SHARED_KEY_MIC)
1151         {
1152           sa->r_auth.data = ikev2_calc_prf(tr_prf, psk, authmsg);
1153           sa->r_auth.method = IKEV2_AUTH_METHOD_SHARED_KEY_MIC;
1154         }
1155       else if (sel_p->auth.method == IKEV2_AUTH_METHOD_RSA_SIG)
1156         {
1157           sa->r_auth.data = ikev2_calc_sign(km->pkey, authmsg);
1158           sa->r_auth.method = IKEV2_AUTH_METHOD_RSA_SIG;
1159         }
1160       vec_free(authmsg);
1161
1162       /* select transforms for 1st child sa */
1163       ikev2_sa_free_proposal_vector(&sa->childs[0].r_proposals);
1164       sa->childs[0].r_proposals = ikev2_select_proposal(sa->childs[0].i_proposals,
1165                                                        IKEV2_PROTOCOL_ESP);
1166     }
1167   else
1168     {
1169       ikev2_set_state(sa, IKEV2_STATE_AUTH_FAILED);
1170     }
1171   vec_free(psk);
1172   vec_free(key_pad);
1173 }
1174
1175 static int
1176 ikev2_create_tunnel_interface(vnet_main_t * vnm, ikev2_sa_t *sa, ikev2_child_sa_t * child)
1177 {
1178   ipsec_add_del_tunnel_args_t a;
1179   ikev2_sa_transform_t * tr;
1180   u32 hw_if_index;
1181   u8  encr_type = 0;
1182
1183   if (!child->r_proposals)
1184     {
1185       ikev2_set_state(sa, IKEV2_STATE_NO_PROPOSAL_CHOSEN);
1186       return 1;
1187     }
1188
1189   a.is_add = 1;
1190   a.local_ip.as_u32 = sa->raddr.as_u32;
1191   a.remote_ip.as_u32 = sa->iaddr.as_u32;
1192   a.local_spi = child->i_proposals[0].spi;
1193   a.remote_spi = child->r_proposals[0].spi;
1194   a.anti_replay = 1;
1195
1196   tr = ikev2_sa_get_td_for_type(child->r_proposals, IKEV2_TRANSFORM_TYPE_ESN);
1197   if (tr)
1198       a.esn = tr->esn_type;
1199   else
1200     a.esn = 0;
1201
1202   tr = ikev2_sa_get_td_for_type(child->r_proposals, IKEV2_TRANSFORM_TYPE_ENCR);
1203   if (tr)
1204     {
1205       if (tr->encr_type == IKEV2_TRANSFORM_ENCR_TYPE_AES_CBC && tr->key_len)
1206         {
1207           switch (tr->key_len)
1208             {
1209               case 16:
1210                 encr_type = IPSEC_CRYPTO_ALG_AES_CBC_128;
1211                 break;
1212               case 24:
1213                 encr_type = IPSEC_CRYPTO_ALG_AES_CBC_192;
1214                 break;
1215               case 32:
1216                 encr_type = IPSEC_CRYPTO_ALG_AES_CBC_256;
1217                 break;
1218               default:
1219                 ikev2_set_state(sa, IKEV2_STATE_NO_PROPOSAL_CHOSEN);
1220                 return 1;
1221                 break;
1222             }
1223         }
1224       else
1225         {
1226           ikev2_set_state(sa, IKEV2_STATE_NO_PROPOSAL_CHOSEN);
1227           return 1;
1228         }
1229     }
1230   else
1231     {
1232       ikev2_set_state(sa, IKEV2_STATE_NO_PROPOSAL_CHOSEN);
1233       return 1;
1234     }
1235
1236   tr = ikev2_sa_get_td_for_type(child->r_proposals, IKEV2_TRANSFORM_TYPE_INTEG);
1237   if (tr)
1238     {
1239       if (tr->integ_type != IKEV2_TRANSFORM_INTEG_TYPE_AUTH_HMAC_SHA1_96)
1240         {
1241           ikev2_set_state(sa, IKEV2_STATE_NO_PROPOSAL_CHOSEN);
1242           return 1;
1243         }
1244     }
1245   else
1246     {
1247       ikev2_set_state(sa, IKEV2_STATE_NO_PROPOSAL_CHOSEN);
1248       return 1;
1249     }
1250
1251   hw_if_index = ipsec_add_del_tunnel_if(vnm, &a);
1252   if (hw_if_index == VNET_API_ERROR_INVALID_VALUE)
1253     {
1254       clib_warning("create tunnel interface failed remote-ip %U remote-spi %u",
1255                    format_ip4_address, &sa->raddr, child->r_proposals[0].spi);
1256       ikev2_set_state(sa, IKEV2_STATE_DELETED);
1257       return hw_if_index;
1258     }
1259
1260   ikev2_calc_child_keys(sa, child);
1261
1262   ipsec_set_interface_key(vnm, hw_if_index,
1263                           IPSEC_IF_SET_KEY_TYPE_LOCAL_CRYPTO,
1264                           encr_type,
1265                           child->sk_er);
1266
1267   ipsec_set_interface_key(vnm, hw_if_index,
1268                           IPSEC_IF_SET_KEY_TYPE_REMOTE_CRYPTO,
1269                           encr_type,
1270                           child->sk_ei);
1271
1272   ipsec_set_interface_key(vnm, hw_if_index,
1273                           IPSEC_IF_SET_KEY_TYPE_LOCAL_INTEG,
1274                           IPSEC_INTEG_ALG_SHA1_96,
1275                           child->sk_ar);
1276
1277   ipsec_set_interface_key(vnm, hw_if_index,
1278                           IPSEC_IF_SET_KEY_TYPE_REMOTE_INTEG,
1279                           IPSEC_INTEG_ALG_SHA1_96,
1280                           child->sk_ai);
1281
1282   return 0;
1283 }
1284
1285 static int
1286 ikev2_delete_tunnel_interface(vnet_main_t * vnm, ikev2_sa_t *sa, ikev2_child_sa_t * child)
1287 {
1288   ipsec_add_del_tunnel_args_t a;
1289
1290   if (!vec_len(child->r_proposals))
1291     return 0;
1292
1293   a.is_add = 0;
1294   a.local_ip.as_u32 = sa->raddr.as_u32;
1295   a.remote_ip.as_u32 = sa->iaddr.as_u32;
1296   a.local_spi = child->i_proposals[0].spi;
1297   a.remote_spi = child->r_proposals[0].spi;
1298
1299   return ipsec_add_del_tunnel_if(vnm, &a);
1300 }
1301
1302 static u32
1303 ikev2_generate_resp(ikev2_sa_t *sa, ike_header_t * ike)
1304 {
1305   v8 * integ = 0;
1306   ike_payload_header_t * ph;
1307   u16 plen;
1308   u32 tlen = 0;
1309
1310   ikev2_sa_transform_t * tr_encr, *tr_integ;
1311   tr_encr = ikev2_sa_get_td_for_type(sa->r_proposals, IKEV2_TRANSFORM_TYPE_ENCR);
1312   tr_integ = ikev2_sa_get_td_for_type(sa->r_proposals, IKEV2_TRANSFORM_TYPE_INTEG);
1313
1314   ikev2_payload_chain_t * chain = 0;
1315   ikev2_payload_new_chain(chain);
1316
1317   if (ike->exchange == IKEV2_EXCHANGE_SA_INIT)
1318     {
1319       if (sa->r_proposals == 0)
1320         {
1321           ikev2_payload_add_notify(chain, IKEV2_NOTIFY_MSG_NO_PROPOSAL_CHOSEN, 0);
1322           ikev2_set_state(sa, IKEV2_STATE_NOTIFY_AND_DELETE);
1323         }
1324       else if (sa->dh_group == IKEV2_TRANSFORM_DH_TYPE_NONE)
1325         {
1326            u8 * data = vec_new(u8, 2);
1327            ikev2_sa_transform_t * tr_dh;
1328            tr_dh = ikev2_sa_get_td_for_type(sa->r_proposals, IKEV2_TRANSFORM_TYPE_DH);
1329            ASSERT(tr_dh && tr_dh->dh_type);
1330
1331            data[0] = (tr_dh->dh_type >> 8) & 0xff;
1332            data[1] = (tr_dh->dh_type) & 0xff;
1333
1334            ikev2_payload_add_notify(chain, IKEV2_NOTIFY_MSG_INVALID_KE_PAYLOAD, data);
1335            vec_free(data);
1336            ikev2_set_state(sa, IKEV2_STATE_NOTIFY_AND_DELETE);
1337         }
1338       else if (sa->state == IKEV2_STATE_NOTIFY_AND_DELETE)
1339         {
1340            u8 * data = vec_new(u8, 1);
1341
1342            data[0] = sa->unsupported_cp;
1343            ikev2_payload_add_notify(chain,
1344                                     IKEV2_NOTIFY_MSG_UNSUPPORTED_CRITICAL_PAYLOAD,
1345                                     data);
1346            vec_free(data);
1347         }
1348       else
1349         {
1350           ike->rspi = clib_host_to_net_u64(sa->rspi);
1351           ikev2_payload_add_sa(chain, sa->r_proposals);
1352           ikev2_payload_add_ke(chain, sa->dh_group, sa->r_dh_data);
1353           ikev2_payload_add_nonce(chain, sa->r_nonce);
1354         }
1355     }
1356   else if (ike->exchange == IKEV2_EXCHANGE_IKE_AUTH)
1357     {
1358       if (sa->state == IKEV2_STATE_AUTHENTICATED)
1359         {
1360           ikev2_payload_add_id(chain, &sa->r_id, IKEV2_PAYLOAD_IDR);
1361           ikev2_payload_add_auth(chain, &sa->r_auth);
1362           ikev2_payload_add_sa(chain, sa->childs[0].r_proposals);
1363           ikev2_payload_add_ts(chain, sa->childs[0].tsi, IKEV2_PAYLOAD_TSI);
1364           ikev2_payload_add_ts(chain, sa->childs[0].tsr, IKEV2_PAYLOAD_TSR);
1365         }
1366       else if (sa->state == IKEV2_STATE_AUTH_FAILED)
1367         {
1368           ikev2_payload_add_notify(chain, IKEV2_NOTIFY_MSG_AUTHENTICATION_FAILED, 0);
1369           ikev2_set_state(sa, IKEV2_STATE_NOTIFY_AND_DELETE);
1370         }
1371       else if (sa->state == IKEV2_STATE_TS_UNACCEPTABLE)
1372         {
1373           ikev2_payload_add_notify(chain, IKEV2_NOTIFY_MSG_TS_UNACCEPTABLE, 0);
1374           ikev2_payload_add_id(chain, &sa->r_id, IKEV2_PAYLOAD_IDR);
1375           ikev2_payload_add_auth(chain, &sa->r_auth);
1376         }
1377       else if (sa->state == IKEV2_STATE_NO_PROPOSAL_CHOSEN)
1378         {
1379           ikev2_payload_add_notify(chain, IKEV2_NOTIFY_MSG_NO_PROPOSAL_CHOSEN, 0);
1380           ikev2_payload_add_id(chain, &sa->r_id, IKEV2_PAYLOAD_IDR);
1381           ikev2_payload_add_auth(chain, &sa->r_auth);
1382           ikev2_payload_add_ts(chain, sa->childs[0].tsi, IKEV2_PAYLOAD_TSI);
1383           ikev2_payload_add_ts(chain, sa->childs[0].tsr, IKEV2_PAYLOAD_TSR);
1384         }
1385       else if (sa->state == IKEV2_STATE_NOTIFY_AND_DELETE)
1386         {
1387            u8 * data = vec_new(u8, 1);
1388
1389            data[0] = sa->unsupported_cp;
1390            ikev2_payload_add_notify(chain,
1391                                     IKEV2_NOTIFY_MSG_UNSUPPORTED_CRITICAL_PAYLOAD,
1392                                     data);
1393            vec_free(data);
1394         }
1395       else
1396         {
1397           ikev2_set_state(sa, IKEV2_STATE_DELETED);
1398           goto done;
1399         }
1400     }
1401   else if (ike->exchange == IKEV2_EXCHANGE_INFORMATIONAL)
1402     {
1403       /* if pending delete */
1404       if (sa->del)
1405         {
1406           /* The response to a request that deletes the IKE SA is an empty
1407              INFORMATIONAL response. */
1408           if (sa->del[0].protocol_id == IKEV2_PROTOCOL_IKE)
1409             {
1410               ikev2_set_state(sa, IKEV2_STATE_NOTIFY_AND_DELETE);
1411             }
1412           /* The response to a request that deletes ESP or AH SAs will contain
1413              delete payloads for the paired SAs going in the other direction. */
1414           else
1415             {
1416               ikev2_payload_add_delete(chain, sa->del);
1417             }
1418           vec_free(sa->del);
1419           sa->del = 0;
1420         }
1421       /* received N(AUTHENTICATION_FAILED) */
1422       else if (sa->state == IKEV2_STATE_AUTH_FAILED)
1423         {
1424           ikev2_set_state(sa, IKEV2_STATE_DELETED);
1425           goto done;
1426         }
1427       /* received unsupported critical payload */
1428       else if (sa->unsupported_cp)
1429         {
1430            u8 * data = vec_new(u8, 1);
1431
1432            data[0] = sa->unsupported_cp;
1433            ikev2_payload_add_notify(chain,
1434                                     IKEV2_NOTIFY_MSG_UNSUPPORTED_CRITICAL_PAYLOAD,
1435                                     data);
1436            vec_free(data);
1437            sa->unsupported_cp = 0;
1438         }
1439       /* else send empty response */
1440     }
1441   else if (ike->exchange == IKEV2_EXCHANGE_CREATE_CHILD_SA)
1442     {
1443       if (sa->rekey)
1444         {
1445           ikev2_payload_add_sa(chain, sa->rekey[0].r_proposal);
1446           ikev2_payload_add_nonce(chain, sa->r_nonce);
1447           ikev2_payload_add_ts(chain, sa->rekey[0].tsi, IKEV2_PAYLOAD_TSI);
1448           ikev2_payload_add_ts(chain, sa->rekey[0].tsr, IKEV2_PAYLOAD_TSR);
1449           vec_del1(sa->rekey, 0);
1450         }
1451       else if (sa->unsupported_cp)
1452         {
1453            u8 * data = vec_new(u8, 1);
1454
1455            data[0] = sa->unsupported_cp;
1456            ikev2_payload_add_notify(chain,
1457                                     IKEV2_NOTIFY_MSG_UNSUPPORTED_CRITICAL_PAYLOAD,
1458                                     data);
1459            vec_free(data);
1460            sa->unsupported_cp = 0;
1461         }
1462       else
1463         {
1464            ikev2_payload_add_notify(chain, IKEV2_NOTIFY_MSG_NO_ADDITIONAL_SAS, 0);
1465         }
1466     }
1467
1468   /* IKEv2 header */
1469   ike->version = IKE_VERSION_2;
1470   ike->flags = IKEV2_HDR_FLAG_RESPONSE;
1471   ike->nextpayload = IKEV2_PAYLOAD_SK;
1472   tlen = sizeof(*ike);
1473
1474
1475   if (ike->exchange == IKEV2_EXCHANGE_SA_INIT)
1476     {
1477       tlen += vec_len(chain->data);
1478       ike->nextpayload = chain->first_payload_type;
1479       ike->length = clib_host_to_net_u32(tlen);
1480       memcpy(ike->payload, chain->data, vec_len(chain->data));
1481
1482       /* store whole IKE payload - needed for PSK auth */
1483       vec_free(sa->last_sa_init_res_packet_data);
1484       vec_add(sa->last_sa_init_res_packet_data, ike, tlen);
1485     }
1486   else
1487     {
1488
1489       ikev2_payload_chain_add_padding(chain, tr_encr->block_size);
1490
1491       /* SK payload */
1492       plen = sizeof(*ph);
1493       ph = (ike_payload_header_t *) &ike->payload[0];
1494       ph->nextpayload = chain->first_payload_type;
1495       ph->flags = 0;
1496       int enc_len = ikev2_encrypt_data(sa, chain->data, ph->payload);
1497       plen += enc_len;
1498
1499       /* add space for hmac */
1500       plen += tr_integ->key_trunc;
1501       tlen += plen;
1502
1503       /* payload and total length */
1504       ph->length = clib_host_to_net_u16(plen);
1505       ike->length = clib_host_to_net_u32(tlen);
1506
1507       /* calc integrity data for whole packet except hash itself */
1508       integ = ikev2_calc_integr(tr_integ, sa->sk_ar, (u8 *) ike,
1509                                 tlen - tr_integ->key_trunc);
1510
1511       memcpy(ike->payload + tlen - tr_integ->key_trunc - sizeof(*ike),
1512              integ, tr_integ->key_trunc);
1513
1514       /* store whole IKE payload - needed for retransmit */
1515       vec_free(sa->last_res_packet_data);
1516       vec_add(sa->last_res_packet_data, ike, tlen);
1517     }
1518
1519 done:
1520   ikev2_payload_destroy_chain (chain);
1521   vec_free(integ);
1522   return tlen;
1523 }
1524
1525 static int
1526 ikev2_retransmit_sa_init (ike_header_t * ike,
1527                           ip4_address_t iaddr,
1528                           ip4_address_t raddr)
1529 {
1530   ikev2_main_t * km = &ikev2_main;
1531   ikev2_sa_t * sa;
1532
1533   pool_foreach (sa, km->sas, ({
1534     if (sa->ispi == clib_net_to_host_u64(ike->ispi) &&
1535         sa->iaddr.as_u32 == iaddr.as_u32 &&
1536         sa->raddr.as_u32 == raddr.as_u32)
1537       {
1538         int p = 0;
1539         u32 len = clib_net_to_host_u32(ike->length);
1540         u8 payload = ike->nextpayload;
1541
1542         while (p < len && payload!= IKEV2_PAYLOAD_NONE) {
1543           ike_payload_header_t * ikep = (ike_payload_header_t *) &ike->payload[p];
1544           u32 plen = clib_net_to_host_u16(ikep->length);
1545
1546           if (plen < sizeof(ike_payload_header_t))
1547             return -1;
1548
1549           if (payload == IKEV2_PAYLOAD_NONCE)
1550             {
1551               if (!memcmp(sa->i_nonce, ikep->payload, plen - sizeof(*ikep)))
1552                 {
1553                   /* req is retransmit */
1554                   if (sa->state == IKEV2_STATE_SA_INIT)
1555                     {
1556                       ike_header_t * tmp;
1557                       tmp = (ike_header_t*)sa->last_sa_init_res_packet_data;
1558                       ike->ispi = tmp->ispi;
1559                       ike->rspi = tmp->rspi;
1560                       ike->nextpayload = tmp->nextpayload;
1561                       ike->version = tmp->version;
1562                       ike->exchange = tmp->exchange;
1563                       ike->flags = tmp->flags;
1564                       ike->msgid = tmp->msgid;
1565                       ike->length = tmp->length;
1566                       memcpy(ike->payload, tmp->payload,
1567                              clib_net_to_host_u32(tmp->length) - sizeof(*ike));
1568                       clib_warning("IKE_SA_INIT retransmit from %U to %U",
1569                                    format_ip4_address, &raddr,
1570                                    format_ip4_address, &iaddr);
1571                       return 1;
1572                     }
1573                   /* else ignore req */
1574                   else
1575                     {
1576                       clib_warning("IKE_SA_INIT ignore from %U to %U",
1577                                    format_ip4_address, &raddr,
1578                                    format_ip4_address, &iaddr);
1579                       return -1;
1580                     }
1581                 }
1582             }
1583           payload = ikep->nextpayload;
1584           p+=plen;
1585         }
1586       }
1587   }));
1588
1589   /* req is not retransmit */
1590   return 0;
1591 }
1592
1593 static int
1594 ikev2_retransmit_resp (ikev2_sa_t * sa, ike_header_t * ike)
1595 {
1596   u32 msg_id = clib_net_to_host_u32(ike->msgid);
1597
1598   /* new req */
1599   if (msg_id > sa->last_msg_id)
1600     {
1601       sa->last_msg_id = msg_id;
1602       return 0;
1603     }
1604   /* retransmitted req */
1605   else if (msg_id == sa->last_msg_id)
1606     {
1607       ike_header_t * tmp;
1608       tmp = (ike_header_t*)sa->last_res_packet_data;
1609       ike->ispi = tmp->ispi;
1610       ike->rspi = tmp->rspi;
1611       ike->nextpayload = tmp->nextpayload;
1612       ike->version = tmp->version;
1613       ike->exchange = tmp->exchange;
1614       ike->flags = tmp->flags;
1615       ike->msgid = tmp->msgid;
1616       ike->length = tmp->length;
1617       memcpy(ike->payload, tmp->payload,
1618              clib_net_to_host_u32(tmp->length) - sizeof(*ike));
1619       clib_warning("IKE msgid %u retransmit from %U to %U",
1620                    msg_id,
1621                    format_ip4_address, &sa->raddr,
1622                    format_ip4_address, &sa->iaddr);
1623       return 1;
1624     }
1625   /* old req ignore */
1626   else
1627     {
1628       clib_warning("IKE msgid %u req ignore from %U to %U",
1629                    msg_id,
1630                    format_ip4_address, &sa->raddr,
1631                    format_ip4_address, &sa->iaddr);
1632       return -1;
1633     }
1634 }
1635
1636 static uword
1637 ikev2_node_fn (vlib_main_t * vm,
1638       vlib_node_runtime_t * node,
1639       vlib_frame_t * frame)
1640 {
1641   u32 n_left_from, * from, * to_next;
1642   ikev2_next_t next_index;
1643   ikev2_main_t * km = &ikev2_main;
1644
1645   from = vlib_frame_vector_args (frame);
1646   n_left_from = frame->n_vectors;
1647   next_index = node->cached_next_index;
1648
1649   while (n_left_from > 0)
1650     {
1651       u32 n_left_to_next;
1652
1653       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1654
1655       while (n_left_from > 0 && n_left_to_next > 0)
1656         {
1657           u32 bi0;
1658           vlib_buffer_t * b0;
1659           u32 next0 = IKEV2_NEXT_ERROR_DROP;
1660           u32 sw_if_index0;
1661           ip4_header_t * ip40;
1662           udp_header_t * udp0;
1663           ike_header_t * ike0;
1664           ikev2_sa_t * sa0 = 0;
1665           int len = 0;
1666           int r;
1667
1668           /* speculatively enqueue b0 to the current next frame */
1669           bi0 = from[0];
1670           to_next[0] = bi0;
1671           from += 1;
1672           to_next += 1;
1673           n_left_from -= 1;
1674           n_left_to_next -= 1;
1675
1676           b0 = vlib_get_buffer (vm, bi0);
1677           ike0 = vlib_buffer_get_current (b0);
1678           vlib_buffer_advance(b0, - sizeof(*udp0));
1679           udp0 = vlib_buffer_get_current (b0);
1680           vlib_buffer_advance(b0, - sizeof(*ip40));
1681           ip40 = vlib_buffer_get_current (b0);
1682
1683           if (ike0->version != IKE_VERSION_2)
1684             {
1685               vlib_node_increment_counter(vm, ikev2_node.index,
1686                                         IKEV2_ERROR_NOT_IKEV2, 1);
1687               goto dispatch0;
1688             }
1689
1690           if (ike0->exchange == IKEV2_EXCHANGE_SA_INIT)
1691             {
1692               ikev2_sa_t sa; /* temporary store for SA */
1693               sa0 = &sa;
1694               memset (sa0, 0, sizeof (*sa0));
1695
1696               if (ike0->rspi == 0)
1697                 {
1698                   sa0->raddr.as_u32 = ip40->dst_address.as_u32;
1699                   sa0->iaddr.as_u32 = ip40->src_address.as_u32;
1700
1701                   r = ikev2_retransmit_sa_init(ike0, sa0->iaddr, sa0->raddr);
1702                   if (r == 1)
1703                     {
1704                       vlib_node_increment_counter(vm, ikev2_node.index,
1705                                                   IKEV2_ERROR_IKE_SA_INIT_RETRANSMIT,
1706                                                   1);
1707                       len = clib_net_to_host_u32(ike0->length);
1708                       goto dispatch0;
1709                     }
1710                   else if (r == -1)
1711                     {
1712                       vlib_node_increment_counter(vm, ikev2_node.index,
1713                                                   IKEV2_ERROR_IKE_SA_INIT_IGNORE,
1714                                                   1);
1715                       goto dispatch0;
1716                     }
1717
1718                   ikev2_process_sa_init_req(vm, sa0, ike0);
1719
1720                   if (sa0->state == IKEV2_STATE_SA_INIT)
1721                     {
1722                       ikev2_sa_free_proposal_vector(&sa0->r_proposals);
1723                       sa0->r_proposals = ikev2_select_proposal(sa0->i_proposals,
1724                                                               IKEV2_PROTOCOL_IKE);
1725                       ikev2_generate_sa_init_data(sa0);
1726                     }
1727
1728                   if (sa0->state == IKEV2_STATE_SA_INIT ||
1729                       sa0->state == IKEV2_STATE_NOTIFY_AND_DELETE)
1730                     {
1731                       len = ikev2_generate_resp(sa0, ike0);
1732                     }
1733
1734                   if (sa0->state == IKEV2_STATE_SA_INIT)
1735                     {
1736                       /* add SA to the pool */
1737                       pool_get (km->sas, sa0);
1738                       memcpy(sa0, &sa, sizeof(*sa0));
1739                       hash_set (km->sa_by_rspi, sa0->rspi, sa0 - km->sas);
1740                     }
1741                   else
1742                     {
1743                       ikev2_sa_free_all_vec(sa0);
1744                     }
1745                 }
1746             }
1747           else if (ike0->exchange == IKEV2_EXCHANGE_IKE_AUTH)
1748             {
1749               uword * p;
1750               p = hash_get(km->sa_by_rspi, clib_net_to_host_u64(ike0->rspi));
1751               if (p)
1752                 {
1753                   sa0 = pool_elt_at_index (km->sas, p[0]);
1754
1755                   r = ikev2_retransmit_resp(sa0, ike0);
1756                   if (r == 1)
1757                     {
1758                       vlib_node_increment_counter(vm, ikev2_node.index,
1759                                                   IKEV2_ERROR_IKE_REQ_RETRANSMIT,
1760                                                   1);
1761                       len = clib_net_to_host_u32(ike0->length);
1762                       goto dispatch0;
1763                     }
1764                   else if (r == -1)
1765                     {
1766                       vlib_node_increment_counter(vm, ikev2_node.index,
1767                                                   IKEV2_ERROR_IKE_REQ_IGNORE,
1768                                                   1);
1769                       goto dispatch0;
1770                     }
1771
1772                   ikev2_process_auth_req(vm, sa0, ike0);
1773                   ikev2_sa_auth(sa0);
1774                   if (sa0->state == IKEV2_STATE_AUTHENTICATED)
1775                     {
1776                       ikev2_initial_contact_cleanup(sa0);
1777                       ikev2_sa_match_ts(sa0);
1778                       if (sa0->state != IKEV2_STATE_TS_UNACCEPTABLE)
1779                         ikev2_create_tunnel_interface(km->vnet_main, sa0,
1780                                                       &sa0->childs[0]);
1781                     }
1782                   len = ikev2_generate_resp(sa0, ike0);
1783                 }
1784             }
1785           else if (ike0->exchange == IKEV2_EXCHANGE_INFORMATIONAL)
1786             {
1787               uword * p;
1788               p = hash_get(km->sa_by_rspi, clib_net_to_host_u64(ike0->rspi));
1789               if (p)
1790                 {
1791                   sa0 = pool_elt_at_index (km->sas, p[0]);
1792
1793                   r = ikev2_retransmit_resp(sa0, ike0);
1794                   if (r == 1)
1795                     {
1796                       vlib_node_increment_counter(vm, ikev2_node.index,
1797                                                   IKEV2_ERROR_IKE_REQ_RETRANSMIT,
1798                                                   1);
1799                       len = clib_net_to_host_u32(ike0->length);
1800                       goto dispatch0;
1801                     }
1802                   else if (r == -1)
1803                     {
1804                       vlib_node_increment_counter(vm, ikev2_node.index,
1805                                                   IKEV2_ERROR_IKE_REQ_IGNORE,
1806                                                   1);
1807                       goto dispatch0;
1808                     }
1809
1810                   ikev2_process_informational_req(vm, sa0, ike0);
1811                   if (sa0->del)
1812                     {
1813                       if (sa0->del[0].protocol_id != IKEV2_PROTOCOL_IKE)
1814                         {
1815                           ikev2_delete_t * d, * tmp, * resp = 0;
1816                           vec_foreach(d, sa0->del)
1817                             {
1818                               ikev2_child_sa_t * ch_sa;
1819                               ch_sa = ikev2_sa_get_child(sa0, d->spi,
1820                                                          d->protocol_id);
1821                               if (ch_sa)
1822                                 {
1823                                   ikev2_delete_tunnel_interface(km->vnet_main,
1824                                                                 sa0, ch_sa);
1825                                   vec_add2(resp, tmp, 1);
1826                                   tmp->protocol_id = d->protocol_id;
1827                                   tmp->spi = ch_sa->r_proposals[0].spi;
1828                                   ikev2_sa_del_child_sa(sa0, ch_sa);
1829                                 }
1830                             }
1831                           vec_free(sa0->del);
1832                           sa0->del = resp;
1833                         }
1834                     }
1835                   len = ikev2_generate_resp(sa0, ike0);
1836                 }
1837             }
1838           else if (ike0->exchange == IKEV2_EXCHANGE_CREATE_CHILD_SA)
1839             {
1840               uword * p;
1841               p = hash_get(km->sa_by_rspi, clib_net_to_host_u64(ike0->rspi));
1842               if (p)
1843                 {
1844                   sa0 = pool_elt_at_index (km->sas, p[0]);
1845
1846                   r = ikev2_retransmit_resp(sa0, ike0);
1847                   if (r == 1)
1848                     {
1849                       vlib_node_increment_counter(vm, ikev2_node.index,
1850                                                   IKEV2_ERROR_IKE_REQ_RETRANSMIT,
1851                                                   1);
1852                       len = clib_net_to_host_u32(ike0->length);
1853                       goto dispatch0;
1854                     }
1855                   else if (r == -1)
1856                     {
1857                       vlib_node_increment_counter(vm, ikev2_node.index,
1858                                                   IKEV2_ERROR_IKE_REQ_IGNORE,
1859                                                   1);
1860                       goto dispatch0;
1861                     }
1862
1863                   ikev2_process_create_child_sa_req(vm, sa0, ike0);
1864                   if (sa0->rekey)
1865                     {
1866                       if (sa0->rekey[0].protocol_id != IKEV2_PROTOCOL_IKE)
1867                         {
1868                           ikev2_child_sa_t * child;
1869                           vec_add2(sa0->childs, child, 1);
1870                           child->r_proposals = sa0->rekey[0].r_proposal;
1871                           child->i_proposals = sa0->rekey[0].i_proposal;
1872                           child->tsi = sa0->rekey[0].tsi;
1873                           child->tsr = sa0->rekey[0].tsr;
1874                           ikev2_create_tunnel_interface(km->vnet_main, sa0,
1875                                                         child);
1876                         }
1877                       len = ikev2_generate_resp(sa0, ike0);
1878                     }
1879                 }
1880             }
1881           else
1882             {
1883               clib_warning("IKEv2 exchange %u packet received from %U to %U",
1884                            ike0->exchange,
1885                            format_ip4_address, ip40->src_address.as_u8,
1886                            format_ip4_address, ip40->dst_address.as_u8);
1887               hexdump((u8 *) ip40, b0->current_length);
1888             }
1889
1890 dispatch0:
1891           /* if we are sending packet back, rewrite headers */
1892           if (len)
1893             {
1894                 next0 = IKEV2_NEXT_IP4_LOOKUP;
1895                 ip40->dst_address.as_u32 = sa0->iaddr.as_u32;
1896                 ip40->src_address.as_u32 = sa0->raddr.as_u32;
1897                 udp0->length = clib_host_to_net_u16(len + sizeof(udp_header_t));
1898                 udp0->checksum = 0;
1899                 b0->current_length = len + sizeof(ip4_header_t) + sizeof(udp_header_t);
1900                 ip40->length = clib_host_to_net_u16(b0->current_length);
1901                 ip40->checksum = ip4_header_checksum (ip40);
1902 #if 0
1903                 clib_warning("sending response:");
1904                 hexdump(vlib_buffer_get_current (b0), b0->current_length);
1905 #endif
1906             }
1907           /* delete sa */
1908           if (sa0 && (sa0->state == IKEV2_STATE_DELETED ||
1909               sa0->state == IKEV2_STATE_NOTIFY_AND_DELETE))
1910             {
1911               ikev2_child_sa_t * c;
1912
1913               vec_foreach(c, sa0->childs)
1914                 ikev2_delete_tunnel_interface(km->vnet_main, sa0, c);
1915
1916               ikev2_delete_sa(sa0);
1917             }
1918           sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX];
1919
1920           if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE)
1921                             && (b0->flags & VLIB_BUFFER_IS_TRACED)))
1922             {
1923               ikev2_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t));
1924               t->sw_if_index = sw_if_index0;
1925               t->next_index = next0;
1926             }
1927
1928           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1929                                            n_left_to_next, bi0, next0);
1930         }
1931
1932       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1933     }
1934
1935   vlib_node_increment_counter (vm, ikev2_node.index,
1936                                IKEV2_ERROR_PROCESSED, frame->n_vectors);
1937   return frame->n_vectors;
1938 }
1939
1940 VLIB_REGISTER_NODE (ikev2_node) = {
1941   .function = ikev2_node_fn,
1942   .name = "ikev2",
1943   .vector_size = sizeof (u32),
1944   .format_trace = format_ikev2_trace,
1945   .type = VLIB_NODE_TYPE_INTERNAL,
1946
1947   .n_errors = ARRAY_LEN(ikev2_error_strings),
1948   .error_strings = ikev2_error_strings,
1949
1950   .n_next_nodes = IKEV2_N_NEXT,
1951
1952   .next_nodes = {
1953     [IKEV2_NEXT_IP4_LOOKUP] = "ip4-lookup",
1954         [IKEV2_NEXT_ERROR_DROP] = "error-drop",
1955   },
1956 };
1957
1958
1959 static ikev2_profile_t *
1960 ikev2_profile_index_by_name(u8 * name)
1961 {
1962   ikev2_main_t * km = &ikev2_main;
1963   uword * p;
1964
1965   p = mhash_get (&km->profile_index_by_name, name);
1966   if (!p)
1967     return 0;
1968
1969   return pool_elt_at_index(km->profiles, p[0]);
1970 }
1971
1972 clib_error_t *
1973 ikev2_set_local_key(vlib_main_t * vm, u8 * file)
1974 {
1975   ikev2_main_t * km = &ikev2_main;
1976
1977   km->pkey = ikev2_load_key_file(file);
1978   if (km->pkey == NULL)
1979     return clib_error_return(0, "load key '%s' failed", file);
1980
1981   return 0;
1982 }
1983
1984 clib_error_t *
1985 ikev2_add_del_profile(vlib_main_t * vm, u8 * name, int is_add)
1986 {
1987   ikev2_main_t * km = &ikev2_main;
1988   ikev2_profile_t * p;
1989
1990   if (is_add)
1991     {
1992       if (ikev2_profile_index_by_name(name))
1993         return clib_error_return(0, "policy %v already exists", name);
1994
1995       pool_get (km->profiles, p);
1996       memset(p, 0, sizeof(*p));
1997       p->name = vec_dup(name);
1998       uword index = p - km->profiles;
1999       mhash_set_mem (&km->profile_index_by_name, name, &index, 0);
2000     }
2001   else
2002     {
2003       p = ikev2_profile_index_by_name(name);
2004       if (!p)
2005         return clib_error_return(0, "policy %v does not exists", name);
2006
2007       vec_free (p->name);
2008       pool_put (km->profiles, p);
2009       mhash_unset (&km->profile_index_by_name, name, 0);
2010     }
2011   return 0;
2012 }
2013
2014 clib_error_t *
2015 ikev2_set_profile_auth(vlib_main_t * vm, u8 * name, u8 auth_method,
2016                        u8 * auth_data, u8 data_hex_format)
2017 {
2018   ikev2_profile_t * p;
2019   clib_error_t * r;
2020
2021   p = ikev2_profile_index_by_name(name);
2022
2023   if (!p) {
2024     r = clib_error_return(0, "unknown profile %v", name);
2025     return r;
2026   }
2027   vec_free(p->auth.data);
2028   p->auth.method = auth_method;
2029   p->auth.data = vec_dup(auth_data);
2030   p->auth.hex = data_hex_format;
2031
2032   if (auth_method == IKEV2_AUTH_METHOD_RSA_SIG)
2033     {
2034       if (p->auth.key)
2035         EVP_PKEY_free(p->auth.key);
2036       p->auth.key = ikev2_load_cert_file(auth_data);
2037       if (p->auth.key == NULL)
2038         return clib_error_return(0, "load cert '%s' failed", auth_data);
2039     }
2040
2041   return 0;
2042 }
2043
2044 clib_error_t *
2045 ikev2_set_profile_id(vlib_main_t * vm, u8 * name, u8 id_type, u8 * data,
2046                      int is_local)
2047 {
2048   ikev2_profile_t * p;
2049   clib_error_t * r;
2050
2051   if (id_type > IKEV2_ID_TYPE_ID_RFC822_ADDR && id_type < IKEV2_ID_TYPE_ID_KEY_ID)
2052     {
2053       r = clib_error_return(0, "unsupported identity type %U",
2054                             format_ikev2_id_type, id_type);
2055       return r;
2056     }
2057
2058   p = ikev2_profile_index_by_name(name);
2059
2060   if (!p) {
2061     r = clib_error_return(0, "unknown profile %v", name);
2062     return r;
2063   }
2064
2065   if (is_local)
2066     {
2067       vec_free(p->loc_id.data);
2068       p->loc_id.type = id_type;
2069       p->loc_id.data = vec_dup(data);
2070     }
2071   else
2072     {
2073       vec_free(p->rem_id.data);
2074       p->rem_id.type = id_type;
2075       p->rem_id.data = vec_dup(data);
2076     }
2077
2078   return 0;
2079 }
2080
2081 clib_error_t *
2082 ikev2_set_profile_ts(vlib_main_t * vm, u8 * name, u8 protocol_id,
2083                      u16 start_port, u16 end_port, ip4_address_t start_addr,
2084                      ip4_address_t end_addr, int is_local)
2085 {
2086   ikev2_profile_t * p;
2087   clib_error_t * r;
2088
2089   p = ikev2_profile_index_by_name(name);
2090
2091   if (!p) {
2092     r = clib_error_return(0, "unknown profile %v", name);
2093     return r;
2094   }
2095
2096   if (is_local)
2097     {
2098       p->loc_ts.start_addr.as_u32= start_addr.as_u32;
2099       p->loc_ts.end_addr.as_u32 = end_addr.as_u32;
2100       p->loc_ts.start_port = start_port;
2101       p->loc_ts.end_port = end_port;
2102       p->loc_ts.protocol_id = protocol_id;
2103       p->loc_ts.ts_type = 7;
2104     }
2105   else
2106     {
2107       p->rem_ts.start_addr.as_u32 = start_addr.as_u32;
2108       p->rem_ts.end_addr.as_u32 = end_addr.as_u32;
2109       p->rem_ts.start_port = start_port;
2110       p->rem_ts.end_port = end_port;
2111       p->rem_ts.protocol_id = protocol_id;
2112       p->rem_ts.ts_type = 7;
2113     }
2114
2115   return 0;
2116 }
2117
2118
2119 clib_error_t *
2120 ikev2_init (vlib_main_t * vm)
2121 {
2122   ikev2_main_t * km = &ikev2_main;
2123   clib_error_t * error;
2124
2125   memset (km, 0, sizeof (ikev2_main_t));
2126   km->vnet_main = vnet_get_main();
2127   km->vlib_main = vm;
2128
2129   ikev2_crypto_init(km);
2130
2131   km->sa_by_rspi = hash_create (0, sizeof (uword));
2132   mhash_init_vec_string (&km->profile_index_by_name, sizeof (uword));
2133
2134   if ((error = vlib_call_init_function (vm, ikev2_cli_init)))
2135     return error;
2136
2137   udp_register_dst_port (vm, 500, ikev2_node.index, 1);
2138
2139   return 0;
2140 }
2141
2142