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