Homelab / InfraAI-generated

Hoe een VPN werkt: WireGuard stap voor stap

Een VPN klinkt als een ondoorzichtige dienst die je aanzet en die dan "iets met beveiliging" doet. WireGuard laat zien dat het mechanisme eronder overzichtelijk is. De Linux-versie telt volgens de whitepaper minder dan 4.000 regels code, zonder de cryptografische bouwstenen meegerekend. Daardoor kun je stap voor stap volgen hoe een VPN-tunnel werkt, van de eerste sleutel tot het laatste byte van een pakket.

Hieronder bouw ik de onderdelen na in een klein Python-script: twee sleutelparen, een versleuteld datapakket in het formaat van WireGuard en een pakket waarin één bit is omgedraaid. Aan het eind zie je ook waar de extra vertraging van een VPN vandaan komt, en waar niet.

Sleutels in plaats van wachtwoorden

Elke WireGuard-kant heeft een privésleutel en een publieke sleutel op de elliptische kromme Curve25519. Er is geen gebruikersnaam en geen certificaat. Je geeft de server de publieke sleutel van je laptop, de laptop krijgt die van de server, en dat is de hele identiteit. In mijn script zag een publieke sleutel er zo uit:

laptop publiek: PZL8qFlaBohOwGfNZt2dz9P669iWhYjNDDZMU8IFo0A= 44 tekens

Dat is 32 bytes in base64. Het handige van deze sleutels is de Diffie-Hellman-eigenschap: de laptop rekent met zijn privésleutel en de publieke sleutel van de server, de server doet het omgekeerde, en beide komen op hetzelfde geheim uit zonder dat het ooit over de lijn gaat. Mijn script controleert dat, en geeft True.

Cryptokey routing: een publieke sleutel per adresblok

Het eigen idee van WireGuard heet cryptokey routing. Bij elke peer staat in de configuratie een lijst AllowedIPs. Volgens wireguard.com werkt die lijst in twee richtingen. Bij verzenden is het een routetabel: een pakket voor 192.168.0.5 gaat versleuteld naar de peer bij wie 192.168.0.0/16 staat. Bij ontvangen is het een toegangslijst: komt er na ontsleuteling een pakket binnen met een bronadres dat niet bij die peer hoort, dan gooit WireGuard het weg.

Wil je al je verkeer door de tunnel, dan zet je bij de server 0.0.0.0/0. Het hulpmiddel wg-quick past dan volgens zijn handleiding de standaardroute aan met ip rule. Een pakket dat je laptop verlaat, weet zo meteen welke sleutel erbij hoort. Dat koppelen van adres aan sleutel is het hele toegangsmodel.

De handshake: één heen en één terug

Voordat er data kan stromen, spreken de twee kanten tijdelijke sessiesleutels af. WireGuard gebruikt daarvoor het Noise-patroon Noise_IKpsk2, zo staat het op de protocolpagina. Het kost één round trip. De laptop stuurt een initiatiebericht, de server antwoordt, en daarna kan het verkeer beginnen.

Als je de velden uit de protocolpagina optelt, is het eerste bericht 148 bytes en het antwoord 92 bytes. In het initiatiebericht zit een nieuwe, eenmalige publieke sleutel, de vaste publieke sleutel van de laptop (versleuteld, zodat een meekijker niet ziet wie er belt) en een versleuteld tijdstempel van 12 bytes in TAI64N-formaat. De server onthoudt per peer het hoogste tijdstempel dat hij zag en weigert alles wat ouder is. Een opgenomen handshake later opnieuw afspelen werkt dus niet.

Die sessiesleutels leven kort. De whitepaper noemt een nieuwe handshake na 120 seconden (Rekey-After-Time) en na 180 seconden weigert WireGuard een oude sessie te gebruiken. Wie later een privésleutel buitmaakt, kan opgenomen verkeer van eerdere sessies daarom niet ontsleutelen.

Stil voor wie de sleutel niet kent

Een WireGuard-server antwoordt niet op pakketten die hij niet kan authenticeren. De whitepaper noemt dat "Silence is a Virtue": geen antwoord, geen opgeslagen toestand. Een poortscanner die op UDP-poort 51820 (de poort uit de quickstart) klopt, krijgt niets terug en kan niet zien of daar iets draait. Pas als het eerste bericht een geldige mac1 bevat, berekend met de publieke sleutel van de server, gaat de server rekenen.

Encapsulatie: een pakket in een pakket

Na de handshake wordt elk IP-pakket van je laptop in zijn geheel versleuteld met ChaCha20-Poly1305 en in een UDP-pakket gestopt. Het transportbericht heeft 16 bytes header: type, ontvanger-index en een teller van 8 bytes. Die teller is de nonce voor de versleuteling en voorkomt ook dat iemand oude pakketten opnieuw instuurt. Achter de versleutelde inhoud komt een authenticatietag van 16 bytes.

WireGuard vult het binnenpakket aan tot een veelvoud van 16 bytes, zodat pakketgroottes minder verraden. Volgens de kernelcode (calculate_skb_padding in send.c) stopt die opvulling bij de MTU van de tunnel. Ik heb dat nagebouwd:

binnenpakket 84 B -> padding 12, WireGuard-bericht 128 B, buiten IPv4 156 B, buiten IPv6 176 B
binnenpakket 1420 B -> padding 0, WireGuard-bericht 1452 B, buiten IPv4 1480 B, buiten IPv6 1500 B

Een ping van 84 bytes wordt dus 156 bytes op de lijn. En daar zie je ook waar het getal 1420 vandaan komt, de MTU van wg0 in het voorbeeld uit de whitepaper: 1420 plus 32 bytes WireGuard, 8 bytes UDP en 40 bytes IPv6-header is precies 1500. Over IPv4 houd je 20 bytes speling. Gaat de MTU-instelling mis, dan krijg je de verbindingen die stil blijven hangen.

