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