src/plugins/wireguard/wireguard_cli.c

   1 /*
   2  * Copyright (c) 2020 Cisco and/or its affiliates.
   3  * Copyright (c) 2020 Doc.ai and/or its affiliates.
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <wireguard/wireguard.h>
  18 #include <wireguard/wireguard_key.h>
  19 #include <wireguard/wireguard_peer.h>
  20 #include <wireguard/wireguard_if.h>
  21
  22 static clib_error_t *
  23 wg_if_create_cli (vlib_main_t * vm,
  24                   unformat_input_t * input, vlib_cli_command_t * cmd)
  25 {
  26   wg_main_t *wmp = &wg_main;
  27   unformat_input_t _line_input, *line_input = &_line_input;
  28   u8 private_key[NOISE_PUBLIC_KEY_LEN];
  29   u32 instance, sw_if_index;
  30   ip_address_t src_ip;
  31   clib_error_t *error;
  32   u8 *private_key_64;
  33   u32 port, generate_key = 0;
  34   int rv;
  35
  36   error = NULL;
  37   instance = sw_if_index = ~0;
  38   private_key_64 = 0;
  39   port = 0;
  40
  41   wg_feature_init (wmp);
  42
  43   if (unformat_user (input, unformat_line_input, line_input))
  44     {
  45       while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
  46         {
  47           if (unformat (line_input, "instance %d", &instance))
  48             ;
  49           else if (unformat (line_input, "private-key %s", &private_key_64))
  50             {
  51               if (!(key_from_base64 (private_key_64,
  52                                      NOISE_KEY_LEN_BASE64, private_key)))
  53                 {
  54                   error = clib_error_return (0, "Error parsing private key");
  55                   break;
  56                 }
  57             }
  58           else if (unformat (line_input, "listen-port %d", &port))
  59             ;
  60           else if (unformat (line_input, "port %d", &port))
  61             ;
  62           else if (unformat (line_input, "generate-key"))
  63             generate_key = 1;
  64           else
  65             if (unformat (line_input, "src %U", unformat_ip_address, &src_ip))
  66             ;
  67           else
  68             {
  69               error = clib_error_return (0, "unknown input: %U",
  70                                          format_unformat_error, line_input);
  71               break;
  72             }
  73         }
  74
  75       unformat_free (line_input);
  76
  77       if (error)
  78         return error;
  79     }
  80
  81   if (generate_key)
  82     curve25519_gen_secret (private_key);
  83
  84   rv = wg_if_create (instance, private_key, port, &src_ip, &sw_if_index);
  85
  86   if (rv)
  87     return clib_error_return (0, "wireguard interface create failed");
  88
  89   vlib_cli_output (vm, "%U\n", format_vnet_sw_if_index_name, vnet_get_main (),
  90                    sw_if_index);
  91   return 0;
  92 }
  93
  94 /*?
  95  * Create a Wireguard interface.
  96 ?*/
  97 /* *INDENT-OFF* */
  98 VLIB_CLI_COMMAND (wg_if_create_command, static) = {
  99   .path = "wireguard create",
 100   .short_help = "wireguard create listen-port <port> "
 101     "private-key <key> src <IP> [generate-key]",
 102   .function = wg_if_create_cli,
 103 };
 104 /* *INDENT-ON* */
 105
 106 static clib_error_t *
 107 wg_if_delete_cli (vlib_main_t * vm,
 108                   unformat_input_t * input, vlib_cli_command_t * cmd)
 109 {
 110   wg_main_t *wmp = &wg_main;
 111   vnet_main_t *vnm;
 112   u32 sw_if_index;
 113   int rv;
 114
 115   wg_feature_init (wmp);
 116
 117   vnm = vnet_get_main ();
 118   sw_if_index = ~0;
 119
 120   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 121     {
 122       if (unformat
 123           (input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index))
 124         ;
 125       else
 126         break;
 127     }
 128
 129   if (~0 != sw_if_index)
 130     {
 131       rv = wg_if_delete (sw_if_index);
 132
 133       if (rv)
 134         return clib_error_return (0, "wireguard interface delete failed");
 135     }
 136   else
 137     return clib_error_return (0, "no such interface: %U",
 138                               format_unformat_error, input);
 139
 140   return 0;
 141 }
 142
 143 /*?
 144  * Delete a Wireguard interface.
 145 ?*/
 146 /* *INDENT-OFF* */
 147 VLIB_CLI_COMMAND (wg_if_delete_command, static) = {
 148   .path = "wireguard delete",
 149   .short_help = "wireguard delete <interface>",
 150   .function = wg_if_delete_cli,
 151 };
 152 /* *INDENT-ON* */
 153
 154
 155 static clib_error_t *
 156 wg_peer_add_command_fn (vlib_main_t * vm,
 157                         unformat_input_t * input, vlib_cli_command_t * cmd)
 158 {
 159   vnet_main_t *vnm = vnet_get_main ();
 160   wg_main_t *wmp = &wg_main;
 161   clib_error_t *error = NULL;
 162   unformat_input_t _line_input, *line_input = &_line_input;
 163
 164   u8 *public_key_64 = 0;
 165   u8 public_key[NOISE_PUBLIC_KEY_LEN];
 166   fib_prefix_t allowed_ip, *allowed_ips = NULL;
 167   ip_prefix_t pfx;
 168   ip_address_t ip;
 169   u32 portDst = 0, table_id = 0;
 170   u32 persistent_keepalive = 0;
 171   u32 tun_sw_if_index = ~0;
 172   u32 peer_index;
 173   int rv;
 174
 175   if (!unformat_user (input, unformat_line_input, line_input))
 176     return 0;
 177
 178   wg_feature_init (wmp);
 179
 180   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 181     {
 182       if (unformat (line_input, "public-key %s", &public_key_64))
 183         {
 184           if (!(key_from_base64 (public_key_64,
 185                                  NOISE_KEY_LEN_BASE64, public_key)))
 186             {
 187               error = clib_error_return (0, "Error parsing private key");
 188               goto done;
 189             }
 190         }
 191       else if (unformat (line_input, "endpoint %U", unformat_ip_address, &ip))
 192         ;
 193       else if (unformat (line_input, "table-id %d", &table_id))
 194         ;
 195       else if (unformat (line_input, "dst-port %d", &portDst))
 196         ;
 197       else if (unformat (line_input, "persistent-keepalive %d",
 198                          &persistent_keepalive))
 199         ;
 200       else if (unformat (line_input, "allowed-ip %U",
 201                          unformat_ip_prefix, &pfx))
 202         {
 203           ip_prefix_to_fib_prefix (&pfx, &allowed_ip);
 204           vec_add1 (allowed_ips, allowed_ip);
 205         }
 206       else if (unformat (line_input, "%U",
 207                          unformat_vnet_sw_interface, vnm, &tun_sw_if_index))
 208         ;
 209       else
 210         {
 211           error = clib_error_return (0, "Input error");
 212           goto done;
 213         }
 214     }
 215
 216   rv = wg_peer_add (tun_sw_if_index, public_key, table_id, &ip_addr_46 (&ip),
 217                     allowed_ips, portDst, persistent_keepalive, &peer_index);
 218
 219   switch (rv)
 220     {
 221     case VNET_API_ERROR_KEY_LENGTH:
 222       error = clib_error_return (0, "Error parsing public key");
 223       break;
 224     case VNET_API_ERROR_ENTRY_ALREADY_EXISTS:
 225       error = clib_error_return (0, "Peer already exist");
 226       break;
 227     case VNET_API_ERROR_INVALID_SW_IF_INDEX:
 228       error = clib_error_return (0, "Tunnel is not specified");
 229       break;
 230     case VNET_API_ERROR_LIMIT_EXCEEDED:
 231       error = clib_error_return (0, "Max peers limit");
 232       break;
 233     case VNET_API_ERROR_INIT_FAILED:
 234       error = clib_error_return (0, "wireguard device parameters is not set");
 235       break;
 236     case VNET_API_ERROR_INVALID_PROTOCOL:
 237       error = clib_error_return (0, "ipv6 not supported yet");
 238       break;
 239     }
 240
 241 done:
 242   vec_free (public_key_64);
 243   vec_free (allowed_ips);
 244   unformat_free (line_input);
 245   return error;
 246 }
 247
 248 /* *INDENT-OFF* */
 249 VLIB_CLI_COMMAND (wg_peer_add_command, static) = {
 250   .path = "wireguard peer add",
 251   .short_help =
 252     "wireguard peer add <wg_int> public-key <pub_key_other> "
 253     "endpoint <ip4_dst> allowed-ip <prefix> "
 254     "dst-port [port_dst] persistent-keepalive [keepalive_interval]",
 255   .function = wg_peer_add_command_fn,
 256 };
 257 /* *INDENT-ON* */
 258
 259 static clib_error_t *
 260 wg_peer_remove_command_fn (vlib_main_t * vm,
 261                            unformat_input_t * input, vlib_cli_command_t * cmd)
 262 {
 263   wg_main_t *wmp = &wg_main;
 264   clib_error_t *error = NULL;
 265   u32 peer_index;
 266   int rv;
 267
 268   unformat_input_t _line_input, *line_input = &_line_input;
 269   if (!unformat_user (input, unformat_line_input, line_input))
 270     return 0;
 271
 272   wg_feature_init (wmp);
 273
 274   if (unformat (line_input, "%d", &peer_index))
 275     ;
 276   else
 277     {
 278       error = clib_error_return (0, "Input error");
 279       goto done;
 280     }
 281
 282   rv = wg_peer_remove (peer_index);
 283
 284   switch (rv)
 285     {
 286     case VNET_API_ERROR_KEY_LENGTH:
 287       error = clib_error_return (0, "Error parsing public key");
 288       break;
 289     }
 290
 291 done:
 292   unformat_free (line_input);
 293   return error;
 294 }
 295
 296 /* *INDENT-OFF* */
 297 VLIB_CLI_COMMAND (wg_peer_remove_command, static) =
 298 {
 299   .path = "wireguard peer remove",
 300   .short_help = "wireguard peer remove <index>",
 301   .function = wg_peer_remove_command_fn,
 302 };
 303 /* *INDENT-ON* */
 304
 305 static walk_rc_t
 306 wg_peer_show_one (index_t peeri, void *arg)
 307 {
 308   vlib_cli_output (arg, "%U", format_wg_peer, peeri);
 309
 310   return (WALK_CONTINUE);
 311 }
 312
 313 static clib_error_t *
 314 wg_show_peer_command_fn (vlib_main_t * vm,
 315                          unformat_input_t * input, vlib_cli_command_t * cmd)
 316 {
 317   wg_peer_walk (wg_peer_show_one, vm);
 318
 319   return NULL;
 320 }
 321
 322 /* *INDENT-OFF* */
 323 VLIB_CLI_COMMAND (wg_show_peers_command, static) =
 324 {
 325   .path = "show wireguard peer",
 326   .short_help = "show wireguard peer",
 327   .function = wg_show_peer_command_fn,
 328 };
 329 /* *INDENT-ON* */
 330
 331 static walk_rc_t
 332 wg_if_show_one (index_t itfi, void *arg)
 333 {
 334   vlib_cli_output (arg, "%U", format_wg_if, itfi);
 335
 336   return (WALK_CONTINUE);
 337 }
 338
 339 static clib_error_t *
 340 wg_show_if_command_fn (vlib_main_t * vm,
 341                        unformat_input_t * input, vlib_cli_command_t * cmd)
 342 {
 343   wg_main_t *wmp = &wg_main;
 344
 345   wg_feature_init (wmp);
 346
 347   wg_if_walk (wg_if_show_one, vm);
 348
 349   return NULL;
 350 }
 351
 352 /* *INDENT-OFF* */
 353 VLIB_CLI_COMMAND (wg_show_itfs_command, static) =
 354 {
 355   .path = "show wireguard interface",
 356   .short_help = "show wireguard",
 357   .function = wg_show_if_command_fn,
 358 };
 359
 360 static clib_error_t *
 361 wg_set_async_mode_command_fn (vlib_main_t *vm, unformat_input_t *input,
 362                               vlib_cli_command_t *cmd)
 363 {
 364   unformat_input_t _line_input, *line_input = &_line_input;
 365   int async_enable = 0;
 366
 367   if (!unformat_user (input, unformat_line_input, line_input))
 368     return 0;
 369
 370   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 371     {
 372       if (unformat (line_input, "on"))
 373         async_enable = 1;
 374       else if (unformat (line_input, "off"))
 375         async_enable = 0;
 376       else
 377         return (clib_error_return (0, "unknown input '%U'",
 378                                    format_unformat_error, line_input));
 379     }
 380
 381   wg_set_async_mode (async_enable);
 382
 383   unformat_free (line_input);
 384   return (NULL);
 385 }
 386
 387 VLIB_CLI_COMMAND (wg_set_async_mode_command, static) = {
 388   .path = "set wireguard async mode",
 389   .short_help = "set wireguard async mode on|off",
 390   .function = wg_set_async_mode_command_fn,
 391 };
 392
 393 static clib_error_t *
 394 wg_show_mode_command_fn (vlib_main_t *vm, unformat_input_t *input,
 395                          vlib_cli_command_t *cmd)
 396 {
 397   vlib_cli_output (vm, "Wireguard mode");
 398
 399 #define _(v, f, s)                                                            \
 400   vlib_cli_output (vm, "\t%s: %s", s,                                         \
 401                    (wg_op_mode_is_set_##f () ? "enabled" : "disabled"));
 402   foreach_wg_op_mode_flags
 403 #undef _
 404
 405     return (NULL);
 406 }
 407
 408 VLIB_CLI_COMMAND (wg_show_modemode_command, static) = {
 409   .path = "show wireguard mode",
 410   .short_help = "show wireguard mode",
 411   .function = wg_show_mode_command_fn,
 412 };
 413
 414 /* *INDENT-ON* */
 415
 416 /*
 417  * fd.io coding-style-patch-verification: ON
 418  *
 419  * Local Variables:
 420  * eval: (c-set-style "gnu")
 421  * End:
 422  */