Wat er gebeurt als iemand onderweg aan een pakket knoeit, liet mijn script ook zien. Eén omgedraaide bit in de versleutelde inhoud gaf bij ontsleutelen InvalidTag. WireGuard laat zo'n pakket vallen zonder iets terug te sturen.

Zwerven tussen netwerken en NAT

Omdat een peer aan zijn sleutel wordt herkend en niet aan zijn IP-adres, mag dat adres veranderen. Beide kanten sturen hun verkeer naar het adres waarvan ze het laatste geldige pakket ontvingen. Loop je van je wifi naar 4G, dan komt het volgende pakket van een nieuw adres, de server past zijn tabel aan, en de tunnel loopt door zonder nieuwe verbinding.

Een router met NAT vergeet een UDP-koppeling als er een tijd niets langskomt. Voor een laptop die zelf geen verkeer start is dat een probleem, want de server kan hem dan niet meer bereiken. Daarvoor is PersistentKeepalive: een leeg, geauthenticeerd pakket op een vast interval. De man-pagina van wg noemt 25 seconden als verstandige waarde.

Waarom een VPN vertraging toevoegt

De versleuteling zelf is het probleem meestal niet. Op deze testmachine, een zuinige Celeron J3455, haalde openssl speed voor ChaCha20-Poly1305 op pakketten van 1424 bytes ongeveer 379 MB per seconde op één kern. Dat is zo'n 3,8 microseconde per pakket.

De vertraging zit in de route. Elk pakket gaat eerst naar de VPN-server en pas daarna naar zijn bestemming. Staat die server in een ander land, dan maakt elk pakket heen en terug die omweg, en die afstand kost tijd die je met geen enkele instelling terugwint. Daarnaast wacht het eerste pakket na een stilte op de handshake van één round trip. Tegenover protocollen die meerdere round trips nodig hebben om op te starten, zoals TCP met TLS, valt dat mee.

Zelf proberen

Het script heeft alleen de Python-bibliotheek cryptography nodig. Het maakt twee X25519-sleutelparen, controleert het gedeelde geheim, bouwt transportberichten met de padding-regel van de kernel en test een gemanipuleerd pakket. Sla het op als wg_proef.py:

import base64, os, struct
from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey
from cryptography.hazmat.primitives import serialization as s
from cryptography.hazmat.primitives.ciphers.aead import ChaCha20Poly1305

def b64(k): return base64.b64encode(k).decode()
raw = dict(encoding=s.Encoding.Raw, format=s.PublicFormat.Raw)
a, b = X25519PrivateKey.generate(), X25519PrivateKey.generate()
apub, bpub = a.public_key().public_bytes(**raw), b.public_key().public_bytes(**raw)
print("laptop publiek:", b64(apub), len(b64(apub)), "tekens")
print("server publiek:", b64(bpub))
print("zelfde geheim aan beide kanten:", a.exchange(b.public_key()) == b.exchange(a.public_key()))

key = os.urandom(32); aead = ChaCha20Poly1305(key)
def transport(inner, counter, receiver=0x1234, mtu=1420):
    pad = min(mtu, -(-len(inner)//16)*16) - len(inner)
    nonce = b"\0"*4 + struct.pack("<Q", counter)
    ct = aead.encrypt(nonce, inner + b"\0"*pad, None)
    hdr = struct.pack("<I", 4) + struct.pack("<I", receiver) + struct.pack("<Q", counter)
    return hdr + ct, pad
for n in (84, 1420):
    msg, pad = transport(os.urandom(n), 0)
    print(f"binnenpakket {n} B -> padding {pad}, WireGuard-bericht {len(msg)} B, "
          f"buiten IPv4 {len(msg)+28} B, buiten IPv6 {len(msg)+48} B")
msg, _ = transport(os.urandom(84), 7)
bad = bytearray(msg); bad[20] ^= 1
try:
    aead.decrypt(b"\0"*4 + struct.pack("<Q", 7), bytes(bad[16:]), None); print("geaccepteerd")
except Exception as e: print("1 bit omgedraaid:", type(e).__name__)
python3 wg_proef.py
laptop publiek: PZL8qFlaBohOwGfNZt2dz9P669iWhYjNDDZMU8IFo0A= 44 tekens
zelfde geheim aan beide kanten: True
binnenpakket 84 B -> padding 12, WireGuard-bericht 128 B, buiten IPv4 156 B, buiten IPv6 176 B
binnenpakket 1420 B -> padding 0, WireGuard-bericht 1452 B, buiten IPv4 1480 B, buiten IPv6 1500 B
1 bit omgedraaid: InvalidTag

De snelheid van de versleuteling op je eigen machine meet je zo:

openssl speed -seconds 2 -bytes 1424 -evp chacha20-poly1305
type           1424 bytes
ChaCha20-Poly1305   378731.31k

Het getal is in duizenden bytes per seconde. Heb je wireguard-tools geïnstalleerd, dan maakt wg genkey | tee privatekey | wg pubkey > publickey uit de quickstart een echt sleutelpaar.

Tot slot

Wat me het meest verraste, is hoe weinig er in een WireGuard-pakket zit. Er staat geen lengteveld in de header en geen veld om een algoritme te kiezen. Het type van een transportbericht is één byte en de rest is een index, een teller en versleutelde inhoud. Een gemiddelde VPN-dienst doet er een app, een serverlijst en een abonnement omheen, maar de tunnel zelf is een rekensom met twee sleutels en een teller die per pakket met één omhooggaat.