src/vnet/ipsec/ipsec_tun.c

   1 /*
   2  * ipsec_tun.h : IPSEC tunnel protection
   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/ipsec/ipsec_tun.h>
  19 #include <vnet/ipsec/esp.h>
  20 #include <vnet/udp/udp.h>
  21
  22 /**
  23  * Pool of tunnel protection objects
  24  */
  25 ipsec_tun_protect_t *ipsec_protect_pool;
  26
  27 /**
  28  * DB of protected tunnels
  29  */
  30 typedef struct ipsec_protect_db_t_
  31 {
  32   u32 *tunnels;
  33   u32 count;
  34 } ipsec_protect_db_t;
  35
  36 static ipsec_protect_db_t ipsec_protect_db;
  37
  38 static int
  39 ipsec_tun_protect_feature_set (ipsec_tun_protect_t * itp, u8 enable)
  40 {
  41   u32 sai = itp->itp_out_sa;
  42   int is_ip4, is_l2, rv;
  43
  44   is_ip4 = ip46_address_is_ip4 (&itp->itp_tun.src);
  45   is_l2 = itp->itp_flags & IPSEC_PROTECT_L2;
  46
  47   if (is_ip4)
  48     {
  49       if (is_l2)
  50         rv = vnet_feature_enable_disable ("ethernet-output",
  51                                           "esp4-encrypt-tun",
  52                                           itp->itp_sw_if_index, enable,
  53                                           &sai, sizeof (sai));
  54       else
  55         rv = vnet_feature_enable_disable ("ip4-output",
  56                                           "esp4-encrypt-tun",
  57                                           itp->itp_sw_if_index, enable,
  58                                           &sai, sizeof (sai));
  59     }
  60   else
  61     {
  62       if (is_l2)
  63         rv = vnet_feature_enable_disable ("ethernet-output",
  64                                           "esp6-encrypt-tun",
  65                                           itp->itp_sw_if_index, enable,
  66                                           &sai, sizeof (sai));
  67       else
  68         rv = vnet_feature_enable_disable ("ip6-output",
  69                                           "esp6-encrypt-tun",
  70                                           itp->itp_sw_if_index, enable,
  71                                           &sai, sizeof (sai));
  72     }
  73
  74   ASSERT (!rv);
  75   return (rv);
  76 }
  77
  78 static void
  79 ipsec_tun_protect_db_add (ipsec_main_t * im, const ipsec_tun_protect_t * itp)
  80 {
  81   const ipsec_sa_t *sa;
  82   u32 sai;
  83
  84   /* *INDENT-OFF* */
  85   FOR_EACH_IPSEC_PROTECT_INPUT_SAI(itp, sai,
  86   ({
  87       sa = ipsec_sa_get (sai);
  88
  89       ipsec_tun_lkup_result_t res = {
  90         .tun_index = itp - ipsec_protect_pool,
  91         .sa_index = sai,
  92       };
  93
  94       /*
  95        * The key is formed from the tunnel's destination
  96        * as the packet lookup is done from the packet's source
  97        */
  98       if (ip46_address_is_ip4 (&itp->itp_crypto.dst))
  99         {
 100           ipsec4_tunnel_key_t key = {
 101             .remote_ip = itp->itp_crypto.dst.ip4,
 102             .spi = clib_host_to_net_u32 (sa->spi),
 103           };
 104           hash_set (im->tun4_protect_by_key, key.as_u64, res.as_u64);
 105           if (1 == hash_elts(im->tun4_protect_by_key))
 106             udp_register_dst_port (vlib_get_main(),
 107                                    UDP_DST_PORT_ipsec,
 108                                    ipsec4_tun_input_node.index, 1);
 109         }
 110       else
 111         {
 112           ipsec6_tunnel_key_t key = {
 113             .remote_ip = itp->itp_crypto.dst.ip6,
 114             .spi = clib_host_to_net_u32 (sa->spi),
 115           };
 116           hash_set_mem_alloc (&im->tun6_protect_by_key, &key, res.as_u64);
 117         }
 118   }))
 119   /* *INDENT-ON* */
 120 }
 121
 122 static void
 123 ipsec_tun_protect_db_remove (ipsec_main_t * im,
 124                              const ipsec_tun_protect_t * itp)
 125 {
 126   const ipsec_sa_t *sa;
 127
 128   /* *INDENT-OFF* */
 129   FOR_EACH_IPSEC_PROTECT_INPUT_SA(itp, sa,
 130   ({
 131       if (ip46_address_is_ip4 (&itp->itp_crypto.dst))
 132         {
 133           ipsec4_tunnel_key_t key = {
 134             .remote_ip = itp->itp_crypto.dst.ip4,
 135             .spi = clib_host_to_net_u32 (sa->spi),
 136           };
 137           hash_unset (im->tun4_protect_by_key, &key);
 138           if (0 == hash_elts(im->tun4_protect_by_key))
 139             udp_unregister_dst_port (vlib_get_main(),
 140                                      UDP_DST_PORT_ipsec,
 141                                      1);
 142         }
 143       else
 144         {
 145           ipsec6_tunnel_key_t key = {
 146             .remote_ip = itp->itp_crypto.dst.ip6,
 147             .spi = clib_host_to_net_u32 (sa->spi),
 148           };
 149           hash_unset_mem_free (&im->tun6_protect_by_key, &key);
 150         }
 151   }))
 152   /* *INDENT-ON* */
 153 }
 154
 155 static void
 156 ipsec_tun_protect_config (ipsec_main_t * im,
 157                           ipsec_tun_protect_t * itp, u32 sa_out, u32 * sas_in)
 158 {
 159   ipsec_sa_t *sa;
 160   u32 ii;
 161
 162   itp->itp_n_sa_in = vec_len (sas_in);
 163   for (ii = 0; ii < itp->itp_n_sa_in; ii++)
 164     itp->itp_in_sas[ii] = sas_in[ii];
 165   itp->itp_out_sa = sa_out;
 166
 167   /* *INDENT-OFF* */
 168   FOR_EACH_IPSEC_PROTECT_INPUT_SA(itp, sa,
 169   ({
 170     if (ipsec_sa_is_set_IS_TUNNEL (sa))
 171       {
 172         itp->itp_crypto.src = sa->tunnel_dst_addr;
 173         itp->itp_crypto.dst = sa->tunnel_src_addr;
 174         ipsec_sa_set_IS_PROTECT (sa);
 175         itp->itp_flags |= IPSEC_PROTECT_ENCAPED;
 176       }
 177     else
 178       {
 179         itp->itp_crypto.src = itp->itp_tun.src;
 180         itp->itp_crypto.dst = itp->itp_tun.dst;
 181         itp->itp_flags &= ~IPSEC_PROTECT_ENCAPED;
 182       }
 183   }));
 184   /* *INDENT-ON* */
 185
 186   /*
 187    * add to the DB against each SA
 188    */
 189   ipsec_tun_protect_db_add (im, itp);
 190
 191   /*
 192    * enable the encrypt feature for egress.
 193    */
 194   ipsec_tun_protect_feature_set (itp, 1);
 195
 196 }
 197
 198 static void
 199 ipsec_tun_protect_unconfig (ipsec_main_t * im, ipsec_tun_protect_t * itp)
 200 {
 201   ipsec_sa_t *sa;
 202   index_t sai;
 203
 204   ipsec_tun_protect_feature_set (itp, 0);
 205
 206   /* *INDENT-OFF* */
 207   FOR_EACH_IPSEC_PROTECT_INPUT_SA(itp, sa,
 208   ({
 209     ipsec_sa_unset_IS_PROTECT (sa);
 210   }));
 211
 212   ipsec_tun_protect_db_remove (im, itp);
 213
 214   ipsec_sa_unlock(itp->itp_out_sa);
 215
 216   FOR_EACH_IPSEC_PROTECT_INPUT_SAI(itp, sai,
 217   ({
 218     ipsec_sa_unlock(sai);
 219   }));
 220   /* *INDENT-ON* */
 221 }
 222
 223 index_t
 224 ipsec_tun_protect_find (u32 sw_if_index)
 225 {
 226   if (vec_len (ipsec_protect_db.tunnels) < sw_if_index)
 227     return (INDEX_INVALID);
 228
 229   return (ipsec_protect_db.tunnels[sw_if_index]);
 230 }
 231
 232 int
 233 ipsec_tun_protect_update (u32 sw_if_index, u32 sa_out, u32 * sas_in)
 234 {
 235   u32 itpi, ii;
 236   ipsec_tun_protect_t *itp;
 237   ipsec_main_t *im;
 238   int rv;
 239
 240   rv = 0;
 241   im = &ipsec_main;
 242   vec_validate_init_empty (ipsec_protect_db.tunnels, sw_if_index,
 243                            INDEX_INVALID);
 244   itpi = ipsec_protect_db.tunnels[sw_if_index];
 245
 246   vec_foreach_index (ii, sas_in)
 247   {
 248     sas_in[ii] = ipsec_sa_find_and_lock (sas_in[ii]);
 249     if (~0 == sas_in[ii])
 250       {
 251         rv = VNET_API_ERROR_INVALID_VALUE;
 252         goto out;
 253       }
 254   }
 255
 256   sa_out = ipsec_sa_find_and_lock (sa_out);
 257
 258   if (~0 == sa_out)
 259     {
 260       rv = VNET_API_ERROR_INVALID_VALUE;
 261       goto out;
 262     }
 263
 264   if (INDEX_INVALID == itpi)
 265     {
 266       vnet_device_class_t *dev_class;
 267       vnet_hw_interface_t *hi;
 268       vnet_main_t *vnm;
 269       u8 is_l2;
 270
 271       vnm = vnet_get_main ();
 272       hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
 273       dev_class = vnet_get_device_class (vnm, hi->dev_class_index);
 274
 275       if (NULL == dev_class->ip_tun_desc)
 276         {
 277           rv = VNET_API_ERROR_INVALID_SW_IF_INDEX;
 278           goto out;
 279         }
 280
 281       pool_get_zero (ipsec_protect_pool, itp);
 282
 283       itp->itp_sw_if_index = sw_if_index;
 284       ipsec_protect_db.tunnels[sw_if_index] = itp - ipsec_protect_pool;
 285       ipsec_protect_db.count++;
 286
 287       itp->itp_n_sa_in = vec_len (sas_in);
 288       for (ii = 0; ii < itp->itp_n_sa_in; ii++)
 289         itp->itp_in_sas[ii] = sas_in[ii];
 290       itp->itp_out_sa = sa_out;
 291
 292       rv = dev_class->ip_tun_desc (sw_if_index,
 293                                    &itp->itp_tun.src,
 294                                    &itp->itp_tun.dst, &is_l2);
 295
 296       if (rv)
 297         goto out;
 298
 299       if (is_l2)
 300         itp->itp_flags |= IPSEC_PROTECT_L2;
 301
 302       /*
 303        * add to the tunnel DB for ingress
 304        *  - if the SA is in trasnport mode, then the packates will arrivw
 305        *    with the IP src,dst of the protected tunnel, in which case we can
 306        *    simply strip the IP header and hand the payload to the protocol
 307        *    appropriate input handler
 308        *  - if the SA is in tunnel mode then there are two IP headers present
 309        *    one for the crytpo tunnel endpoints (described in the SA) and one
 310        *    for the tunnel endpoints. The outer IP headers in the srriving
 311        *    packets will have the crypto endpoints. So the DB needs to contain
 312        *    the crpto endpoint. Once the crypto header is stripped, revealing,
 313        *    the tunnel-IP we have 2 choices:
 314        *     1) do a tunnel lookup based on the revealed header
 315        *     2) skip the tunnel lookup and assume that the packet matches the
 316        *        one that is protected here.
 317        *    If we did 1) then we would allow our peer to use the SA for tunnel
 318        *    X to inject traffic onto tunnel Y, this is not good. If we do 2)
 319        *    then we don't verify that the peer is indeed using SA for tunnel
 320        *    X and addressing tunnel X. So we take a compromise, once the SA
 321        *    matches to tunnel X we veriy that the inner IP matches the value
 322        *    of the tunnel we are protecting, else it's dropped.
 323        */
 324       ipsec_tun_protect_config (im, itp, sa_out, sas_in);
 325
 326       if (1 == hash_elts (im->tun4_protect_by_key))
 327         ip4_register_protocol (IP_PROTOCOL_IPSEC_ESP,
 328                                ipsec4_tun_input_node.index);
 329       if (1 == hash_elts (im->tun6_protect_by_key))
 330         ip6_register_protocol (IP_PROTOCOL_IPSEC_ESP,
 331                                ipsec6_tun_input_node.index);
 332     }
 333   else
 334     {
 335       /* updating SAs only */
 336       itp = pool_elt_at_index (ipsec_protect_pool, itpi);
 337
 338       ipsec_tun_protect_unconfig (im, itp);
 339       ipsec_tun_protect_config (im, itp, sa_out, sas_in);
 340     }
 341
 342   vec_free (sas_in);
 343 out:
 344   return (rv);
 345 }
 346
 347 int
 348 ipsec_tun_protect_del (u32 sw_if_index)
 349 {
 350   ipsec_tun_protect_t *itp;
 351   ipsec_main_t *im;
 352   index_t itpi;
 353
 354   im = &ipsec_main;
 355
 356   vec_validate_init_empty (ipsec_protect_db.tunnels, sw_if_index,
 357                            INDEX_INVALID);
 358   itpi = ipsec_protect_db.tunnels[sw_if_index];
 359
 360   if (INDEX_INVALID == itpi)
 361     return (VNET_API_ERROR_NO_SUCH_ENTRY);
 362
 363   itp = ipsec_tun_protect_get (itpi);
 364   ipsec_tun_protect_unconfig (im, itp);
 365
 366   ipsec_protect_db.tunnels[itp->itp_sw_if_index] = INDEX_INVALID;
 367
 368   pool_put (ipsec_protect_pool, itp);
 369
 370   if (0 == hash_elts (im->tun4_protect_by_key))
 371     ip4_unregister_protocol (IP_PROTOCOL_IPSEC_ESP);
 372   if (0 == hash_elts (im->tun6_protect_by_key))
 373     ip6_unregister_protocol (IP_PROTOCOL_IPSEC_ESP);
 374
 375   return (0);
 376 }
 377
 378 void
 379 ipsec_tun_protect_walk (ipsec_tun_protect_walk_cb_t fn, void *ctx)
 380 {
 381   index_t itpi;
 382
 383   /* *INDENT-OFF* */
 384   pool_foreach_index(itpi, ipsec_protect_pool,
 385   ({
 386     fn (itpi, ctx);
 387   }));
 388   /* *INDENT-ON* */
 389 }
 390
 391 clib_error_t *
 392 ipsec_tunnel_protect_init (vlib_main_t * vm)
 393 {
 394   ipsec_main_t *im;
 395
 396   im = &ipsec_main;
 397   im->tun6_protect_by_key = hash_create_mem (0,
 398                                              sizeof (ipsec6_tunnel_key_t),
 399                                              sizeof (u64));
 400   im->tun4_protect_by_key = hash_create (0, sizeof (u64));
 401
 402   return 0;
 403 }
 404
 405 VLIB_INIT_FUNCTION (ipsec_tunnel_protect_init);
 406
 407
 408 /*
 409  * fd.io coding-style-patch-verification: ON
 410  *
 411  * Local Variables:
 412  * eval: (c-set-style "gnu")
 413  * End:
 414  */