--- author: mikeconrad categories: - Automation - IaC - Open Source - Security - Self Hosted - Software Engineering - SSH date: "2024-09-25T09:56:04Z" tags: - Blog Post title: Standing up a Wireguard VPN --- VPN’s have traditionally been slow, complex and hard to set up and configure. That all changed several years ago when Wireguard was officially merged into the mainline Linux kernel ([src](https://arstechnica.com/gadgets/2020/03/wireguard-vpn-makes-it-to-1-0-0-and-into-the-next-linux-kernel/)). I won’t go over all the reasons for why you should want to use Wireguard in this article, instead I will be focusing on just how easy it is to set up and configure. For this tutorial we will be using Terraform to stand up a Digital Ocean droplet and then install Wireguard onto that. The Digital Ocean droplet will be acting as our “server” in this example and we will be using our own computer as the “client”. Of course, you don’t have to use Terraform, you just need a Linux box to install Wireguard on. You can find the code for this tutorial on my personal Git server [here](https://git.hackanooga.com/mikeconrad/wireguard-terraform-digitalocean). ### Create Droplet with Terraform I have written some very basic Terraform to get us started. The Terraform is very basic and just creates a droplet with a predefined ssh key and a setup script passed as user data. When the droplet gets created, the script will get copied to the instance and automatically executed. After a few minutes everything should be ready to go. If you want to clone the repo above, feel free to, or if you would rather do everything by hand that’s great too. I will assume that you are doing everything by hand. The process of deploying from the repo should be pretty self explainitory. My reasoning for doing it this way is because I wanted to better understand the process. First create our main.tf with the following contents: ``` # main.tf # Attach an SSH key to our droplet resource "digitalocean_ssh_key" "default" { name = "Terraform Example" public_key = file("./tf-digitalocean.pub") } # Create a new Web Droplet in the nyc1 region resource "digitalocean_droplet" "web" { image = "ubuntu-22-04-x64" name = "wireguard" region = "nyc1" size = "s-2vcpu-4gb" ssh_keys = [digitalocean_ssh_key.default.fingerprint] user_data = file("setup.sh") } output "droplet_output" { value = digitalocean_droplet.web.ipv4_address } ``` Next create a terraform.tf file in the same directory with the following contents: ``` terraform { required_providers { digitalocean = { source = "digitalocean/digitalocean" version = "2.41.0" } } } provider "digitalocean" { } ``` Now we will need to create the ssh key that we defined in our Terraform code. ``` $ ssh-keygen -t rsa -C "WireguardVPN" -f ./tf-digitalocean -q -N "" ``` Next we need to set an environment variable for our DigitalOcean access token. ``` $ export DIGITALOCEAN_ACCESS_TOKEN=dop_v1_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ``` Now we are ready to initialize our Terraform and apply it: ``` $ terraform init $ terraform apply Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols: + create Terraform will perform the following actions: # digitalocean_droplet.web will be created + resource "digitalocean_droplet" "web" { + backups = false + created_at = (known after apply) + disk = (known after apply) + graceful_shutdown = false + id = (known after apply) + image = "ubuntu-22-04-x64" + ipv4_address = (known after apply) + ipv4_address_private = (known after apply) + ipv6 = false + ipv6_address = (known after apply) + locked = (known after apply) + memory = (known after apply) + monitoring = false + name = "wireguard" + price_hourly = (known after apply) + price_monthly = (known after apply) + private_networking = (known after apply) + region = "nyc1" + resize_disk = true + size = "s-2vcpu-4gb" + ssh_keys = (known after apply) + status = (known after apply) + urn = (known after apply) + user_data = "69d130f386b262b136863be5fcffc32bff055ac0" + vcpus = (known after apply) + volume_ids = (known after apply) + vpc_uuid = (known after apply) } # digitalocean_ssh_key.default will be created + resource "digitalocean_ssh_key" "default" { + fingerprint = (known after apply) + id = (known after apply) + name = "Terraform Example" + public_key = <<-EOT ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDXOBlFdNqV48oxWobrn2rPt4y1FTqrqscA5bSu2f3CogwbDKDyNglXu8RL4opjfdBHQES+pEqvt21niqes8z2QsBTF3TRQ39SaHM8wnOTeC8d0uSgyrp9b7higHd0SDJVJZT0Bz5AlpYfCO/gpEW51XrKKeud7vImj8nGPDHnENN0Ie0UVYZ5+V1zlr0BBI7LX01MtzUOgSldDX0lif7IZWW4XEv40ojWyYJNQwO/gwyDrdAq+kl+xZu7LmBhngcqd02+X6w4SbdgYg2flu25Td0MME0DEsXKiZYf7kniTrKgCs4kJAmidCDYlYRt43dlM69pB5jVD/u4r3O+erTapH/O1EDhsdA9y0aYpKOv26ssYU+ZXK/nax+Heu0giflm7ENTCblKTPCtpG1DBthhX6Ml0AYjZF1cUaaAvpN8UjElxQ9r+PSwXloSnf25/r9UOBs1uco8VDwbx5cM0SpdYm6ERtLqGRYrG2SDJ8yLgiCE9EK9n3uQExyrTMKWzVAc= WireguardVPN EOT } Plan: 2 to add, 0 to change, 0 to destroy. Changes to Outputs: + droplet_output = (known after apply) Do you want to perform these actions? Terraform will perform the actions described above. Only 'yes' will be accepted to approve. Enter a value: yes digitalocean_ssh_key.default: Creating... digitalocean_ssh_key.default: Creation complete after 1s [id=43499750] digitalocean_droplet.web: Creating... digitalocean_droplet.web: Still creating... [10s elapsed] digitalocean_droplet.web: Still creating... [20s elapsed] digitalocean_droplet.web: Still creating... [30s elapsed] digitalocean_droplet.web: Creation complete after 31s [id=447469336] Apply complete! Resources: 2 added, 0 changed, 0 destroyed. Outputs: droplet_output = "159.223.113.207" ``` All pretty standard stuff. Nice! It only took about 30 seconds or so on my machine to spin up a droplet and start provisioning it. It is worth noting that the setup script will take a few minutes to run. Before we log into our new droplet, let’s take a quick look at the setup script that we are running. ``` #!/usr/bin/env sh set -e set -u # Set the listen port used by Wireguard, this is the default so feel free to change it. LISTENPORT=51820 CONFIG_DIR=/root/wireguard-conf umask 077 mkdir -p $CONFIG_DIR/client # Install wireguard apt update && apt install -y wireguard # Generate public/private key for the "server". wg genkey > $CONFIG_DIR/privatekey wg pubkey < $CONFIG_DIR/privatekey > $CONFIG_DIR/publickey # Generate public/private key for the "client" wg genkey > $CONFIG_DIR/client/privatekey wg pubkey < $CONFIG_DIR/client/privatekey > $CONFIG_DIR/client/publickey # Generate server config echo "[Interface] Address = 10.66.66.1/24,fd42:42:42::1/64 ListenPort = $LISTENPORT PrivateKey = $(cat $CONFIG_DIR/privatekey) ### Client config [Peer] PublicKey = $(cat $CONFIG_DIR/client/publickey) AllowedIPs = 10.66.66.2/32,fd42:42:42::2/128 " > /etc/wireguard/do.conf # Generate client config. This will need to be copied to your machine. echo "[Interface] PrivateKey = $(cat $CONFIG_DIR/client/privatekey) Address = 10.66.66.2/32,fd42:42:42::2/128 DNS = 1.1.1.1,1.0.0.1 [Peer] PublicKey = $(cat publickey) Endpoint = $(curl icanhazip.com):$LISTENPORT AllowedIPs = 0.0.0.0/0,::/0 " > client-config.conf wg-quick up do # Add iptables rules to forward internet traffic through this box # We are assuming our Wireguard interface is called do and our # primary public facing interface is called eth0. iptables -I INPUT -p udp --dport 51820 -j ACCEPT iptables -I FORWARD -i eth0 -o do -j ACCEPT iptables -I FORWARD -i do -j ACCEPT iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE ip6tables -I FORWARD -i do -j ACCEPT ip6tables -t nat -A POSTROUTING -o eth0 -j MASQUERADE # Enable routing on the server echo "net.ipv4.ip_forward = 1 net.ipv6.conf.all.forwarding = 1" >/etc/sysctl.d/wg.conf sysctl --system ``` As you can see, it is pretty straightforward. All you really need to do is: On the “server” side: 1. Generate a private key and derive a public key from it for both the “server” and the “client”. 2. Create a “server” config that tells the droplet what address to bind to for the wireguard interface, which private key to use to secure that interface and what port to listen on. 3. The “server” config also needs to know what peers or “clients” to accept connections from in the AllowedIPs block. In this case we are just specifying one. The “server” also needs to know the public key of the “client” that will be connecting. On the “client” side: 1. Create a “client” config that tells our machine what address to assign to the wireguard interface (obviously needs to be on the same subnet as the interface on the server side). 2. The client needs to know which private key to use to secure the interface. 3. It also needs to know the public key of the server as well as the public IP address/hostname of the “server” it is connecting to as well as the port it is listening on. 4. Finally it needs to know what traffic to route over the wireguard interface. In this example we are simply routing all traffic but you could restrict this as you see fit. Now that we have our configs in place, we need to copy the client config to our local machine. The following command should work as long as you make sure to replace the IP address with the IP address of your newly created droplet: ``` ## Make sure you have Wireguard installed on your local machine as well. ## https://wireguard.com/install ## Copy the client config to our local machine and move it to our wireguard directory. $ ssh -i tf-digitalocean root@157.230.177.54 -- cat /root/wireguard-conf/client-config.conf| sudo tee /etc/wireguard/do.conf ``` Before we try to connect, let’s log into the server and make sure everything is set up correctly: ``` $ ssh -i tf-digitalocean root@159.223.113.207 Welcome to Ubuntu 22.04.4 LTS (GNU/Linux 5.15.0-113-generic x86_64) * Documentation: https://help.ubuntu.com * Management: https://landscape.canonical.com * Support: https://ubuntu.com/pro System information as of Wed Sep 25 13:19:02 UTC 2024 System load: 0.03 Processes: 113 Usage of /: 2.1% of 77.35GB Users logged in: 0 Memory usage: 6% IPv4 address for eth0: 157.230.221.196 Swap usage: 0% IPv4 address for eth0: 10.10.0.5 Expanded Security Maintenance for Applications is not enabled. 70 updates can be applied immediately. 40 of these updates are standard security updates. To see these additional updates run: apt list --upgradable Enable ESM Apps to receive additional future security updates. See https://ubuntu.com/esm or run: sudo pro status New release '24.04.1 LTS' available. Run 'do-release-upgrade' to upgrade to it. Last login: Wed Sep 25 13:16:25 2024 from 74.221.191.214 root@wireguard:~# ``` Awesome! We are connected. Now let’s check the wireguard interface using the `wg` command. If our config was correct, we should see an interface line and 1 peer line like so. If the peer line is missing then something is wrong with the configuration. Most likely a mismatch between public/private key.: ``` root@wireguard:~# wg interface: do public key: fTvqo/cZVofJ9IZgWHwU6XKcIwM/EcxUsMw4voeS/Hg= private key: (hidden) listening port: 51820 peer: 5RxMenh1L+rNJobROkUrub4DBUj+nEUPKiNe4DFR8iY= allowed ips: 10.66.66.2/32, fd42:42:42::2/128 root@wireguard:~# ``` So now we should be ready to go! On your local machine go ahead and try it out: ``` ## Start the interface with wg-quick up [interface_name] $ sudo wg-quick up do [sudo] password for mikeconrad: [#] ip link add do type wireguard [#] wg setconf do /dev/fd/63 [#] ip -4 address add 10.66.66.2/32 dev do [#] ip -6 address add fd42:42:42::2/128 dev do [#] ip link set mtu 1420 up dev do [#] resolvconf -a do -m 0 -x [#] wg set do fwmark 51820 [#] ip -6 route add ::/0 dev do table 51820 [#] ip -6 rule add not fwmark 51820 table 51820 [#] ip -6 rule add table main suppress_prefixlength 0 [#] ip6tables-restore -n [#] ip -4 route add 0.0.0.0/0 dev do table 51820 [#] ip -4 rule add not fwmark 51820 table 51820 [#] ip -4 rule add table main suppress_prefixlength 0 [#] sysctl -q net.ipv4.conf.all.src_valid_mark=1 [#] iptables-restore -n ## Check our config $ sudo wg interface: do public key: fJ8mptCR/utCR4K2LmJTKTjn3xc4RDmZ3NNEQGwI7iI= private key: (hidden) listening port: 34596 fwmark: 0xca6c peer: duTHwMhzSZxnRJ2GFCUCHE4HgY5tSeRn9EzQt9XVDx4= endpoint: 157.230.177.54:51820 allowed ips: 0.0.0.0/0, ::/0 latest handshake: 1 second ago transfer: 1.82 KiB received, 2.89 KiB sent ## Make sure we can ping the outside world mikeconrad@pop-os:~/projects/wireguard-terraform-digitalocean$ ping 1.1.1.1 PING 1.1.1.1 (1.1.1.1) 56(84) bytes of data. 64 bytes from 1.1.1.1: icmp_seq=1 ttl=56 time=28.0 ms ^C --- 1.1.1.1 ping statistics --- 1 packets transmitted, 1 received, 0% packet loss, time 0ms rtt min/avg/max/mdev = 27.991/27.991/27.991/0.000 ms ## Verify our traffic is actually going over the tunnel. $ curl icanhazip.com 157.230.177.54 ``` We should also be able to ssh into our instance over the VPN using the `10.66.66.1` address: ``` $ ssh -i tf-digitalocean root@10.66.66.1 The authenticity of host '10.66.66.1 (10.66.66.1)' can't be established. ED25519 key fingerprint is SHA256:E7BKSO3qP+iVVXfb/tLaUfKIc4RvtZ0k248epdE04m8. This host key is known by the following other names/addresses: ~/.ssh/known_hosts:130: [hashed name] Are you sure you want to continue connecting (yes/no/[fingerprint])? yes Warning: Permanently added '10.66.66.1' (ED25519) to the list of known hosts. Welcome to Ubuntu 22.04.4 LTS (GNU/Linux 5.15.0-113-generic x86_64) * Documentation: https://help.ubuntu.com * Management: https://landscape.canonical.com * Support: https://ubuntu.com/pro System information as of Wed Sep 25 13:32:12 UTC 2024 System load: 0.02 Processes: 109 Usage of /: 2.1% of 77.35GB Users logged in: 0 Memory usage: 6% IPv4 address for eth0: 157.230.177.54 Swap usage: 0% IPv4 address for eth0: 10.10.0.5 Expanded Security Maintenance for Applications is not enabled. 73 updates can be applied immediately. 40 of these updates are standard security updates. To see these additional updates run: apt list --upgradable Enable ESM Apps to receive additional future security updates. See https://ubuntu.com/esm or run: sudo pro status New release '24.04.1 LTS' available. Run 'do-release-upgrade' to upgrade to it. root@wireguard:~# ``` Looks like everything is working! If you run the script from the repo you will have a fully functioning Wireguard VPN in less than 5 minutes! Pretty cool stuff! This article was not meant to be exhaustive but instead a simple primer to get your feet wet. The setup script I used is heavily inspired by [angristan/wireguard-install](https://github.com/angristan/wireguard-install). Another great resource is the [Unofficial docs repo](https://github.com/pirate/wireguard-docs).