src/plugins/wireguard/wireguard_input.c

   1 /*
   2  * Copyright (c) 2020 Doc.ai and/or its affiliates.
   3  * Copyright (c) 2020 Cisco 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 <vlib/vlib.h>
  18 #include <vnet/vnet.h>
  19 #include <vppinfra/error.h>
  20 #include <wireguard/wireguard.h>
  21
  22 #include <wireguard/wireguard_send.h>
  23 #include <wireguard/wireguard_if.h>
  24
  25 #define foreach_wg_input_error                                                \
  26   _ (NONE, "No error")                                                        \
  27   _ (HANDSHAKE_MAC, "Invalid MAC handshake")                                  \
  28   _ (HANDSHAKE_RATELIMITED, "Handshake ratelimited")                          \
  29   _ (PEER, "Peer error")                                                      \
  30   _ (INTERFACE, "Interface error")                                            \
  31   _ (DECRYPTION, "Failed during decryption")                                  \
  32   _ (KEEPALIVE_SEND, "Failed while sending Keepalive")                        \
  33   _ (HANDSHAKE_SEND, "Failed while sending Handshake")                        \
  34   _ (HANDSHAKE_RECEIVE, "Failed while receiving Handshake")                   \
  35   _ (COOKIE_DECRYPTION, "Failed during Cookie decryption")                    \
  36   _ (COOKIE_SEND, "Failed during sending Cookie")                             \
  37   _ (NO_BUFFERS, "No buffers")                                                \
  38   _ (UNDEFINED, "Undefined error")                                            \
  39   _ (CRYPTO_ENGINE_ERROR, "crypto engine error (packet dropped)")
  40
  41 typedef enum
  42 {
  43 #define _(sym,str) WG_INPUT_ERROR_##sym,
  44   foreach_wg_input_error
  45 #undef _
  46     WG_INPUT_N_ERROR,
  47 } wg_input_error_t;
  48
  49 static char *wg_input_error_strings[] = {
  50 #define _(sym,string) string,
  51   foreach_wg_input_error
  52 #undef _
  53 };
  54
  55 typedef struct
  56 {
  57   message_type_t type;
  58   u16 current_length;
  59   bool is_keepalive;
  60   index_t peer;
  61 } wg_input_trace_t;
  62
  63 typedef struct
  64 {
  65   index_t peer;
  66   u16 next;
  67 } wg_input_post_trace_t;
  68
  69 u8 *
  70 format_wg_message_type (u8 * s, va_list * args)
  71 {
  72   message_type_t type = va_arg (*args, message_type_t);
  73
  74   switch (type)
  75     {
  76 #define _(v,a) case MESSAGE_##v: return (format (s, "%s", a));
  77       foreach_wg_message_type
  78 #undef _
  79     }
  80   return (format (s, "unknown"));
  81 }
  82
  83 /* packet trace format function */
  84 static u8 *
  85 format_wg_input_trace (u8 * s, va_list * args)
  86 {
  87   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  88   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  89
  90   wg_input_trace_t *t = va_arg (*args, wg_input_trace_t *);
  91
  92   s = format (s, "Wireguard input: \n");
  93   s = format (s, "    Type: %U\n", format_wg_message_type, t->type);
  94   s = format (s, "    Peer: %d\n", t->peer);
  95   s = format (s, "    Length: %d\n", t->current_length);
  96   s = format (s, "    Keepalive: %s", t->is_keepalive ? "true" : "false");
  97
  98   return s;
  99 }
 100
 101 /* post-node packet trace format function */
 102 static u8 *
 103 format_wg_input_post_trace (u8 *s, va_list *args)
 104 {
 105   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
 106   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
 107
 108   wg_input_post_trace_t *t = va_arg (*args, wg_input_post_trace_t *);
 109
 110   s = format (s, "WG input post: \n");
 111   s = format (s, "  peer: %u\n", t->peer);
 112   s = format (s, "  next: %u\n", t->next);
 113
 114   return s;
 115 }
 116
 117 typedef enum
 118 {
 119   WG_INPUT_NEXT_HANDOFF_HANDSHAKE,
 120   WG_INPUT_NEXT_HANDOFF_DATA,
 121   WG_INPUT_NEXT_IP4_INPUT,
 122   WG_INPUT_NEXT_IP6_INPUT,
 123   WG_INPUT_NEXT_PUNT,
 124   WG_INPUT_NEXT_ERROR,
 125   WG_INPUT_N_NEXT,
 126 } wg_input_next_t;
 127
 128 static u8
 129 is_ip4_header (u8 *data)
 130 {
 131   return (data[0] >> 4) == 0x4;
 132 }
 133
 134 static wg_input_error_t
 135 wg_handshake_process (vlib_main_t *vm, wg_main_t *wmp, vlib_buffer_t *b,
 136                       u32 node_idx, u8 is_ip4)
 137 {
 138   ASSERT (vm->thread_index == 0);
 139
 140   enum cookie_mac_state mac_state;
 141   bool packet_needs_cookie;
 142   bool under_load;
 143   index_t *wg_ifs;
 144   wg_if_t *wg_if;
 145   wg_peer_t *peer = NULL;
 146
 147   void *current_b_data = vlib_buffer_get_current (b);
 148
 149   ip46_address_t src_ip;
 150   if (is_ip4)
 151     {
 152       ip4_header_t *iph4 =
 153         current_b_data - sizeof (udp_header_t) - sizeof (ip4_header_t);
 154       ip46_address_set_ip4 (&src_ip, &iph4->src_address);
 155     }
 156   else
 157     {
 158       ip6_header_t *iph6 =
 159         current_b_data - sizeof (udp_header_t) - sizeof (ip6_header_t);
 160       ip46_address_set_ip6 (&src_ip, &iph6->src_address);
 161     }
 162
 163   udp_header_t *uhd = current_b_data - sizeof (udp_header_t);
 164   u16 udp_src_port = clib_host_to_net_u16 (uhd->src_port);
 165   u16 udp_dst_port = clib_host_to_net_u16 (uhd->dst_port);
 166
 167   message_header_t *header = current_b_data;
 168
 169   if (PREDICT_FALSE (header->type == MESSAGE_HANDSHAKE_COOKIE))
 170     {
 171       message_handshake_cookie_t *packet =
 172         (message_handshake_cookie_t *) current_b_data;
 173       u32 *entry =
 174         wg_index_table_lookup (&wmp->index_table, packet->receiver_index);
 175       if (entry)
 176         peer = wg_peer_get (*entry);
 177       else
 178         return WG_INPUT_ERROR_PEER;
 179
 180       if (!cookie_maker_consume_payload (
 181             vm, &peer->cookie_maker, packet->nonce, packet->encrypted_cookie))
 182         return WG_INPUT_ERROR_COOKIE_DECRYPTION;
 183
 184       return WG_INPUT_ERROR_NONE;
 185     }
 186
 187   u32 len = (header->type == MESSAGE_HANDSHAKE_INITIATION ?
 188              sizeof (message_handshake_initiation_t) :
 189              sizeof (message_handshake_response_t));
 190
 191   message_macs_t *macs = (message_macs_t *)
 192     ((u8 *) current_b_data + len - sizeof (*macs));
 193
 194   index_t *ii;
 195   wg_ifs = wg_if_indexes_get_by_port (udp_dst_port);
 196   if (NULL == wg_ifs)
 197     return WG_INPUT_ERROR_INTERFACE;
 198
 199   vec_foreach (ii, wg_ifs)
 200     {
 201       wg_if = wg_if_get (*ii);
 202       if (NULL == wg_if)
 203         continue;
 204
 205       under_load = wg_if_is_under_load (vm, wg_if);
 206       mac_state = cookie_checker_validate_macs (
 207         vm, &wg_if->cookie_checker, macs, current_b_data, len, under_load,
 208         &src_ip, udp_src_port);
 209       if (mac_state == INVALID_MAC)
 210         {
 211           wg_if_dec_handshake_num (wg_if);
 212           wg_if = NULL;
 213           continue;
 214         }
 215       break;
 216     }
 217
 218   if (NULL == wg_if)
 219     return WG_INPUT_ERROR_HANDSHAKE_MAC;
 220
 221   if ((under_load && mac_state == VALID_MAC_WITH_COOKIE)
 222       || (!under_load && mac_state == VALID_MAC_BUT_NO_COOKIE))
 223     packet_needs_cookie = false;
 224   else if (under_load && mac_state == VALID_MAC_BUT_NO_COOKIE)
 225     packet_needs_cookie = true;
 226   else if (mac_state == VALID_MAC_WITH_COOKIE_BUT_RATELIMITED)
 227     return WG_INPUT_ERROR_HANDSHAKE_RATELIMITED;
 228   else
 229     return WG_INPUT_ERROR_HANDSHAKE_MAC;
 230
 231   switch (header->type)
 232     {
 233     case MESSAGE_HANDSHAKE_INITIATION:
 234       {
 235         message_handshake_initiation_t *message = current_b_data;
 236
 237         if (packet_needs_cookie)
 238           {
 239
 240             if (!wg_send_handshake_cookie (vm, message->sender_index,
 241                                            &wg_if->cookie_checker, macs,
 242                                            &ip_addr_46 (&wg_if->src_ip),
 243                                            wg_if->port, &src_ip, udp_src_port))
 244               return WG_INPUT_ERROR_COOKIE_SEND;
 245
 246             return WG_INPUT_ERROR_NONE;
 247           }
 248
 249         noise_remote_t *rp;
 250         if (noise_consume_initiation
 251             (vm, noise_local_get (wg_if->local_idx), &rp,
 252              message->sender_index, message->unencrypted_ephemeral,
 253              message->encrypted_static, message->encrypted_timestamp))
 254           {
 255             peer = wg_peer_get (rp->r_peer_idx);
 256           }
 257         else
 258           {
 259             return WG_INPUT_ERROR_PEER;
 260           }
 261
 262         wg_peer_update_endpoint (rp->r_peer_idx, &src_ip, udp_src_port);
 263
 264         if (PREDICT_FALSE (!wg_send_handshake_response (vm, peer)))
 265           {
 266             vlib_node_increment_counter (vm, node_idx,
 267                                          WG_INPUT_ERROR_HANDSHAKE_SEND, 1);
 268           }
 269         break;
 270       }
 271     case MESSAGE_HANDSHAKE_RESPONSE:
 272       {
 273         message_handshake_response_t *resp = current_b_data;
 274
 275         if (packet_needs_cookie)
 276           {
 277             if (!wg_send_handshake_cookie (vm, resp->sender_index,
 278                                            &wg_if->cookie_checker, macs,
 279                                            &ip_addr_46 (&wg_if->src_ip),
 280                                            wg_if->port, &src_ip, udp_src_port))
 281               return WG_INPUT_ERROR_COOKIE_SEND;
 282
 283             return WG_INPUT_ERROR_NONE;
 284           }
 285
 286         index_t peeri = INDEX_INVALID;
 287         u32 *entry =
 288           wg_index_table_lookup (&wmp->index_table, resp->receiver_index);
 289
 290         if (PREDICT_TRUE (entry != NULL))
 291           {
 292             peeri = *entry;
 293             peer = wg_peer_get (peeri);
 294             if (wg_peer_is_dead (peer))
 295               return WG_INPUT_ERROR_PEER;
 296           }
 297         else
 298           return WG_INPUT_ERROR_PEER;
 299
 300         if (!noise_consume_response
 301             (vm, &peer->remote, resp->sender_index,
 302              resp->receiver_index, resp->unencrypted_ephemeral,
 303              resp->encrypted_nothing))
 304           {
 305             return WG_INPUT_ERROR_PEER;
 306           }
 307
 308         wg_peer_update_endpoint (peeri, &src_ip, udp_src_port);
 309
 310         if (noise_remote_begin_session (vm, &peer->remote))
 311           {
 312
 313             wg_timers_session_derived (peer);
 314             wg_timers_handshake_complete (peer);
 315             if (PREDICT_FALSE (!wg_send_keepalive (vm, peer)))
 316               {
 317                 vlib_node_increment_counter (vm, node_idx,
 318                                              WG_INPUT_ERROR_KEEPALIVE_SEND, 1);
 319               }
 320             else
 321               {
 322                 wg_peer_update_flags (peeri, WG_PEER_ESTABLISHED, true);
 323               }
 324           }
 325         break;
 326       }
 327     default:
 328       return WG_INPUT_ERROR_HANDSHAKE_RECEIVE;
 329     }
 330
 331   wg_timers_any_authenticated_packet_received (peer);
 332   wg_timers_any_authenticated_packet_traversal (peer);
 333   return WG_INPUT_ERROR_NONE;
 334 }
 335
 336 static_always_inline int
 337 wg_input_post_process (vlib_main_t *vm, vlib_buffer_t *b, u16 *next,
 338                        wg_peer_t *peer, message_data_t *data,
 339                        bool *is_keepalive)
 340 {
 341   next[0] = WG_INPUT_NEXT_PUNT;
 342   noise_keypair_t *kp;
 343   vlib_buffer_t *lb;
 344
 345   if ((kp = wg_get_active_keypair (&peer->remote, data->receiver_index)) ==
 346       NULL)
 347     return -1;
 348
 349   if (!noise_counter_recv (&kp->kp_ctr, data->counter))
 350     {
 351       return -1;
 352     }
 353
 354   lb = b;
 355   /* Find last buffer in the chain */
 356   while (lb->flags & VLIB_BUFFER_NEXT_PRESENT)
 357     lb = vlib_get_buffer (vm, lb->next_buffer);
 358
 359   u16 encr_len = vlib_buffer_length_in_chain (vm, b) - sizeof (message_data_t);
 360   u16 decr_len = encr_len - NOISE_AUTHTAG_LEN;
 361
 362   vlib_buffer_advance (b, sizeof (message_data_t));
 363   vlib_buffer_chain_increase_length (b, lb, -NOISE_AUTHTAG_LEN);
 364   vnet_buffer_offload_flags_clear (b, VNET_BUFFER_OFFLOAD_F_UDP_CKSUM);
 365
 366   /* Keepalive packet has zero length */
 367   if (decr_len == 0)
 368     {
 369       *is_keepalive = true;
 370       return 0;
 371     }
 372
 373   wg_timers_data_received (peer);
 374
 375   ip46_address_t src_ip;
 376   u8 is_ip4_inner = is_ip4_header (vlib_buffer_get_current (b));
 377   if (is_ip4_inner)
 378     {
 379       ip46_address_set_ip4 (
 380         &src_ip, &((ip4_header_t *) vlib_buffer_get_current (b))->src_address);
 381     }
 382   else
 383     {
 384       ip46_address_set_ip6 (
 385         &src_ip, &((ip6_header_t *) vlib_buffer_get_current (b))->src_address);
 386     }
 387
 388   const fib_prefix_t *allowed_ip;
 389   bool allowed = false;
 390
 391   /*
 392    * we could make this into an ACL, but the expectation
 393    * is that there aren't many allowed IPs and thus a linear
 394    * walk is faster than an ACL
 395    */
 396   vec_foreach (allowed_ip, peer->allowed_ips)
 397     {
 398       if (fib_prefix_is_cover_addr_46 (allowed_ip, &src_ip))
 399         {
 400           allowed = true;
 401           break;
 402         }
 403     }
 404   if (allowed)
 405     {
 406       vnet_buffer (b)->sw_if_index[VLIB_RX] = peer->wg_sw_if_index;
 407       next[0] =
 408         is_ip4_inner ? WG_INPUT_NEXT_IP4_INPUT : WG_INPUT_NEXT_IP6_INPUT;
 409     }
 410
 411   return 0;
 412 }
 413
 414 static_always_inline void
 415 wg_input_process_ops (vlib_main_t *vm, vlib_node_runtime_t *node,
 416                       vnet_crypto_op_t *ops, vlib_buffer_t *b[], u16 *nexts,
 417                       u16 drop_next)
 418 {
 419   u32 n_fail, n_ops = vec_len (ops);
 420   vnet_crypto_op_t *op = ops;
 421
 422   if (n_ops == 0)
 423     return;
 424
 425   n_fail = n_ops - vnet_crypto_process_ops (vm, op, n_ops);
 426
 427   while (n_fail)
 428     {
 429       ASSERT (op - ops < n_ops);
 430
 431       if (op->status != VNET_CRYPTO_OP_STATUS_COMPLETED)
 432         {
 433           u32 bi = op->user_data;
 434           b[bi]->error = node->errors[WG_INPUT_ERROR_DECRYPTION];
 435           nexts[bi] = drop_next;
 436           n_fail--;
 437         }
 438       op++;
 439     }
 440 }
 441
 442 static_always_inline void
 443 wg_input_process_chained_ops (vlib_main_t *vm, vlib_node_runtime_t *node,
 444                               vnet_crypto_op_t *ops, vlib_buffer_t *b[],
 445                               u16 *nexts, vnet_crypto_op_chunk_t *chunks,
 446                               u16 drop_next)
 447 {
 448   u32 n_fail, n_ops = vec_len (ops);
 449   vnet_crypto_op_t *op = ops;
 450
 451   if (n_ops == 0)
 452     return;
 453
 454   n_fail = n_ops - vnet_crypto_process_chained_ops (vm, op, chunks, n_ops);
 455
 456   while (n_fail)
 457     {
 458       ASSERT (op - ops < n_ops);
 459
 460       if (op->status != VNET_CRYPTO_OP_STATUS_COMPLETED)
 461         {
 462           u32 bi = op->user_data;
 463           b[bi]->error = node->errors[WG_INPUT_ERROR_DECRYPTION];
 464           nexts[bi] = drop_next;
 465           n_fail--;
 466         }
 467       op++;
 468     }
 469 }
 470
 471 static_always_inline void
 472 wg_input_chain_crypto (vlib_main_t *vm, wg_per_thread_data_t *ptd,
 473                        vlib_buffer_t *b, vlib_buffer_t *lb, u8 *start,
 474                        u32 start_len, u16 *n_ch)
 475 {
 476   vnet_crypto_op_chunk_t *ch;
 477   vlib_buffer_t *cb = b;
 478   u32 n_chunks = 1;
 479
 480   vec_add2 (ptd->chunks, ch, 1);
 481   ch->len = start_len;
 482   ch->src = ch->dst = start;
 483   cb = vlib_get_buffer (vm, cb->next_buffer);
 484
 485   while (1)
 486     {
 487       vec_add2 (ptd->chunks, ch, 1);
 488       n_chunks += 1;
 489       if (lb == cb)
 490         ch->len = cb->current_length - NOISE_AUTHTAG_LEN;
 491       else
 492         ch->len = cb->current_length;
 493
 494       ch->src = ch->dst = vlib_buffer_get_current (cb);
 495
 496       if (!(cb->flags & VLIB_BUFFER_NEXT_PRESENT))
 497         break;
 498
 499       cb = vlib_get_buffer (vm, cb->next_buffer);
 500     }
 501
 502   if (n_ch)
 503     *n_ch = n_chunks;
 504 }
 505
 506 always_inline void
 507 wg_prepare_sync_dec_op (vlib_main_t *vm, wg_per_thread_data_t *ptd,
 508                         vlib_buffer_t *b, vlib_buffer_t *lb,
 509                         vnet_crypto_op_t **crypto_ops, u8 *src, u32 src_len,
 510                         u8 *dst, u8 *aad, u32 aad_len,
 511                         vnet_crypto_key_index_t key_index, u32 bi, u8 *iv)
 512 {
 513   vnet_crypto_op_t _op, *op = &_op;
 514   u8 src_[] = {};
 515
 516   vec_add2_aligned (crypto_ops[0], op, 1, CLIB_CACHE_LINE_BYTES);
 517   vnet_crypto_op_init (op, VNET_CRYPTO_OP_CHACHA20_POLY1305_DEC);
 518
 519   op->tag_len = NOISE_AUTHTAG_LEN;
 520   op->tag = vlib_buffer_get_tail (lb) - NOISE_AUTHTAG_LEN;
 521   op->key_index = key_index;
 522   op->aad = aad;
 523   op->aad_len = aad_len;
 524   op->iv = iv;
 525   op->user_data = bi;
 526   op->flags |= VNET_CRYPTO_OP_FLAG_HMAC_CHECK;
 527
 528   if (b != lb)
 529     {
 530       /* Chained buffers */
 531       op->flags |= VNET_CRYPTO_OP_FLAG_CHAINED_BUFFERS;
 532       op->chunk_index = vec_len (ptd->chunks);
 533       wg_input_chain_crypto (vm, ptd, b, lb, src, src_len + NOISE_AUTHTAG_LEN,
 534                              &op->n_chunks);
 535     }
 536   else
 537     {
 538       op->src = !src ? src_ : src;
 539       op->len = src_len;
 540       op->dst = dst;
 541     }
 542 }
 543
 544 static_always_inline void
 545 wg_input_add_to_frame (vlib_main_t *vm, vnet_crypto_async_frame_t *f,
 546                        u32 key_index, u32 crypto_len, i16 crypto_start_offset,
 547                        u32 buffer_index, u16 next_node, u8 *iv, u8 *tag,
 548                        u8 flags)
 549 {
 550   vnet_crypto_async_frame_elt_t *fe;
 551   u16 index;
 552
 553   ASSERT (f->n_elts < VNET_CRYPTO_FRAME_SIZE);
 554
 555   index = f->n_elts;
 556   fe = &f->elts[index];
 557   f->n_elts++;
 558   fe->key_index = key_index;
 559   fe->crypto_total_length = crypto_len;
 560   fe->crypto_start_offset = crypto_start_offset;
 561   fe->iv = iv;
 562   fe->tag = tag;
 563   fe->flags = flags;
 564   f->buffer_indices[index] = buffer_index;
 565   f->next_node_index[index] = next_node;
 566 }
 567
 568 static_always_inline enum noise_state_crypt
 569 wg_input_process (vlib_main_t *vm, wg_per_thread_data_t *ptd,
 570                   vnet_crypto_op_t **crypto_ops,
 571                   vnet_crypto_async_frame_t **async_frame, vlib_buffer_t *b,
 572                   vlib_buffer_t *lb, u32 buf_idx, noise_remote_t *r,
 573                   uint32_t r_idx, uint64_t nonce, uint8_t *src, size_t srclen,
 574                   size_t srclen_total, uint8_t *dst, u32 from_idx, u8 *iv,
 575                   f64 time, u8 is_async, u16 async_next_node)
 576 {
 577   noise_keypair_t *kp;
 578   enum noise_state_crypt ret = SC_FAILED;
 579
 580   if ((kp = wg_get_active_keypair (r, r_idx)) == NULL)
 581     {
 582       goto error;
 583     }
 584
 585   /* We confirm that our values are within our tolerances. These values
 586    * are the same as the encrypt routine.
 587    *
 588    * kp_ctr isn't locked here, we're happy to accept a racy read. */
 589   if (wg_birthdate_has_expired_opt (kp->kp_birthdate, REJECT_AFTER_TIME,
 590                                     time) ||
 591       kp->kp_ctr.c_recv >= REJECT_AFTER_MESSAGES)
 592     goto error;
 593
 594   /* Decrypt, then validate the counter. We don't want to validate the
 595    * counter before decrypting as we do not know the message is authentic
 596    * prior to decryption. */
 597
 598   clib_memset (iv, 0, 4);
 599   clib_memcpy (iv + 4, &nonce, sizeof (nonce));
 600
 601   if (is_async)
 602     {
 603       u8 flags = VNET_CRYPTO_OP_FLAG_HMAC_CHECK;
 604       u8 *tag = vlib_buffer_get_tail (lb) - NOISE_AUTHTAG_LEN;
 605
 606       if (b != lb)
 607         flags |= VNET_CRYPTO_OP_FLAG_CHAINED_BUFFERS;
 608
 609       if (NULL == *async_frame ||
 610           vnet_crypto_async_frame_is_full (*async_frame))
 611         {
 612           *async_frame = vnet_crypto_async_get_frame (
 613             vm, VNET_CRYPTO_OP_CHACHA20_POLY1305_TAG16_AAD0_DEC);
 614           if (PREDICT_FALSE (NULL == *async_frame))
 615             goto error;
 616           /* Save the frame to the list we'll submit at the end */
 617           vec_add1 (ptd->async_frames, *async_frame);
 618         }
 619
 620       wg_input_add_to_frame (vm, *async_frame, kp->kp_recv_index, srclen_total,
 621                              src - b->data, buf_idx, async_next_node, iv, tag,
 622                              flags);
 623     }
 624   else
 625     {
 626       wg_prepare_sync_dec_op (vm, ptd, b, lb, crypto_ops, src, srclen, dst,
 627                               NULL, 0, kp->kp_recv_index, from_idx, iv);
 628     }
 629
 630   /* If we've received the handshake confirming data packet then move the
 631    * next keypair into current. If we do slide the next keypair in, then
 632    * we skip the REKEY_AFTER_TIME_RECV check. This is safe to do as a
 633    * data packet can't confirm a session that we are an INITIATOR of. */
 634   if (kp == r->r_next)
 635     {
 636       clib_rwlock_writer_lock (&r->r_keypair_lock);
 637       if (kp == r->r_next && kp->kp_local_index == r_idx)
 638         {
 639           noise_remote_keypair_free (vm, r, &r->r_previous);
 640           r->r_previous = r->r_current;
 641           r->r_current = r->r_next;
 642           r->r_next = NULL;
 643
 644           ret = SC_CONN_RESET;
 645           clib_rwlock_writer_unlock (&r->r_keypair_lock);
 646           goto error;
 647         }
 648       clib_rwlock_writer_unlock (&r->r_keypair_lock);
 649     }
 650
 651   /* Similar to when we encrypt, we want to notify the caller when we
 652    * are approaching our tolerances. We notify if:
 653    *  - we're the initiator and the current keypair is older than
 654    *    REKEY_AFTER_TIME_RECV seconds. */
 655   ret = SC_KEEP_KEY_FRESH;
 656   kp = r->r_current;
 657   if (kp != NULL && kp->kp_valid && kp->kp_is_initiator &&
 658       wg_birthdate_has_expired_opt (kp->kp_birthdate, REKEY_AFTER_TIME_RECV,
 659                                     time))
 660     goto error;
 661
 662   ret = SC_OK;
 663 error:
 664   return ret;
 665 }
 666
 667 static_always_inline void
 668 wg_find_outer_addr_port (vlib_buffer_t *b, ip46_address_t *addr, u16 *port,
 669                          u8 is_ip4)
 670 {
 671   if (is_ip4)
 672     {
 673       ip4_udp_header_t *ip4_udp_hdr =
 674         vlib_buffer_get_current (b) - sizeof (ip4_udp_header_t);
 675       ip46_address_set_ip4 (addr, &ip4_udp_hdr->ip4.src_address);
 676       *port = clib_net_to_host_u16 (ip4_udp_hdr->udp.src_port);
 677     }
 678   else
 679     {
 680       ip6_udp_header_t *ip6_udp_hdr =
 681         vlib_buffer_get_current (b) - sizeof (ip6_udp_header_t);
 682       ip46_address_set_ip6 (addr, &ip6_udp_hdr->ip6.src_address);
 683       *port = clib_net_to_host_u16 (ip6_udp_hdr->udp.src_port);
 684     }
 685 }
 686
 687 always_inline uword
 688 wg_input_inline (vlib_main_t *vm, vlib_node_runtime_t *node,
 689                  vlib_frame_t *frame, u8 is_ip4, u16 async_next_node)
 690 {
 691   vnet_main_t *vnm = vnet_get_main ();
 692   vnet_interface_main_t *im = &vnm->interface_main;
 693   wg_main_t *wmp = &wg_main;
 694   wg_per_thread_data_t *ptd =
 695     vec_elt_at_index (wmp->per_thread_data, vm->thread_index);
 696   u32 *from = vlib_frame_vector_args (frame);
 697   u32 n_left_from = frame->n_vectors;
 698
 699   vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b = bufs;
 700   vlib_buffer_t *lb;
 701   u32 thread_index = vm->thread_index;
 702   vnet_crypto_op_t **crypto_ops;
 703   const u16 drop_next = WG_INPUT_NEXT_PUNT;
 704   message_type_t header_type;
 705   vlib_buffer_t *data_bufs[VLIB_FRAME_SIZE];
 706   u32 data_bi[VLIB_FRAME_SIZE];  /* buffer index for data */
 707   u32 other_bi[VLIB_FRAME_SIZE]; /* buffer index for drop or handoff */
 708   u16 other_nexts[VLIB_FRAME_SIZE], *other_next = other_nexts, n_other = 0;
 709   u16 data_nexts[VLIB_FRAME_SIZE], *data_next = data_nexts, n_data = 0;
 710   u16 n_async = 0;
 711   const u8 is_async = wg_op_mode_is_set_ASYNC ();
 712   vnet_crypto_async_frame_t *async_frame = NULL;
 713
 714   vlib_get_buffers (vm, from, bufs, n_left_from);
 715   vec_reset_length (ptd->crypto_ops);
 716   vec_reset_length (ptd->chained_crypto_ops);
 717   vec_reset_length (ptd->chunks);
 718   vec_reset_length (ptd->async_frames);
 719
 720   f64 time = clib_time_now (&vm->clib_time) + vm->time_offset;
 721
 722   wg_peer_t *peer = NULL;
 723   u32 *last_peer_time_idx = NULL;
 724   u32 last_rec_idx = ~0;
 725
 726   bool is_keepalive = false;
 727   u32 *peer_idx = NULL;
 728   index_t peeri = INDEX_INVALID;
 729
 730   while (n_left_from > 0)
 731     {
 732       if (n_left_from > 2)
 733         {
 734           u8 *p;
 735           vlib_prefetch_buffer_header (b[2], LOAD);
 736           p = vlib_buffer_get_current (b[1]);
 737           CLIB_PREFETCH (p, CLIB_CACHE_LINE_BYTES, LOAD);
 738           CLIB_PREFETCH (vlib_buffer_get_tail (b[1]), CLIB_CACHE_LINE_BYTES,
 739                          LOAD);
 740         }
 741
 742       other_next[n_other] = WG_INPUT_NEXT_PUNT;
 743       data_nexts[n_data] = WG_INPUT_N_NEXT;
 744
 745       header_type =
 746         ((message_header_t *) vlib_buffer_get_current (b[0]))->type;
 747
 748       if (PREDICT_TRUE (header_type == MESSAGE_DATA))
 749         {
 750           message_data_t *data = vlib_buffer_get_current (b[0]);
 751           u8 *iv_data = b[0]->pre_data;
 752           u32 buf_idx = from[b - bufs];
 753           u32 n_bufs;
 754           peer_idx = wg_index_table_lookup (&wmp->index_table,
 755                                             data->receiver_index);
 756
 757           if (data->receiver_index != last_rec_idx)
 758             {
 759               peer_idx = wg_index_table_lookup (&wmp->index_table,
 760                                                 data->receiver_index);
 761               if (PREDICT_TRUE (peer_idx != NULL))
 762                 {
 763                   peeri = *peer_idx;
 764                   peer = wg_peer_get (peeri);
 765                   last_rec_idx = data->receiver_index;
 766                 }
 767               else
 768                 {
 769                   peer = NULL;
 770                   last_rec_idx = ~0;
 771                 }
 772             }
 773
 774           if (PREDICT_FALSE (!peer_idx))
 775             {
 776               other_next[n_other] = WG_INPUT_NEXT_ERROR;
 777               b[0]->error = node->errors[WG_INPUT_ERROR_PEER];
 778               other_bi[n_other] = buf_idx;
 779               n_other += 1;
 780               goto out;
 781             }
 782
 783           if (PREDICT_FALSE (~0 == peer->input_thread_index))
 784             {
 785               /* this is the first packet to use this peer, claim the peer
 786                * for this thread.
 787                */
 788               clib_atomic_cmp_and_swap (&peer->input_thread_index, ~0,
 789                                         wg_peer_assign_thread (thread_index));
 790             }
 791
 792           if (PREDICT_TRUE (thread_index != peer->input_thread_index))
 793             {
 794               other_next[n_other] = WG_INPUT_NEXT_HANDOFF_DATA;
 795               other_bi[n_other] = buf_idx;
 796               n_other += 1;
 797               goto next;
 798             }
 799
 800           lb = b[0];
 801           n_bufs = vlib_buffer_chain_linearize (vm, b[0]);
 802           if (n_bufs == 0)
 803             {
 804               other_next[n_other] = WG_INPUT_NEXT_ERROR;
 805               b[0]->error = node->errors[WG_INPUT_ERROR_NO_BUFFERS];
 806               other_bi[n_other] = buf_idx;
 807               n_other += 1;
 808               goto out;
 809             }
 810
 811           if (n_bufs > 1)
 812             {
 813               vlib_buffer_t *before_last = b[0];
 814
 815               /* Find last and before last buffer in the chain */
 816               while (lb->flags & VLIB_BUFFER_NEXT_PRESENT)
 817                 {
 818                   before_last = lb;
 819                   lb = vlib_get_buffer (vm, lb->next_buffer);
 820                 }
 821
 822               /* Ensure auth tag is contiguous and not splitted into two last
 823                * buffers */
 824               if (PREDICT_FALSE (lb->current_length < NOISE_AUTHTAG_LEN))
 825                 {
 826                   u32 len_diff = NOISE_AUTHTAG_LEN - lb->current_length;
 827
 828                   before_last->current_length -= len_diff;
 829                   if (before_last == b[0])
 830                     before_last->flags &= ~VLIB_BUFFER_TOTAL_LENGTH_VALID;
 831
 832                   vlib_buffer_advance (lb, (signed) -len_diff);
 833
 834                   clib_memcpy_fast (vlib_buffer_get_current (lb),
 835                                     vlib_buffer_get_tail (before_last),
 836                                     len_diff);
 837                 }
 838             }
 839
 840           u16 encr_len = b[0]->current_length - sizeof (message_data_t);
 841           u16 decr_len = encr_len - NOISE_AUTHTAG_LEN;
 842           u16 encr_len_total =
 843             vlib_buffer_length_in_chain (vm, b[0]) - sizeof (message_data_t);
 844           u16 decr_len_total = encr_len_total - NOISE_AUTHTAG_LEN;
 845
 846           if (lb != b[0])
 847             crypto_ops = &ptd->chained_crypto_ops;
 848           else
 849             crypto_ops = &ptd->crypto_ops;
 850
 851           enum noise_state_crypt state_cr =
 852             wg_input_process (vm, ptd, crypto_ops, &async_frame, b[0], lb,
 853                               buf_idx, &peer->remote, data->receiver_index,
 854                               data->counter, data->encrypted_data, decr_len,
 855                               decr_len_total, data->encrypted_data, n_data,
 856                               iv_data, time, is_async, async_next_node);
 857
 858           if (PREDICT_FALSE (state_cr == SC_FAILED))
 859             {
 860               wg_peer_update_flags (*peer_idx, WG_PEER_ESTABLISHED, false);
 861               other_next[n_other] = WG_INPUT_NEXT_ERROR;
 862               b[0]->error = node->errors[WG_INPUT_ERROR_DECRYPTION];
 863               other_bi[n_other] = buf_idx;
 864               n_other += 1;
 865               goto out;
 866             }
 867           if (!is_async)
 868             {
 869               data_bufs[n_data] = b[0];
 870               data_bi[n_data] = buf_idx;
 871               n_data += 1;
 872             }
 873           else
 874             {
 875               n_async += 1;
 876             }
 877
 878           if (PREDICT_FALSE (state_cr == SC_CONN_RESET))
 879             {
 880               wg_timers_handshake_complete (peer);
 881               goto next;
 882             }
 883           else if (PREDICT_FALSE (state_cr == SC_KEEP_KEY_FRESH))
 884             {
 885               wg_send_handshake_from_mt (peeri, false);
 886               goto next;
 887             }
 888           else if (PREDICT_TRUE (state_cr == SC_OK))
 889             goto next;
 890         }
 891       else
 892         {
 893           /* Handshake packets should be processed in main thread */
 894           if (thread_index != 0)
 895             {
 896               other_next[n_other] = WG_INPUT_NEXT_HANDOFF_HANDSHAKE;
 897               other_bi[n_other] = from[b - bufs];
 898               n_other += 1;
 899               goto next;
 900             }
 901
 902           wg_input_error_t ret =
 903             wg_handshake_process (vm, wmp, b[0], node->node_index, is_ip4);
 904           if (ret != WG_INPUT_ERROR_NONE)
 905             {
 906               other_next[n_other] = WG_INPUT_NEXT_ERROR;
 907               b[0]->error = node->errors[ret];
 908               other_bi[n_other] = from[b - bufs];
 909               n_other += 1;
 910             }
 911           else
 912             {
 913               other_bi[n_other] = from[b - bufs];
 914               n_other += 1;
 915             }
 916         }
 917
 918     out:
 919       if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&
 920                          (b[0]->flags & VLIB_BUFFER_IS_TRACED)))
 921         {
 922           wg_input_trace_t *t = vlib_add_trace (vm, node, b[0], sizeof (*t));
 923           t->type = header_type;
 924           t->current_length = b[0]->current_length;
 925           t->is_keepalive = is_keepalive;
 926           t->peer = peer_idx ? peeri : INDEX_INVALID;
 927         }
 928
 929     next:
 930       n_left_from -= 1;
 931       b += 1;
 932     }
 933
 934   /* decrypt packets */
 935   wg_input_process_ops (vm, node, ptd->crypto_ops, data_bufs, data_nexts,
 936                         drop_next);
 937   wg_input_process_chained_ops (vm, node, ptd->chained_crypto_ops, data_bufs,
 938                                 data_nexts, ptd->chunks, drop_next);
 939
 940   /* process after decryption */
 941   b = data_bufs;
 942   n_left_from = n_data;
 943   last_rec_idx = ~0;
 944   last_peer_time_idx = NULL;
 945
 946   while (n_left_from > 0)
 947     {
 948       bool is_keepalive = false;
 949       u32 *peer_idx = NULL;
 950
 951       if (PREDICT_FALSE (data_next[0] == WG_INPUT_NEXT_PUNT))
 952         {
 953           goto trace;
 954         }
 955       if (n_left_from > 2)
 956         {
 957           u8 *p;
 958           vlib_prefetch_buffer_header (b[2], LOAD);
 959           p = vlib_buffer_get_current (b[1]);
 960           CLIB_PREFETCH (p, CLIB_CACHE_LINE_BYTES, LOAD);
 961           CLIB_PREFETCH (vlib_buffer_get_tail (b[1]), CLIB_CACHE_LINE_BYTES,
 962                          LOAD);
 963         }
 964
 965       message_data_t *data = vlib_buffer_get_current (b[0]);
 966       ip46_address_t out_src_ip;
 967       u16 out_udp_src_port;
 968
 969       wg_find_outer_addr_port (b[0], &out_src_ip, &out_udp_src_port, is_ip4);
 970
 971       if (data->receiver_index != last_rec_idx)
 972         {
 973           peer_idx =
 974             wg_index_table_lookup (&wmp->index_table, data->receiver_index);
 975           if (PREDICT_TRUE (peer_idx != NULL))
 976             {
 977               peeri = *peer_idx;
 978               peer = wg_peer_get (peeri);
 979               last_rec_idx = data->receiver_index;
 980             }
 981           else
 982             {
 983               peer = NULL;
 984               last_rec_idx = ~0;
 985             }
 986         }
 987
 988       if (PREDICT_TRUE (peer != NULL))
 989         {
 990           if (PREDICT_FALSE (wg_input_post_process (vm, b[0], data_next, peer,
 991                                                     data, &is_keepalive) < 0))
 992             goto trace;
 993         }
 994       else
 995         {
 996           data_next[0] = WG_INPUT_NEXT_PUNT;
 997           goto trace;
 998         }
 999
1000       if (PREDICT_FALSE (peer_idx && (last_peer_time_idx != peer_idx)))
1001         {
1002           if (PREDICT_FALSE (
1003                 !ip46_address_is_equal (&peer->dst.addr, &out_src_ip) ||
1004                 peer->dst.port != out_udp_src_port))
1005             wg_peer_update_endpoint_from_mt (peeri, &out_src_ip,
1006                                              out_udp_src_port);
1007           wg_timers_any_authenticated_packet_received_opt (peer, time);
1008           wg_timers_any_authenticated_packet_traversal (peer);
1009           wg_peer_update_flags (*peer_idx, WG_PEER_ESTABLISHED, true);
1010           last_peer_time_idx = peer_idx;
1011         }
1012
1013       vlib_increment_combined_counter (im->combined_sw_if_counters +
1014                                          VNET_INTERFACE_COUNTER_RX,
1015                                        vm->thread_index, peer->wg_sw_if_index,
1016                                        1 /* packets */, b[0]->current_length);
1017
1018     trace:
1019       if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&
1020                          (b[0]->flags & VLIB_BUFFER_IS_TRACED)))
1021         {
1022           wg_input_trace_t *t = vlib_add_trace (vm, node, b[0], sizeof (*t));
1023           t->type = header_type;
1024           t->current_length = b[0]->current_length;
1025           t->is_keepalive = is_keepalive;
1026           t->peer = peer_idx ? peeri : INDEX_INVALID;
1027         }
1028
1029       b += 1;
1030       n_left_from -= 1;
1031       data_next += 1;
1032     }
1033
1034   if (n_async)
1035     {
1036       /* submit all of the open frames */
1037       vnet_crypto_async_frame_t **async_frame;
1038       vec_foreach (async_frame, ptd->async_frames)
1039         {
1040           if (PREDICT_FALSE (
1041                 vnet_crypto_async_submit_open_frame (vm, *async_frame) < 0))
1042             {
1043               u32 n_drop = (*async_frame)->n_elts;
1044               u32 *bi = (*async_frame)->buffer_indices;
1045               u16 index = n_other;
1046               while (n_drop--)
1047                 {
1048                   other_bi[index] = bi[0];
1049                   vlib_buffer_t *b = vlib_get_buffer (vm, bi[0]);
1050                   other_nexts[index] = drop_next;
1051                   b->error = node->errors[WG_INPUT_ERROR_CRYPTO_ENGINE_ERROR];
1052                   bi++;
1053                   index++;
1054                 }
1055               n_other += (*async_frame)->n_elts;
1056
1057               vnet_crypto_async_reset_frame (*async_frame);
1058               vnet_crypto_async_free_frame (vm, *async_frame);
1059             }
1060         }
1061     }
1062
1063   /* enqueue other bufs */
1064   if (n_other)
1065     vlib_buffer_enqueue_to_next (vm, node, other_bi, other_next, n_other);
1066
1067   /* enqueue data bufs */
1068   if (n_data)
1069     vlib_buffer_enqueue_to_next (vm, node, data_bi, data_nexts, n_data);
1070
1071   return frame->n_vectors;
1072 }
1073
1074 always_inline uword
1075 wg_input_post (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame,
1076                u8 is_ip4)
1077 {
1078   vnet_main_t *vnm = vnet_get_main ();
1079   vnet_interface_main_t *im = &vnm->interface_main;
1080   wg_main_t *wmp = &wg_main;
1081   vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b = bufs;
1082   u16 nexts[VLIB_FRAME_SIZE], *next = nexts;
1083   u32 *from = vlib_frame_vector_args (frame);
1084   u32 n_left = frame->n_vectors;
1085   wg_peer_t *peer = NULL;
1086   u32 *peer_idx = NULL;
1087   u32 *last_peer_time_idx = NULL;
1088   index_t peeri = INDEX_INVALID;
1089   u32 last_rec_idx = ~0;
1090   f64 time = clib_time_now (&vm->clib_time) + vm->time_offset;
1091
1092   vlib_get_buffers (vm, from, b, n_left);
1093
1094   if (n_left >= 2)
1095     {
1096       vlib_prefetch_buffer_header (b[0], LOAD);
1097       vlib_prefetch_buffer_header (b[1], LOAD);
1098     }
1099
1100   while (n_left > 0)
1101     {
1102       if (n_left > 2)
1103         {
1104           u8 *p;
1105           vlib_prefetch_buffer_header (b[2], LOAD);
1106           p = vlib_buffer_get_current (b[1]);
1107           CLIB_PREFETCH (p, CLIB_CACHE_LINE_BYTES, LOAD);
1108         }
1109
1110       bool is_keepalive = false;
1111       message_data_t *data = vlib_buffer_get_current (b[0]);
1112       ip46_address_t out_src_ip;
1113       u16 out_udp_src_port;
1114
1115       wg_find_outer_addr_port (b[0], &out_src_ip, &out_udp_src_port, is_ip4);
1116
1117       if (data->receiver_index != last_rec_idx)
1118         {
1119           peer_idx =
1120             wg_index_table_lookup (&wmp->index_table, data->receiver_index);
1121
1122           if (PREDICT_TRUE (peer_idx != NULL))
1123             {
1124               peeri = *peer_idx;
1125               peer = wg_peer_get (peeri);
1126               last_rec_idx = data->receiver_index;
1127             }
1128           else
1129             {
1130               peer = NULL;
1131               last_rec_idx = ~0;
1132             }
1133         }
1134
1135       if (PREDICT_TRUE (peer != NULL))
1136         {
1137           if (PREDICT_FALSE (wg_input_post_process (vm, b[0], next, peer, data,
1138                                                     &is_keepalive) < 0))
1139             goto trace;
1140         }
1141       else
1142         {
1143           next[0] = WG_INPUT_NEXT_PUNT;
1144           goto trace;
1145         }
1146
1147       if (PREDICT_FALSE (peer_idx && (last_peer_time_idx != peer_idx)))
1148         {
1149           if (PREDICT_FALSE (
1150                 !ip46_address_is_equal (&peer->dst.addr, &out_src_ip) ||
1151                 peer->dst.port != out_udp_src_port))
1152             wg_peer_update_endpoint_from_mt (peeri, &out_src_ip,
1153                                              out_udp_src_port);
1154           wg_timers_any_authenticated_packet_received_opt (peer, time);
1155           wg_timers_any_authenticated_packet_traversal (peer);
1156           wg_peer_update_flags (*peer_idx, WG_PEER_ESTABLISHED, true);
1157           last_peer_time_idx = peer_idx;
1158         }
1159
1160       vlib_increment_combined_counter (im->combined_sw_if_counters +
1161                                          VNET_INTERFACE_COUNTER_RX,
1162                                        vm->thread_index, peer->wg_sw_if_index,
1163                                        1 /* packets */, b[0]->current_length);
1164
1165     trace:
1166       if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&
1167                          (b[0]->flags & VLIB_BUFFER_IS_TRACED)))
1168         {
1169           wg_input_post_trace_t *t =
1170             vlib_add_trace (vm, node, b[0], sizeof (*t));
1171           t->next = next[0];
1172           t->peer = peer_idx ? peeri : INDEX_INVALID;
1173         }
1174
1175       b += 1;
1176       next += 1;
1177       n_left -= 1;
1178     }
1179
1180   vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors);
1181   return frame->n_vectors;
1182 }
1183
1184 VLIB_NODE_FN (wg4_input_node)
1185 (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
1186 {
1187   return wg_input_inline (vm, node, frame, /* is_ip4 */ 1,
1188                           wg_decrypt_async_next.wg4_post_next);
1189 }
1190
1191 VLIB_NODE_FN (wg6_input_node)
1192 (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
1193 {
1194   return wg_input_inline (vm, node, frame, /* is_ip4 */ 0,
1195                           wg_decrypt_async_next.wg6_post_next);
1196 }
1197
1198 VLIB_NODE_FN (wg4_input_post_node)
1199 (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
1200 {
1201   return wg_input_post (vm, node, from_frame, /* is_ip4 */ 1);
1202 }
1203
1204 VLIB_NODE_FN (wg6_input_post_node)
1205 (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
1206 {
1207   return wg_input_post (vm, node, from_frame, /* is_ip4 */ 0);
1208 }
1209
1210 /* *INDENT-OFF* */
1211 VLIB_REGISTER_NODE (wg4_input_node) =
1212 {
1213   .name = "wg4-input",
1214   .vector_size = sizeof (u32),
1215   .format_trace = format_wg_input_trace,
1216   .type = VLIB_NODE_TYPE_INTERNAL,
1217   .n_errors = ARRAY_LEN (wg_input_error_strings),
1218   .error_strings = wg_input_error_strings,
1219   .n_next_nodes = WG_INPUT_N_NEXT,
1220   /* edit / add dispositions here */
1221   .next_nodes = {
1222         [WG_INPUT_NEXT_HANDOFF_HANDSHAKE] = "wg4-handshake-handoff",
1223         [WG_INPUT_NEXT_HANDOFF_DATA] = "wg4-input-data-handoff",
1224         [WG_INPUT_NEXT_IP4_INPUT] = "ip4-input-no-checksum",
1225         [WG_INPUT_NEXT_IP6_INPUT] = "ip6-input",
1226         [WG_INPUT_NEXT_PUNT] = "error-punt",
1227         [WG_INPUT_NEXT_ERROR] = "error-drop",
1228   },
1229 };
1230
1231 VLIB_REGISTER_NODE (wg6_input_node) =
1232 {
1233   .name = "wg6-input",
1234   .vector_size = sizeof (u32),
1235   .format_trace = format_wg_input_trace,
1236   .type = VLIB_NODE_TYPE_INTERNAL,
1237   .n_errors = ARRAY_LEN (wg_input_error_strings),
1238   .error_strings = wg_input_error_strings,
1239   .n_next_nodes = WG_INPUT_N_NEXT,
1240   /* edit / add dispositions here */
1241   .next_nodes = {
1242         [WG_INPUT_NEXT_HANDOFF_HANDSHAKE] = "wg6-handshake-handoff",
1243         [WG_INPUT_NEXT_HANDOFF_DATA] = "wg6-input-data-handoff",
1244         [WG_INPUT_NEXT_IP4_INPUT] = "ip4-input-no-checksum",
1245         [WG_INPUT_NEXT_IP6_INPUT] = "ip6-input",
1246         [WG_INPUT_NEXT_PUNT] = "error-punt",
1247         [WG_INPUT_NEXT_ERROR] = "error-drop",
1248   },
1249 };
1250
1251 VLIB_REGISTER_NODE (wg4_input_post_node) = {
1252   .name = "wg4-input-post-node",
1253   .vector_size = sizeof (u32),
1254   .format_trace = format_wg_input_post_trace,
1255   .type = VLIB_NODE_TYPE_INTERNAL,
1256   .sibling_of = "wg4-input",
1257
1258   .n_errors = ARRAY_LEN (wg_input_error_strings),
1259   .error_strings = wg_input_error_strings,
1260 };
1261
1262 VLIB_REGISTER_NODE (wg6_input_post_node) = {
1263   .name = "wg6-input-post-node",
1264   .vector_size = sizeof (u32),
1265   .format_trace = format_wg_input_post_trace,
1266   .type = VLIB_NODE_TYPE_INTERNAL,
1267   .sibling_of = "wg6-input",
1268
1269   .n_errors = ARRAY_LEN (wg_input_error_strings),
1270   .error_strings = wg_input_error_strings,
1271 };
1272
1273 /* *INDENT-ON* */
1274
1275 /*
1276  * fd.io coding-style-patch-verification: ON
1277  *
1278  * Local Variables:
1279  * eval: (c-set-style "gnu")
1280  * End:
1281  */