src/vnet/ipsec/ipsec_sa.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 <vnet/ipsec/ipsec.h>
  17 #include <vnet/ipsec/esp.h>
  18 #include <vnet/udp/udp_local.h>
  19 #include <vnet/fib/fib_table.h>
  20 #include <vnet/fib/fib_entry_track.h>
  21 #include <vnet/ipsec/ipsec_tun.h>
  22
  23 /**
  24  * @brief
  25  * SA packet & bytes counters
  26  */
  27 vlib_combined_counter_main_t ipsec_sa_counters = {
  28   .name = "SA",
  29   .stat_segment_name = "/net/ipsec/sa",
  30 };
  31
  32
  33 static clib_error_t *
  34 ipsec_call_add_del_callbacks (ipsec_main_t * im, ipsec_sa_t * sa,
  35                               u32 sa_index, int is_add)
  36 {
  37   ipsec_ah_backend_t *ab;
  38   ipsec_esp_backend_t *eb;
  39   switch (sa->protocol)
  40     {
  41     case IPSEC_PROTOCOL_AH:
  42       ab = pool_elt_at_index (im->ah_backends, im->ah_current_backend);
  43       if (ab->add_del_sa_sess_cb)
  44         return ab->add_del_sa_sess_cb (sa_index, is_add);
  45       break;
  46     case IPSEC_PROTOCOL_ESP:
  47       eb = pool_elt_at_index (im->esp_backends, im->esp_current_backend);
  48       if (eb->add_del_sa_sess_cb)
  49         return eb->add_del_sa_sess_cb (sa_index, is_add);
  50       break;
  51     }
  52   return 0;
  53 }
  54
  55 void
  56 ipsec_mk_key (ipsec_key_t * key, const u8 * data, u8 len)
  57 {
  58   memset (key, 0, sizeof (*key));
  59
  60   if (len > sizeof (key->data))
  61     key->len = sizeof (key->data);
  62   else
  63     key->len = len;
  64
  65   memcpy (key->data, data, key->len);
  66 }
  67
  68 /**
  69  * 'stack' (resolve the recursion for) the SA tunnel destination
  70  */
  71 static void
  72 ipsec_sa_stack (ipsec_sa_t * sa)
  73 {
  74   ipsec_main_t *im = &ipsec_main;
  75   fib_forward_chain_type_t fct;
  76   dpo_id_t tmp = DPO_INVALID;
  77
  78   fct =
  79     fib_forw_chain_type_from_fib_proto ((ipsec_sa_is_set_IS_TUNNEL_V6 (sa) ?
  80                                          FIB_PROTOCOL_IP6 :
  81                                          FIB_PROTOCOL_IP4));
  82
  83   fib_entry_contribute_forwarding (sa->fib_entry_index, fct, &tmp);
  84
  85   if (IPSEC_PROTOCOL_AH == sa->protocol)
  86     dpo_stack_from_node ((ipsec_sa_is_set_IS_TUNNEL_V6 (sa) ?
  87                           im->ah6_encrypt_node_index :
  88                           im->ah4_encrypt_node_index), &sa->dpo, &tmp);
  89   else
  90     dpo_stack_from_node ((ipsec_sa_is_set_IS_TUNNEL_V6 (sa) ?
  91                           im->esp6_encrypt_node_index :
  92                           im->esp4_encrypt_node_index), &sa->dpo, &tmp);
  93   dpo_reset (&tmp);
  94 }
  95
  96 void
  97 ipsec_sa_set_crypto_alg (ipsec_sa_t * sa, ipsec_crypto_alg_t crypto_alg)
  98 {
  99   ipsec_main_t *im = &ipsec_main;
 100   sa->crypto_alg = crypto_alg;
 101   sa->crypto_iv_size = im->crypto_algs[crypto_alg].iv_size;
 102   sa->esp_block_align = clib_max (4, im->crypto_algs[crypto_alg].block_align);
 103   sa->sync_op_data.crypto_enc_op_id = im->crypto_algs[crypto_alg].enc_op_id;
 104   sa->sync_op_data.crypto_dec_op_id = im->crypto_algs[crypto_alg].dec_op_id;
 105   sa->crypto_calg = im->crypto_algs[crypto_alg].alg;
 106   ASSERT (sa->crypto_iv_size <= ESP_MAX_IV_SIZE);
 107   ASSERT (sa->esp_block_align <= ESP_MAX_BLOCK_SIZE);
 108   if (IPSEC_CRYPTO_ALG_IS_GCM (crypto_alg))
 109     {
 110       sa->integ_icv_size = im->crypto_algs[crypto_alg].icv_size;
 111       ipsec_sa_set_IS_AEAD (sa);
 112     }
 113 }
 114
 115 void
 116 ipsec_sa_set_integ_alg (ipsec_sa_t * sa, ipsec_integ_alg_t integ_alg)
 117 {
 118   ipsec_main_t *im = &ipsec_main;
 119   sa->integ_alg = integ_alg;
 120   sa->integ_icv_size = im->integ_algs[integ_alg].icv_size;
 121   sa->sync_op_data.integ_op_id = im->integ_algs[integ_alg].op_id;
 122   sa->integ_calg = im->integ_algs[integ_alg].alg;
 123   ASSERT (sa->integ_icv_size <= ESP_MAX_ICV_SIZE);
 124 }
 125
 126 void
 127 ipsec_sa_set_async_op_ids (ipsec_sa_t * sa)
 128 {
 129   /* *INDENT-OFF* */
 130   if (ipsec_sa_is_set_USE_ESN (sa))
 131     {
 132 #define _(n, s, k) \
 133   if( sa->sync_op_data.crypto_enc_op_id == VNET_CRYPTO_OP_##n##_ENC ) \
 134     sa->async_op_data.crypto_async_enc_op_id = \
 135       VNET_CRYPTO_OP_##n##_TAG16_AAD12_ENC; \
 136   if( sa->sync_op_data.crypto_dec_op_id == VNET_CRYPTO_OP_##n##_DEC ) \
 137     sa->async_op_data.crypto_async_dec_op_id = \
 138       VNET_CRYPTO_OP_##n##_TAG16_AAD12_DEC;
 139     foreach_crypto_aead_alg
 140 #undef _
 141     }
 142   else
 143     {
 144 #define _(n, s, k) \
 145   if( sa->sync_op_data.crypto_enc_op_id == VNET_CRYPTO_OP_##n##_ENC ) \
 146     sa->async_op_data.crypto_async_enc_op_id = \
 147       VNET_CRYPTO_OP_##n##_TAG16_AAD8_ENC; \
 148   if( sa->sync_op_data.crypto_dec_op_id == VNET_CRYPTO_OP_##n##_DEC ) \
 149     sa->async_op_data.crypto_async_dec_op_id = \
 150       VNET_CRYPTO_OP_##n##_TAG16_AAD8_DEC;
 151     foreach_crypto_aead_alg
 152 #undef _
 153     }
 154
 155 #define _(c, h, s, k ,d) \
 156   if( sa->sync_op_data.crypto_enc_op_id == VNET_CRYPTO_OP_##c##_ENC && \
 157       sa->sync_op_data.integ_op_id == VNET_CRYPTO_OP_##h##_HMAC) \
 158     sa->async_op_data.crypto_async_enc_op_id = \
 159       VNET_CRYPTO_OP_##c##_##h##_TAG##d##_ENC; \
 160   if( sa->sync_op_data.crypto_dec_op_id == VNET_CRYPTO_OP_##c##_DEC && \
 161       sa->sync_op_data.integ_op_id == VNET_CRYPTO_OP_##h##_HMAC) \
 162     sa->async_op_data.crypto_async_dec_op_id = \
 163       VNET_CRYPTO_OP_##c##_##h##_TAG##d##_DEC;
 164   foreach_crypto_link_async_alg
 165 #undef _
 166   /* *INDENT-ON* */
 167 }
 168
 169 int
 170 ipsec_sa_add_and_lock (u32 id,
 171                        u32 spi,
 172                        ipsec_protocol_t proto,
 173                        ipsec_crypto_alg_t crypto_alg,
 174                        const ipsec_key_t * ck,
 175                        ipsec_integ_alg_t integ_alg,
 176                        const ipsec_key_t * ik,
 177                        ipsec_sa_flags_t flags,
 178                        u32 tx_table_id,
 179                        u32 salt,
 180                        const ip46_address_t * tun_src,
 181                        const ip46_address_t * tun_dst,
 182                        tunnel_encap_decap_flags_t tunnel_flags,
 183                        ip_dscp_t dscp,
 184                        u32 * sa_out_index, u16 src_port, u16 dst_port)
 185 {
 186   vlib_main_t *vm = vlib_get_main ();
 187   ipsec_main_t *im = &ipsec_main;
 188   clib_error_t *err;
 189   ipsec_sa_t *sa;
 190   u32 sa_index;
 191   uword *p;
 192
 193   p = hash_get (im->sa_index_by_sa_id, id);
 194   if (p)
 195     return VNET_API_ERROR_ENTRY_ALREADY_EXISTS;
 196
 197   pool_get_aligned_zero (im->sad, sa, CLIB_CACHE_LINE_BYTES);
 198
 199   fib_node_init (&sa->node, FIB_NODE_TYPE_IPSEC_SA);
 200   fib_node_lock (&sa->node);
 201   sa_index = sa - im->sad;
 202
 203   vlib_validate_combined_counter (&ipsec_sa_counters, sa_index);
 204   vlib_zero_combined_counter (&ipsec_sa_counters, sa_index);
 205
 206   sa->id = id;
 207   sa->spi = spi;
 208   sa->stat_index = sa_index;
 209   sa->protocol = proto;
 210   sa->flags = flags;
 211   sa->tunnel_flags = tunnel_flags;
 212   sa->dscp = dscp;
 213   sa->salt = salt;
 214   sa->encrypt_thread_index = (vlib_num_workers ())? ~0 : 0;
 215   sa->decrypt_thread_index = (vlib_num_workers ())? ~0 : 0;
 216   if (integ_alg != IPSEC_INTEG_ALG_NONE)
 217     {
 218       ipsec_sa_set_integ_alg (sa, integ_alg);
 219       clib_memcpy (&sa->integ_key, ik, sizeof (sa->integ_key));
 220     }
 221   ipsec_sa_set_crypto_alg (sa, crypto_alg);
 222   ipsec_sa_set_async_op_ids (sa);
 223
 224   clib_memcpy (&sa->crypto_key, ck, sizeof (sa->crypto_key));
 225   ip46_address_copy (&sa->tunnel_src_addr, tun_src);
 226   ip46_address_copy (&sa->tunnel_dst_addr, tun_dst);
 227
 228   sa->crypto_key_index = vnet_crypto_key_add (vm,
 229                                               im->crypto_algs[crypto_alg].alg,
 230                                               (u8 *) ck->data, ck->len);
 231   if (~0 == sa->crypto_key_index)
 232     {
 233       pool_put (im->sad, sa);
 234       return VNET_API_ERROR_KEY_LENGTH;
 235     }
 236
 237   if (integ_alg != IPSEC_INTEG_ALG_NONE)
 238     {
 239       sa->integ_key_index = vnet_crypto_key_add (vm,
 240                                                  im->
 241                                                  integ_algs[integ_alg].alg,
 242                                                  (u8 *) ik->data, ik->len);
 243       if (~0 == sa->integ_key_index)
 244         {
 245           pool_put (im->sad, sa);
 246           return VNET_API_ERROR_KEY_LENGTH;
 247         }
 248     }
 249
 250   if (sa->async_op_data.crypto_async_enc_op_id &&
 251       !ipsec_sa_is_set_IS_AEAD (sa))
 252     {                           //AES-CBC & HMAC
 253       sa->async_op_data.linked_key_index =
 254         vnet_crypto_key_add_linked (vm, sa->crypto_key_index,
 255                                     sa->integ_key_index);
 256     }
 257
 258   if (im->async_mode)
 259     sa->crypto_op_data = sa->async_op_data.data;
 260   else
 261     sa->crypto_op_data = sa->sync_op_data.data;
 262
 263   err = ipsec_check_support_cb (im, sa);
 264   if (err)
 265     {
 266       clib_warning ("%s", err->what);
 267       pool_put (im->sad, sa);
 268       return VNET_API_ERROR_UNIMPLEMENTED;
 269     }
 270
 271   err = ipsec_call_add_del_callbacks (im, sa, sa_index, 1);
 272   if (err)
 273     {
 274       pool_put (im->sad, sa);
 275       return VNET_API_ERROR_SYSCALL_ERROR_1;
 276     }
 277
 278   if (ipsec_sa_is_set_IS_TUNNEL (sa) && !ipsec_sa_is_set_IS_INBOUND (sa))
 279     {
 280       fib_protocol_t fproto = (ipsec_sa_is_set_IS_TUNNEL_V6 (sa) ?
 281                                FIB_PROTOCOL_IP6 : FIB_PROTOCOL_IP4);
 282       fib_prefix_t pfx = {
 283         .fp_addr = sa->tunnel_dst_addr,
 284         .fp_len = (ipsec_sa_is_set_IS_TUNNEL_V6 (sa) ? 128 : 32),
 285         .fp_proto = fproto,
 286       };
 287       sa->tx_fib_index = fib_table_find (fproto, tx_table_id);
 288       if (sa->tx_fib_index == ~((u32) 0))
 289         {
 290           pool_put (im->sad, sa);
 291           return VNET_API_ERROR_NO_SUCH_FIB;
 292         }
 293
 294       sa->fib_entry_index = fib_entry_track (sa->tx_fib_index,
 295                                              &pfx,
 296                                              FIB_NODE_TYPE_IPSEC_SA,
 297                                              sa_index, &sa->sibling);
 298       ipsec_sa_stack (sa);
 299
 300       /* generate header templates */
 301       if (ipsec_sa_is_set_IS_TUNNEL_V6 (sa))
 302         {
 303           sa->ip6_hdr.ip_version_traffic_class_and_flow_label = 0x60;
 304           ip6_set_dscp_network_order (&sa->ip6_hdr, sa->dscp);
 305
 306           sa->ip6_hdr.hop_limit = 254;
 307           sa->ip6_hdr.src_address.as_u64[0] =
 308             sa->tunnel_src_addr.ip6.as_u64[0];
 309           sa->ip6_hdr.src_address.as_u64[1] =
 310             sa->tunnel_src_addr.ip6.as_u64[1];
 311           sa->ip6_hdr.dst_address.as_u64[0] =
 312             sa->tunnel_dst_addr.ip6.as_u64[0];
 313           sa->ip6_hdr.dst_address.as_u64[1] =
 314             sa->tunnel_dst_addr.ip6.as_u64[1];
 315           if (ipsec_sa_is_set_UDP_ENCAP (sa))
 316             sa->ip6_hdr.protocol = IP_PROTOCOL_UDP;
 317           else
 318             sa->ip6_hdr.protocol = IP_PROTOCOL_IPSEC_ESP;
 319         }
 320       else
 321         {
 322           sa->ip4_hdr.ip_version_and_header_length = 0x45;
 323           sa->ip4_hdr.ttl = 254;
 324           sa->ip4_hdr.src_address.as_u32 = sa->tunnel_src_addr.ip4.as_u32;
 325           sa->ip4_hdr.dst_address.as_u32 = sa->tunnel_dst_addr.ip4.as_u32;
 326           sa->ip4_hdr.tos = sa->dscp << 2;
 327
 328           if (ipsec_sa_is_set_UDP_ENCAP (sa))
 329             sa->ip4_hdr.protocol = IP_PROTOCOL_UDP;
 330           else
 331             sa->ip4_hdr.protocol = IP_PROTOCOL_IPSEC_ESP;
 332           sa->ip4_hdr.checksum = ip4_header_checksum (&sa->ip4_hdr);
 333         }
 334     }
 335
 336   if (ipsec_sa_is_set_UDP_ENCAP (sa))
 337     {
 338       if (dst_port == IPSEC_UDP_PORT_NONE)
 339         sa->udp_hdr.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_ipsec);
 340       else
 341         sa->udp_hdr.dst_port = clib_host_to_net_u16 (dst_port);
 342
 343       if (src_port == IPSEC_UDP_PORT_NONE)
 344         sa->udp_hdr.src_port = clib_host_to_net_u16 (UDP_DST_PORT_ipsec);
 345       else
 346         sa->udp_hdr.src_port = clib_host_to_net_u16 (src_port);
 347
 348       if (ipsec_sa_is_set_IS_INBOUND (sa))
 349         ipsec_register_udp_port (clib_host_to_net_u16 (sa->udp_hdr.dst_port));
 350     }
 351
 352   hash_set (im->sa_index_by_sa_id, sa->id, sa_index);
 353
 354   if (sa_out_index)
 355     *sa_out_index = sa_index;
 356
 357   return (0);
 358 }
 359
 360 static void
 361 ipsec_sa_del (ipsec_sa_t * sa)
 362 {
 363   vlib_main_t *vm = vlib_get_main ();
 364   ipsec_main_t *im = &ipsec_main;
 365   u32 sa_index;
 366
 367   sa_index = sa - im->sad;
 368   hash_unset (im->sa_index_by_sa_id, sa->id);
 369
 370   /* no recovery possible when deleting an SA */
 371   (void) ipsec_call_add_del_callbacks (im, sa, sa_index, 0);
 372
 373   if (ipsec_sa_is_set_UDP_ENCAP (sa) && ipsec_sa_is_set_IS_INBOUND (sa))
 374     ipsec_unregister_udp_port (clib_net_to_host_u16 (sa->udp_hdr.dst_port));
 375
 376   if (ipsec_sa_is_set_IS_TUNNEL (sa) && !ipsec_sa_is_set_IS_INBOUND (sa))
 377     {
 378       fib_entry_untrack (sa->fib_entry_index, sa->sibling);
 379       dpo_reset (&sa->dpo);
 380     }
 381   vnet_crypto_key_del (vm, sa->crypto_key_index);
 382   if (sa->integ_alg != IPSEC_INTEG_ALG_NONE)
 383     vnet_crypto_key_del (vm, sa->integ_key_index);
 384   pool_put (im->sad, sa);
 385 }
 386
 387 void
 388 ipsec_sa_unlock (index_t sai)
 389 {
 390   ipsec_main_t *im = &ipsec_main;
 391   ipsec_sa_t *sa;
 392
 393   if (INDEX_INVALID == sai)
 394     return;
 395
 396   sa = pool_elt_at_index (im->sad, sai);
 397
 398   fib_node_unlock (&sa->node);
 399 }
 400
 401 void
 402 ipsec_sa_lock (index_t sai)
 403 {
 404   ipsec_main_t *im = &ipsec_main;
 405   ipsec_sa_t *sa;
 406
 407   if (INDEX_INVALID == sai)
 408     return;
 409
 410   sa = pool_elt_at_index (im->sad, sai);
 411
 412   fib_node_lock (&sa->node);
 413 }
 414
 415 index_t
 416 ipsec_sa_find_and_lock (u32 id)
 417 {
 418   ipsec_main_t *im = &ipsec_main;
 419   ipsec_sa_t *sa;
 420   uword *p;
 421
 422   p = hash_get (im->sa_index_by_sa_id, id);
 423
 424   if (!p)
 425     return INDEX_INVALID;
 426
 427   sa = pool_elt_at_index (im->sad, p[0]);
 428
 429   fib_node_lock (&sa->node);
 430
 431   return (p[0]);
 432 }
 433
 434 int
 435 ipsec_sa_unlock_id (u32 id)
 436 {
 437   ipsec_main_t *im = &ipsec_main;
 438   uword *p;
 439
 440   p = hash_get (im->sa_index_by_sa_id, id);
 441
 442   if (!p)
 443     return VNET_API_ERROR_NO_SUCH_ENTRY;
 444
 445   ipsec_sa_unlock (p[0]);
 446
 447   return (0);
 448 }
 449
 450 void
 451 ipsec_sa_clear (index_t sai)
 452 {
 453   vlib_zero_combined_counter (&ipsec_sa_counters, sai);
 454 }
 455
 456 void
 457 ipsec_sa_walk (ipsec_sa_walk_cb_t cb, void *ctx)
 458 {
 459   ipsec_main_t *im = &ipsec_main;
 460   ipsec_sa_t *sa;
 461
 462   /* *INDENT-OFF* */
 463   pool_foreach (sa, im->sad,
 464   ({
 465     if (WALK_CONTINUE != cb(sa, ctx))
 466       break;
 467   }));
 468   /* *INDENT-ON* */
 469 }
 470
 471 /**
 472  * Function definition to get a FIB node from its index
 473  */
 474 static fib_node_t *
 475 ipsec_sa_fib_node_get (fib_node_index_t index)
 476 {
 477   ipsec_main_t *im;
 478   ipsec_sa_t *sa;
 479
 480   im = &ipsec_main;
 481   sa = pool_elt_at_index (im->sad, index);
 482
 483   return (&sa->node);
 484 }
 485
 486 static ipsec_sa_t *
 487 ipsec_sa_from_fib_node (fib_node_t * node)
 488 {
 489   ASSERT (FIB_NODE_TYPE_IPSEC_SA == node->fn_type);
 490   return ((ipsec_sa_t *) (((char *) node) -
 491                           STRUCT_OFFSET_OF (ipsec_sa_t, node)));
 492
 493 }
 494
 495 /**
 496  * Function definition to inform the FIB node that its last lock has gone.
 497  */
 498 static void
 499 ipsec_sa_last_lock_gone (fib_node_t * node)
 500 {
 501   /*
 502    * The ipsec SA is a root of the graph. As such
 503    * it never has children and thus is never locked.
 504    */
 505   ipsec_sa_del (ipsec_sa_from_fib_node (node));
 506 }
 507
 508 /**
 509  * Function definition to backwalk a FIB node
 510  */
 511 static fib_node_back_walk_rc_t
 512 ipsec_sa_back_walk (fib_node_t * node, fib_node_back_walk_ctx_t * ctx)
 513 {
 514   ipsec_sa_stack (ipsec_sa_from_fib_node (node));
 515
 516   return (FIB_NODE_BACK_WALK_CONTINUE);
 517 }
 518
 519 /*
 520  * Virtual function table registered by SAs
 521  * for participation in the FIB object graph.
 522  */
 523 const static fib_node_vft_t ipsec_sa_vft = {
 524   .fnv_get = ipsec_sa_fib_node_get,
 525   .fnv_last_lock = ipsec_sa_last_lock_gone,
 526   .fnv_back_walk = ipsec_sa_back_walk,
 527 };
 528
 529 /* force inclusion from application's main.c */
 530 clib_error_t *
 531 ipsec_sa_interface_init (vlib_main_t * vm)
 532 {
 533   fib_node_register_type (FIB_NODE_TYPE_IPSEC_SA, &ipsec_sa_vft);
 534
 535   return 0;
 536 }
 537
 538 VLIB_INIT_FUNCTION (ipsec_sa_interface_init);
 539
 540 /*
 541  * fd.io coding-style-patch-verification: ON
 542  *
 543  * Local Variables:
 544  * eval: (c-set-style "gnu")
 545  * End:
 546  */