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->thread_index = (vlib_num_workers ()) ? ~0 : 0;
 215   if (integ_alg != IPSEC_INTEG_ALG_NONE)
 216     {
 217       ipsec_sa_set_integ_alg (sa, integ_alg);
 218       clib_memcpy (&sa->integ_key, ik, sizeof (sa->integ_key));
 219     }
 220   ipsec_sa_set_crypto_alg (sa, crypto_alg);
 221   ipsec_sa_set_async_op_ids (sa);
 222
 223   clib_memcpy (&sa->crypto_key, ck, sizeof (sa->crypto_key));
 224   ip46_address_copy (&sa->tunnel_src_addr, tun_src);
 225   ip46_address_copy (&sa->tunnel_dst_addr, tun_dst);
 226
 227   sa->crypto_key_index = vnet_crypto_key_add (vm,
 228                                               im->crypto_algs[crypto_alg].alg,
 229                                               (u8 *) ck->data, ck->len);
 230   if (~0 == sa->crypto_key_index)
 231     {
 232       pool_put (im->sad, sa);
 233       return VNET_API_ERROR_KEY_LENGTH;
 234     }
 235
 236   if (integ_alg != IPSEC_INTEG_ALG_NONE)
 237     {
 238       sa->integ_key_index = vnet_crypto_key_add (vm,
 239                                                  im->
 240                                                  integ_algs[integ_alg].alg,
 241                                                  (u8 *) ik->data, ik->len);
 242       if (~0 == sa->integ_key_index)
 243         {
 244           pool_put (im->sad, sa);
 245           return VNET_API_ERROR_KEY_LENGTH;
 246         }
 247     }
 248
 249   if (sa->async_op_data.crypto_async_enc_op_id &&
 250       !ipsec_sa_is_set_IS_AEAD (sa))
 251     {                           //AES-CBC & HMAC
 252       sa->async_op_data.linked_key_index =
 253         vnet_crypto_key_add_linked (vm, sa->crypto_key_index,
 254                                     sa->integ_key_index);
 255     }
 256
 257   if (im->async_mode)
 258     sa->crypto_op_data = sa->async_op_data.data;
 259   else
 260     sa->crypto_op_data = sa->sync_op_data.data;
 261
 262   err = ipsec_check_support_cb (im, sa);
 263   if (err)
 264     {
 265       clib_warning ("%s", err->what);
 266       pool_put (im->sad, sa);
 267       return VNET_API_ERROR_UNIMPLEMENTED;
 268     }
 269
 270   err = ipsec_call_add_del_callbacks (im, sa, sa_index, 1);
 271   if (err)
 272     {
 273       pool_put (im->sad, sa);
 274       return VNET_API_ERROR_SYSCALL_ERROR_1;
 275     }
 276
 277   if (ipsec_sa_is_set_IS_TUNNEL (sa) && !ipsec_sa_is_set_IS_INBOUND (sa))
 278     {
 279       fib_protocol_t fproto = (ipsec_sa_is_set_IS_TUNNEL_V6 (sa) ?
 280                                FIB_PROTOCOL_IP6 : FIB_PROTOCOL_IP4);
 281       fib_prefix_t pfx = {
 282         .fp_addr = sa->tunnel_dst_addr,
 283         .fp_len = (ipsec_sa_is_set_IS_TUNNEL_V6 (sa) ? 128 : 32),
 284         .fp_proto = fproto,
 285       };
 286       sa->tx_fib_index = fib_table_find (fproto, tx_table_id);
 287       if (sa->tx_fib_index == ~((u32) 0))
 288         {
 289           pool_put (im->sad, sa);
 290           return VNET_API_ERROR_NO_SUCH_FIB;
 291         }
 292
 293       sa->fib_entry_index = fib_entry_track (sa->tx_fib_index,
 294                                              &pfx,
 295                                              FIB_NODE_TYPE_IPSEC_SA,
 296                                              sa_index, &sa->sibling);
 297       ipsec_sa_stack (sa);
 298
 299       /* generate header templates */
 300       if (ipsec_sa_is_set_IS_TUNNEL_V6 (sa))
 301         {
 302           sa->ip6_hdr.ip_version_traffic_class_and_flow_label = 0x60;
 303           ip6_set_dscp_network_order (&sa->ip6_hdr, sa->dscp);
 304
 305           sa->ip6_hdr.hop_limit = 254;
 306           sa->ip6_hdr.src_address.as_u64[0] =
 307             sa->tunnel_src_addr.ip6.as_u64[0];
 308           sa->ip6_hdr.src_address.as_u64[1] =
 309             sa->tunnel_src_addr.ip6.as_u64[1];
 310           sa->ip6_hdr.dst_address.as_u64[0] =
 311             sa->tunnel_dst_addr.ip6.as_u64[0];
 312           sa->ip6_hdr.dst_address.as_u64[1] =
 313             sa->tunnel_dst_addr.ip6.as_u64[1];
 314           if (ipsec_sa_is_set_UDP_ENCAP (sa))
 315             sa->ip6_hdr.protocol = IP_PROTOCOL_UDP;
 316           else
 317             sa->ip6_hdr.protocol = IP_PROTOCOL_IPSEC_ESP;
 318         }
 319       else
 320         {
 321           sa->ip4_hdr.ip_version_and_header_length = 0x45;
 322           sa->ip4_hdr.ttl = 254;
 323           sa->ip4_hdr.src_address.as_u32 = sa->tunnel_src_addr.ip4.as_u32;
 324           sa->ip4_hdr.dst_address.as_u32 = sa->tunnel_dst_addr.ip4.as_u32;
 325           sa->ip4_hdr.tos = sa->dscp << 2;
 326
 327           if (ipsec_sa_is_set_UDP_ENCAP (sa))
 328             sa->ip4_hdr.protocol = IP_PROTOCOL_UDP;
 329           else
 330             sa->ip4_hdr.protocol = IP_PROTOCOL_IPSEC_ESP;
 331           sa->ip4_hdr.checksum = ip4_header_checksum (&sa->ip4_hdr);
 332         }
 333     }
 334
 335   if (ipsec_sa_is_set_UDP_ENCAP (sa))
 336     {
 337       if (dst_port == IPSEC_UDP_PORT_NONE)
 338         sa->udp_hdr.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_ipsec);
 339       else
 340         sa->udp_hdr.dst_port = clib_host_to_net_u16 (dst_port);
 341
 342       if (src_port == IPSEC_UDP_PORT_NONE)
 343         sa->udp_hdr.src_port = clib_host_to_net_u16 (UDP_DST_PORT_ipsec);
 344       else
 345         sa->udp_hdr.src_port = clib_host_to_net_u16 (src_port);
 346
 347       if (ipsec_sa_is_set_IS_INBOUND (sa))
 348         ipsec_register_udp_port (clib_host_to_net_u16 (sa->udp_hdr.dst_port));
 349     }
 350
 351   hash_set (im->sa_index_by_sa_id, sa->id, sa_index);
 352
 353   if (sa_out_index)
 354     *sa_out_index = sa_index;
 355
 356   return (0);
 357 }
 358
 359 static void
 360 ipsec_sa_del (ipsec_sa_t * sa)
 361 {
 362   vlib_main_t *vm = vlib_get_main ();
 363   ipsec_main_t *im = &ipsec_main;
 364   u32 sa_index;
 365
 366   sa_index = sa - im->sad;
 367   hash_unset (im->sa_index_by_sa_id, sa->id);
 368
 369   /* no recovery possible when deleting an SA */
 370   (void) ipsec_call_add_del_callbacks (im, sa, sa_index, 0);
 371
 372   if (ipsec_sa_is_set_UDP_ENCAP (sa) && ipsec_sa_is_set_IS_INBOUND (sa))
 373     ipsec_unregister_udp_port (clib_net_to_host_u16 (sa->udp_hdr.dst_port));
 374
 375   if (ipsec_sa_is_set_IS_TUNNEL (sa) && !ipsec_sa_is_set_IS_INBOUND (sa))
 376     {
 377       fib_entry_untrack (sa->fib_entry_index, sa->sibling);
 378       dpo_reset (&sa->dpo);
 379     }
 380   vnet_crypto_key_del (vm, sa->crypto_key_index);
 381   if (sa->integ_alg != IPSEC_INTEG_ALG_NONE)
 382     vnet_crypto_key_del (vm, sa->integ_key_index);
 383   pool_put (im->sad, sa);
 384 }
 385
 386 void
 387 ipsec_sa_unlock (index_t sai)
 388 {
 389   ipsec_main_t *im = &ipsec_main;
 390   ipsec_sa_t *sa;
 391
 392   if (INDEX_INVALID == sai)
 393     return;
 394
 395   sa = pool_elt_at_index (im->sad, sai);
 396
 397   fib_node_unlock (&sa->node);
 398 }
 399
 400 void
 401 ipsec_sa_lock (index_t sai)
 402 {
 403   ipsec_main_t *im = &ipsec_main;
 404   ipsec_sa_t *sa;
 405
 406   if (INDEX_INVALID == sai)
 407     return;
 408
 409   sa = pool_elt_at_index (im->sad, sai);
 410
 411   fib_node_lock (&sa->node);
 412 }
 413
 414 index_t
 415 ipsec_sa_find_and_lock (u32 id)
 416 {
 417   ipsec_main_t *im = &ipsec_main;
 418   ipsec_sa_t *sa;
 419   uword *p;
 420
 421   p = hash_get (im->sa_index_by_sa_id, id);
 422
 423   if (!p)
 424     return INDEX_INVALID;
 425
 426   sa = pool_elt_at_index (im->sad, p[0]);
 427
 428   fib_node_lock (&sa->node);
 429
 430   return (p[0]);
 431 }
 432
 433 int
 434 ipsec_sa_unlock_id (u32 id)
 435 {
 436   ipsec_main_t *im = &ipsec_main;
 437   uword *p;
 438
 439   p = hash_get (im->sa_index_by_sa_id, id);
 440
 441   if (!p)
 442     return VNET_API_ERROR_NO_SUCH_ENTRY;
 443
 444   ipsec_sa_unlock (p[0]);
 445
 446   return (0);
 447 }
 448
 449 void
 450 ipsec_sa_clear (index_t sai)
 451 {
 452   vlib_zero_combined_counter (&ipsec_sa_counters, sai);
 453 }
 454
 455 void
 456 ipsec_sa_walk (ipsec_sa_walk_cb_t cb, void *ctx)
 457 {
 458   ipsec_main_t *im = &ipsec_main;
 459   ipsec_sa_t *sa;
 460
 461   /* *INDENT-OFF* */
 462   pool_foreach (sa, im->sad)
 463    {
 464     if (WALK_CONTINUE != cb(sa, ctx))
 465       break;
 466   }
 467   /* *INDENT-ON* */
 468 }
 469
 470 /**
 471  * Function definition to get a FIB node from its index
 472  */
 473 static fib_node_t *
 474 ipsec_sa_fib_node_get (fib_node_index_t index)
 475 {
 476   ipsec_main_t *im;
 477   ipsec_sa_t *sa;
 478
 479   im = &ipsec_main;
 480   sa = pool_elt_at_index (im->sad, index);
 481
 482   return (&sa->node);
 483 }
 484
 485 static ipsec_sa_t *
 486 ipsec_sa_from_fib_node (fib_node_t * node)
 487 {
 488   ASSERT (FIB_NODE_TYPE_IPSEC_SA == node->fn_type);
 489   return ((ipsec_sa_t *) (((char *) node) -
 490                           STRUCT_OFFSET_OF (ipsec_sa_t, node)));
 491
 492 }
 493
 494 /**
 495  * Function definition to inform the FIB node that its last lock has gone.
 496  */
 497 static void
 498 ipsec_sa_last_lock_gone (fib_node_t * node)
 499 {
 500   /*
 501    * The ipsec SA is a root of the graph. As such
 502    * it never has children and thus is never locked.
 503    */
 504   ipsec_sa_del (ipsec_sa_from_fib_node (node));
 505 }
 506
 507 /**
 508  * Function definition to backwalk a FIB node
 509  */
 510 static fib_node_back_walk_rc_t
 511 ipsec_sa_back_walk (fib_node_t * node, fib_node_back_walk_ctx_t * ctx)
 512 {
 513   ipsec_sa_stack (ipsec_sa_from_fib_node (node));
 514
 515   return (FIB_NODE_BACK_WALK_CONTINUE);
 516 }
 517
 518 /*
 519  * Virtual function table registered by SAs
 520  * for participation in the FIB object graph.
 521  */
 522 const static fib_node_vft_t ipsec_sa_vft = {
 523   .fnv_get = ipsec_sa_fib_node_get,
 524   .fnv_last_lock = ipsec_sa_last_lock_gone,
 525   .fnv_back_walk = ipsec_sa_back_walk,
 526 };
 527
 528 /* force inclusion from application's main.c */
 529 clib_error_t *
 530 ipsec_sa_interface_init (vlib_main_t * vm)
 531 {
 532   fib_node_register_type (FIB_NODE_TYPE_IPSEC_SA, &ipsec_sa_vft);
 533
 534   return 0;
 535 }
 536
 537 VLIB_INIT_FUNCTION (ipsec_sa_interface_init);
 538
 539 /*
 540  * fd.io coding-style-patch-verification: ON
 541  *
 542  * Local Variables:
 543  * eval: (c-set-style "gnu")
 544  * End:
 545  */