src/vnet/ipsec/ipsec_if.c

   1 /*
   2  * ipsec_if.c : IPSec interface support
   3  *
   4  * Copyright (c) 2015 Cisco and/or its affiliates.
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at:
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <vnet/vnet.h>
  19 #include <vnet/api_errno.h>
  20 #include <vnet/ip/ip.h>
  21
  22 #include <vnet/ipsec/ipsec.h>
  23 #include <vnet/ipsec/esp.h>
  24
  25 void vl_api_rpc_call_main_thread (void *fp, u8 * data, u32 data_length);
  26
  27 static u8 *
  28 format_ipsec_name (u8 * s, va_list * args)
  29 {
  30   u32 dev_instance = va_arg (*args, u32);
  31   return format (s, "ipsec%d", dev_instance);
  32 }
  33
  34 static uword
  35 dummy_interface_tx (vlib_main_t * vm,
  36                     vlib_node_runtime_t * node, vlib_frame_t * frame)
  37 {
  38   clib_warning ("you shouldn't be here, leaking buffers...");
  39   return frame->n_vectors;
  40 }
  41
  42 static clib_error_t *
  43 ipsec_admin_up_down_function (vnet_main_t * vnm, u32 hw_if_index, u32 flags)
  44 {
  45   ipsec_main_t *im = &ipsec_main;
  46   clib_error_t *err = 0;
  47   ipsec_tunnel_if_t *t;
  48   vnet_hw_interface_t *hi;
  49   ipsec_sa_t *sa;
  50
  51   hi = vnet_get_hw_interface (vnm, hw_if_index);
  52   if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
  53     {
  54       t = pool_elt_at_index (im->tunnel_interfaces, hi->hw_instance);
  55       ASSERT (im->cb.check_support_cb);
  56       sa = pool_elt_at_index (im->sad, t->input_sa_index);
  57       err = im->cb.check_support_cb (sa);
  58       if (err)
  59         return err;
  60
  61       sa = pool_elt_at_index (im->sad, t->output_sa_index);
  62       err = im->cb.check_support_cb (sa);
  63       if (err)
  64         return err;
  65
  66       vnet_hw_interface_set_flags (vnm, hw_if_index,
  67                                    VNET_HW_INTERFACE_FLAG_LINK_UP);
  68     }
  69   else
  70     vnet_hw_interface_set_flags (vnm, hw_if_index, 0 /* down */ );
  71
  72   return /* no error */ 0;
  73 }
  74
  75 /* *INDENT-OFF* */
  76 VNET_DEVICE_CLASS (ipsec_device_class, static) =
  77 {
  78   .name = "IPSec",
  79   .format_device_name = format_ipsec_name,
  80   .format_tx_trace = format_ipsec_if_output_trace,
  81   .tx_function = dummy_interface_tx,
  82   .admin_up_down_function = ipsec_admin_up_down_function,
  83 };
  84 /* *INDENT-ON* */
  85
  86 /* *INDENT-OFF* */
  87 VNET_HW_INTERFACE_CLASS (ipsec_hw_class) =
  88 {
  89   .name = "IPSec",
  90   .build_rewrite = default_build_rewrite,
  91 };
  92 /* *INDENT-ON* */
  93
  94 static int
  95 ipsec_add_del_tunnel_if_rpc_callback (ipsec_add_del_tunnel_args_t * a)
  96 {
  97   vnet_main_t *vnm = vnet_get_main ();
  98   ASSERT (vlib_get_thread_index () == 0);
  99
 100   return ipsec_add_del_tunnel_if_internal (vnm, a, NULL);
 101 }
 102
 103 int
 104 ipsec_add_del_tunnel_if (ipsec_add_del_tunnel_args_t * args)
 105 {
 106   vl_api_rpc_call_main_thread (ipsec_add_del_tunnel_if_rpc_callback,
 107                                (u8 *) args, sizeof (*args));
 108   return 0;
 109 }
 110
 111 int
 112 ipsec_add_del_tunnel_if_internal (vnet_main_t * vnm,
 113                                   ipsec_add_del_tunnel_args_t * args,
 114                                   u32 * sw_if_index)
 115 {
 116   ipsec_tunnel_if_t *t;
 117   ipsec_main_t *im = &ipsec_main;
 118   vnet_hw_interface_t *hi = NULL;
 119   u32 hw_if_index = ~0;
 120   uword *p;
 121   ipsec_sa_t *sa;
 122
 123   u64 key = (u64) args->remote_ip.as_u32 << 32 | (u64) args->remote_spi;
 124   p = hash_get (im->ipsec_if_pool_index_by_key, key);
 125
 126   if (args->is_add)
 127     {
 128       /* check if same src/dst pair exists */
 129       if (p)
 130         return VNET_API_ERROR_INVALID_VALUE;
 131
 132       pool_get_aligned (im->tunnel_interfaces, t, CLIB_CACHE_LINE_BYTES);
 133       memset (t, 0, sizeof (*t));
 134
 135       pool_get (im->sad, sa);
 136       memset (sa, 0, sizeof (*sa));
 137       t->input_sa_index = sa - im->sad;
 138       sa->spi = args->remote_spi;
 139       sa->tunnel_src_addr.ip4.as_u32 = args->remote_ip.as_u32;
 140       sa->tunnel_dst_addr.ip4.as_u32 = args->local_ip.as_u32;
 141       sa->is_tunnel = 1;
 142       sa->use_esn = args->esn;
 143       sa->use_anti_replay = args->anti_replay;
 144       sa->integ_alg = args->integ_alg;
 145       if (args->remote_integ_key_len <= sizeof (args->remote_integ_key))
 146         {
 147           sa->integ_key_len = args->remote_integ_key_len;
 148           clib_memcpy (sa->integ_key, args->remote_integ_key,
 149                        args->remote_integ_key_len);
 150         }
 151       sa->crypto_alg = args->crypto_alg;
 152       if (args->remote_crypto_key_len <= sizeof (args->remote_crypto_key))
 153         {
 154           sa->crypto_key_len = args->remote_crypto_key_len;
 155           clib_memcpy (sa->crypto_key, args->remote_crypto_key,
 156                        args->remote_crypto_key_len);
 157         }
 158
 159       if (im->cb.add_del_sa_sess_cb &&
 160           im->cb.add_del_sa_sess_cb (t->input_sa_index, args->is_add) < 0)
 161         return VNET_API_ERROR_SYSCALL_ERROR_1;
 162
 163       pool_get (im->sad, sa);
 164       memset (sa, 0, sizeof (*sa));
 165       t->output_sa_index = sa - im->sad;
 166       sa->spi = args->local_spi;
 167       sa->tunnel_src_addr.ip4.as_u32 = args->local_ip.as_u32;
 168       sa->tunnel_dst_addr.ip4.as_u32 = args->remote_ip.as_u32;
 169       sa->is_tunnel = 1;
 170       sa->seq = 1;
 171       sa->use_esn = args->esn;
 172       sa->use_anti_replay = args->anti_replay;
 173       sa->integ_alg = args->integ_alg;
 174       if (args->local_integ_key_len <= sizeof (args->local_integ_key))
 175         {
 176           sa->integ_key_len = args->local_integ_key_len;
 177           clib_memcpy (sa->integ_key, args->local_integ_key,
 178                        args->local_integ_key_len);
 179         }
 180       sa->crypto_alg = args->crypto_alg;
 181       if (args->local_crypto_key_len <= sizeof (args->local_crypto_key))
 182         {
 183           sa->crypto_key_len = args->local_crypto_key_len;
 184           clib_memcpy (sa->crypto_key, args->local_crypto_key,
 185                        args->local_crypto_key_len);
 186         }
 187
 188       if (im->cb.add_del_sa_sess_cb &&
 189           im->cb.add_del_sa_sess_cb (t->output_sa_index, args->is_add) < 0)
 190         return VNET_API_ERROR_SYSCALL_ERROR_1;
 191
 192       hash_set (im->ipsec_if_pool_index_by_key, key,
 193                 t - im->tunnel_interfaces);
 194
 195       if (vec_len (im->free_tunnel_if_indices) > 0)
 196         {
 197           hw_if_index =
 198             im->free_tunnel_if_indices[vec_len (im->free_tunnel_if_indices) -
 199                                        1];
 200           _vec_len (im->free_tunnel_if_indices) -= 1;
 201         }
 202       else
 203         {
 204           hw_if_index =
 205             vnet_register_interface (vnm, ipsec_device_class.index,
 206                                      t - im->tunnel_interfaces,
 207                                      ipsec_hw_class.index,
 208                                      t - im->tunnel_interfaces);
 209         }
 210
 211       hi = vnet_get_hw_interface (vnm, hw_if_index);
 212       hi->output_node_index = ipsec_if_output_node.index;
 213       t->hw_if_index = hw_if_index;
 214
 215       /*1st interface, register protocol */
 216       if (pool_elts (im->tunnel_interfaces) == 1)
 217         ip4_register_protocol (IP_PROTOCOL_IPSEC_ESP,
 218                                ipsec_if_input_node.index);
 219
 220     }
 221   else
 222     {
 223       /* check if exists */
 224       if (!p)
 225         return VNET_API_ERROR_INVALID_VALUE;
 226
 227       t = pool_elt_at_index (im->tunnel_interfaces, p[0]);
 228       hi = vnet_get_hw_interface (vnm, t->hw_if_index);
 229       vnet_sw_interface_set_flags (vnm, hi->sw_if_index, 0);    /* admin down */
 230       vec_add1 (im->free_tunnel_if_indices, t->hw_if_index);
 231
 232       /* delete input and output SA */
 233       sa = pool_elt_at_index (im->sad, t->input_sa_index);
 234
 235       if (im->cb.add_del_sa_sess_cb &&
 236           im->cb.add_del_sa_sess_cb (t->input_sa_index, args->is_add) < 0)
 237         return VNET_API_ERROR_SYSCALL_ERROR_1;
 238
 239       pool_put (im->sad, sa);
 240
 241       sa = pool_elt_at_index (im->sad, t->output_sa_index);
 242
 243       if (im->cb.add_del_sa_sess_cb &&
 244           im->cb.add_del_sa_sess_cb (t->output_sa_index, args->is_add) < 0)
 245         return VNET_API_ERROR_SYSCALL_ERROR_1;
 246
 247       pool_put (im->sad, sa);
 248
 249       hash_unset (im->ipsec_if_pool_index_by_key, key);
 250       pool_put (im->tunnel_interfaces, t);
 251     }
 252
 253   if (sw_if_index)
 254     *sw_if_index = hi->sw_if_index;
 255
 256   return 0;
 257 }
 258
 259 int
 260 ipsec_add_del_ipsec_gre_tunnel (vnet_main_t * vnm,
 261                                 ipsec_add_del_ipsec_gre_tunnel_args_t * args)
 262 {
 263   ipsec_tunnel_if_t *t = 0;
 264   ipsec_main_t *im = &ipsec_main;
 265   uword *p;
 266   ipsec_sa_t *sa;
 267   u64 key;
 268   u32 isa, osa;
 269
 270   p = hash_get (im->sa_index_by_sa_id, args->local_sa_id);
 271   if (!p)
 272     return VNET_API_ERROR_INVALID_VALUE;
 273   isa = p[0];
 274
 275   p = hash_get (im->sa_index_by_sa_id, args->remote_sa_id);
 276   if (!p)
 277     return VNET_API_ERROR_INVALID_VALUE;
 278   osa = p[0];
 279   sa = pool_elt_at_index (im->sad, p[0]);
 280
 281   if (sa->is_tunnel)
 282     key = (u64) sa->tunnel_dst_addr.ip4.as_u32 << 32 | (u64) sa->spi;
 283   else
 284     key = (u64) args->remote_ip.as_u32 << 32 | (u64) sa->spi;
 285
 286   p = hash_get (im->ipsec_if_pool_index_by_key, key);
 287
 288   if (args->is_add)
 289     {
 290       /* check if same src/dst pair exists */
 291       if (p)
 292         return VNET_API_ERROR_INVALID_VALUE;
 293
 294       pool_get_aligned (im->tunnel_interfaces, t, CLIB_CACHE_LINE_BYTES);
 295       memset (t, 0, sizeof (*t));
 296
 297       t->input_sa_index = isa;
 298       t->output_sa_index = osa;
 299       t->hw_if_index = ~0;
 300       hash_set (im->ipsec_if_pool_index_by_key, key,
 301                 t - im->tunnel_interfaces);
 302
 303       /*1st interface, register protocol */
 304       if (pool_elts (im->tunnel_interfaces) == 1)
 305         ip4_register_protocol (IP_PROTOCOL_IPSEC_ESP,
 306                                ipsec_if_input_node.index);
 307     }
 308   else
 309     {
 310       /* check if exists */
 311       if (!p)
 312         return VNET_API_ERROR_INVALID_VALUE;
 313
 314       t = pool_elt_at_index (im->tunnel_interfaces, p[0]);
 315       hash_unset (im->ipsec_if_pool_index_by_key, key);
 316       pool_put (im->tunnel_interfaces, t);
 317     }
 318   return 0;
 319 }
 320
 321 int
 322 ipsec_set_interface_key (vnet_main_t * vnm, u32 hw_if_index,
 323                          ipsec_if_set_key_type_t type, u8 alg, u8 * key)
 324 {
 325   ipsec_main_t *im = &ipsec_main;
 326   vnet_hw_interface_t *hi;
 327   ipsec_tunnel_if_t *t;
 328   ipsec_sa_t *sa;
 329
 330   hi = vnet_get_hw_interface (vnm, hw_if_index);
 331   t = pool_elt_at_index (im->tunnel_interfaces, hi->dev_instance);
 332
 333   if (type == IPSEC_IF_SET_KEY_TYPE_LOCAL_CRYPTO)
 334     {
 335       sa = pool_elt_at_index (im->sad, t->output_sa_index);
 336       sa->crypto_alg = alg;
 337       sa->crypto_key_len = vec_len (key);
 338       clib_memcpy (sa->crypto_key, key, vec_len (key));
 339
 340       if (im->cb.add_del_sa_sess_cb &&
 341           im->cb.add_del_sa_sess_cb (t->output_sa_index, 0) < 0)
 342         return VNET_API_ERROR_SYSCALL_ERROR_1;
 343     }
 344   else if (type == IPSEC_IF_SET_KEY_TYPE_LOCAL_INTEG)
 345     {
 346       sa = pool_elt_at_index (im->sad, t->output_sa_index);
 347       sa->integ_alg = alg;
 348       sa->integ_key_len = vec_len (key);
 349       clib_memcpy (sa->integ_key, key, vec_len (key));
 350
 351       if (im->cb.add_del_sa_sess_cb &&
 352           im->cb.add_del_sa_sess_cb (t->output_sa_index, 0) < 0)
 353         return VNET_API_ERROR_SYSCALL_ERROR_1;
 354     }
 355   else if (type == IPSEC_IF_SET_KEY_TYPE_REMOTE_CRYPTO)
 356     {
 357       sa = pool_elt_at_index (im->sad, t->input_sa_index);
 358       sa->crypto_alg = alg;
 359       sa->crypto_key_len = vec_len (key);
 360       clib_memcpy (sa->crypto_key, key, vec_len (key));
 361
 362       if (im->cb.add_del_sa_sess_cb &&
 363           im->cb.add_del_sa_sess_cb (t->input_sa_index, 0) < 0)
 364         return VNET_API_ERROR_SYSCALL_ERROR_1;
 365     }
 366   else if (type == IPSEC_IF_SET_KEY_TYPE_REMOTE_INTEG)
 367     {
 368       sa = pool_elt_at_index (im->sad, t->input_sa_index);
 369       sa->integ_alg = alg;
 370       sa->integ_key_len = vec_len (key);
 371       clib_memcpy (sa->integ_key, key, vec_len (key));
 372
 373       if (im->cb.add_del_sa_sess_cb &&
 374           im->cb.add_del_sa_sess_cb (t->input_sa_index, 0) < 0)
 375         return VNET_API_ERROR_SYSCALL_ERROR_1;
 376     }
 377   else
 378     return VNET_API_ERROR_INVALID_VALUE;
 379
 380   return 0;
 381 }
 382
 383
 384 clib_error_t *
 385 ipsec_tunnel_if_init (vlib_main_t * vm)
 386 {
 387   ipsec_main_t *im = &ipsec_main;
 388
 389   im->ipsec_if_pool_index_by_key = hash_create (0, sizeof (uword));
 390
 391   return 0;
 392 }
 393
 394 VLIB_INIT_FUNCTION (ipsec_tunnel_if_init);
 395
 396
 397 /*
 398  * fd.io coding-style-patch-verification: ON
 399  *
 400  * Local Variables:
 401  * eval: (c-set-style "gnu")
 402  * End:
 403  */