src/plugins/wireguard/wireguard_api.c

   1 /*
   2  * Copyright (c) 2020 Doc.ai 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 <vnet/vnet.h>
  17 #include <vlibmemory/api.h>
  18
  19 #include <vnet/format_fns.h>
  20 #include <vnet/ip/ip_types_api.h>
  21 #include <vlibapi/api.h>
  22
  23 #include <wireguard/wireguard.api_enum.h>
  24 #include <wireguard/wireguard.api_types.h>
  25
  26 #include <wireguard/wireguard_key.h>
  27 #include <wireguard/wireguard.h>
  28 #include <wireguard/wireguard_if.h>
  29 #include <wireguard/wireguard_peer.h>
  30
  31 #define REPLY_MSG_ID_BASE wmp->msg_id_base
  32 #include <vlibapi/api_helper_macros.h>
  33
  34 static void
  35   vl_api_wireguard_interface_create_t_handler
  36   (vl_api_wireguard_interface_create_t * mp)
  37 {
  38   vl_api_wireguard_interface_create_reply_t *rmp;
  39   wg_main_t *wmp = &wg_main;
  40   u8 private_key[NOISE_PUBLIC_KEY_LEN];
  41   ip_address_t src;
  42   u32 sw_if_index;
  43   int rv = 0;
  44
  45   ip_address_decode2 (&mp->interface.src_ip, &src);
  46
  47   if (AF_IP6 == ip_addr_version (&src))
  48     rv = VNET_API_ERROR_INVALID_PROTOCOL;
  49   else
  50     {
  51       if (mp->generate_key)
  52         curve25519_gen_secret (private_key);
  53       else
  54         clib_memcpy (private_key, mp->interface.private_key,
  55                      NOISE_PUBLIC_KEY_LEN);
  56
  57       rv = wg_if_create (ntohl (mp->interface.user_instance), private_key,
  58                          ntohs (mp->interface.port), &src, &sw_if_index);
  59     }
  60
  61   /* *INDENT-OFF* */
  62   REPLY_MACRO2(VL_API_WIREGUARD_INTERFACE_CREATE_REPLY,
  63   {
  64     rmp->sw_if_index = htonl(sw_if_index);
  65   });
  66   /* *INDENT-ON* */
  67 }
  68
  69 static void
  70   vl_api_wireguard_interface_delete_t_handler
  71   (vl_api_wireguard_interface_delete_t * mp)
  72 {
  73   vl_api_wireguard_interface_delete_reply_t *rmp;
  74   wg_main_t *wmp = &wg_main;
  75   int rv = 0;
  76
  77   VALIDATE_SW_IF_INDEX (mp);
  78
  79   rv = wg_if_delete (ntohl (mp->sw_if_index));
  80
  81   BAD_SW_IF_INDEX_LABEL;
  82
  83   /* *INDENT-OFF* */
  84   REPLY_MACRO(VL_API_WIREGUARD_INTERFACE_DELETE_REPLY);
  85   /* *INDENT-ON* */
  86 }
  87
  88 typedef struct wg_deatils_walk_t_
  89 {
  90   vl_api_registration_t *reg;
  91   u32 context;
  92 } wg_deatils_walk_t;
  93
  94 static walk_rc_t
  95 wireguard_if_send_details (index_t wgii, void *data)
  96 {
  97   vl_api_wireguard_interface_details_t *rmp;
  98   wg_deatils_walk_t *ctx = data;
  99   const wg_if_t *wgi;
 100
 101   wgi = wg_if_get (wgii);
 102
 103   rmp = vl_msg_api_alloc_zero (sizeof (*rmp));
 104   rmp->_vl_msg_id = htons (VL_API_WIREGUARD_INTERFACE_DETAILS +
 105                            wg_main.msg_id_base);
 106
 107   clib_memcpy (rmp->interface.private_key,
 108                wgi->local.l_private, NOISE_PUBLIC_KEY_LEN);
 109   rmp->interface.sw_if_index = htonl (wgi->sw_if_index);
 110   rmp->interface.port = htons (wgi->port);
 111   ip_address_encode2 (&wgi->src_ip, &rmp->interface.src_ip);
 112
 113   rmp->context = ctx->context;
 114
 115   vl_api_send_msg (ctx->reg, (u8 *) rmp);
 116
 117   return (WALK_CONTINUE);
 118 }
 119
 120 static void
 121 vl_api_wireguard_interface_dump_t_handler (vl_api_wireguard_interface_dump_t *
 122                                            mp)
 123 {
 124   vl_api_registration_t *reg;
 125
 126   reg = vl_api_client_index_to_registration (mp->client_index);
 127   if (reg == 0)
 128     return;
 129
 130   wg_deatils_walk_t ctx = {
 131     .reg = reg,
 132     .context = mp->context,
 133   };
 134
 135   wg_if_walk (wireguard_if_send_details, &ctx);
 136 }
 137
 138 static void
 139 vl_api_wireguard_peer_add_t_handler (vl_api_wireguard_peer_add_t * mp)
 140 {
 141   vl_api_wireguard_peer_add_reply_t *rmp;
 142   wg_main_t *wmp = &wg_main;
 143   index_t peeri;
 144   int ii, rv = 0;
 145
 146   ip_address_t endpoint;
 147   fib_prefix_t *allowed_ips = NULL;
 148
 149   VALIDATE_SW_IF_INDEX (&(mp->peer));
 150
 151   if (0 == mp->peer.n_allowed_ips)
 152     {
 153       rv = VNET_API_ERROR_INVALID_VALUE;
 154       goto done;
 155     }
 156
 157   vec_validate (allowed_ips, mp->peer.n_allowed_ips - 1);
 158   ip_address_decode2 (&mp->peer.endpoint, &endpoint);
 159
 160   for (ii = 0; ii < mp->peer.n_allowed_ips; ii++)
 161     ip_prefix_decode (&mp->peer.allowed_ips[ii], &allowed_ips[ii]);
 162
 163   if (AF_IP6 == ip_addr_version (&endpoint) ||
 164       FIB_PROTOCOL_IP6 == allowed_ips[0].fp_proto)
 165     /* ip6 currently not supported, but the API needs to support it
 166      * else we'll need to change it later, and that's a PITA */
 167     rv = VNET_API_ERROR_INVALID_PROTOCOL;
 168   else
 169     rv = wg_peer_add (ntohl (mp->peer.sw_if_index),
 170                       mp->peer.public_key,
 171                       ntohl (mp->peer.table_id),
 172                       &ip_addr_46 (&endpoint),
 173                       allowed_ips,
 174                       ntohs (mp->peer.port),
 175                       ntohs (mp->peer.persistent_keepalive), &peeri);
 176
 177   vec_free (allowed_ips);
 178 done:
 179   BAD_SW_IF_INDEX_LABEL;
 180   /* *INDENT-OFF* */
 181   REPLY_MACRO2(VL_API_WIREGUARD_PEER_ADD_REPLY,
 182   {
 183     rmp->peer_index = ntohl (peeri);
 184   });
 185   /* *INDENT-ON* */
 186 }
 187
 188 static void
 189 vl_api_wireguard_peer_remove_t_handler (vl_api_wireguard_peer_remove_t * mp)
 190 {
 191   vl_api_wireguard_peer_remove_reply_t *rmp;
 192   wg_main_t *wmp = &wg_main;
 193   int rv = 0;
 194
 195   rv = wg_peer_remove (ntohl (mp->peer_index));
 196
 197   /* *INDENT-OFF* */
 198   REPLY_MACRO(VL_API_WIREGUARD_PEER_REMOVE_REPLY);
 199   /* *INDENT-ON* */
 200 }
 201
 202 static walk_rc_t
 203 send_wg_peers_details (index_t peeri, void *data)
 204 {
 205   vl_api_wireguard_peers_details_t *rmp;
 206   wg_deatils_walk_t *ctx = data;
 207   const wg_peer_t *peer;
 208   u8 n_allowed_ips;
 209   size_t ss;
 210
 211   peer = wg_peer_get (peeri);
 212   n_allowed_ips = vec_len (peer->allowed_ips);
 213
 214   ss = (sizeof (*rmp) + (n_allowed_ips * sizeof (rmp->peer.allowed_ips[0])));
 215
 216   rmp = vl_msg_api_alloc_zero (ss);
 217
 218   rmp->_vl_msg_id = htons (VL_API_WIREGUARD_PEERS_DETAILS +
 219                            wg_main.msg_id_base);
 220
 221   if (peer->is_dead)
 222     rmp->peer.flags = WIREGUARD_PEER_STATUS_DEAD;
 223   clib_memcpy (rmp->peer.public_key,
 224                peer->remote.r_public, NOISE_PUBLIC_KEY_LEN);
 225
 226   ip_address_encode (&peer->dst.addr, IP46_TYPE_ANY, &rmp->peer.endpoint);
 227   rmp->peer.port = htons (peer->dst.port);
 228   rmp->peer.n_allowed_ips = n_allowed_ips;
 229   rmp->peer.sw_if_index = htonl (peer->wg_sw_if_index);
 230
 231   int ii;
 232   for (ii = 0; ii < n_allowed_ips; ii++)
 233     ip_prefix_encode (&peer->allowed_ips[ii].prefix,
 234                       &rmp->peer.allowed_ips[ii]);
 235
 236   rmp->context = ctx->context;
 237
 238   vl_api_send_msg (ctx->reg, (u8 *) rmp);
 239
 240   return (WALK_CONTINUE);
 241 }
 242
 243 static void
 244 vl_api_wireguard_peers_dump_t_handler (vl_api_wireguard_peers_dump_t * mp)
 245 {
 246   vl_api_registration_t *reg;
 247
 248   reg = vl_api_client_index_to_registration (mp->client_index);
 249   if (reg == NULL)
 250     return;
 251
 252   wg_deatils_walk_t ctx = {
 253     .reg = reg,
 254     .context = mp->context,
 255   };
 256
 257   wg_peer_walk (send_wg_peers_details, &ctx);
 258 }
 259
 260 /* set tup the API message handling tables */
 261 #include <wireguard/wireguard.api.c>
 262 static clib_error_t *
 263 wg_api_hookup (vlib_main_t * vm)
 264 {
 265   wg_main_t *wmp = &wg_main;
 266   wmp->msg_id_base = setup_message_id_table ();
 267   return 0;
 268 }
 269
 270 VLIB_API_INIT_FUNCTION (wg_api_hookup);
 271
 272 /*
 273  * fd.io coding-style-patch-verification: ON
 274  *
 275  * Local Variables:
 276  * eval: (c-set-style "gnu")
 277  * End:
 278  */