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/fib/fib_table.h>
  18
  19 static clib_error_t *
  20 ipsec_call_add_del_callbacks (ipsec_main_t * im, ipsec_sa_t * sa,
  21                               u32 sa_index, int is_add)
  22 {
  23   ipsec_ah_backend_t *ab;
  24   ipsec_esp_backend_t *eb;
  25   switch (sa->protocol)
  26     {
  27     case IPSEC_PROTOCOL_AH:
  28       ab = pool_elt_at_index (im->ah_backends, im->ah_current_backend);
  29       if (ab->add_del_sa_sess_cb)
  30         return ab->add_del_sa_sess_cb (sa_index, is_add);
  31       break;
  32     case IPSEC_PROTOCOL_ESP:
  33       eb = pool_elt_at_index (im->esp_backends, im->esp_current_backend);
  34       if (eb->add_del_sa_sess_cb)
  35         return eb->add_del_sa_sess_cb (sa_index, is_add);
  36       break;
  37     }
  38   return 0;
  39 }
  40
  41 void
  42 ipsec_mk_key (ipsec_key_t * key, const u8 * data, u8 len)
  43 {
  44   memset (key, 0, sizeof (*key));
  45
  46   if (len > sizeof (key->data))
  47     key->len = sizeof (key->data);
  48   else
  49     key->len = len;
  50
  51   memcpy (key->data, data, key->len);
  52 }
  53
  54 /**
  55  * 'stack' (resolve the recursion for) the SA tunnel destination
  56  */
  57 static void
  58 ipsec_sa_stack (ipsec_sa_t * sa)
  59 {
  60   fib_forward_chain_type_t fct;
  61   dpo_id_t tmp = DPO_INVALID;
  62   vlib_node_t *node;
  63
  64   fct = fib_forw_chain_type_from_fib_proto ((sa->is_tunnel_ip6 ?
  65                                              FIB_PROTOCOL_IP6 :
  66                                              FIB_PROTOCOL_IP4));
  67
  68   fib_entry_contribute_forwarding (sa->fib_entry_index, fct, &tmp);
  69
  70   node = vlib_get_node_by_name (vlib_get_main (),
  71                                 (sa->is_tunnel_ip6 ?
  72                                  (u8 *) "ah6-encrypt" :
  73                                  (u8 *) "ah4-encrypt"));
  74   dpo_stack_from_node (node->index, &sa->dpo[IPSEC_PROTOCOL_AH], &tmp);
  75
  76   node = vlib_get_node_by_name (vlib_get_main (),
  77                                 (sa->is_tunnel_ip6 ?
  78                                  (u8 *) "esp6-encrypt" :
  79                                  (u8 *) "esp4-encrypt"));
  80   dpo_stack_from_node (node->index, &sa->dpo[IPSEC_PROTOCOL_ESP], &tmp);
  81 }
  82
  83 int
  84 ipsec_sa_add (u32 id,
  85               u32 spi,
  86               ipsec_protocol_t proto,
  87               ipsec_crypto_alg_t crypto_alg,
  88               const ipsec_key_t * ck,
  89               ipsec_integ_alg_t integ_alg,
  90               const ipsec_key_t * ik,
  91               ipsec_sa_flags_t flags,
  92               u32 tx_table_id,
  93               const ip46_address_t * tun_src,
  94               const ip46_address_t * tun_dst, u32 * sa_out_index)
  95 {
  96   ipsec_main_t *im = &ipsec_main;
  97   clib_error_t *err;
  98   ipsec_sa_t *sa;
  99   u32 sa_index;
 100   uword *p;
 101
 102   p = hash_get (im->sa_index_by_sa_id, id);
 103   if (p)
 104     return VNET_API_ERROR_ENTRY_ALREADY_EXISTS;
 105
 106   pool_get_zero (im->sad, sa);
 107
 108   fib_node_init (&sa->node, FIB_NODE_TYPE_IPSEC_SA);
 109   sa_index = sa - im->sad;
 110
 111   sa->id = id;
 112   sa->spi = spi;
 113   sa->protocol = proto;
 114   sa->crypto_alg = crypto_alg;
 115   clib_memcpy (&sa->crypto_key, ck, sizeof (sa->crypto_key));
 116   sa->integ_alg = integ_alg;
 117   clib_memcpy (&sa->integ_key, ik, sizeof (sa->integ_key));
 118   ip46_address_copy (&sa->tunnel_src_addr, tun_src);
 119   ip46_address_copy (&sa->tunnel_dst_addr, tun_dst);
 120
 121   if (flags & IPSEC_SA_FLAG_USE_EXTENDED_SEQ_NUM)
 122     sa->use_esn = 1;
 123   if (flags & IPSEC_SA_FLAG_USE_ANTI_REPLAY)
 124     sa->use_anti_replay = 1;
 125   if (flags & IPSEC_SA_FLAG_IS_TUNNEL)
 126     sa->is_tunnel = 1;
 127   if (flags & IPSEC_SA_FLAG_IS_TUNNEL_V6)
 128     sa->is_tunnel_ip6 = 1;
 129   if (flags & IPSEC_SA_FLAG_UDP_ENCAP)
 130     sa->udp_encap = 1;
 131
 132   err = ipsec_check_support_cb (im, sa);
 133   if (err)
 134     {
 135       clib_warning ("%s", err->what);
 136       pool_put (im->sad, sa);
 137       return VNET_API_ERROR_UNIMPLEMENTED;
 138     }
 139
 140   err = ipsec_call_add_del_callbacks (im, sa, sa_index, 1);
 141   if (err)
 142     {
 143       pool_put (im->sad, sa);
 144       return VNET_API_ERROR_SYSCALL_ERROR_1;
 145     }
 146
 147   if (sa->is_tunnel)
 148     {
 149       fib_protocol_t fproto = (sa->is_tunnel_ip6 ?
 150                                FIB_PROTOCOL_IP6 : FIB_PROTOCOL_IP4);
 151       fib_prefix_t pfx = {
 152         .fp_addr = sa->tunnel_dst_addr,
 153         .fp_len = (sa->is_tunnel_ip6 ? 128 : 32),
 154         .fp_proto = fproto,
 155       };
 156       sa->tx_fib_index = fib_table_find (fproto, tx_table_id);
 157       if (sa->tx_fib_index == ~((u32) 0))
 158         {
 159           pool_put (im->sad, sa);
 160           return VNET_API_ERROR_NO_SUCH_FIB;
 161         }
 162
 163       sa->fib_entry_index = fib_table_entry_special_add (sa->tx_fib_index,
 164                                                          &pfx,
 165                                                          FIB_SOURCE_RR,
 166                                                          FIB_ENTRY_FLAG_NONE);
 167       sa->sibling = fib_entry_child_add (sa->fib_entry_index,
 168                                          FIB_NODE_TYPE_IPSEC_SA, sa_index);
 169       ipsec_sa_stack (sa);
 170     }
 171   hash_set (im->sa_index_by_sa_id, sa->id, sa_index);
 172
 173   if (sa_out_index)
 174     *sa_out_index = sa_index;
 175
 176   return (0);
 177 }
 178
 179 u32
 180 ipsec_sa_del (u32 id)
 181 {
 182   ipsec_main_t *im = &ipsec_main;
 183   ipsec_sa_t *sa = 0;
 184   uword *p;
 185   u32 sa_index;
 186   clib_error_t *err;
 187
 188   p = hash_get (im->sa_index_by_sa_id, id);
 189
 190   if (!p)
 191     return VNET_API_ERROR_NO_SUCH_ENTRY;
 192
 193   sa_index = p[0];
 194   sa = pool_elt_at_index (im->sad, sa_index);
 195   if (ipsec_is_sa_used (sa_index))
 196     {
 197       clib_warning ("sa_id %u used in policy", sa->id);
 198       /* sa used in policy */
 199       return VNET_API_ERROR_SYSCALL_ERROR_1;
 200     }
 201   hash_unset (im->sa_index_by_sa_id, sa->id);
 202   err = ipsec_call_add_del_callbacks (im, sa, sa_index, 0);
 203   if (err)
 204     return VNET_API_ERROR_SYSCALL_ERROR_1;
 205   if (sa->is_tunnel)
 206     {
 207       fib_entry_child_remove (sa->fib_entry_index, sa->sibling);
 208       fib_table_entry_special_remove
 209         (sa->tx_fib_index,
 210          fib_entry_get_prefix (sa->fib_entry_index), FIB_SOURCE_RR);
 211       dpo_reset (&sa->dpo[IPSEC_PROTOCOL_AH]);
 212       dpo_reset (&sa->dpo[IPSEC_PROTOCOL_ESP]);
 213     }
 214   pool_put (im->sad, sa);
 215   return 0;
 216 }
 217
 218 u8
 219 ipsec_is_sa_used (u32 sa_index)
 220 {
 221   ipsec_main_t *im = &ipsec_main;
 222   ipsec_tunnel_if_t *t;
 223   ipsec_policy_t *p;
 224
 225   /* *INDENT-OFF* */
 226   pool_foreach(p, im->policies, ({
 227      if (p->policy == IPSEC_POLICY_ACTION_PROTECT)
 228        {
 229          if (p->sa_index == sa_index)
 230            return 1;
 231        }
 232   }));
 233
 234   pool_foreach(t, im->tunnel_interfaces, ({
 235     if (t->input_sa_index == sa_index)
 236       return 1;
 237     if (t->output_sa_index == sa_index)
 238       return 1;
 239   }));
 240   /* *INDENT-ON* */
 241
 242   return 0;
 243 }
 244
 245 int
 246 ipsec_set_sa_key (u32 id, const ipsec_key_t * ck, const ipsec_key_t * ik)
 247 {
 248   ipsec_main_t *im = &ipsec_main;
 249   uword *p;
 250   u32 sa_index;
 251   ipsec_sa_t *sa = 0;
 252   clib_error_t *err;
 253
 254   p = hash_get (im->sa_index_by_sa_id, id);
 255   if (!p)
 256     return VNET_API_ERROR_SYSCALL_ERROR_1;      /* no such sa-id */
 257
 258   sa_index = p[0];
 259   sa = pool_elt_at_index (im->sad, sa_index);
 260
 261   /* new crypto key */
 262   if (ck)
 263     {
 264       clib_memcpy (&sa->crypto_key, ck, sizeof (sa->crypto_key));
 265     }
 266
 267   /* new integ key */
 268   if (ik)
 269     {
 270       clib_memcpy (&sa->integ_key, 0, sizeof (sa->integ_key));
 271     }
 272
 273   if (ck || ik)
 274     {
 275       err = ipsec_call_add_del_callbacks (im, sa, sa_index, 0);
 276       if (err)
 277         return VNET_API_ERROR_SYSCALL_ERROR_1;
 278     }
 279
 280   return 0;
 281 }
 282
 283 u32
 284 ipsec_get_sa_index_by_sa_id (u32 sa_id)
 285 {
 286   ipsec_main_t *im = &ipsec_main;
 287   uword *p = hash_get (im->sa_index_by_sa_id, sa_id);
 288   if (!p)
 289     return ~0;
 290
 291   return p[0];
 292 }
 293
 294 /**
 295  * Function definition to get a FIB node from its index
 296  */
 297 static fib_node_t *
 298 ipsec_sa_fib_node_get (fib_node_index_t index)
 299 {
 300   ipsec_main_t *im;
 301   ipsec_sa_t *sa;
 302
 303   im = &ipsec_main;
 304   sa = pool_elt_at_index (im->sad, index);
 305
 306   return (&sa->node);
 307 }
 308
 309 /**
 310  * Function definition to inform the FIB node that its last lock has gone.
 311  */
 312 static void
 313 ipsec_sa_last_lock_gone (fib_node_t * node)
 314 {
 315   /*
 316    * The ipsec SA is a root of the graph. As such
 317    * it never has children and thus is never locked.
 318    */
 319   ASSERT (0);
 320 }
 321
 322 static ipsec_sa_t *
 323 ipsec_sa_from_fib_node (fib_node_t * node)
 324 {
 325   ASSERT (FIB_NODE_TYPE_IPSEC_SA == node->fn_type);
 326   return ((ipsec_sa_t *) (((char *) node) -
 327                           STRUCT_OFFSET_OF (ipsec_sa_t, node)));
 328
 329 }
 330
 331 /**
 332  * Function definition to backwalk a FIB node
 333  */
 334 static fib_node_back_walk_rc_t
 335 ipsec_sa_back_walk (fib_node_t * node, fib_node_back_walk_ctx_t * ctx)
 336 {
 337   ipsec_sa_stack (ipsec_sa_from_fib_node (node));
 338
 339   return (FIB_NODE_BACK_WALK_CONTINUE);
 340 }
 341
 342 /*
 343  * Virtual function table registered by MPLS GRE tunnels
 344  * for participation in the FIB object graph.
 345  */
 346 const static fib_node_vft_t ipsec_sa_vft = {
 347   .fnv_get = ipsec_sa_fib_node_get,
 348   .fnv_last_lock = ipsec_sa_last_lock_gone,
 349   .fnv_back_walk = ipsec_sa_back_walk,
 350 };
 351
 352 /* force inclusion from application's main.c */
 353 clib_error_t *
 354 ipsec_sa_interface_init (vlib_main_t * vm)
 355 {
 356   fib_node_register_type (FIB_NODE_TYPE_IPSEC_SA, &ipsec_sa_vft);
 357
 358   return 0;
 359 }
 360
 361 VLIB_INIT_FUNCTION (ipsec_sa_interface_init);
 362
 363 /*
 364  * fd.io coding-style-patch-verification: ON
 365  *
 366  * Local Variables:
 367  * eval: (c-set-style "gnu")
 368  * End:
 369  */