ligang/vpp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
vpp/test/test_wireguard.py
Dave Wallace 8800f732f8 tests: refactor asf framework code 
- Make framework.py classes a subset of asfframework.py classes
- Remove all packet related code from asfframework.py
- Add test class and test case set up debug output to log
- Repatriate packet tests from asf to test directory
- Remove non-packet related code from framework.py and
  inherit them from asfframework.py classes
- Clean up unused import variables
- Re-enable BFD tests on Ubuntu 22.04 and fix
  intermittent test failures in echo_looped_back
  testcases (where # control packets verified but
  not guaranteed to be received during test)
- Re-enable Wireguard tests on Ubuntu 22.04 and fix
  intermittent test failures in handshake ratelimiting
  testcases and event testcase
- Run Wiregard testcase suites solo
- Improve debug output in log.txt
- Increase VCL/LDP post sleep timeout to allow iperf server
  to finish cleanly.
- Fix pcap history files to be sorted by suite and testcase
  and ensure order/timestamp is correct based on creation
  in the testcase.
- Decode pcap files for each suite and testcase for all
  errors or if configured via comandline option / env var
- Improve vpp corefile detection to allow complete corefile
  generation
- Disable vm vpp interfaces testcases on debian11
- Clean up failed unittest dir when retrying failed testcases
  and unify testname directory and failed linknames into
  framwork functions

Type: test

Change-Id: I0764f79ea5bb639d278bf635ed2408d4d5220e1e
Signed-off-by: Dave Wallace <dwallacelf@gmail.com>
2023-11-03 05:06:43 +00:00

2950 lines
103 KiB
Python
Raw Permalink Blame History

