src/plugins/urpf/urpf.c

   1 /*
   2  * Copyright (c) 2020 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 <urpf/urpf.h>
  17
  18 #include <vnet/fib/fib_table.h>
  19
  20 /* *INDENT-OFF* */
  21 static const char *urpf_feat_arcs[N_AF][VLIB_N_DIR] =
  22 {
  23   [AF_IP4] = {
  24     [VLIB_RX] = "ip4-unicast",
  25     [VLIB_TX] = "ip4-output",
  26   },
  27   [AF_IP6] = {
  28     [VLIB_RX] = "ip6-unicast",
  29     [VLIB_TX] = "ip6-output",
  30   },
  31 };
  32
  33 static const char *urpf_feats[N_AF][VLIB_N_DIR][URPF_N_MODES] =
  34 {
  35   [AF_IP4] = {
  36     [VLIB_RX] = {
  37       [URPF_MODE_STRICT] = "ip4-rx-urpf-strict",
  38       [URPF_MODE_LOOSE] = "ip4-rx-urpf-loose",
  39     },
  40     [VLIB_TX] = {
  41       [URPF_MODE_STRICT] = "ip4-tx-urpf-strict",
  42       [URPF_MODE_LOOSE] = "ip4-tx-urpf-loose",
  43     },
  44   },
  45   [AF_IP6] = {
  46     [VLIB_RX] = {
  47       [URPF_MODE_STRICT] = "ip6-rx-urpf-strict",
  48       [URPF_MODE_LOOSE] = "ip6-rx-urpf-loose",
  49     },
  50     [VLIB_TX] = {
  51       [URPF_MODE_STRICT] = "ip6-tx-urpf-strict",
  52       [URPF_MODE_LOOSE] = "ip6-tx-urpf-loose",
  53     },
  54   },
  55 };
  56 /* *INDENT-ON* */
  57
  58 /**
  59  * Per-af, per-direction, per-interface uRPF configs
  60  */
  61
  62 urpf_data_t *urpf_cfgs[N_AF][VLIB_N_DIR];
  63
  64 u8 *
  65 format_urpf_mode (u8 * s, va_list * a)
  66 {
  67   urpf_mode_t mode = va_arg (*a, int);
  68
  69   switch (mode)
  70     {
  71 #define _(a,b)                                  \
  72     case URPF_MODE_##a:                         \
  73       return (format (s, "%s", b));
  74       foreach_urpf_mode
  75 #undef _
  76     }
  77
  78   return (format (s, "unknown"));
  79 }
  80
  81 static uword
  82 unformat_urpf_mode (unformat_input_t * input, va_list * args)
  83 {
  84   urpf_mode_t *mode = va_arg (*args, urpf_mode_t *);
  85
  86   if (0)
  87     ;
  88 #define _(a,b)                                                  \
  89   else if (unformat (input, b))                                 \
  90     {                                                           \
  91     *mode = URPF_MODE_##a;                                      \
  92     return (1);                                                 \
  93     }
  94   foreach_urpf_mode
  95 #undef _
  96     return 0;
  97 }
  98
  99 int
 100 urpf_update (urpf_mode_t mode, u32 sw_if_index, ip_address_family_t af,
 101              vlib_dir_t dir, u32 table_id)
 102 {
 103   fib_protocol_t proto;
 104   u32 fib_index;
 105   if (table_id != ~0)
 106     {
 107       proto = ip_address_family_to_fib_proto (af);
 108       fib_index = fib_table_find (proto, table_id);
 109       if (fib_index == (~0))
 110         return VNET_API_ERROR_INVALID_VALUE;
 111     }
 112   else
 113     {
 114       bool is_ip4 = (AF_IP4 == af);
 115       u32 *fib_index_by_sw_if_index = is_ip4 ?
 116                                               ip4_main.fib_index_by_sw_if_index :
 117                                               ip6_main.fib_index_by_sw_if_index;
 118
 119       fib_index = fib_index_by_sw_if_index[sw_if_index];
 120     }
 121   urpf_data_t old;
 122   urpf_mode_t off = URPF_MODE_OFF;
 123   urpf_data_t empty = { .fib_index = 0, .mode = off };
 124   vec_validate_init_empty (urpf_cfgs[af][dir], sw_if_index, empty);
 125   old = urpf_cfgs[af][dir][sw_if_index];
 126
 127   urpf_data_t data = { .fib_index = fib_index,
 128                        .mode = mode,
 129                        .fib_index_is_custom = (table_id != ~0) };
 130   urpf_cfgs[af][dir][sw_if_index] = data;
 131   if (data.mode != old.mode || data.fib_index != old.fib_index)
 132     {
 133       if (URPF_MODE_OFF != old.mode)
 134         /* disable what we have */
 135         vnet_feature_enable_disable (urpf_feat_arcs[af][dir],
 136                                      urpf_feats[af][dir][old.mode],
 137                                      sw_if_index, 0, 0, 0);
 138
 139       if (URPF_MODE_OFF != data.mode)
 140         /* enable what's new */
 141         vnet_feature_enable_disable (urpf_feat_arcs[af][dir],
 142                                      urpf_feats[af][dir][data.mode],
 143                                      sw_if_index, 1, 0, 0);
 144     }
 145   /* else - no change to existing config */
 146   return 0;
 147 }
 148
 149 static void
 150 urpf_table_bind_v4 (ip4_main_t *im, uword opaque, u32 sw_if_index,
 151                     u32 new_fib_index, u32 old_fib_index)
 152 {
 153   vlib_dir_t dir;
 154   urpf_data_t empty = { .fib_index = 0, .mode = URPF_MODE_OFF };
 155   FOREACH_VLIB_DIR (dir)
 156   {
 157     vec_validate_init_empty (urpf_cfgs[AF_IP4][dir], sw_if_index, empty);
 158     if (!urpf_cfgs[AF_IP4][dir][sw_if_index].fib_index_is_custom)
 159       {
 160         urpf_cfgs[AF_IP4][dir][sw_if_index].fib_index = new_fib_index;
 161       }
 162   }
 163 }
 164
 165 static void
 166 urpf_table_bind_v6 (ip6_main_t *im, uword opaque, u32 sw_if_index,
 167                     u32 new_fib_index, u32 old_fib_index)
 168 {
 169   vlib_dir_t dir;
 170   urpf_data_t empty = { .fib_index = 0, .mode = URPF_MODE_OFF };
 171   FOREACH_VLIB_DIR (dir)
 172   {
 173     vec_validate_init_empty (urpf_cfgs[AF_IP6][dir], sw_if_index, empty);
 174     if (!urpf_cfgs[AF_IP6][dir][sw_if_index].fib_index_is_custom)
 175       {
 176         urpf_cfgs[AF_IP6][dir][sw_if_index].fib_index = new_fib_index;
 177       }
 178   }
 179 }
 180
 181 static clib_error_t *
 182 urpf_init (vlib_main_t *vm)
 183 {
 184   ip4_table_bind_callback_t cb4 = {
 185     .function = urpf_table_bind_v4,
 186   };
 187   vec_add1 (ip4_main.table_bind_callbacks, cb4);
 188
 189   ip6_table_bind_callback_t cb6 = {
 190     .function = urpf_table_bind_v6,
 191   };
 192   vec_add1 (ip6_main.table_bind_callbacks, cb6);
 193   return (NULL);
 194 }
 195
 196 VLIB_INIT_FUNCTION (urpf_init);
 197
 198 static clib_error_t *
 199 urpf_cli_update (vlib_main_t * vm,
 200                  unformat_input_t * input, vlib_cli_command_t * cmd)
 201 {
 202   unformat_input_t _line_input, *line_input = &_line_input;
 203   vnet_main_t *vnm = vnet_get_main ();
 204   clib_error_t *error = NULL;
 205   ip_address_family_t af;
 206   urpf_mode_t mode;
 207   u32 sw_if_index;
 208   vlib_dir_t dir;
 209   u32 table_id;
 210
 211   sw_if_index = ~0;
 212   af = AF_IP4;
 213   dir = VLIB_RX;
 214   mode = URPF_MODE_STRICT;
 215   table_id = ~0;
 216
 217   if (!unformat_user (input, unformat_line_input, line_input))
 218     return 0;
 219
 220   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 221     {
 222       if (unformat (line_input, "%U",
 223                     unformat_vnet_sw_interface, vnm, &sw_if_index))
 224         ;
 225       else if (unformat (line_input, "%U", unformat_urpf_mode, &mode))
 226         ;
 227       else if (unformat (line_input, "table %d", &table_id))
 228         ;
 229       else if (unformat (line_input, "%U", unformat_ip_address_family, &af))
 230         ;
 231       else if (unformat (line_input, "%U", unformat_vlib_rx_tx, &dir))
 232         ;
 233       else
 234         {
 235           error = unformat_parse_error (line_input);
 236           goto done;
 237         }
 238     }
 239
 240   if (~0 == sw_if_index)
 241     {
 242       error = clib_error_return (0, "unknown interface `%U'",
 243                                  format_unformat_error, line_input);
 244       goto done;
 245     }
 246
 247   int rv = 0;
 248   rv = urpf_update (mode, sw_if_index, af, dir, table_id);
 249   if (rv)
 250     {
 251       error = clib_error_return (0, "unknown table id");
 252       goto done;
 253     }
 254 done:
 255   unformat_free (line_input);
 256
 257   return error;
 258 }
 259
 260 /*?
 261  * This command configures uRPF on an interface.
 262  * Two flavours are supported (the default is strict):
 263  * - loose: accept ingress packet if there is a route to reach the source
 264  * - strict: accept ingress packet if it arrived on an interface which
 265  *          the route to the source uses. i.e. an interface that the source
 266  *          is reachable via.
 267  *
 268  * @cliexpar
 269  * @parblock
 270  * Example of graph node before range checking is enabled:
 271  * @cliexstart{show vlib graph ip4-rx-urpf-strict}
 272  *            Name                      Next                    Previous
 273  * ip4-rx-urpf-strict         ip4-drop [0]
 274  * @cliexend
 275  *
 276  * Example of how to enable unicast source checking on an interface:
 277  * @cliexcmd{set urpf ip4 rx GigabitEthernet2/0/0 loose}
 278  *
 279  * Example of graph node after range checking is enabled:
 280  * @cliexstart{show vlib graph ip4-rx-urpf-loose}
 281  *       Name                    Next                  Previous
 282  * ip4-rx-urpf-loose          ip4-drop [0]        ip4-input-no-checksum
 283  *                    ip4-source-and-port-range-       ip4-input
 284  * @cliexend
 285  *
 286  * Example of how to display the feature enabled on an interface:
 287  * @cliexstart{show ip interface features GigabitEthernet2/0/0}
 288  * IP feature paths configured on GigabitEthernet2/0/0...
 289  *
 290  * ipv4 unicast:
 291  *   ip4-rx-urpf-loose
 292  *   ip4-lookup
 293  *
 294  * ipv4 multicast:
 295  *   ip4-lookup-multicast
 296  *
 297  * ipv4 multicast:
 298  *   interface-output
 299  *
 300  * ipv6 unicast:
 301  *   ip6-lookup
 302  *
 303  * ipv6 multicast:
 304  *   ip6-lookup
 305  *
 306  * ipv6 multicast:
 307  *   interface-output
 308  * @cliexend
 309  *
 310  * Example of how to disable unicast source checking on an interface:
 311  * @cliexcmd{set urpf ip4 off GigabitEthernet2/0/0}
 312  * @endparblock
 313 ?*/
 314 /* *INDENT-OFF* */
 315 VLIB_CLI_COMMAND (set_interface_ip_source_check_command, static) = {
 316   .path = "set urpf",
 317   .function = urpf_cli_update,
 318   .short_help = "set urpf [ip4|ip6] [rx|tx] [off|strict|loose] "
 319                 "<INTERFACE> [table <table>]",
 320 };
 321 /* *INDENT-ON* */
 322
 323 static clib_error_t *
 324 urpf_cli_accept (vlib_main_t * vm,
 325                  unformat_input_t * input, vlib_cli_command_t * cmd)
 326 {
 327   unformat_input_t _line_input, *line_input = &_line_input;
 328   clib_error_t *error = NULL;
 329   fib_prefix_t fpfx;
 330   ip_prefix_t pfx;
 331   u32 table_id, is_add, fib_index;
 332
 333   is_add = 1;
 334   table_id = 0;
 335
 336   /* Get a line of input. */
 337   if (!unformat_user (input, unformat_line_input, line_input))
 338     return 0;
 339
 340   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 341     {
 342       if (unformat (line_input, "table %d", &table_id))
 343         ;
 344       else if (unformat (line_input, "del"))
 345         is_add = 0;
 346       else if (unformat (line_input, "add"))
 347         is_add = 1;
 348       else if (unformat (line_input, "%U", unformat_ip_prefix, &pfx))
 349         ;
 350       else
 351         {
 352           error = unformat_parse_error (line_input);
 353           goto done;
 354         }
 355     }
 356
 357   ip_prefix_to_fib_prefix (&pfx, &fpfx);
 358
 359   fib_index = fib_table_find (fpfx.fp_proto, table_id);
 360
 361   if (~0 == fib_index)
 362     {
 363       error = clib_error_return (0, "Nonexistent table id %d", table_id);
 364       goto done;
 365     }
 366
 367   if (is_add)
 368     fib_table_entry_special_add (fib_index,
 369                                  &fpfx,
 370                                  FIB_SOURCE_URPF_EXEMPT, FIB_ENTRY_FLAG_DROP);
 371   else
 372     fib_table_entry_special_remove (fib_index, &fpfx, FIB_SOURCE_URPF_EXEMPT);
 373
 374 done:
 375   unformat_free (line_input);
 376
 377   return (error);
 378 }
 379
 380 /*?
 381  * Add an exemption for a prefix to pass the Unicast Reverse Path
 382  * Forwarding (uRPF) loose check. This is for testing purposes only.
 383  * If the '<em>table</em>' is not enter it is defaulted to 0. Default
 384  * is to '<em>add</em>'. VPP always performs a loose uRPF check for
 385  * for-us traffic.
 386  *
 387  * @cliexpar
 388  * Example of how to add a uRPF exception to a FIB table to pass the
 389  * loose RPF tests:
 390  * @cliexcmd{set urpf-accept table 7 10.0.0.0/8 add}
 391 ?*/
 392 /* *INDENT-OFF* */
 393 VLIB_CLI_COMMAND (urpf_accept_command, static) = {
 394   .path = "set urpf-accept",
 395   .function = urpf_cli_accept,
 396   .short_help = "urpf-accept [table <table-id>] [add|del] <PREFIX>",
 397 };
 398 /* *INDENT-ON* */
 399
 400 /*
 401  * fd.io coding-style-patch-verification: ON
 402  *
 403  * Local Variables:
 404  * eval: (c-set-style "gnu")
 405  * End:
 406  */