wireguard: add async mode for encryption packets
[vpp.git] / 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  */