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     {
 249       if (ipsec_sa_is_set_IS_ASYNC (sa))
 250         {
 251           vnet_crypto_request_async_mode (1);
 252           sa->crypto_op_data = sa->async_op_data.data;
 253         }
 254       else
 255         sa->crypto_op_data = sa->sync_op_data.data;
 256     }
 257
 258   err = ipsec_check_support_cb (im, sa);
 259   if (err)
 260     {
 261       clib_warning ("%s", err->what);
 262       pool_put (ipsec_sa_pool, sa);
 263       return VNET_API_ERROR_UNIMPLEMENTED;
 264     }
 265
 266   err = ipsec_call_add_del_callbacks (im, sa, sa_index, 1);
 267   if (err)
 268     {
 269       pool_put (ipsec_sa_pool, sa);
 270       return VNET_API_ERROR_SYSCALL_ERROR_1;
 271     }
 272
 273   if (ipsec_sa_is_set_IS_TUNNEL (sa) &&
 274       AF_IP6 == ip_addr_version (&tun->t_src))
 275     ipsec_sa_set_IS_TUNNEL_V6 (sa);
 276
 277   if (ipsec_sa_is_set_IS_TUNNEL (sa) && !ipsec_sa_is_set_IS_INBOUND (sa))
 278     {
 279       sa->tunnel_flags = sa->tunnel.t_encap_decap_flags;
 280
 281       rv = tunnel_resolve (&sa->tunnel, FIB_NODE_TYPE_IPSEC_SA, sa_index);
 282
 283       if (rv)
 284         {
 285           pool_put (ipsec_sa_pool, sa);
 286           return rv;
 287         }
 288       ipsec_sa_stack (sa);
 289
 290       /* generate header templates */
 291       if (ipsec_sa_is_set_IS_TUNNEL_V6 (sa))
 292         {
 293           tunnel_build_v6_hdr (&sa->tunnel,
 294                                (ipsec_sa_is_set_UDP_ENCAP (sa) ?
 295                                   IP_PROTOCOL_UDP :
 296                                   IP_PROTOCOL_IPSEC_ESP),
 297                                &sa->ip6_hdr);
 298         }
 299       else
 300         {
 301           tunnel_build_v4_hdr (&sa->tunnel,
 302                                (ipsec_sa_is_set_UDP_ENCAP (sa) ?
 303                                   IP_PROTOCOL_UDP :
 304                                   IP_PROTOCOL_IPSEC_ESP),
 305                                &sa->ip4_hdr);
 306         }
 307     }
 308
 309   if (ipsec_sa_is_set_UDP_ENCAP (sa))
 310     {
 311       if (dst_port == IPSEC_UDP_PORT_NONE)
 312         sa->udp_hdr.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_ipsec);
 313       else
 314         sa->udp_hdr.dst_port = clib_host_to_net_u16 (dst_port);
 315
 316       if (src_port == IPSEC_UDP_PORT_NONE)
 317         sa->udp_hdr.src_port = clib_host_to_net_u16 (UDP_DST_PORT_ipsec);
 318       else
 319         sa->udp_hdr.src_port = clib_host_to_net_u16 (src_port);
 320
 321       if (ipsec_sa_is_set_IS_INBOUND (sa))
 322         ipsec_register_udp_port (clib_host_to_net_u16 (sa->udp_hdr.dst_port));
 323     }
 324
 325   hash_set (im->sa_index_by_sa_id, sa->id, sa_index);
 326
 327   if (sa_out_index)
 328     *sa_out_index = sa_index;
 329
 330   return (0);
 331 }
 332
 333 static void
 334 ipsec_sa_del (ipsec_sa_t * sa)
 335 {
 336   vlib_main_t *vm = vlib_get_main ();
 337   ipsec_main_t *im = &ipsec_main;
 338   u32 sa_index;
 339
 340   sa_index = sa - ipsec_sa_pool;
 341   hash_unset (im->sa_index_by_sa_id, sa->id);
 342   tunnel_unresolve (&sa->tunnel);
 343
 344   /* no recovery possible when deleting an SA */
 345   (void) ipsec_call_add_del_callbacks (im, sa, sa_index, 0);
 346
 347   if (ipsec_sa_is_set_IS_ASYNC (sa))
 348     vnet_crypto_request_async_mode (0);
 349   if (ipsec_sa_is_set_UDP_ENCAP (sa) && ipsec_sa_is_set_IS_INBOUND (sa))
 350     ipsec_unregister_udp_port (clib_net_to_host_u16 (sa->udp_hdr.dst_port));
 351
 352   if (ipsec_sa_is_set_IS_TUNNEL (sa) && !ipsec_sa_is_set_IS_INBOUND (sa))
 353     dpo_reset (&sa->dpo);
 354   vnet_crypto_key_del (vm, sa->crypto_key_index);
 355   if (sa->integ_alg != IPSEC_INTEG_ALG_NONE)
 356     vnet_crypto_key_del (vm, sa->integ_key_index);
 357   pool_put (ipsec_sa_pool, sa);
 358 }
 359
 360 void
 361 ipsec_sa_unlock (index_t sai)
 362 {
 363   ipsec_sa_t *sa;
 364
 365   if (INDEX_INVALID == sai)
 366     return;
 367
 368   sa = ipsec_sa_get (sai);
 369
 370   fib_node_unlock (&sa->node);
 371 }
 372
 373 void
 374 ipsec_sa_lock (index_t sai)
 375 {
 376   ipsec_sa_t *sa;
 377
 378   if (INDEX_INVALID == sai)
 379     return;
 380
 381   sa = ipsec_sa_get (sai);
 382
 383   fib_node_lock (&sa->node);
 384 }
 385
 386 index_t
 387 ipsec_sa_find_and_lock (u32 id)
 388 {
 389   ipsec_main_t *im = &ipsec_main;
 390   ipsec_sa_t *sa;
 391   uword *p;
 392
 393   p = hash_get (im->sa_index_by_sa_id, id);
 394
 395   if (!p)
 396     return INDEX_INVALID;
 397
 398   sa = ipsec_sa_get (p[0]);
 399
 400   fib_node_lock (&sa->node);
 401
 402   return (p[0]);
 403 }
 404
 405 int
 406 ipsec_sa_unlock_id (u32 id)
 407 {
 408   ipsec_main_t *im = &ipsec_main;
 409   uword *p;
 410
 411   p = hash_get (im->sa_index_by_sa_id, id);
 412
 413   if (!p)
 414     return VNET_API_ERROR_NO_SUCH_ENTRY;
 415
 416   ipsec_sa_unlock (p[0]);
 417
 418   return (0);
 419 }
 420
 421 void
 422 ipsec_sa_clear (index_t sai)
 423 {
 424   vlib_zero_combined_counter (&ipsec_sa_counters, sai);
 425 }
 426
 427 void
 428 ipsec_sa_walk (ipsec_sa_walk_cb_t cb, void *ctx)
 429 {
 430   ipsec_sa_t *sa;
 431
 432   /* *INDENT-OFF* */
 433   pool_foreach (sa, ipsec_sa_pool)
 434     {
 435       if (WALK_CONTINUE != cb (sa, ctx))
 436         break;
 437     }
 438   /* *INDENT-ON* */
 439 }
 440
 441 /**
 442  * Function definition to get a FIB node from its index
 443  */
 444 static fib_node_t *
 445 ipsec_sa_fib_node_get (fib_node_index_t index)
 446 {
 447   ipsec_sa_t *sa;
 448
 449   sa = ipsec_sa_get (index);
 450
 451   return (&sa->node);
 452 }
 453
 454 static ipsec_sa_t *
 455 ipsec_sa_from_fib_node (fib_node_t * node)
 456 {
 457   ASSERT (FIB_NODE_TYPE_IPSEC_SA == node->fn_type);
 458   return ((ipsec_sa_t *) (((char *) node) -
 459                           STRUCT_OFFSET_OF (ipsec_sa_t, node)));
 460
 461 }
 462
 463 /**
 464  * Function definition to inform the FIB node that its last lock has gone.
 465  */
 466 static void
 467 ipsec_sa_last_lock_gone (fib_node_t * node)
 468 {
 469   /*
 470    * The ipsec SA is a root of the graph. As such
 471    * it never has children and thus is never locked.
 472    */
 473   ipsec_sa_del (ipsec_sa_from_fib_node (node));
 474 }
 475
 476 /**
 477  * Function definition to backwalk a FIB node
 478  */
 479 static fib_node_back_walk_rc_t
 480 ipsec_sa_back_walk (fib_node_t * node, fib_node_back_walk_ctx_t * ctx)
 481 {
 482   ipsec_sa_stack (ipsec_sa_from_fib_node (node));
 483
 484   return (FIB_NODE_BACK_WALK_CONTINUE);
 485 }
 486
 487 /*
 488  * Virtual function table registered by SAs
 489  * for participation in the FIB object graph.
 490  */
 491 const static fib_node_vft_t ipsec_sa_vft = {
 492   .fnv_get = ipsec_sa_fib_node_get,
 493   .fnv_last_lock = ipsec_sa_last_lock_gone,
 494   .fnv_back_walk = ipsec_sa_back_walk,
 495 };
 496
 497 /* force inclusion from application's main.c */
 498 clib_error_t *
 499 ipsec_sa_interface_init (vlib_main_t * vm)
 500 {
 501   fib_node_register_type (FIB_NODE_TYPE_IPSEC_SA, &ipsec_sa_vft);
 502
 503   return 0;
 504 }
 505
 506 VLIB_INIT_FUNCTION (ipsec_sa_interface_init);
 507
 508 /*
 509  * fd.io coding-style-patch-verification: ON
 510  *
 511  * Local Variables:
 512  * eval: (c-set-style "gnu")
 513  * End:
 514  */