#!/usr/bin/env python3
""" Wg tests """
import datetime
import base64
import os
from hashlib import blake2s
from config import config
from scapy.packet import Raw
from scapy.layers.l2 import Ether
from scapy.layers.inet import IP, UDP
from scapy.layers.inet6 import IPv6
from scapy.layers.vxlan import VXLAN
from scapy.contrib.wireguard import (
Wireguard,
WireguardResponse,
WireguardInitiation,
WireguardTransport,
WireguardCookieReply,
)
from cryptography.hazmat.primitives.asymmetric.x25519 import (
X25519PrivateKey,
X25519PublicKey,
)
from cryptography.hazmat.primitives.serialization import (
Encoding,
PrivateFormat,
PublicFormat,
NoEncryption,
)
from noise.connection import NoiseConnection, Keypair
from Crypto.Cipher import ChaCha20_Poly1305
from Crypto.Random import get_random_bytes
from vpp_interface import VppInterface
from vpp_pg_interface import is_ipv6_misc
from vpp_ip_route import VppIpRoute, VppRoutePath
from vpp_l2 import VppBridgeDomain, VppBridgeDomainPort
from vpp_vxlan_tunnel import VppVxlanTunnel
from vpp_object import VppObject
from vpp_papi import VppEnum
from asfframework import tag_run_solo, tag_fixme_vpp_debug
from framework import VppTestCase
from re import compile
import unittest
""" TestWg is a subclass of VPPTestCase classes.
Wg test.
"""
def private_key_bytes(k):
return k.private_bytes(Encoding.Raw, PrivateFormat.Raw, NoEncryption())
def public_key_bytes(k):
return k.public_bytes(Encoding.Raw, PublicFormat.Raw)
def get_field_bytes(pkt, name):
fld, val = pkt.getfield_and_val(name)
return fld.i2m(pkt, val)
class VppWgInterface(VppInterface):
"""
VPP WireGuard interface
"""
def __init__(self, test, src, port):
super(VppWgInterface, self).__init__(test)
self.port = port
self.src = src
self.private_key = X25519PrivateKey.generate()
self.public_key = self.private_key.public_key()
# cookie related params
self.cookie_key = blake2s(b"cookie--" + self.public_key_bytes()).digest()
def public_key_bytes(self):
return public_key_bytes(self.public_key)
def private_key_bytes(self):
return private_key_bytes(self.private_key)
def add_vpp_config(self):
r = self.test.vapi.wireguard_interface_create(
interface={
"user_instance": 0xFFFFFFFF,
"port": self.port,
"src_ip": self.src,
"private_key": private_key_bytes(self.private_key),
"generate_key": False,
}
)
self.set_sw_if_index(r.sw_if_index)
self.test.registry.register(self, self.test.logger)
return self
def remove_vpp_config(self):
self.test.vapi.wireguard_interface_delete(sw_if_index=self._sw_if_index)
def query_vpp_config(self):
ts = self.test.vapi.wireguard_interface_dump(sw_if_index=0xFFFFFFFF)
for t in ts:
if (
t.interface.sw_if_index == self._sw_if_index
and str(t.interface.src_ip) == self.src
and t.interface.port == self.port
and t.interface.private_key == private_key_bytes(self.private_key)
):
return True
return False
def want_events(self, peer_index=0xFFFFFFFF):
self.test.vapi.want_wireguard_peer_events(
enable_disable=1,
pid=os.getpid(),
sw_if_index=self._sw_if_index,
peer_index=peer_index,
)
def wait_events(self, expect, peers, timeout=5):
for i in range(len(peers)):
rv = self.test.vapi.wait_for_event(timeout, "wireguard_peer_event")
self.test.assertEqual(rv.peer_index, peers[i])
self.test.assertEqual(rv.flags, expect)
def __str__(self):
return self.object_id()
def object_id(self):
return "wireguard-%d" % self._sw_if_index
NOISE_HANDSHAKE_NAME = b"Noise_IKpsk2_25519_ChaChaPoly_BLAKE2s"
NOISE_IDENTIFIER_NAME = b"WireGuard v1 zx2c4 Jason@zx2c4.com"
HANDSHAKE_COUNTING_INTERVAL = 0.5
UNDER_LOAD_INTERVAL = 1.0
HANDSHAKE_NUM_PER_PEER_UNTIL_UNDER_LOAD = 40
HANDSHAKE_NUM_BEFORE_RATELIMITING = 5
HANDSHAKE_JITTER = 0.5
class VppWgPeer(VppObject):
def __init__(self, test, itf, endpoint, port, allowed_ips, persistent_keepalive=15):
self._test = test
self.itf = itf
self.endpoint = endpoint
self.port = port
self.allowed_ips = allowed_ips
self.persistent_keepalive = persistent_keepalive
# remote peer's public
self.private_key = X25519PrivateKey.generate()
self.public_key = self.private_key.public_key()
# cookie related params
self.cookie_key = blake2s(b"cookie--" + self.public_key_bytes()).digest()
self.last_sent_cookie = None
self.last_mac1 = None
self.last_received_cookie = None
self.noise = NoiseConnection.from_name(NOISE_HANDSHAKE_NAME)
def change_endpoint(self, endpoint, port):
self.endpoint = endpoint
self.port = port
def add_vpp_config(self):
rv = self._test.vapi.wireguard_peer_add(
peer={
"public_key": self.public_key_bytes(),
"port": self.port,
"endpoint": self.endpoint,
"n_allowed_ips": len(self.allowed_ips),
"allowed_ips": self.allowed_ips,
"sw_if_index": self.itf.sw_if_index,
"persistent_keepalive": self.persistent_keepalive,
}
)
self.index = rv.peer_index
self.receiver_index = self.index + 1
self._test.registry.register(self, self._test.logger)
return self
def remove_vpp_config(self):
self._test.vapi.wireguard_peer_remove(peer_index=self.index)
def object_id(self):
return "wireguard-peer-%s" % self.index
def public_key_bytes(self):
return public_key_bytes(self.public_key)
def query_vpp_config(self):
peers = self._test.vapi.wireguard_peers_dump()
for p in peers:
# "::" endpoint will be returned as "0.0.0.0" in peer's details
endpoint = "0.0.0.0" if self.endpoint == "::" else self.endpoint
if (
p.peer.public_key == self.public_key_bytes()
and p.peer.port == self.port
and str(p.peer.endpoint) == endpoint
and p.peer.sw_if_index == self.itf.sw_if_index
and len(self.allowed_ips) == p.peer.n_allowed_ips
):
self.allowed_ips.sort()
p.peer.allowed_ips.sort()
for a1, a2 in zip(self.allowed_ips, p.peer.allowed_ips):
if str(a1) != str(a2):
return False
return True
return False
def mk_tunnel_header(self, tx_itf, is_ip6=False):
if is_ip6 is False:
return (
Ether(dst=tx_itf.local_mac, src=tx_itf.remote_mac)
/ IP(src=self.endpoint, dst=self.itf.src)
/ UDP(sport=self.port, dport=self.itf.port)
)
else:
return (
Ether(dst=tx_itf.local_mac, src=tx_itf.remote_mac)
/ IPv6(src=self.endpoint, dst=self.itf.src)
/ UDP(sport=self.port, dport=self.itf.port)
)
def noise_reset(self):
self.noise = NoiseConnection.from_name(NOISE_HANDSHAKE_NAME)
def noise_init(self, public_key=None):
self.noise.set_prologue(NOISE_IDENTIFIER_NAME)
self.noise.set_psks(psk=bytes(bytearray(32)))
if not public_key:
public_key = self.itf.public_key
# local/this private
self.noise.set_keypair_from_private_bytes(
Keypair.STATIC, private_key_bytes(self.private_key)
)
# remote's public
self.noise.set_keypair_from_public_bytes(
Keypair.REMOTE_STATIC, public_key_bytes(public_key)
)
self.noise.start_handshake()
def mk_cookie(self, p, tx_itf, is_resp=False, is_ip6=False):
self.verify_header(p, is_ip6)
wg_pkt = Wireguard(p[Raw])
if is_resp:
self._test.assertEqual(wg_pkt[Wireguard].message_type, 2)
self._test.assertEqual(wg_pkt[Wireguard].reserved_zero, 0)
self._test.assertEqual(wg_pkt[WireguardResponse].mac2, bytes([0] * 16))
else:
self._test.assertEqual(wg_pkt[Wireguard].message_type, 1)
self._test.assertEqual(wg_pkt[Wireguard].reserved_zero, 0)
self._test.assertEqual(wg_pkt[WireguardInitiation].mac2, bytes([0] * 16))
# collect info from wg packet (initiation or response)
src = get_field_bytes(p[IPv6 if is_ip6 else IP], "src")
sport = p[UDP].sport.to_bytes(2, byteorder="big")
if is_resp:
mac1 = wg_pkt[WireguardResponse].mac1
sender_index = wg_pkt[WireguardResponse].sender_index
else:
mac1 = wg_pkt[WireguardInitiation].mac1
sender_index = wg_pkt[WireguardInitiation].sender_index
# make cookie reply
cookie_reply = Wireguard() / WireguardCookieReply()
cookie_reply[Wireguard].message_type = 3
cookie_reply[Wireguard].reserved_zero = 0
cookie_reply[WireguardCookieReply].receiver_index = sender_index
nonce = get_random_bytes(24)
cookie_reply[WireguardCookieReply].nonce = nonce
# generate cookie data
changing_secret = get_random_bytes(32)
self.last_sent_cookie = blake2s(
src + sport, digest_size=16, key=changing_secret
).digest()
# encrypt cookie data
cipher = ChaCha20_Poly1305.new(key=self.cookie_key, nonce=nonce)
cipher.update(mac1)
ciphertext, tag = cipher.encrypt_and_digest(self.last_sent_cookie)
cookie_reply[WireguardCookieReply].encrypted_cookie = ciphertext + tag
# prepare cookie reply to be sent
cookie_reply = self.mk_tunnel_header(tx_itf, is_ip6) / cookie_reply
return cookie_reply
def consume_cookie(self, p, is_ip6=False):
self.verify_header(p, is_ip6)
cookie_reply = Wireguard(p[Raw])
self._test.assertEqual(cookie_reply[Wireguard].message_type, 3)
self._test.assertEqual(cookie_reply[Wireguard].reserved_zero, 0)
self._test.assertEqual(
cookie_reply[WireguardCookieReply].receiver_index, self.receiver_index
)
# collect info from cookie reply
nonce = cookie_reply[WireguardCookieReply].nonce
encrypted_cookie = cookie_reply[WireguardCookieReply].encrypted_cookie
ciphertext, tag = encrypted_cookie[:16], encrypted_cookie[16:]
# decrypt cookie data
cipher = ChaCha20_Poly1305.new(key=self.itf.cookie_key, nonce=nonce)
cipher.update(self.last_mac1)
self.last_received_cookie = cipher.decrypt_and_verify(ciphertext, tag)
def mk_handshake(self, tx_itf, is_ip6=False, public_key=None):
self.noise.set_as_initiator()
self.noise_init(public_key)
p = Wireguard() / WireguardInitiation()
p[Wireguard].message_type = 1
p[Wireguard].reserved_zero = 0
p[WireguardInitiation].sender_index = self.receiver_index
# some random data for the message
# lifted from the noise protocol's wireguard example
now = datetime.datetime.now()
tai = struct.pack(
"!qi",
4611686018427387914 + int(now.timestamp()),
int(now.microsecond * 1e3),
)
b = self.noise.write_message(payload=tai)
# load noise into init message
p[WireguardInitiation].unencrypted_ephemeral = b[0:32]
p[WireguardInitiation].encrypted_static = b[32:80]
p[WireguardInitiation].encrypted_timestamp = b[80:108]
# generate the mac1 hash
mac_key = blake2s(b"mac1----" + self.itf.public_key_bytes()).digest()
mac1 = blake2s(bytes(p)[0:116], digest_size=16, key=mac_key).digest()
p[WireguardInitiation].mac1 = mac1
self.last_mac1 = mac1
# generate the mac2 hash
if self.last_received_cookie:
mac2 = blake2s(
bytes(p)[0:132], digest_size=16, key=self.last_received_cookie
).digest()
p[WireguardInitiation].mac2 = mac2
self.last_received_cookie = None
else:
p[WireguardInitiation].mac2 = bytearray(16)
p = self.mk_tunnel_header(tx_itf, is_ip6) / p
return p
def verify_header(self, p, is_ip6=False):
if is_ip6 is False:
self._test.assertEqual(p[IP].src, self.itf.src)
self._test.assertEqual(p[IP].dst, self.endpoint)
self._test.assert_packet_checksums_valid(p)
else:
self._test.assertEqual(p[IPv6].src, self.itf.src)
self._test.assertEqual(p[IPv6].dst, self.endpoint)
self._test.assert_packet_checksums_valid(p, False)
self._test.assertEqual(p[UDP].sport, self.itf.port)
self._test.assertEqual(p[UDP].dport, self.port)
def consume_init(self, p, tx_itf, is_ip6=False, is_mac2=False):
self.noise.set_as_responder()
self.noise_init(self.itf.public_key)
self.verify_header(p, is_ip6)
init = Wireguard(p[Raw])
self._test.assertEqual(init[Wireguard].message_type, 1)
self._test.assertEqual(init[Wireguard].reserved_zero, 0)
self.sender = init[WireguardInitiation].sender_index
# validate the mac1 hash
mac_key = blake2s(b"mac1----" + public_key_bytes(self.public_key)).digest()
mac1 = blake2s(bytes(init)[0:-32], digest_size=16, key=mac_key).digest()
self._test.assertEqual(init[WireguardInitiation].mac1, mac1)
# validate the mac2 hash
if is_mac2:
self._test.assertNotEqual(init[WireguardInitiation].mac2, bytes([0] * 16))
self._test.assertNotEqual(self.last_sent_cookie, None)
mac2 = blake2s(
bytes(init)[0:-16], digest_size=16, key=self.last_sent_cookie
).digest()
self._test.assertEqual(init[WireguardInitiation].mac2, mac2)
self.last_sent_cookie = None
else:
self._test.assertEqual(init[WireguardInitiation].mac2, bytes([0] * 16))
# this passes only unencrypted_ephemeral, encrypted_static,
# encrypted_timestamp fields of the init
payload = self.noise.read_message(bytes(init)[8:-32])
# build the response
b = self.noise.write_message()
mac_key = blake2s(b"mac1----" + public_key_bytes(self.itf.public_key)).digest()
resp = Wireguard(message_type=2, reserved_zero=0) / WireguardResponse(
sender_index=self.receiver_index,
receiver_index=self.sender,
unencrypted_ephemeral=b[0:32],
encrypted_nothing=b[32:],
)
mac1 = blake2s(bytes(resp)[:-32], digest_size=16, key=mac_key).digest()
resp[WireguardResponse].mac1 = mac1
self.last_mac1 = mac1
resp = self.mk_tunnel_header(tx_itf, is_ip6) / resp
self._test.assertTrue(self.noise.handshake_finished)
return resp
def consume_response(self, p, is_ip6=False):
self.verify_header(p, is_ip6)
resp = Wireguard(p[Raw])
self._test.assertEqual(resp[Wireguard].message_type, 2)
self._test.assertEqual(resp[Wireguard].reserved_zero, 0)
self._test.assertEqual(
resp[WireguardResponse].receiver_index, self.receiver_index
)
self.sender = resp[Wireguard].sender_index
payload = self.noise.read_message(bytes(resp)[12:60])
self._test.assertEqual(payload, b"")
self._test.assertTrue(self.noise.handshake_finished)
def decrypt_transport(self, p, is_ip6=False):
self.verify_header(p, is_ip6)
p = Wireguard(p[Raw])
self._test.assertEqual(p[Wireguard].message_type, 4)
self._test.assertEqual(p[Wireguard].reserved_zero, 0)
self._test.assertEqual(
p[WireguardTransport].receiver_index, self.receiver_index
)
d = self.noise.decrypt(p[WireguardTransport].encrypted_encapsulated_packet)
return d
def encrypt_transport(self, p):
return self.noise.encrypt(bytes(p))
def validate_encapped(self, rxs, tx, is_tunnel_ip6=False, is_transport_ip6=False):
ret_rxs = []
for rx in rxs:
rx = self.decrypt_transport(rx, is_tunnel_ip6)
if is_transport_ip6 is False:
rx = IP(rx)
# check the original packet is present
self._test.assertEqual(rx[IP].dst, tx[IP].dst)
self._test.assertEqual(rx[IP].ttl, tx[IP].ttl - 1)
else:
rx = IPv6(rx)
# check the original packet is present
self._test.assertEqual(rx[IPv6].dst, tx[IPv6].dst)
self._test.assertEqual(rx[IPv6].hlim, tx[IPv6].hlim - 1)
ret_rxs.append(rx)
return ret_rxs
def want_events(self):
self._test.vapi.want_wireguard_peer_events(
enable_disable=1,
pid=os.getpid(),
peer_index=self.index,
sw_if_index=self.itf.sw_if_index,
)
def wait_event(self, expect, timeout=5):
rv = self._test.vapi.wait_for_event(timeout, "wireguard_peer_event")
self._test.assertEqual(rv.flags, expect)
self._test.assertEqual(rv.peer_index, self.index)
def is_handshake_init(p):
wg_p = Wireguard(p[Raw])
return wg_p[Wireguard].message_type == 1
@unittest.skipIf(
"wireguard" in config.excluded_plugins, "Exclude Wireguard plugin tests"
)
@tag_run_solo
class TestWg(VppTestCase):
"""Wireguard Test Case"""
error_str = compile(r"Error")
wg4_output_node_name = "/err/wg4-output-tun/"
wg4_input_node_name = "/err/wg4-input/"
wg6_output_node_name = "/err/wg6-output-tun/"
wg6_input_node_name = "/err/wg6-input/"
kp4_error = wg4_output_node_name + "Keypair error"
mac4_error = wg4_input_node_name + "Invalid MAC handshake"
peer4_in_err = wg4_input_node_name + "Peer error"
peer4_out_err = wg4_output_node_name + "Peer error"
kp6_error = wg6_output_node_name + "Keypair error"
mac6_error = wg6_input_node_name + "Invalid MAC handshake"
peer6_in_err = wg6_input_node_name + "Peer error"
peer6_out_err = wg6_output_node_name + "Peer error"
cookie_dec4_err = wg4_input_node_name + "Failed during Cookie decryption"
cookie_dec6_err = wg6_input_node_name + "Failed during Cookie decryption"
ratelimited4_err = wg4_input_node_name + "Handshake ratelimited"
ratelimited6_err = wg6_input_node_name + "Handshake ratelimited"
@classmethod
def setUpClass(cls):
super(TestWg, cls).setUpClass()
try:
cls.create_pg_interfaces(range(3))
for i in cls.pg_interfaces:
i.admin_up()
i.config_ip4()
i.config_ip6()
i.resolve_arp()
i.resolve_ndp()
except Exception:
super(TestWg, cls).tearDownClass()
raise
@classmethod
def tearDownClass(cls):
super(TestWg, cls).tearDownClass()
def setUp(self):
super(VppTestCase, self).setUp()
self.base_kp4_err = self.statistics.get_err_counter(self.kp4_error)
self.base_mac4_err = self.statistics.get_err_counter(self.mac4_error)
self.base_peer4_in_err = self.statistics.get_err_counter(self.peer4_in_err)
self.base_peer4_out_err = self.statistics.get_err_counter(self.peer4_out_err)
self.base_kp6_err = self.statistics.get_err_counter(self.kp6_error)
self.base_mac6_err = self.statistics.get_err_counter(self.mac6_error)
self.base_peer6_in_err = self.statistics.get_err_counter(self.peer6_in_err)
self.base_peer6_out_err = self.statistics.get_err_counter(self.peer6_out_err)
self.base_cookie_dec4_err = self.statistics.get_err_counter(
self.cookie_dec4_err
)
self.base_cookie_dec6_err = self.statistics.get_err_counter(
self.cookie_dec6_err
)
self.base_ratelimited4_err = self.statistics.get_err_counter(
self.ratelimited4_err
)
self.base_ratelimited6_err = self.statistics.get_err_counter(
self.ratelimited6_err
)
def send_and_assert_no_replies_ignoring_init(
self, intf, pkts, remark="", timeout=None
):
self.pg_send(intf, pkts)
def _filter_out_fn(p):
return is_ipv6_misc(p) or is_handshake_init(p)
try:
if not timeout:
timeout = 1
for i in self.pg_interfaces:
i.assert_nothing_captured(
timeout=timeout, remark=remark, filter_out_fn=_filter_out_fn
)
timeout = 0.1
finally:
pass
def test_wg_interface(self):
"""Simple interface creation"""
port = 12312
# Create interface
wg0 = VppWgInterface(self, self.pg1.local_ip4, port).add_vpp_config()
self.logger.info(self.vapi.cli("sh int"))
# delete interface
wg0.remove_vpp_config()
def test_handshake_hash(self):
"""test hashing an init message"""
# a init packet generated by linux given the key below
h = (
"0100000098b9032b"
"55cc4b39e73c3d24"
"a2a1ab884b524a81"
"1808bb86640fb70d"
"e93154fec1879125"
"ab012624a27f0b75"
"c0a2582f438ddb5f"
"8e768af40b4ab444"
"02f9ff473e1b797e"
"80d39d93c5480c82"
"a3d4510f70396976"
"586fb67300a5167b"
"ae6ca3ff3dfd00eb"
"59be198810f5aa03"
"6abc243d2155ee4f"
"2336483900aef801"
"08752cd700000000"
"0000000000000000"
"00000000"
)
b = bytearray.fromhex(h)
tgt = Wireguard(b)
pubb = base64.b64decode("aRuHFTTxICIQNefp05oKWlJv3zgKxb8+WW7JJMh0jyM=")
pub = X25519PublicKey.from_public_bytes(pubb)
self.assertEqual(pubb, public_key_bytes(pub))
# strip the macs and build a new packet
init = b[0:-32]
mac_key = blake2s(b"mac1----" + public_key_bytes(pub)).digest()
init += blake2s(init, digest_size=16, key=mac_key).digest()
init += b"\x00" * 16
act = Wireguard(init)
self.assertEqual(tgt, act)
def _test_wg_send_cookie_tmpl(self, is_resp, is_ip6):
port = 12323
# create wg interface
if is_ip6:
wg0 = VppWgInterface(self, self.pg1.local_ip6, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip6()
else:
wg0 = VppWgInterface(self, self.pg1.local_ip4, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip4()
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
# create a peer
if is_ip6:
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_ip6, port + 1, ["1::3:0/112"]
).add_vpp_config()
else:
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_ip4, port + 1, ["10.11.3.0/24"]
).add_vpp_config()
self.assertEqual(len(self.vapi.wireguard_peers_dump()), 1)
if is_resp:
# skip the first automatic handshake
self.pg1.get_capture(1, timeout=HANDSHAKE_JITTER)
# prepare and send a handshake initiation
# expect the peer to send a handshake response
init = peer_1.mk_handshake(self.pg1, is_ip6=is_ip6)
rxs = self.send_and_expect(self.pg1, [init], self.pg1)
else:
# wait for the peer to send a handshake initiation
rxs = self.pg1.get_capture(1, timeout=2)
# prepare and send a wrong cookie reply
# expect no replies and the cookie error incremented
cookie = peer_1.mk_cookie(rxs[0], self.pg1, is_resp=is_resp, is_ip6=is_ip6)
cookie.nonce = b"1234567890"
self.send_and_assert_no_replies(self.pg1, [cookie], timeout=0.1)
if is_ip6:
self.assertEqual(
self.base_cookie_dec6_err + 1,
self.statistics.get_err_counter(self.cookie_dec6_err),
)
else:
self.assertEqual(
self.base_cookie_dec4_err + 1,
self.statistics.get_err_counter(self.cookie_dec4_err),
)
# prepare and send a correct cookie reply
cookie = peer_1.mk_cookie(rxs[0], self.pg1, is_resp=is_resp, is_ip6=is_ip6)
self.pg_send(self.pg1, [cookie])
# wait for the peer to send a handshake initiation with mac2 set
rxs = self.pg1.get_capture(1, timeout=6)
# verify the initiation and its mac2
peer_1.consume_init(rxs[0], self.pg1, is_ip6=is_ip6, is_mac2=True)
# remove configs
peer_1.remove_vpp_config()
wg0.remove_vpp_config()
def test_wg_send_cookie_on_init_v4(self):
"""Send cookie on handshake initiation (v4)"""
self._test_wg_send_cookie_tmpl(is_resp=False, is_ip6=False)
def test_wg_send_cookie_on_init_v6(self):
"""Send cookie on handshake initiation (v6)"""
self._test_wg_send_cookie_tmpl(is_resp=False, is_ip6=True)
def test_wg_send_cookie_on_resp_v4(self):
"""Send cookie on handshake response (v4)"""
self._test_wg_send_cookie_tmpl(is_resp=True, is_ip6=False)
def test_wg_send_cookie_on_resp_v6(self):
"""Send cookie on handshake response (v6)"""
self._test_wg_send_cookie_tmpl(is_resp=True, is_ip6=True)
def _test_wg_receive_cookie_tmpl(self, is_resp, is_ip6):
port = 12323
# create wg interface
if is_ip6:
wg0 = VppWgInterface(self, self.pg1.local_ip6, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip6()
else:
wg0 = VppWgInterface(self, self.pg1.local_ip4, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip4()
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
# create a peer
if is_ip6:
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_ip6, port + 1, ["1::3:0/112"]
).add_vpp_config()
else:
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_ip4, port + 1, ["10.11.3.0/24"]
).add_vpp_config()
self.assertEqual(len(self.vapi.wireguard_peers_dump()), 1)
if is_resp:
# wait for the peer to send a handshake initiation
rxs = self.pg1.get_capture(1, timeout=2)
# prepare and send a bunch of handshake responses
# expect to switch to under load state
resp = peer_1.consume_init(rxs[0], self.pg1, is_ip6=is_ip6)
txs = [resp] * HANDSHAKE_NUM_PER_PEER_UNTIL_UNDER_LOAD
rxs = self.send_and_expect_some(self.pg1, txs, self.pg1)
# reset noise to be able to turn into initiator later
peer_1.noise_reset()
else:
# skip the first automatic handshake
self.pg1.get_capture(1, timeout=HANDSHAKE_JITTER)
# prepare and send a bunch of handshake initiations
# expect to switch to under load state
init = peer_1.mk_handshake(self.pg1, is_ip6=is_ip6)
txs = [init] * HANDSHAKE_NUM_PER_PEER_UNTIL_UNDER_LOAD
rxs = self.send_and_expect_some(self.pg1, txs, self.pg1)
# expect the peer to send a cookie reply
peer_1.consume_cookie(rxs[-1], is_ip6=is_ip6)
# prepare and send a handshake initiation with wrong mac2
# expect a cookie reply
init = peer_1.mk_handshake(self.pg1, is_ip6=is_ip6)
init.mac2 = b"1234567890"
rxs = self.send_and_expect(self.pg1, [init], self.pg1)
peer_1.consume_cookie(rxs[0], is_ip6=is_ip6)
# prepare and send a handshake initiation with correct mac2
# expect a handshake response
init = peer_1.mk_handshake(self.pg1, is_ip6=is_ip6)
rxs = self.send_and_expect(self.pg1, [init], self.pg1)
# verify the response
peer_1.consume_response(rxs[0], is_ip6=is_ip6)
# clear up under load state
self.sleep(UNDER_LOAD_INTERVAL)
# remove configs
peer_1.remove_vpp_config()
wg0.remove_vpp_config()
def test_wg_receive_cookie_on_init_v4(self):
"""Receive cookie on handshake initiation (v4)"""
self._test_wg_receive_cookie_tmpl(is_resp=False, is_ip6=False)
def test_wg_receive_cookie_on_init_v6(self):
"""Receive cookie on handshake initiation (v6)"""
self._test_wg_receive_cookie_tmpl(is_resp=False, is_ip6=True)
def test_wg_receive_cookie_on_resp_v4(self):
"""Receive cookie on handshake response (v4)"""
self._test_wg_receive_cookie_tmpl(is_resp=True, is_ip6=False)
def test_wg_receive_cookie_on_resp_v6(self):
"""Receive cookie on handshake response (v6)"""
self._test_wg_receive_cookie_tmpl(is_resp=True, is_ip6=True)
def test_wg_under_load_interval(self):
"""Under load interval"""
port = 12323
# create wg interface
wg0 = VppWgInterface(self, self.pg1.local_ip4, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip4()
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
# create a peer
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_ip4, port + 1, ["10.11.3.0/24"]
).add_vpp_config()
self.assertEqual(len(self.vapi.wireguard_peers_dump()), 1)
# skip the first automatic handshake
self.pg1.get_capture(1, timeout=HANDSHAKE_JITTER)
# prepare and send a bunch of handshake initiations
# expect to switch to under load state
init = peer_1.mk_handshake(self.pg1)
txs = [init] * HANDSHAKE_NUM_PER_PEER_UNTIL_UNDER_LOAD
rxs = self.send_and_expect_some(self.pg1, txs, self.pg1)
# expect the peer to send a cookie reply
peer_1.consume_cookie(rxs[-1])
# sleep till the next counting interval
# expect under load state is still active
self.sleep(HANDSHAKE_COUNTING_INTERVAL)
# prepare and send a handshake initiation with wrong mac2
# expect a cookie reply
init = peer_1.mk_handshake(self.pg1)
init.mac2 = b"1234567890"
rxs = self.send_and_expect(self.pg1, [init], self.pg1)
peer_1.consume_cookie(rxs[0])
# sleep till the end of being under load
# expect under load state is over
self.sleep(UNDER_LOAD_INTERVAL - HANDSHAKE_COUNTING_INTERVAL)
# prepare and send a handshake initiation with wrong mac2
# expect a handshake response
init = peer_1.mk_handshake(self.pg1)
init.mac2 = b"1234567890"
rxs = self.send_and_expect(self.pg1, [init], self.pg1)
# verify the response
peer_1.consume_response(rxs[0])
# remove configs
peer_1.remove_vpp_config()
wg0.remove_vpp_config()
def _test_wg_handshake_ratelimiting_tmpl(self, is_ip6):
port = 12323
# create wg interface
if is_ip6:
wg0 = VppWgInterface(self, self.pg1.local_ip6, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip6()
else:
wg0 = VppWgInterface(self, self.pg1.local_ip4, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip4()
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
# create a peer
if is_ip6:
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_ip6, port + 1, ["1::3:0/112"]
).add_vpp_config()
else:
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_ip4, port + 1, ["10.11.3.0/24"]
).add_vpp_config()
self.assertEqual(len(self.vapi.wireguard_peers_dump()), 1)
# skip the first automatic handshake
self.pg1.get_capture(1, timeout=HANDSHAKE_JITTER)
# prepare and send a bunch of handshake initiations
# expect to switch to under load state
init = peer_1.mk_handshake(self.pg1, is_ip6=is_ip6)
txs = [init] * HANDSHAKE_NUM_PER_PEER_UNTIL_UNDER_LOAD
rxs = self.send_and_expect_some(self.pg1, txs, self.pg1)
# expect the peer to send a cookie reply
peer_1.consume_cookie(rxs[-1], is_ip6=is_ip6)
# prepare and send a bunch of handshake initiations with correct mac2
# expect a handshake response and then ratelimiting
NUM_TO_REJECT = 10
init = peer_1.mk_handshake(self.pg1, is_ip6=is_ip6)
txs = [init] * (HANDSHAKE_NUM_BEFORE_RATELIMITING + NUM_TO_REJECT)
# TODO: Deterimine why no handshake response is sent back if test is
# not run in as part of the test suite. It fails only very occasionally
# when run solo.
#
# Until then, if no response, don't fail trying to verify it.
# The error counter test still verifies that the correct number of
# handshake initiaions are ratelimited.
try:
rxs = self.send_and_expect_some(self.pg1, txs, self.pg1)
except:
self.logger.debug(
f"{self._testMethodDoc}: send_and_expect_some() failed to get any response packets."
)
rxs = None
pass
if is_ip6:
self.assertEqual(
self.base_ratelimited6_err + NUM_TO_REJECT,
self.statistics.get_err_counter(self.ratelimited6_err),
)
else:
self.assertEqual(
self.base_ratelimited4_err + NUM_TO_REJECT,
self.statistics.get_err_counter(self.ratelimited4_err),
)
# verify the response
if rxs is not None:
peer_1.consume_response(rxs[0], is_ip6=is_ip6)
# clear up under load state
self.sleep(UNDER_LOAD_INTERVAL)
# remove configs
peer_1.remove_vpp_config()
wg0.remove_vpp_config()
def test_wg_handshake_ratelimiting_v4(self):
"""Handshake ratelimiting (v4)"""
self._test_wg_handshake_ratelimiting_tmpl(is_ip6=False)
def test_wg_handshake_ratelimiting_v6(self):
"""Handshake ratelimiting (v6)"""
self._test_wg_handshake_ratelimiting_tmpl(is_ip6=True)
def test_wg_handshake_ratelimiting_multi_peer(self):
"""Handshake ratelimiting (multiple peer)"""
port = 12323
# create wg interface
wg0 = VppWgInterface(self, self.pg1.local_ip4, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip4()
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
# create two peers
NUM_PEERS = 2
self.pg1.generate_remote_hosts(NUM_PEERS)
self.pg1.configure_ipv4_neighbors()
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_hosts[0].ip4, port + 1, ["10.11.3.0/24"]
).add_vpp_config()
peer_2 = VppWgPeer(
self, wg0, self.pg1.remote_hosts[1].ip4, port + 1, ["10.11.4.0/24"]
).add_vpp_config()
self.assertEqual(len(self.vapi.wireguard_peers_dump()), 2)
# skip the first automatic handshake
self.pg1.get_capture(NUM_PEERS, timeout=HANDSHAKE_JITTER)
# (peer_1) prepare and send a bunch of handshake initiations
# expect not to switch to under load state
init_1 = peer_1.mk_handshake(self.pg1)
txs = [init_1] * HANDSHAKE_NUM_PER_PEER_UNTIL_UNDER_LOAD
rxs = self.send_and_expect_some(self.pg1, txs, self.pg1)
# (peer_1) expect the peer to send a handshake response
peer_1.consume_response(rxs[0])
peer_1.noise_reset()
# (peer_1) send another bunch of handshake initiations
# expect to switch to under load state
rxs = self.send_and_expect_some(self.pg1, txs, self.pg1)
# (peer_1) expect the peer to send a cookie reply
peer_1.consume_cookie(rxs[-1])
# (peer_2) prepare and send a handshake initiation
# expect a cookie reply
init_2 = peer_2.mk_handshake(self.pg1)
rxs = self.send_and_expect(self.pg1, [init_2], self.pg1)
peer_2.consume_cookie(rxs[0])
# (peer_1) (peer_2) prepare and send a bunch of handshake initiations with correct mac2
# expect a handshake response and then ratelimiting
PEER_1_NUM_TO_REJECT = 2
PEER_2_NUM_TO_REJECT = 5
init_1 = peer_1.mk_handshake(self.pg1)
txs = [init_1] * (HANDSHAKE_NUM_BEFORE_RATELIMITING + PEER_1_NUM_TO_REJECT)
init_2 = peer_2.mk_handshake(self.pg1)
txs += [init_2] * (HANDSHAKE_NUM_BEFORE_RATELIMITING + PEER_2_NUM_TO_REJECT)
rxs = self.send_and_expect_some(self.pg1, txs, self.pg1)
self.assertTrue(
self.base_ratelimited4_err + PEER_1_NUM_TO_REJECT
< self.statistics.get_err_counter(self.ratelimited4_err)
<= self.base_ratelimited4_err + PEER_1_NUM_TO_REJECT + PEER_2_NUM_TO_REJECT
)
# (peer_1) (peer_2) verify the response
peer_1.consume_response(rxs[0])
peer_2.consume_response(rxs[1])
# clear up under load state
self.sleep(UNDER_LOAD_INTERVAL)
# remove configs
peer_1.remove_vpp_config()
peer_2.remove_vpp_config()
wg0.remove_vpp_config()
def _test_wg_peer_roaming_on_handshake_tmpl(self, is_endpoint_set, is_resp, is_ip6):
port = 12323
# create wg interface
if is_ip6:
wg0 = VppWgInterface(self, self.pg1.local_ip6, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip6()
else:
wg0 = VppWgInterface(self, self.pg1.local_ip4, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip4()
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
# create more remote hosts
NUM_REMOTE_HOSTS = 2
self.pg1.generate_remote_hosts(NUM_REMOTE_HOSTS)
if is_ip6:
self.pg1.configure_ipv6_neighbors()
else:
self.pg1.configure_ipv4_neighbors()
# create a peer
if is_ip6:
peer_1 = VppWgPeer(
test=self,
itf=wg0,
endpoint=self.pg1.remote_hosts[0].ip6 if is_endpoint_set else "::",
port=port + 1 if is_endpoint_set else 0,
allowed_ips=["1::3:0/112"],
).add_vpp_config()
else:
peer_1 = VppWgPeer(
test=self,
itf=wg0,
endpoint=self.pg1.remote_hosts[0].ip4 if is_endpoint_set else "0.0.0.0",
port=port + 1 if is_endpoint_set else 0,
allowed_ips=["10.11.3.0/24"],
).add_vpp_config()
self.assertTrue(peer_1.query_vpp_config())
if is_resp:
# wait for the peer to send a handshake initiation
rxs = self.pg1.get_capture(1, timeout=2)
# prepare a handshake response
resp = peer_1.consume_init(rxs[0], self.pg1, is_ip6=is_ip6)
# change endpoint
if is_ip6:
peer_1.change_endpoint(self.pg1.remote_hosts[1].ip6, port + 100)
resp[IPv6].src, resp[UDP].sport = peer_1.endpoint, peer_1.port
else:
peer_1.change_endpoint(self.pg1.remote_hosts[1].ip4, port + 100)
resp[IP].src, resp[UDP].sport = peer_1.endpoint, peer_1.port
# send the handshake response
# expect a keepalive message sent to the new endpoint
rxs = self.send_and_expect(self.pg1, [resp], self.pg1)
# verify the keepalive message
b = peer_1.decrypt_transport(rxs[0], is_ip6=is_ip6)
self.assertEqual(0, len(b))
else:
# change endpoint
if is_ip6:
peer_1.change_endpoint(self.pg1.remote_hosts[1].ip6, port + 100)
else:
peer_1.change_endpoint(self.pg1.remote_hosts[1].ip4, port + 100)
# prepare and send a handshake initiation
# expect a handshake response sent to the new endpoint
init = peer_1.mk_handshake(self.pg1, is_ip6=is_ip6)
rxs = self.send_and_expect(self.pg1, [init], self.pg1)
# verify the response
peer_1.consume_response(rxs[0], is_ip6=is_ip6)
self.assertTrue(peer_1.query_vpp_config())
# remove configs
peer_1.remove_vpp_config()
wg0.remove_vpp_config()
def test_wg_peer_roaming_on_init_v4(self):
"""Peer roaming on handshake initiation (v4)"""
self._test_wg_peer_roaming_on_handshake_tmpl(
is_endpoint_set=False, is_resp=False, is_ip6=False
)
def test_wg_peer_roaming_on_init_v6(self):
"""Peer roaming on handshake initiation (v6)"""
self._test_wg_peer_roaming_on_handshake_tmpl(
is_endpoint_set=False, is_resp=False, is_ip6=True
)
def test_wg_peer_roaming_on_resp_v4(self):
"""Peer roaming on handshake response (v4)"""
self._test_wg_peer_roaming_on_handshake_tmpl(
is_endpoint_set=True, is_resp=True, is_ip6=False
)
def test_wg_peer_roaming_on_resp_v6(self):
"""Peer roaming on handshake response (v6)"""
self._test_wg_peer_roaming_on_handshake_tmpl(
is_endpoint_set=True, is_resp=True, is_ip6=True
)
def _test_wg_peer_roaming_on_data_tmpl(self, is_async, is_ip6):
self.vapi.wg_set_async_mode(is_async)
port = 12323
# create wg interface
if is_ip6:
wg0 = VppWgInterface(self, self.pg1.local_ip6, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip6()
else:
wg0 = VppWgInterface(self, self.pg1.local_ip4, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip4()
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
# create more remote hosts
NUM_REMOTE_HOSTS = 2
self.pg1.generate_remote_hosts(NUM_REMOTE_HOSTS)
if is_ip6:
self.pg1.configure_ipv6_neighbors()
else:
self.pg1.configure_ipv4_neighbors()
# create a peer
if is_ip6:
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_hosts[0].ip6, port + 1, ["1::3:0/112"]
).add_vpp_config()
else:
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_hosts[0].ip4, port + 1, ["10.11.3.0/24"]
).add_vpp_config()
self.assertTrue(peer_1.query_vpp_config())
# create a route to rewrite traffic into the wg interface
if is_ip6:
r1 = VppIpRoute(
self, "1::3:0", 112, [VppRoutePath("1::3:1", wg0.sw_if_index)]
).add_vpp_config()
else:
r1 = VppIpRoute(
self, "10.11.3.0", 24, [VppRoutePath("10.11.3.1", wg0.sw_if_index)]
).add_vpp_config()
# wait for the peer to send a handshake initiation
rxs = self.pg1.get_capture(1, timeout=2)
# prepare and send a handshake response
# expect a keepalive message
resp = peer_1.consume_init(rxs[0], self.pg1, is_ip6=is_ip6)
rxs = self.send_and_expect(self.pg1, [resp], self.pg1)
# verify the keepalive message
b = peer_1.decrypt_transport(rxs[0], is_ip6=is_ip6)
self.assertEqual(0, len(b))
# change endpoint
if is_ip6:
peer_1.change_endpoint(self.pg1.remote_hosts[1].ip6, port + 100)
else:
peer_1.change_endpoint(self.pg1.remote_hosts[1].ip4, port + 100)
# prepare and send a data packet
# expect endpoint change
if is_ip6:
ip_header = IPv6(src="1::3:1", dst=self.pg0.remote_ip6, hlim=20)
else:
ip_header = IP(src="10.11.3.1", dst=self.pg0.remote_ip4, ttl=20)
data = (
peer_1.mk_tunnel_header(self.pg1, is_ip6=is_ip6)
/ Wireguard(message_type=4, reserved_zero=0)
/ WireguardTransport(
receiver_index=peer_1.sender,
counter=0,
encrypted_encapsulated_packet=peer_1.encrypt_transport(
ip_header / UDP(sport=222, dport=223) / Raw()
),
)
)
rxs = self.send_and_expect(self.pg1, [data], self.pg0)
if is_ip6:
self.assertEqual(rxs[0][IPv6].dst, self.pg0.remote_ip6)
self.assertEqual(rxs[0][IPv6].hlim, 19)
else:
self.assertEqual(rxs[0][IP].dst, self.pg0.remote_ip4)
self.assertEqual(rxs[0][IP].ttl, 19)
self.assertTrue(peer_1.query_vpp_config())
# prepare and send a packet that will be rewritten into the wg interface
# expect a data packet sent to the new endpoint
if is_ip6:
ip_header = IPv6(src=self.pg0.remote_ip6, dst="1::3:2")
else:
ip_header = IP(src=self.pg0.remote_ip4, dst="10.11.3.2")
p = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ ip_header
/ UDP(sport=555, dport=556)
/ Raw()
)
rxs = self.send_and_expect(self.pg0, [p], self.pg1)
# verify the data packet
peer_1.validate_encapped(rxs, p, is_tunnel_ip6=is_ip6, is_transport_ip6=is_ip6)
# remove configs
r1.remove_vpp_config()
peer_1.remove_vpp_config()
wg0.remove_vpp_config()
def test_wg_peer_roaming_on_data_v4_sync(self):
"""Peer roaming on data packet (v4, sync)"""
self._test_wg_peer_roaming_on_data_tmpl(is_async=False, is_ip6=False)
def test_wg_peer_roaming_on_data_v6_sync(self):
"""Peer roaming on data packet (v6, sync)"""
self._test_wg_peer_roaming_on_data_tmpl(is_async=False, is_ip6=True)
def test_wg_peer_roaming_on_data_v4_async(self):
"""Peer roaming on data packet (v4, async)"""
self._test_wg_peer_roaming_on_data_tmpl(is_async=True, is_ip6=False)
def test_wg_peer_roaming_on_data_v6_async(self):
"""Peer roaming on data packet (v6, async)"""
self._test_wg_peer_roaming_on_data_tmpl(is_async=True, is_ip6=True)
def test_wg_peer_resp(self):
"""Send handshake response IPv4 tunnel"""
port = 12323
# Create interfaces
wg0 = VppWgInterface(self, self.pg1.local_ip4, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip4()
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_ip4, port + 1, ["10.11.3.0/24"]
).add_vpp_config()
self.assertEqual(len(self.vapi.wireguard_peers_dump()), 1)
r1 = VppIpRoute(
self, "10.11.3.0", 24, [VppRoutePath("10.11.3.1", wg0.sw_if_index)]
).add_vpp_config()
# wait for the peer to send a handshake
rx = self.pg1.get_capture(1, timeout=2)
# consume the handshake in the noise protocol and
# generate the response
resp = peer_1.consume_init(rx[0], self.pg1)
# send the response, get keepalive
rxs = self.send_and_expect(self.pg1, [resp], self.pg1)
for rx in rxs:
b = peer_1.decrypt_transport(rx)
self.assertEqual(0, len(b))
# send a packets that are routed into the tunnel
p = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ IP(src=self.pg0.remote_ip4, dst="10.11.3.2")
/ UDP(sport=555, dport=556)
/ Raw(b"\x00" * 80)
)
rxs = self.send_and_expect(self.pg0, p * 255, self.pg1)
peer_1.validate_encapped(rxs, p)
# send packets into the tunnel, expect to receive them on
# the other side
p = [
(
peer_1.mk_tunnel_header(self.pg1)
/ Wireguard(message_type=4, reserved_zero=0)
/ WireguardTransport(
receiver_index=peer_1.sender,
counter=ii,
encrypted_encapsulated_packet=peer_1.encrypt_transport(
(
IP(src="10.11.3.1", dst=self.pg0.remote_ip4, ttl=20)
/ UDP(sport=222, dport=223)
/ Raw()
)
),
)
)
for ii in range(255)
]
rxs = self.send_and_expect(self.pg1, p, self.pg0)
for rx in rxs:
self.assertEqual(rx[IP].dst, self.pg0.remote_ip4)
self.assertEqual(rx[IP].ttl, 19)
r1.remove_vpp_config()
peer_1.remove_vpp_config()
wg0.remove_vpp_config()
def test_wg_peer_resp_ipv6(self):
"""Send handshake response IPv6 tunnel"""
port = 12323
# Create interfaces
wg0 = VppWgInterface(self, self.pg1.local_ip6, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip4()
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_ip6, port + 1, ["10.11.3.0/24"]
).add_vpp_config()
self.assertEqual(len(self.vapi.wireguard_peers_dump()), 1)
r1 = VppIpRoute(
self, "10.11.3.0", 24, [VppRoutePath("10.11.3.1", wg0.sw_if_index)]
).add_vpp_config()
# wait for the peer to send a handshake
rx = self.pg1.get_capture(1, timeout=2)
# consume the handshake in the noise protocol and
# generate the response
resp = peer_1.consume_init(rx[0], self.pg1, is_ip6=True)
# send the response, get keepalive
rxs = self.send_and_expect(self.pg1, [resp], self.pg1)
for rx in rxs:
b = peer_1.decrypt_transport(rx, True)
self.assertEqual(0, len(b))
# send a packets that are routed into the tunnel
p = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ IP(src=self.pg0.remote_ip4, dst="10.11.3.2")
/ UDP(sport=555, dport=556)
/ Raw(b"\x00" * 80)
)
rxs = self.send_and_expect(self.pg0, p * 2, self.pg1)
peer_1.validate_encapped(rxs, p, True)
# send packets into the tunnel, expect to receive them on
# the other side
p = [
(
peer_1.mk_tunnel_header(self.pg1, True)
/ Wireguard(message_type=4, reserved_zero=0)
/ WireguardTransport(
receiver_index=peer_1.sender,
counter=ii,
encrypted_encapsulated_packet=peer_1.encrypt_transport(
(
IP(src="10.11.3.1", dst=self.pg0.remote_ip4, ttl=20)
/ UDP(sport=222, dport=223)
/ Raw()
)
),
)
)
for ii in range(255)
]
rxs = self.send_and_expect(self.pg1, p, self.pg0)
for rx in rxs:
self.assertEqual(rx[IP].dst, self.pg0.remote_ip4)
self.assertEqual(rx[IP].ttl, 19)
r1.remove_vpp_config()
peer_1.remove_vpp_config()
wg0.remove_vpp_config()
def test_wg_peer_v4o4(self):
"""Test v4o4"""
port = 12333
# Create interfaces
wg0 = VppWgInterface(self, self.pg1.local_ip4, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip4()
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_ip4, port + 1, ["10.11.3.0/24"]
).add_vpp_config()
self.assertEqual(len(self.vapi.wireguard_peers_dump()), 1)
r1 = VppIpRoute(
self, "10.11.3.0", 24, [VppRoutePath("10.11.3.1", wg0.sw_if_index)]
).add_vpp_config()
r2 = VppIpRoute(
self, "20.22.3.0", 24, [VppRoutePath("20.22.3.1", wg0.sw_if_index)]
).add_vpp_config()
# route a packet into the wg interface
# use the allowed-ip prefix
# this is dropped because the peer is not initiated
p = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ IP(src=self.pg0.remote_ip4, dst="10.11.3.2")
/ UDP(sport=555, dport=556)
/ Raw()
)
self.send_and_assert_no_replies_ignoring_init(self.pg0, [p])
self.assertEqual(
self.base_kp4_err + 1, self.statistics.get_err_counter(self.kp4_error)
)
# route a packet into the wg interface
# use a not allowed-ip prefix
# this is dropped because there is no matching peer
p = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ IP(src=self.pg0.remote_ip4, dst="20.22.3.2")
/ UDP(sport=555, dport=556)
/ Raw()
)
self.send_and_assert_no_replies_ignoring_init(self.pg0, [p])
self.assertEqual(
self.base_peer4_out_err + 1,
self.statistics.get_err_counter(self.peer4_out_err),
)
# send a handsake from the peer with an invalid MAC
p = peer_1.mk_handshake(self.pg1)
p[WireguardInitiation].mac1 = b"foobar"
self.send_and_assert_no_replies_ignoring_init(self.pg1, [p])
self.assertEqual(
self.base_mac4_err + 1, self.statistics.get_err_counter(self.mac4_error)
)
# send a handsake from the peer but signed by the wrong key.
p = peer_1.mk_handshake(
self.pg1, False, X25519PrivateKey.generate().public_key()
)
self.send_and_assert_no_replies_ignoring_init(self.pg1, [p])
self.assertEqual(
self.base_peer4_in_err + 1,
self.statistics.get_err_counter(self.peer4_in_err),
)
# send a valid handsake init for which we expect a response
p = peer_1.mk_handshake(self.pg1)
rx = self.send_and_expect(self.pg1, [p], self.pg1)
peer_1.consume_response(rx[0])
# route a packet into the wg interface
# this is dropped because the peer is still not initiated
p = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ IP(src=self.pg0.remote_ip4, dst="10.11.3.2")
/ UDP(sport=555, dport=556)
/ Raw()
)
self.send_and_assert_no_replies_ignoring_init(self.pg0, [p])
self.assertEqual(
self.base_kp4_err + 2, self.statistics.get_err_counter(self.kp4_error)
)
# send a data packet from the peer through the tunnel
# this completes the handshake
p = (
IP(src="10.11.3.1", dst=self.pg0.remote_ip4, ttl=20)
/ UDP(sport=222, dport=223)
/ Raw()
)
d = peer_1.encrypt_transport(p)
p = peer_1.mk_tunnel_header(self.pg1) / (
Wireguard(message_type=4, reserved_zero=0)
/ WireguardTransport(
receiver_index=peer_1.sender, counter=0, encrypted_encapsulated_packet=d
)
)
rxs = self.send_and_expect(self.pg1, [p], self.pg0)
for rx in rxs:
self.assertEqual(rx[IP].dst, self.pg0.remote_ip4)
self.assertEqual(rx[IP].ttl, 19)
# send a packets that are routed into the tunnel
p = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ IP(src=self.pg0.remote_ip4, dst="10.11.3.2")
/ UDP(sport=555, dport=556)
/ Raw(b"\x00" * 80)
)
rxs = self.send_and_expect(self.pg0, p * 255, self.pg1)
for rx in rxs:
rx = IP(peer_1.decrypt_transport(rx))
# check the original packet is present
self.assertEqual(rx[IP].dst, p[IP].dst)
self.assertEqual(rx[IP].ttl, p[IP].ttl - 1)
# send packets into the tunnel, expect to receive them on
# the other side
p = [
(
peer_1.mk_tunnel_header(self.pg1)
/ Wireguard(message_type=4, reserved_zero=0)
/ WireguardTransport(
receiver_index=peer_1.sender,
counter=ii + 1,
encrypted_encapsulated_packet=peer_1.encrypt_transport(
(
IP(src="10.11.3.1", dst=self.pg0.remote_ip4, ttl=20)
/ UDP(sport=222, dport=223)
/ Raw()
)
),
)
)
for ii in range(255)
]
rxs = self.send_and_expect(self.pg1, p, self.pg0)
for rx in rxs:
self.assertEqual(rx[IP].dst, self.pg0.remote_ip4)
self.assertEqual(rx[IP].ttl, 19)
r1.remove_vpp_config()
r2.remove_vpp_config()
peer_1.remove_vpp_config()
wg0.remove_vpp_config()
def test_wg_peer_v6o6(self):
"""Test v6o6"""
port = 12343
# Create interfaces
wg0 = VppWgInterface(self, self.pg1.local_ip6, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip6()
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_ip6, port + 1, ["1::3:0/112"]
).add_vpp_config()
self.assertEqual(len(self.vapi.wireguard_peers_dump()), 1)
r1 = VppIpRoute(
self, "1::3:0", 112, [VppRoutePath("1::3:1", wg0.sw_if_index)]
).add_vpp_config()
r2 = VppIpRoute(
self, "22::3:0", 112, [VppRoutePath("22::3:1", wg0.sw_if_index)]
).add_vpp_config()
# route a packet into the wg interface
# use the allowed-ip prefix
# this is dropped because the peer is not initiated
p = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ IPv6(src=self.pg0.remote_ip6, dst="1::3:2")
/ UDP(sport=555, dport=556)
/ Raw()
)
self.send_and_assert_no_replies_ignoring_init(self.pg0, [p])
self.assertEqual(
self.base_kp6_err + 1, self.statistics.get_err_counter(self.kp6_error)
)
# route a packet into the wg interface
# use a not allowed-ip prefix
# this is dropped because there is no matching peer
p = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ IPv6(src=self.pg0.remote_ip6, dst="22::3:2")
/ UDP(sport=555, dport=556)
/ Raw()
)
self.send_and_assert_no_replies_ignoring_init(self.pg0, [p])
self.assertEqual(
self.base_peer6_out_err + 1,
self.statistics.get_err_counter(self.peer6_out_err),
)
# send a handsake from the peer with an invalid MAC
p = peer_1.mk_handshake(self.pg1, True)
p[WireguardInitiation].mac1 = b"foobar"
self.send_and_assert_no_replies_ignoring_init(self.pg1, [p])
self.assertEqual(
self.base_mac6_err + 1, self.statistics.get_err_counter(self.mac6_error)
)
# send a handsake from the peer but signed by the wrong key.
p = peer_1.mk_handshake(
self.pg1, True, X25519PrivateKey.generate().public_key()
)
self.send_and_assert_no_replies_ignoring_init(self.pg1, [p])
self.assertEqual(
self.base_peer6_in_err + 1,
self.statistics.get_err_counter(self.peer6_in_err),
)
# send a valid handsake init for which we expect a response
p = peer_1.mk_handshake(self.pg1, True)
rx = self.send_and_expect(self.pg1, [p], self.pg1)
peer_1.consume_response(rx[0], True)
# route a packet into the wg interface
# this is dropped because the peer is still not initiated
p = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ IPv6(src=self.pg0.remote_ip6, dst="1::3:2")
/ UDP(sport=555, dport=556)
/ Raw()
)
self.send_and_assert_no_replies_ignoring_init(self.pg0, [p])
self.assertEqual(
self.base_kp6_err + 2, self.statistics.get_err_counter(self.kp6_error)
)
# send a data packet from the peer through the tunnel
# this completes the handshake
p = (
IPv6(src="1::3:1", dst=self.pg0.remote_ip6, hlim=20)
/ UDP(sport=222, dport=223)
/ Raw()
)
d = peer_1.encrypt_transport(p)
p = peer_1.mk_tunnel_header(self.pg1, True) / (
Wireguard(message_type=4, reserved_zero=0)
/ WireguardTransport(
receiver_index=peer_1.sender, counter=0, encrypted_encapsulated_packet=d
)
)
rxs = self.send_and_expect(self.pg1, [p], self.pg0)
for rx in rxs:
self.assertEqual(rx[IPv6].dst, self.pg0.remote_ip6)
self.assertEqual(rx[IPv6].hlim, 19)
# send a packets that are routed into the tunnel
p = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ IPv6(src=self.pg0.remote_ip6, dst="1::3:2")
/ UDP(sport=555, dport=556)
/ Raw(b"\x00" * 80)
)
rxs = self.send_and_expect(self.pg0, p * 255, self.pg1)
for rx in rxs:
rx = IPv6(peer_1.decrypt_transport(rx, True))
# check the original packet is present
self.assertEqual(rx[IPv6].dst, p[IPv6].dst)
self.assertEqual(rx[IPv6].hlim, p[IPv6].hlim - 1)
# send packets into the tunnel, expect to receive them on
# the other side
p = [
(
peer_1.mk_tunnel_header(self.pg1, True)
/ Wireguard(message_type=4, reserved_zero=0)
/ WireguardTransport(
receiver_index=peer_1.sender,
counter=ii + 1,
encrypted_encapsulated_packet=peer_1.encrypt_transport(
(
IPv6(src="1::3:1", dst=self.pg0.remote_ip6, hlim=20)
/ UDP(sport=222, dport=223)
/ Raw()
)
),
)
)
for ii in range(255)
]
rxs = self.send_and_expect(self.pg1, p, self.pg0)
for rx in rxs:
self.assertEqual(rx[IPv6].dst, self.pg0.remote_ip6)
self.assertEqual(rx[IPv6].hlim, 19)
r1.remove_vpp_config()
r2.remove_vpp_config()
peer_1.remove_vpp_config()
wg0.remove_vpp_config()
def test_wg_peer_v6o4(self):
"""Test v6o4"""
port = 12353
# Create interfaces
wg0 = VppWgInterface(self, self.pg1.local_ip4, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip6()
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_ip4, port + 1, ["1::3:0/112"]
).add_vpp_config()
self.assertEqual(len(self.vapi.wireguard_peers_dump()), 1)
r1 = VppIpRoute(
self, "1::3:0", 112, [VppRoutePath("1::3:1", wg0.sw_if_index)]
).add_vpp_config()
# route a packet into the wg interface
# use the allowed-ip prefix
# this is dropped because the peer is not initiated
p = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ IPv6(src=self.pg0.remote_ip6, dst="1::3:2")
/ UDP(sport=555, dport=556)
/ Raw()
)
self.send_and_assert_no_replies_ignoring_init(self.pg0, [p])
self.assertEqual(
self.base_kp6_err + 1, self.statistics.get_err_counter(self.kp6_error)
)
# send a handsake from the peer with an invalid MAC
p = peer_1.mk_handshake(self.pg1)
p[WireguardInitiation].mac1 = b"foobar"
self.send_and_assert_no_replies_ignoring_init(self.pg1, [p])
self.assertEqual(
self.base_mac4_err + 1, self.statistics.get_err_counter(self.mac4_error)
)
# send a handsake from the peer but signed by the wrong key.
p = peer_1.mk_handshake(
self.pg1, False, X25519PrivateKey.generate().public_key()
)
self.send_and_assert_no_replies_ignoring_init(self.pg1, [p])
self.assertEqual(
self.base_peer4_in_err + 1,
self.statistics.get_err_counter(self.peer4_in_err),
)
# send a valid handsake init for which we expect a response
p = peer_1.mk_handshake(self.pg1)
rx = self.send_and_expect(self.pg1, [p], self.pg1)
peer_1.consume_response(rx[0])
# route a packet into the wg interface
# this is dropped because the peer is still not initiated
p = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ IPv6(src=self.pg0.remote_ip6, dst="1::3:2")
/ UDP(sport=555, dport=556)
/ Raw()
)
self.send_and_assert_no_replies_ignoring_init(self.pg0, [p])
self.assertEqual(
self.base_kp6_err + 2, self.statistics.get_err_counter(self.kp6_error)
)
# send a data packet from the peer through the tunnel
# this completes the handshake
p = (
IPv6(src="1::3:1", dst=self.pg0.remote_ip6, hlim=20)
/ UDP(sport=222, dport=223)
/ Raw()
)
d = peer_1.encrypt_transport(p)
p = peer_1.mk_tunnel_header(self.pg1) / (
Wireguard(message_type=4, reserved_zero=0)
/ WireguardTransport(
receiver_index=peer_1.sender, counter=0, encrypted_encapsulated_packet=d
)
)
rxs = self.send_and_expect(self.pg1, [p], self.pg0)
for rx in rxs:
self.assertEqual(rx[IPv6].dst, self.pg0.remote_ip6)
self.assertEqual(rx[IPv6].hlim, 19)
# send a packets that are routed into the tunnel
p = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ IPv6(src=self.pg0.remote_ip6, dst="1::3:2")
/ UDP(sport=555, dport=556)
/ Raw(b"\x00" * 80)
)
rxs = self.send_and_expect(self.pg0, p * 255, self.pg1)
for rx in rxs:
rx = IPv6(peer_1.decrypt_transport(rx))
# check the original packet is present
self.assertEqual(rx[IPv6].dst, p[IPv6].dst)
self.assertEqual(rx[IPv6].hlim, p[IPv6].hlim - 1)
# send packets into the tunnel, expect to receive them on
# the other side
p = [
(
peer_1.mk_tunnel_header(self.pg1)
/ Wireguard(message_type=4, reserved_zero=0)
/ WireguardTransport(
receiver_index=peer_1.sender,
counter=ii + 1,
encrypted_encapsulated_packet=peer_1.encrypt_transport(
(
IPv6(src="1::3:1", dst=self.pg0.remote_ip6, hlim=20)
/ UDP(sport=222, dport=223)
/ Raw()
)
),
)
)
for ii in range(255)
]
rxs = self.send_and_expect(self.pg1, p, self.pg0)
for rx in rxs:
self.assertEqual(rx[IPv6].dst, self.pg0.remote_ip6)
self.assertEqual(rx[IPv6].hlim, 19)
r1.remove_vpp_config()
peer_1.remove_vpp_config()
wg0.remove_vpp_config()
def test_wg_peer_v4o6(self):
"""Test v4o6"""
port = 12363
# Create interfaces
wg0 = VppWgInterface(self, self.pg1.local_ip6, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip4()
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_ip6, port + 1, ["10.11.3.0/24"]
).add_vpp_config()
self.assertEqual(len(self.vapi.wireguard_peers_dump()), 1)
r1 = VppIpRoute(
self, "10.11.3.0", 24, [VppRoutePath("10.11.3.1", wg0.sw_if_index)]
).add_vpp_config()
# route a packet into the wg interface
# use the allowed-ip prefix
# this is dropped because the peer is not initiated
p = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ IP(src=self.pg0.remote_ip4, dst="10.11.3.2")
/ UDP(sport=555, dport=556)
/ Raw()
)
self.send_and_assert_no_replies_ignoring_init(self.pg0, [p])
self.assertEqual(
self.base_kp4_err + 1, self.statistics.get_err_counter(self.kp4_error)
)
# send a handsake from the peer with an invalid MAC
p = peer_1.mk_handshake(self.pg1, True)
p[WireguardInitiation].mac1 = b"foobar"
self.send_and_assert_no_replies_ignoring_init(self.pg1, [p])
self.assertEqual(
self.base_mac6_err + 1, self.statistics.get_err_counter(self.mac6_error)
)
# send a handsake from the peer but signed by the wrong key.
p = peer_1.mk_handshake(
self.pg1, True, X25519PrivateKey.generate().public_key()
)
self.send_and_assert_no_replies_ignoring_init(self.pg1, [p])
self.assertEqual(
self.base_peer6_in_err + 1,
self.statistics.get_err_counter(self.peer6_in_err),
)
# send a valid handsake init for which we expect a response
p = peer_1.mk_handshake(self.pg1, True)
rx = self.send_and_expect(self.pg1, [p], self.pg1)
peer_1.consume_response(rx[0], True)
# route a packet into the wg interface
# this is dropped because the peer is still not initiated
p = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ IP(src=self.pg0.remote_ip4, dst="10.11.3.2")
/ UDP(sport=555, dport=556)
/ Raw()
)
self.send_and_assert_no_replies_ignoring_init(self.pg0, [p])
self.assertEqual(
self.base_kp4_err + 2, self.statistics.get_err_counter(self.kp4_error)
)
# send a data packet from the peer through the tunnel
# this completes the handshake
p = (
IP(src="10.11.3.1", dst=self.pg0.remote_ip4, ttl=20)
/ UDP(sport=222, dport=223)
/ Raw()
)
d = peer_1.encrypt_transport(p)
p = peer_1.mk_tunnel_header(self.pg1, True) / (
Wireguard(message_type=4, reserved_zero=0)
/ WireguardTransport(
receiver_index=peer_1.sender, counter=0, encrypted_encapsulated_packet=d
)
)
rxs = self.send_and_expect(self.pg1, [p], self.pg0)
for rx in rxs:
self.assertEqual(rx[IP].dst, self.pg0.remote_ip4)
self.assertEqual(rx[IP].ttl, 19)
# send a packets that are routed into the tunnel
p = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ IP(src=self.pg0.remote_ip4, dst="10.11.3.2")
/ UDP(sport=555, dport=556)
/ Raw(b"\x00" * 80)
)
rxs = self.send_and_expect(self.pg0, p * 255, self.pg1)
for rx in rxs:
rx = IP(peer_1.decrypt_transport(rx, True))
# check the original packet is present
self.assertEqual(rx[IP].dst, p[IP].dst)
self.assertEqual(rx[IP].ttl, p[IP].ttl - 1)
# send packets into the tunnel, expect to receive them on
# the other side
p = [
(
peer_1.mk_tunnel_header(self.pg1, True)
/ Wireguard(message_type=4, reserved_zero=0)
/ WireguardTransport(
receiver_index=peer_1.sender,
counter=ii + 1,
encrypted_encapsulated_packet=peer_1.encrypt_transport(
(
IP(src="10.11.3.1", dst=self.pg0.remote_ip4, ttl=20)
/ UDP(sport=222, dport=223)
/ Raw()
)
),
)
)
for ii in range(255)
]
rxs = self.send_and_expect(self.pg1, p, self.pg0)
for rx in rxs:
self.assertEqual(rx[IP].dst, self.pg0.remote_ip4)
self.assertEqual(rx[IP].ttl, 19)
r1.remove_vpp_config()
peer_1.remove_vpp_config()
wg0.remove_vpp_config()
def test_wg_multi_peer(self):
"""multiple peer setup"""
port = 12373
# Create interfaces
wg0 = VppWgInterface(self, self.pg1.local_ip4, port).add_vpp_config()
wg1 = VppWgInterface(self, self.pg2.local_ip4, port + 1).add_vpp_config()
wg0.admin_up()
wg1.admin_up()
# Check peer counter
self.assertEqual(len(self.vapi.wireguard_peers_dump()), 0)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
# Create many peers on sencond interface
NUM_PEERS = 16
self.pg2.generate_remote_hosts(NUM_PEERS)
self.pg2.configure_ipv4_neighbors()
self.pg1.generate_remote_hosts(NUM_PEERS)
self.pg1.configure_ipv4_neighbors()
peers_1 = []
peers_2 = []
routes_1 = []
routes_2 = []
for i in range(NUM_PEERS):
peers_1.append(
VppWgPeer(
self,
wg0,
self.pg1.remote_hosts[i].ip4,
port + 1 + i,
["10.0.%d.4/32" % i],
).add_vpp_config()
)
routes_1.append(
VppIpRoute(
self,
"10.0.%d.4" % i,
32,
[VppRoutePath(self.pg1.remote_hosts[i].ip4, wg0.sw_if_index)],
).add_vpp_config()
)
peers_2.append(
VppWgPeer(
self,
wg1,
self.pg2.remote_hosts[i].ip4,
port + 100 + i,
["10.100.%d.4/32" % i],
).add_vpp_config()
)
routes_2.append(
VppIpRoute(
self,
"10.100.%d.4" % i,
32,
[VppRoutePath(self.pg2.remote_hosts[i].ip4, wg1.sw_if_index)],
).add_vpp_config()
)
self.assertEqual(len(self.vapi.wireguard_peers_dump()), NUM_PEERS * 2)
self.logger.info(self.vapi.cli("show wireguard peer"))
self.logger.info(self.vapi.cli("show wireguard interface"))
self.logger.info(self.vapi.cli("show adj 37"))
self.logger.info(self.vapi.cli("sh ip fib 172.16.3.17"))
self.logger.info(self.vapi.cli("sh ip fib 10.11.3.0"))
# remove routes
for r in routes_1:
r.remove_vpp_config()
for r in routes_2:
r.remove_vpp_config()
# remove peers
for p in peers_1:
self.assertTrue(p.query_vpp_config())
p.remove_vpp_config()
for p in peers_2:
self.assertTrue(p.query_vpp_config())
p.remove_vpp_config()
wg0.remove_vpp_config()
wg1.remove_vpp_config()
def test_wg_multi_interface(self):
"""Multi-tunnel on the same port"""
port = 12500
# Create many wireguard interfaces
NUM_IFS = 4
self.pg1.generate_remote_hosts(NUM_IFS)
self.pg1.configure_ipv4_neighbors()
self.pg0.generate_remote_hosts(NUM_IFS)
self.pg0.configure_ipv4_neighbors()
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
# Create interfaces with a peer on each
peers = []
routes = []
wg_ifs = []
for i in range(NUM_IFS):
# Use the same port for each interface
wg0 = VppWgInterface(self, self.pg1.local_ip4, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip4()
wg_ifs.append(wg0)
peers.append(
VppWgPeer(
self,
wg0,
self.pg1.remote_hosts[i].ip4,
port + 1 + i,
["10.0.%d.0/24" % i],
).add_vpp_config()
)
routes.append(
VppIpRoute(
self,
"10.0.%d.0" % i,
24,
[VppRoutePath("10.0.%d.4" % i, wg0.sw_if_index)],
).add_vpp_config()
)
self.assertEqual(len(self.vapi.wireguard_peers_dump()), NUM_IFS)
# skip the first automatic handshake
self.pg1.get_capture(NUM_IFS, timeout=HANDSHAKE_JITTER)
for i in range(NUM_IFS):
# send a valid handsake init for which we expect a response
p = peers[i].mk_handshake(self.pg1)
rx = self.send_and_expect(self.pg1, [p], self.pg1)
peers[i].consume_response(rx[0])
# send a data packet from the peer through the tunnel
# this completes the handshake
p = (
IP(src="10.0.%d.4" % i, dst=self.pg0.remote_hosts[i].ip4, ttl=20)
/ UDP(sport=222, dport=223)
/ Raw()
)
d = peers[i].encrypt_transport(p)
p = peers[i].mk_tunnel_header(self.pg1) / (
Wireguard(message_type=4, reserved_zero=0)
/ WireguardTransport(
receiver_index=peers[i].sender,
counter=0,
encrypted_encapsulated_packet=d,
)
)
rxs = self.send_and_expect(self.pg1, [p], self.pg0)
for rx in rxs:
self.assertEqual(rx[IP].dst, self.pg0.remote_hosts[i].ip4)
self.assertEqual(rx[IP].ttl, 19)
# send a packets that are routed into the tunnel
for i in range(NUM_IFS):
p = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ IP(src=self.pg0.remote_hosts[i].ip4, dst="10.0.%d.4" % i)
/ UDP(sport=555, dport=556)
/ Raw(b"\x00" * 80)
)
rxs = self.send_and_expect(self.pg0, p * 64, self.pg1)
for rx in rxs:
rx = IP(peers[i].decrypt_transport(rx))
# check the oringial packet is present
self.assertEqual(rx[IP].dst, p[IP].dst)
self.assertEqual(rx[IP].ttl, p[IP].ttl - 1)
# send packets into the tunnel
for i in range(NUM_IFS):
p = [
(
peers[i].mk_tunnel_header(self.pg1)
/ Wireguard(message_type=4, reserved_zero=0)
/ WireguardTransport(
receiver_index=peers[i].sender,
counter=ii + 1,
encrypted_encapsulated_packet=peers[i].encrypt_transport(
(
IP(
src="10.0.%d.4" % i,
dst=self.pg0.remote_hosts[i].ip4,
ttl=20,
)
/ UDP(sport=222, dport=223)
/ Raw()
)
),
)
)
for ii in range(64)
]
rxs = self.send_and_expect(self.pg1, p, self.pg0)
for rx in rxs:
self.assertEqual(rx[IP].dst, self.pg0.remote_hosts[i].ip4)
self.assertEqual(rx[IP].ttl, 19)
for r in routes:
r.remove_vpp_config()
for p in peers:
p.remove_vpp_config()
for i in wg_ifs:
i.remove_vpp_config()
def test_wg_event(self):
"""Test events"""
port = 12600
ESTABLISHED_FLAG = (
VppEnum.vl_api_wireguard_peer_flags_t.WIREGUARD_PEER_ESTABLISHED
)
DEAD_FLAG = VppEnum.vl_api_wireguard_peer_flags_t.WIREGUARD_PEER_STATUS_DEAD
# Create interfaces
wg0 = VppWgInterface(self, self.pg1.local_ip4, port).add_vpp_config()
wg1 = VppWgInterface(self, self.pg2.local_ip4, port + 1).add_vpp_config()
wg0.admin_up()
wg1.admin_up()
# Check peer counter
self.assertEqual(len(self.vapi.wireguard_peers_dump()), 0)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
# Create peers
NUM_PEERS = 2
self.pg2.generate_remote_hosts(NUM_PEERS)
self.pg2.configure_ipv4_neighbors()
self.pg1.generate_remote_hosts(NUM_PEERS)
self.pg1.configure_ipv4_neighbors()
peers_0 = []
peers_1 = []
routes_0 = []
routes_1 = []
for i in range(NUM_PEERS):
peers_0.append(
VppWgPeer(
self,
wg0,
self.pg1.remote_hosts[i].ip4,
port + 1 + i,
["10.0.%d.4/32" % i],
).add_vpp_config()
)
routes_0.append(
VppIpRoute(
self,
"10.0.%d.4" % i,
32,
[VppRoutePath(self.pg1.remote_hosts[i].ip4, wg0.sw_if_index)],
).add_vpp_config()
)
peers_1.append(
VppWgPeer(
self,
wg1,
self.pg2.remote_hosts[i].ip4,
port + 100 + i,
["10.100.%d.4/32" % i],
).add_vpp_config()
)
routes_1.append(
VppIpRoute(
self,
"10.100.%d.4" % i,
32,
[VppRoutePath(self.pg2.remote_hosts[i].ip4, wg1.sw_if_index)],
).add_vpp_config()
)
self.assertEqual(len(self.vapi.wireguard_peers_dump()), NUM_PEERS * 2)
# skip the first automatic handshake
self.pg1.get_capture(NUM_PEERS, timeout=HANDSHAKE_JITTER)
self.pg2.get_capture(NUM_PEERS, timeout=HANDSHAKE_JITTER)
# Want events from the first perr of wg0
# and from all wg1 peers
peers_0[0].want_events()
wg1.want_events()
for i in range(NUM_PEERS):
# wg0 peers: send a valid handsake init for which we expect a response
p = peers_0[i].mk_handshake(self.pg1)
rx = self.send_and_expect(self.pg1, [p], self.pg1)
peers_0[i].consume_response(rx[0])
# wg0 peers: send empty packet, it means successful connection (WIREGUARD_PEER_ESTABLISHED)
keepalive = peers_0[i].encrypt_transport(0)
p = peers_0[i].mk_tunnel_header(self.pg1) / (
Wireguard(message_type=4, reserved_zero=0)
/ WireguardTransport(
receiver_index=peers_0[i].sender,
counter=0,
encrypted_encapsulated_packet=keepalive,
)
)
# TODO: Figure out wny there are sometimes wg packets received here
# self.send_and_assert_no_replies(self.pg1, [p])
self.pg_send(self.pg1, [p])
# wg0 peers: wait for established flag
if i == 0:
peers_0[0].wait_event(ESTABLISHED_FLAG)
# wg1 peers: send a valid handsake init for which we expect a response
p = peers_1[i].mk_handshake(self.pg2)
rx = self.send_and_expect(self.pg2, [p], self.pg2)
peers_1[i].consume_response(rx[0])
# wg1 peers: send empty packet, it means successful connection (WIREGUARD_PEER_ESTABLISHED)
keepalive = peers_1[i].encrypt_transport(0)
p = peers_1[i].mk_tunnel_header(self.pg2) / (
Wireguard(message_type=4, reserved_zero=0)
/ WireguardTransport(
receiver_index=peers_1[i].sender,
counter=0,
encrypted_encapsulated_packet=keepalive,
)
)
self.send_and_assert_no_replies(self.pg2, [p])
# wg1 peers: wait for established flag
wg1.wait_events(ESTABLISHED_FLAG, [peers_1[0].index, peers_1[1].index])
# remove routes
for r in routes_0:
r.remove_vpp_config()
for r in routes_1:
r.remove_vpp_config()
# remove peers
for i in range(NUM_PEERS):
self.assertTrue(peers_0[i].query_vpp_config())
peers_0[i].remove_vpp_config()
if i == 0:
peers_0[i].wait_event(0)
peers_0[i].wait_event(DEAD_FLAG)
for p in peers_1:
self.assertTrue(p.query_vpp_config())
p.remove_vpp_config()
p.wait_event(0)
p.wait_event(DEAD_FLAG)
wg0.remove_vpp_config()
wg1.remove_vpp_config()
def test_wg_sending_handshake_when_admin_down(self):
"""Sending handshake when admin down"""
port = 12323
# create wg interface
wg0 = VppWgInterface(self, self.pg1.local_ip4, port).add_vpp_config()
wg0.config_ip4()
# create a peer
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_ip4, port + 1, ["10.11.3.0/24"]
).add_vpp_config()
self.assertEqual(len(self.vapi.wireguard_peers_dump()), 1)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
# wait for the peer to send a handshake initiation
# expect no handshakes
for i in range(2):
self.pg1.assert_nothing_captured(remark="handshake packet(s) sent")
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
# administratively enable the wg interface
# expect the peer to send a handshake initiation
wg0.admin_up()
rxs = self.pg1.get_capture(1, timeout=2)
peer_1.consume_init(rxs[0], self.pg1)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
# administratively disable the wg interface
# expect no handshakes
wg0.admin_down()
for i in range(6):
self.pg1.assert_nothing_captured(remark="handshake packet(s) sent")
# remove configs
peer_1.remove_vpp_config()
wg0.remove_vpp_config()
def test_wg_sending_data_when_admin_down(self):
"""Sending data when admin down"""
port = 12323
# create wg interface
wg0 = VppWgInterface(self, self.pg1.local_ip4, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip4()
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
# create a peer
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_ip4, port + 1, ["10.11.3.0/24"]
).add_vpp_config()
self.assertEqual(len(self.vapi.wireguard_peers_dump()), 1)
# create a route to rewrite traffic into the wg interface
r1 = VppIpRoute(
self, "10.11.3.0", 24, [VppRoutePath("10.11.3.1", wg0.sw_if_index)]
).add_vpp_config()
# wait for the peer to send a handshake initiation
rxs = self.pg1.get_capture(1, timeout=2)
# prepare and send a handshake response
# expect a keepalive message
resp = peer_1.consume_init(rxs[0], self.pg1)
rxs = self.send_and_expect(self.pg1, [resp], self.pg1)
# verify the keepalive message
b = peer_1.decrypt_transport(rxs[0])
self.assertEqual(0, len(b))
# prepare and send a packet that will be rewritten into the wg interface
# expect a data packet sent
p = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ IP(src=self.pg0.remote_ip4, dst="10.11.3.2")
/ UDP(sport=555, dport=556)
/ Raw()
)
rxs = self.send_and_expect(self.pg0, [p], self.pg1)
# verify the data packet
peer_1.validate_encapped(rxs, p)
# administratively disable the wg interface
wg0.admin_down()
# send a packet that will be rewritten into the wg interface
# expect no data packets sent
self.send_and_assert_no_replies(self.pg0, [p])
# administratively enable the wg interface
# expect the peer to send a handshake initiation
wg0.admin_up()
peer_1.noise_reset()
rxs = self.pg1.get_capture(1, timeout=2)
resp = peer_1.consume_init(rxs[0], self.pg1)
# send a packet that will be rewritten into the wg interface
# expect no data packets sent because the peer is not initiated
self.send_and_assert_no_replies(self.pg0, [p])
self.assertEqual(
self.base_kp4_err + 1, self.statistics.get_err_counter(self.kp4_error)
)
# send a handshake response and expect a keepalive message
rxs = self.send_and_expect(self.pg1, [resp], self.pg1)
# verify the keepalive message
b = peer_1.decrypt_transport(rxs[0])
self.assertEqual(0, len(b))
# send a packet that will be rewritten into the wg interface
# expect a data packet sent
rxs = self.send_and_expect(self.pg0, [p], self.pg1)
# verify the data packet
peer_1.validate_encapped(rxs, p)
# remove configs
r1.remove_vpp_config()
peer_1.remove_vpp_config()
wg0.remove_vpp_config()
def _test_wg_large_packet_tmpl(self, is_async, is_ip6):
self.vapi.wg_set_async_mode(is_async)
port = 12323
# create wg interface
if is_ip6:
wg0 = VppWgInterface(self, self.pg1.local_ip6, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip6()
else:
wg0 = VppWgInterface(self, self.pg1.local_ip4, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip4()
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
# create a peer
if is_ip6:
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_ip6, port + 1, ["1::3:0/112"]
).add_vpp_config()
else:
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_ip4, port + 1, ["10.11.3.0/24"]
).add_vpp_config()
self.assertEqual(len(self.vapi.wireguard_peers_dump()), 1)
# create a route to rewrite traffic into the wg interface
if is_ip6:
r1 = VppIpRoute(
self, "1::3:0", 112, [VppRoutePath("1::3:1", wg0.sw_if_index)]
).add_vpp_config()
else:
r1 = VppIpRoute(
self, "10.11.3.0", 24, [VppRoutePath("10.11.3.1", wg0.sw_if_index)]
).add_vpp_config()
# wait for the peer to send a handshake initiation
rxs = self.pg1.get_capture(1, timeout=2)
# prepare and send a handshake response
# expect a keepalive message
resp = peer_1.consume_init(rxs[0], self.pg1, is_ip6=is_ip6)
rxs = self.send_and_expect(self.pg1, [resp], self.pg1)
# verify the keepalive message
b = peer_1.decrypt_transport(rxs[0], is_ip6=is_ip6)
self.assertEqual(0, len(b))
# prepare and send data packets
# expect to receive them decrypted
if is_ip6:
ip_header = IPv6(src="1::3:1", dst=self.pg0.remote_ip6, hlim=20)
else:
ip_header = IP(src="10.11.3.1", dst=self.pg0.remote_ip4, ttl=20)
packet_len_opts = (
2500, # two buffers
1500, # one buffer
4500, # three buffers
1910 if is_ip6 else 1950, # auth tag is not contiguous
)
txs = []
for l in packet_len_opts:
txs.append(
peer_1.mk_tunnel_header(self.pg1, is_ip6=is_ip6)
/ Wireguard(message_type=4, reserved_zero=0)
/ WireguardTransport(
receiver_index=peer_1.sender,
counter=len(txs),
encrypted_encapsulated_packet=peer_1.encrypt_transport(
ip_header / UDP(sport=222, dport=223) / Raw(b"\xfe" * l)
),
)
)
rxs = self.send_and_expect(self.pg1, txs, self.pg0)
# verify decrypted packets
for i, l in enumerate(packet_len_opts):
if is_ip6:
self.assertEqual(rxs[i][IPv6].dst, self.pg0.remote_ip6)
self.assertEqual(rxs[i][IPv6].hlim, ip_header.hlim - 1)
else:
self.assertEqual(rxs[i][IP].dst, self.pg0.remote_ip4)
self.assertEqual(rxs[i][IP].ttl, ip_header.ttl - 1)
self.assertEqual(len(rxs[i][Raw]), l)
self.assertEqual(bytes(rxs[i][Raw]), b"\xfe" * l)
# prepare and send packets that will be rewritten into the wg interface
# expect data packets sent
if is_ip6:
ip_header = IPv6(src=self.pg0.remote_ip6, dst="1::3:2")
else:
ip_header = IP(src=self.pg0.remote_ip4, dst="10.11.3.2")
packet_len_opts = (
2500, # two buffers
1500, # one buffer
4500, # three buffers
1980 if is_ip6 else 2000, # no free space to write auth tag
)
txs = []
for l in packet_len_opts:
txs.append(
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ ip_header
/ UDP(sport=555, dport=556)
/ Raw(b"\xfe" * l)
)
rxs = self.send_and_expect(self.pg0, txs, self.pg1)
# verify the data packets
rxs_decrypted = peer_1.validate_encapped(
rxs, ip_header, is_tunnel_ip6=is_ip6, is_transport_ip6=is_ip6
)
for i, l in enumerate(packet_len_opts):
self.assertEqual(len(rxs_decrypted[i][Raw]), l)
self.assertEqual(bytes(rxs_decrypted[i][Raw]), b"\xfe" * l)
# remove configs
r1.remove_vpp_config()
peer_1.remove_vpp_config()
wg0.remove_vpp_config()
def test_wg_large_packet_v4_sync(self):
"""Large packet (v4, sync)"""
self._test_wg_large_packet_tmpl(is_async=False, is_ip6=False)
def test_wg_large_packet_v6_sync(self):
"""Large packet (v6, sync)"""
self._test_wg_large_packet_tmpl(is_async=False, is_ip6=True)
def test_wg_large_packet_v4_async(self):
"""Large packet (v4, async)"""
self._test_wg_large_packet_tmpl(is_async=True, is_ip6=False)
def test_wg_large_packet_v6_async(self):
"""Large packet (v6, async)"""
self._test_wg_large_packet_tmpl(is_async=True, is_ip6=True)
def test_wg_lack_of_buf_headroom(self):
"""Lack of buffer's headroom (v6 vxlan over v6 wg)"""
port = 12323
# create wg interface
wg0 = VppWgInterface(self, self.pg1.local_ip6, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip6()
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
# create a peer
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_ip6, port + 1, ["::/0"]
).add_vpp_config()
self.assertEqual(len(self.vapi.wireguard_peers_dump()), 1)
# create a route to enable communication between wg interface addresses
r1 = VppIpRoute(
self, wg0.remote_ip6, 128, [VppRoutePath("0.0.0.0", wg0.sw_if_index)]
).add_vpp_config()
# wait for the peer to send a handshake initiation
rxs = self.pg1.get_capture(1, timeout=2)
# prepare and send a handshake response
# expect a keepalive message
resp = peer_1.consume_init(rxs[0], self.pg1, is_ip6=True)
rxs = self.send_and_expect(self.pg1, [resp], self.pg1)
# verify the keepalive message
b = peer_1.decrypt_transport(rxs[0], is_ip6=True)
self.assertEqual(0, len(b))
# create vxlan interface over the wg interface
vxlan0 = VppVxlanTunnel(self, src=wg0.local_ip6, dst=wg0.remote_ip6, vni=1111)
vxlan0.add_vpp_config()
# create bridge domain
bd1 = VppBridgeDomain(self, bd_id=1)
bd1.add_vpp_config()
# add the vxlan interface and pg0 to the bridge domain
bd1_ports = (
VppBridgeDomainPort(self, bd1, vxlan0).add_vpp_config(),
VppBridgeDomainPort(self, bd1, self.pg0).add_vpp_config(),
)
# prepare and send packets that will be rewritten into the vxlan interface
# expect they to be rewritten into the wg interface then and data packets sent
tx = (
Ether(dst="00:00:00:00:00:01", src="00:00:00:00:00:02")
/ IPv6(src="::1", dst="::2", hlim=20)
/ UDP(sport=1111, dport=1112)
/ Raw(b"\xfe" * 1900)
)
rxs = self.send_and_expect(self.pg0, [tx] * 5, self.pg1)
# verify the data packet
for rx in rxs:
rx_decrypted = IPv6(peer_1.decrypt_transport(rx, is_ip6=True))
self.assertEqual(rx_decrypted[VXLAN].vni, vxlan0.vni)
inner = rx_decrypted[VXLAN].payload
# check the original packet is present
self.assertEqual(inner[IPv6].dst, tx[IPv6].dst)
self.assertEqual(inner[IPv6].hlim, tx[IPv6].hlim)
self.assertEqual(len(inner[Raw]), len(tx[Raw]))
self.assertEqual(bytes(inner[Raw]), bytes(tx[Raw]))
# remove configs
for bdp in bd1_ports:
bdp.remove_vpp_config()
bd1.remove_vpp_config()
vxlan0.remove_vpp_config()
r1.remove_vpp_config()
peer_1.remove_vpp_config()
wg0.remove_vpp_config()
@tag_fixme_vpp_debug
class WireguardHandoffTests(TestWg):
"""Wireguard Tests in multi worker setup"""
vpp_worker_count = 2
def test_wg_peer_init(self):
"""Handoff"""
port = 12383
# Create interfaces
wg0 = VppWgInterface(self, self.pg1.local_ip4, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip4()
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_ip4, port + 1, ["10.11.2.0/24", "10.11.3.0/24"]
).add_vpp_config()
self.assertEqual(len(self.vapi.wireguard_peers_dump()), 1)
r1 = VppIpRoute(
self, "10.11.3.0", 24, [VppRoutePath("10.11.3.1", wg0.sw_if_index)]
).add_vpp_config()
# skip the first automatic handshake
self.pg1.get_capture(1, timeout=HANDSHAKE_JITTER)
# send a valid handsake init for which we expect a response
p = peer_1.mk_handshake(self.pg1)
rx = self.send_and_expect(self.pg1, [p], self.pg1)
peer_1.consume_response(rx[0])
# send a data packet from the peer through the tunnel
# this completes the handshake and pins the peer to worker 0
p = (
IP(src="10.11.3.1", dst=self.pg0.remote_ip4, ttl=20)
/ UDP(sport=222, dport=223)
/ Raw()
)
d = peer_1.encrypt_transport(p)
p = peer_1.mk_tunnel_header(self.pg1) / (
Wireguard(message_type=4, reserved_zero=0)
/ WireguardTransport(
receiver_index=peer_1.sender, counter=0, encrypted_encapsulated_packet=d
)
)
rxs = self.send_and_expect(self.pg1, [p], self.pg0, worker=0)
for rx in rxs:
self.assertEqual(rx[IP].dst, self.pg0.remote_ip4)
self.assertEqual(rx[IP].ttl, 19)
# send a packets that are routed into the tunnel
# and pins the peer tp worker 1
pe = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ IP(src=self.pg0.remote_ip4, dst="10.11.3.2")
/ UDP(sport=555, dport=556)
/ Raw(b"\x00" * 80)
)
rxs = self.send_and_expect(self.pg0, pe * 255, self.pg1, worker=1)
peer_1.validate_encapped(rxs, pe)
# send packets into the tunnel, from the other worker
p = [
(
peer_1.mk_tunnel_header(self.pg1)
/ Wireguard(message_type=4, reserved_zero=0)
/ WireguardTransport(
receiver_index=peer_1.sender,
counter=ii + 1,
encrypted_encapsulated_packet=peer_1.encrypt_transport(
(
IP(src="10.11.3.1", dst=self.pg0.remote_ip4, ttl=20)
/ UDP(sport=222, dport=223)
/ Raw()
)
),
)
)
for ii in range(255)
]
rxs = self.send_and_expect(self.pg1, p, self.pg0, worker=1)
for rx in rxs:
self.assertEqual(rx[IP].dst, self.pg0.remote_ip4)
self.assertEqual(rx[IP].ttl, 19)
# send a packets that are routed into the tunnel
# from worker 0
rxs = self.send_and_expect(self.pg0, pe * 255, self.pg1, worker=0)
peer_1.validate_encapped(rxs, pe)
r1.remove_vpp_config()
peer_1.remove_vpp_config()
wg0.remove_vpp_config()
@unittest.skip("test disabled")
def test_wg_multi_interface(self):
"""Multi-tunnel on the same port"""
@unittest.skipIf(
"wireguard" in config.excluded_plugins, "Exclude Wireguard plugin tests"
)
@tag_run_solo
class TestWgFIB(VppTestCase):
"""Wireguard FIB Test Case"""
@classmethod
def setUpClass(cls):
super(TestWgFIB, cls).setUpClass()
@classmethod
def tearDownClass(cls):
super(TestWgFIB, cls).tearDownClass()
def setUp(self):
super(TestWgFIB, self).setUp()
self.create_pg_interfaces(range(2))
for i in self.pg_interfaces:
i.admin_up()
i.config_ip4()
def tearDown(self):
for i in self.pg_interfaces:
i.unconfig_ip4()
i.admin_down()
super(TestWgFIB, self).tearDown()
def test_wg_fib_tracking(self):
"""FIB tracking"""
port = 12323
# create wg interface
wg0 = VppWgInterface(self, self.pg1.local_ip4, port).add_vpp_config()
wg0.admin_up()
wg0.config_ip4()
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
# create a peer
peer_1 = VppWgPeer(
self, wg0, self.pg1.remote_ip4, port + 1, ["10.11.3.0/24"]
).add_vpp_config()
self.assertEqual(len(self.vapi.wireguard_peers_dump()), 1)
# create a route to rewrite traffic into the wg interface
r1 = VppIpRoute(
self, "10.11.3.0", 24, [VppRoutePath("10.11.3.1", wg0.sw_if_index)]
).add_vpp_config()
# resolve ARP and expect the adjacency to update
self.pg1.resolve_arp()
# wait for the peer to send a handshake initiation
rxs = self.pg1.get_capture(2, timeout=6)
# prepare and send a handshake response
# expect a keepalive message
resp = peer_1.consume_init(rxs[1], self.pg1)
rxs = self.send_and_expect(self.pg1, [resp], self.pg1)
# verify the keepalive message
b = peer_1.decrypt_transport(rxs[0])
self.assertEqual(0, len(b))
# prepare and send a packet that will be rewritten into the wg interface
# expect a data packet sent
p = (
Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
/ IP(src=self.pg0.remote_ip4, dst="10.11.3.2")
/ UDP(sport=555, dport=556)
/ Raw()
)
rxs = self.send_and_expect(self.pg0, [p], self.pg1)
# verify the data packet
peer_1.validate_encapped(rxs, p)
# remove configs
r1.remove_vpp_config()
peer_1.remove_vpp_config()
wg0.remove_vpp_config()
Reference in New Issue View Git Blame Copy Permalink