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 ipsec_sa_t *ipsec_sa_pool;
  33
  34 static clib_error_t *
  35 ipsec_call_add_del_callbacks (ipsec_main_t * im, ipsec_sa_t * sa,
  36                               u32 sa_index, int is_add)
  37 {
  38   ipsec_ah_backend_t *ab;
  39   ipsec_esp_backend_t *eb;
  40   switch (sa->protocol)
  41     {
  42     case IPSEC_PROTOCOL_AH:
  43       ab = pool_elt_at_index (im->ah_backends, im->ah_current_backend);
  44       if (ab->add_del_sa_sess_cb)
  45         return ab->add_del_sa_sess_cb (sa_index, is_add);
  46       break;
  47     case IPSEC_PROTOCOL_ESP:
  48       eb = pool_elt_at_index (im->esp_backends, im->esp_current_backend);
  49       if (eb->add_del_sa_sess_cb)
  50         return eb->add_del_sa_sess_cb (sa_index, is_add);
  51       break;
  52     }
  53   return 0;
  54 }
  55
  56 void
  57 ipsec_mk_key (ipsec_key_t * key, const u8 * data, u8 len)
  58 {
  59   memset (key, 0, sizeof (*key));
  60
  61   if (len > sizeof (key->data))
  62     key->len = sizeof (key->data);
  63   else
  64     key->len = len;
  65
  66   memcpy (key->data, data, key->len);
  67 }
  68
  69 /**
  70  * 'stack' (resolve the recursion for) the SA tunnel destination
  71  */
  72 static void
  73 ipsec_sa_stack (ipsec_sa_t * sa)
  74 {
  75   ipsec_main_t *im = &ipsec_main;
  76   dpo_id_t tmp = DPO_INVALID;
  77
  78   tunnel_contribute_forwarding (&sa->tunnel, &tmp);
  79
  80   if (IPSEC_PROTOCOL_AH == sa->protocol)
  81     dpo_stack_from_node ((ipsec_sa_is_set_IS_TUNNEL_V6 (sa) ?
  82                           im->ah6_encrypt_node_index :
  83                           im->ah4_encrypt_node_index), &sa->dpo, &tmp);
  84   else
  85     dpo_stack_from_node ((ipsec_sa_is_set_IS_TUNNEL_V6 (sa) ?
  86                           im->esp6_encrypt_node_index :
  87                           im->esp4_encrypt_node_index), &sa->dpo, &tmp);
  88   dpo_reset (&tmp);
  89 }
  90
  91 void
  92 ipsec_sa_set_crypto_alg (ipsec_sa_t * sa, ipsec_crypto_alg_t crypto_alg)
  93 {
  94   ipsec_main_t *im = &ipsec_main;
  95   sa->crypto_alg = crypto_alg;
  96   sa->crypto_iv_size = im->crypto_algs[crypto_alg].iv_size;
  97   sa->esp_block_align = clib_max (4, im->crypto_algs[crypto_alg].block_align);
  98   sa->sync_op_data.crypto_enc_op_id = im->crypto_algs[crypto_alg].enc_op_id;
  99   sa->sync_op_data.crypto_dec_op_id = im->crypto_algs[crypto_alg].dec_op_id;
 100   sa->crypto_calg = im->crypto_algs[crypto_alg].alg;
 101   ASSERT (sa->crypto_iv_size <= ESP_MAX_IV_SIZE);
 102   ASSERT (sa->esp_block_align <= ESP_MAX_BLOCK_SIZE);
 103   if (IPSEC_CRYPTO_ALG_IS_GCM (crypto_alg))
 104     {
 105       sa->integ_icv_size = im->crypto_algs[crypto_alg].icv_size;
 106       ipsec_sa_set_IS_CTR (sa);
 107       ipsec_sa_set_IS_AEAD (sa);
 108     }
 109   else if (IPSEC_CRYPTO_ALG_IS_CTR (crypto_alg))
 110     {
 111       ipsec_sa_set_IS_CTR (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, u32 spi, ipsec_protocol_t proto,
 171                        ipsec_crypto_alg_t crypto_alg, const ipsec_key_t *ck,
 172                        ipsec_integ_alg_t integ_alg, const ipsec_key_t *ik,
 173                        ipsec_sa_flags_t flags, u32 salt, u16 src_port,
 174                        u16 dst_port, const tunnel_t *tun, u32 *sa_out_index)
 175 {
 176   vlib_main_t *vm = vlib_get_main ();
 177   ipsec_main_t *im = &ipsec_main;
 178   clib_error_t *err;
 179   ipsec_sa_t *sa;
 180   u32 sa_index;
 181   uword *p;
 182   int rv;
 183
 184   p = hash_get (im->sa_index_by_sa_id, id);
 185   if (p)
 186     return VNET_API_ERROR_ENTRY_ALREADY_EXISTS;
 187
 188   pool_get_aligned_zero (ipsec_sa_pool, sa, CLIB_CACHE_LINE_BYTES);
 189
 190   fib_node_init (&sa->node, FIB_NODE_TYPE_IPSEC_SA);
 191   fib_node_lock (&sa->node);
 192   sa_index = sa - ipsec_sa_pool;
 193
 194   vlib_validate_combined_counter (&ipsec_sa_counters, sa_index);
 195   vlib_zero_combined_counter (&ipsec_sa_counters, sa_index);
 196
 197   tunnel_copy (tun, &sa->tunnel);
 198   sa->id = id;
 199   sa->spi = spi;
 200   sa->stat_index = sa_index;
 201   sa->protocol = proto;
 202   sa->flags = flags;
 203   sa->salt = salt;
 204   sa->thread_index = (vlib_num_workers ()) ? ~0 : 0;
 205   if (integ_alg != IPSEC_INTEG_ALG_NONE)
 206     {
 207       ipsec_sa_set_integ_alg (sa, integ_alg);
 208       clib_memcpy (&sa->integ_key, ik, sizeof (sa->integ_key));
 209     }
 210   ipsec_sa_set_crypto_alg (sa, crypto_alg);
 211   ipsec_sa_set_async_op_ids (sa);
 212
 213   clib_memcpy (&sa->crypto_key, ck, sizeof (sa->crypto_key));
 214
 215   sa->crypto_key_index = vnet_crypto_key_add (vm,
 216                                               im->crypto_algs[crypto_alg].alg,
 217                                               (u8 *) ck->data, ck->len);
 218   if (~0 == sa->crypto_key_index)
 219     {
 220       pool_put (ipsec_sa_pool, sa);
 221       return VNET_API_ERROR_KEY_LENGTH;
 222     }
 223
 224   if (integ_alg != IPSEC_INTEG_ALG_NONE)
 225     {
 226       sa->integ_key_index = vnet_crypto_key_add (vm,
 227                                                  im->
 228                                                  integ_algs[integ_alg].alg,
 229                                                  (u8 *) ik->data, ik->len);
 230       if (~0 == sa->integ_key_index)
 231         {
 232           pool_put (ipsec_sa_pool, sa);
 233           return VNET_API_ERROR_KEY_LENGTH;
 234         }
 235     }
 236
 237   if (sa->async_op_data.crypto_async_enc_op_id &&
 238       !ipsec_sa_is_set_IS_AEAD (sa))
 239     {                           //AES-CBC & HMAC
 240       sa->async_op_data.linked_key_index =
 241         vnet_crypto_key_add_linked (vm, sa->crypto_key_index,
 242                                     sa->integ_key_index);
 243     }
 244
 245   if (im->async_mode)
 246     sa->crypto_op_data = sa->async_op_data.data;
 247   else
 248     sa->crypto_op_data = sa->sync_op_data.data;
 249
 250   err = ipsec_check_support_cb (im, sa);
 251   if (err)
 252     {
 253       clib_warning ("%s", err->what);
 254       pool_put (ipsec_sa_pool, sa);
 255       return VNET_API_ERROR_UNIMPLEMENTED;
 256     }
 257
 258   err = ipsec_call_add_del_callbacks (im, sa, sa_index, 1);
 259   if (err)
 260     {
 261       pool_put (ipsec_sa_pool, sa);
 262       return VNET_API_ERROR_SYSCALL_ERROR_1;
 263     }
 264
 265   if (ipsec_sa_is_set_IS_TUNNEL (sa) && !ipsec_sa_is_set_IS_INBOUND (sa))
 266     {
 267       sa->tunnel_flags = sa->tunnel.t_encap_decap_flags;
 268
 269       rv = tunnel_resolve (&sa->tunnel, FIB_NODE_TYPE_IPSEC_SA, sa_index);
 270
 271       if (rv)
 272         {
 273           pool_put (ipsec_sa_pool, sa);
 274           return rv;
 275         }
 276       ipsec_sa_stack (sa);
 277
 278       /* generate header templates */
 279       if (ipsec_sa_is_set_IS_TUNNEL_V6 (sa))
 280         {
 281           tunnel_build_v6_hdr (&sa->tunnel,
 282                                (ipsec_sa_is_set_UDP_ENCAP (sa) ?
 283                                   IP_PROTOCOL_UDP :
 284                                   IP_PROTOCOL_IPSEC_ESP),
 285                                &sa->ip6_hdr);
 286         }
 287       else
 288         {
 289           tunnel_build_v4_hdr (&sa->tunnel,
 290                                (ipsec_sa_is_set_UDP_ENCAP (sa) ?
 291                                   IP_PROTOCOL_UDP :
 292                                   IP_PROTOCOL_IPSEC_ESP),
 293                                &sa->ip4_hdr);
 294         }
 295     }
 296
 297   if (ipsec_sa_is_set_UDP_ENCAP (sa))
 298     {
 299       if (dst_port == IPSEC_UDP_PORT_NONE)
 300         sa->udp_hdr.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_ipsec);
 301       else
 302         sa->udp_hdr.dst_port = clib_host_to_net_u16 (dst_port);
 303
 304       if (src_port == IPSEC_UDP_PORT_NONE)
 305         sa->udp_hdr.src_port = clib_host_to_net_u16 (UDP_DST_PORT_ipsec);
 306       else
 307         sa->udp_hdr.src_port = clib_host_to_net_u16 (src_port);
 308
 309       if (ipsec_sa_is_set_IS_INBOUND (sa))
 310         ipsec_register_udp_port (clib_host_to_net_u16 (sa->udp_hdr.dst_port));
 311     }
 312
 313   hash_set (im->sa_index_by_sa_id, sa->id, sa_index);
 314
 315   if (sa_out_index)
 316     *sa_out_index = sa_index;
 317
 318   return (0);
 319 }
 320
 321 static void
 322 ipsec_sa_del (ipsec_sa_t * sa)
 323 {
 324   vlib_main_t *vm = vlib_get_main ();
 325   ipsec_main_t *im = &ipsec_main;
 326   u32 sa_index;
 327
 328   sa_index = sa - ipsec_sa_pool;
 329   hash_unset (im->sa_index_by_sa_id, sa->id);
 330   tunnel_unresolve (&sa->tunnel);
 331
 332   /* no recovery possible when deleting an SA */
 333   (void) ipsec_call_add_del_callbacks (im, sa, sa_index, 0);
 334
 335   if (ipsec_sa_is_set_UDP_ENCAP (sa) && ipsec_sa_is_set_IS_INBOUND (sa))
 336     ipsec_unregister_udp_port (clib_net_to_host_u16 (sa->udp_hdr.dst_port));
 337
 338   if (ipsec_sa_is_set_IS_TUNNEL (sa) && !ipsec_sa_is_set_IS_INBOUND (sa))
 339     dpo_reset (&sa->dpo);
 340   vnet_crypto_key_del (vm, sa->crypto_key_index);
 341   if (sa->integ_alg != IPSEC_INTEG_ALG_NONE)
 342     vnet_crypto_key_del (vm, sa->integ_key_index);
 343   pool_put (ipsec_sa_pool, sa);
 344 }
 345
 346 void
 347 ipsec_sa_unlock (index_t sai)
 348 {
 349   ipsec_sa_t *sa;
 350
 351   if (INDEX_INVALID == sai)
 352     return;
 353
 354   sa = ipsec_sa_get (sai);
 355
 356   fib_node_unlock (&sa->node);
 357 }
 358
 359 void
 360 ipsec_sa_lock (index_t sai)
 361 {
 362   ipsec_sa_t *sa;
 363
 364   if (INDEX_INVALID == sai)
 365     return;
 366
 367   sa = ipsec_sa_get (sai);
 368
 369   fib_node_lock (&sa->node);
 370 }
 371
 372 index_t
 373 ipsec_sa_find_and_lock (u32 id)
 374 {
 375   ipsec_main_t *im = &ipsec_main;
 376   ipsec_sa_t *sa;
 377   uword *p;
 378
 379   p = hash_get (im->sa_index_by_sa_id, id);
 380
 381   if (!p)
 382     return INDEX_INVALID;
 383
 384   sa = ipsec_sa_get (p[0]);
 385
 386   fib_node_lock (&sa->node);
 387
 388   return (p[0]);
 389 }
 390
 391 int
 392 ipsec_sa_unlock_id (u32 id)
 393 {
 394   ipsec_main_t *im = &ipsec_main;
 395   uword *p;
 396
 397   p = hash_get (im->sa_index_by_sa_id, id);
 398
 399   if (!p)
 400     return VNET_API_ERROR_NO_SUCH_ENTRY;
 401
 402   ipsec_sa_unlock (p[0]);
 403
 404   return (0);
 405 }
 406
 407 void
 408 ipsec_sa_clear (index_t sai)
 409 {
 410   vlib_zero_combined_counter (&ipsec_sa_counters, sai);
 411 }
 412
 413 void
 414 ipsec_sa_walk (ipsec_sa_walk_cb_t cb, void *ctx)
 415 {
 416   ipsec_sa_t *sa;
 417
 418   /* *INDENT-OFF* */
 419   pool_foreach (sa, ipsec_sa_pool)
 420     {
 421       if (WALK_CONTINUE != cb (sa, ctx))
 422         break;
 423     }
 424   /* *INDENT-ON* */
 425 }
 426
 427 /**
 428  * Function definition to get a FIB node from its index
 429  */
 430 static fib_node_t *
 431 ipsec_sa_fib_node_get (fib_node_index_t index)
 432 {
 433   ipsec_sa_t *sa;
 434
 435   sa = ipsec_sa_get (index);
 436
 437   return (&sa->node);
 438 }
 439
 440 static ipsec_sa_t *
 441 ipsec_sa_from_fib_node (fib_node_t * node)
 442 {
 443   ASSERT (FIB_NODE_TYPE_IPSEC_SA == node->fn_type);
 444   return ((ipsec_sa_t *) (((char *) node) -
 445                           STRUCT_OFFSET_OF (ipsec_sa_t, node)));
 446
 447 }
 448
 449 /**
 450  * Function definition to inform the FIB node that its last lock has gone.
 451  */
 452 static void
 453 ipsec_sa_last_lock_gone (fib_node_t * node)
 454 {
 455   /*
 456    * The ipsec SA is a root of the graph. As such
 457    * it never has children and thus is never locked.
 458    */
 459   ipsec_sa_del (ipsec_sa_from_fib_node (node));
 460 }
 461
 462 /**
 463  * Function definition to backwalk a FIB node
 464  */
 465 static fib_node_back_walk_rc_t
 466 ipsec_sa_back_walk (fib_node_t * node, fib_node_back_walk_ctx_t * ctx)
 467 {
 468   ipsec_sa_stack (ipsec_sa_from_fib_node (node));
 469
 470   return (FIB_NODE_BACK_WALK_CONTINUE);
 471 }
 472
 473 /*
 474  * Virtual function table registered by SAs
 475  * for participation in the FIB object graph.
 476  */
 477 const static fib_node_vft_t ipsec_sa_vft = {
 478   .fnv_get = ipsec_sa_fib_node_get,
 479   .fnv_last_lock = ipsec_sa_last_lock_gone,
 480   .fnv_back_walk = ipsec_sa_back_walk,
 481 };
 482
 483 /* force inclusion from application's main.c */
 484 clib_error_t *
 485 ipsec_sa_interface_init (vlib_main_t * vm)
 486 {
 487   fib_node_register_type (FIB_NODE_TYPE_IPSEC_SA, &ipsec_sa_vft);
 488
 489   return 0;
 490 }
 491
 492 VLIB_INIT_FUNCTION (ipsec_sa_interface_init);
 493
 494 /*
 495  * fd.io coding-style-patch-verification: ON
 496  *
 497  * Local Variables:
 498  * eval: (c-set-style "gnu")
 499  * End:
 500  */