Add wg-quick deep dive postHEADmaster

3 files changed, 515 insertions, 0 deletions

diff --git a/posts/wg-quick-deep-dive/main.md b/posts/wg-quick-deep-dive/main.md
new file mode 100644
index 0000000..5f671fe
--- /dev/null
+++ b/posts/wg-quick-deep-dive/main.md
@@ -0,0 +1,511 @@
+`wg-quick(8)` on Linux - a deep dive
+====================================
+
+Perhaps you have decided to secure your company's internal database or tunnel all your traffic through a VPN.
+You enter the command wg-quick up wg0, watch as commands scroll past your screen, and suddenly realize you
+can't access the network.
+
+If this situation sounds familiar, you're not alone. WireGuard is a Layer 3 VPN that has become the de-facto
+standard for good reasons — it's fast, simple, and secure. Anecdotally, it's known to be easier to configure
+than its bulkier and more convoluted predecessor, OpenVPN. However, configuring or debugging WireGuard networks
+requires a robust understanding of networking, something the thorough WireGuard
+[documentation](https://www.wireguard.com/#conceptual-overview) can help most users with.
+
+I recently reviewed the source for `wg-quick(8)` and discovered that it was not entirely documented. Some of the documented
+parts assumed an in-depth understanding of networking. This research turned out to be a surprisingly
+instructive exercise in Linux networking, and I'm sharing my results here. Hopefully, it can fill in some gaps in the
+existing documentation.
+
+In particular, this guide:
+
+1. Provides additional exposition on Linux networking
+2. Details default-route handling
+3. Explains the default firewall configuration
+4. Describes the multicast limitations of WireGuard tunnels
+
+The Basics
+----------
+
+WireGuard adheres to the Unix philosophy of "doing one thing well," fostering a design of modular systems.
+Accordingly, it integrates into the Linux networking stack as a network interface, configured
+through the user space tool `wg(8)`. However, to enable traffic flow, IP addresses must be assigned, and
+routes need to be configured. While this is a relatively simple procedure, it can become tedious and requires
+automation to ensure reliability. This is where `wg-quick(8)` steps in.
+
+> This is an extremely simple script for easily bringing up a WireGuard interface, suitable for a few
+common use cases. ... Generally speaking, this utility is just a simple script that wraps invocations
+to `wg(8)` and `ip(8)` in order to set up a WireGuard interface. It is designed for users with simple
+needs, and users with more advanced needs are highly encouraged to use a more specific tool, a more
+complete network manager, or otherwise just use `wg(8)` and `ip(8)`, as usual.
+>
+> \- `wg-quick(8)`
+
+`wg-quick` serves as a straightforward orchestration tool for creating and removing WireGuard tunnels.
+It is the de-facto standard for configuring tunnels since it is cross-platform, supported by all official
+clients. Its strength lies in the fact that the configuration provides a complete description of the tunnel,
+allowing tunnels to be brought up or down with a single command. Additionally, the interface can be initiated
+at boot through systemd, although - oddly - this feature remains undocumented. Without additional tooling, `wg-quick`
+can configure either a static server endpoint or a roaming peer.
+
+A "static server endpoint" refers to a computer with a static IP, typically provided by cloud computing vendors,
+which functions as a node connecting peers. Often, it may facilitate access to protected resources, like a database.
+A roaming peer, on the other hand, is a machine that connects using the static IP of the server and can access the
+server or other peers. Peers typically lack a fixed endpoint and "roam" from one IP to another.
+
+There's also a special provision for cases where a peer routes all their internet traffic through the tunnel, aligning
+with how most consumers conceive of a VPN. However, VPNs can also selectively transmit traffic bound for specific
+computers. Unfortunately, the server configuration for this setup cannot be handled with wg-quick alone since it
+necessitates Network Address Translation (NAT). This limitation likely stands as an exception, enabling VPN providers
+to distribute `wg-quick` configurations instead of writing their own tools to route traffic.
+
+wg-quick is by no means the sole configuration tool for WireGuard. It's supported alongside other network management
+systems such as networkd and NetworkManager. Specifically, NetworkManager is a prevalent tool for managing WiFi networks
+on desktop environments, and it has the capability to import WireGuard tunnels using the .conf format, just like wg-quick.
+(The extent of feature compatibility between them, however, is something I'm not fully aware of at the moment.) On the
+other hand, networkd is more commonly leveraged for network management on servers. In the near future, I'll be releasing a
+tool that can "import" (or more accurately, transpile) wg-quick files into networkd configurations. When choosing between
+these options, it would be wise to defer to your system's network manager. Most users configure WireGuard tunnels within
+the initial network namespace. Multiple tools can end up tripping over one another while
+managing the same network resources.
+
+It is also worth stating that `wg-quick` is not the only configuration tool. WireGuard is supported both by
+`networkd` and `NetworkManager`. `NetworkManager` is commonly used to manage WiFi networks on the desktop
+and can import WireGuard tunnels using the `.conf` format shared with `wg-quick`. (Although I am unaware of
+the feature compatibility.) `networkd` is commonly used to manage networks on the server. Soon, I will be
+releasing a tool I wrote which allows `wg-quick` files to be "imported" (or more accurately transpiled) to
+`networkd`. When considering which option to use, I would default to your system's network manager. WireGuard
+tunnels affect resources in the global network namespace, so it makes sense for them to be managed by an entity
+responsible for managing network resources globally.
+
+The process of manually configuring a WireGuard tunnel is thoroughly outlined on the [quickstart page](https://www.wireguard.com/quickstart/).
+If you've set up a network with static IP addresses, you might already be acquainted with this process. However, many
+enthusiasts and developers may have avoided this route, since the aptly named Dynamic Host Configuration Protocol (DHCP)
+takes care of automating IP management.  In the following section, I'll delve into configuring network interfaces on Linux,
+assuming that you possess a fundamental understanding of networking concepts. Should you be new to setting up a static network,
+or if you find yourself unfamiliar with terms like private IP address space, subnets, public IPs, routers, subnet masks, and
+interfaces, I strongly recommend taking the time to acquaint yourself with these concepts before proceeding.
+
+### Revisiting a Simple Network
+
+WireGuard seamlessly integrates with the Linux networking stack, functioning as a networking interface. The Linux networking
+system is indeed robust, supporting a wide array of features. However newcomers should be warned, the documentation often appears
+to lag behind the pace of feature development. In this article, we'll explore the fundamentals of a simple Local Area Network (LAN)
+and shed light on how packets are routed on contemporary Linux systems. This foundational knowledge is essential for understanding
+how `wg-quick` interfaces with these routing constructs.
+
+Assigning a static IP address to a networking interface can be accomplished using the following command. This sets up a LAN with the
+subnet `192.168.0.0-127` and assigns the networking interface the IP address `192.168.0.22`:
+
+```
+[#] ip -4 addr add 192.168.0.22/25 dev eth0
+```
+
+Should you attempt to transmit data to a peer at `192.168.0.11` (e.g., using a UDP socket), how does the kernel determine where to
+route these packets? Upon executing the command above, the kernel modifies a structure known as the routing table. Routing tables
+function as a database, directing traffic to a specific interface by matching the destination IP address. Most routes are automatically
+appended to the `main` routing table, which can be viewed with the command `ip route show`:
+
+```
+[#] ip -4 route show table main
+
+192.168.0.0/25 dev eth0 proto kernel scope link src 192.168.0.22
+```
+
+In essence, packets destined for our subnet will be sent using eth0 with the source IP address `192.168.0.22`. The kernel
+automatically adds this route for a subnet assigned to a link, known as a prefix route. If multiple competing routes
+exist in a routing table, the route is selected using the longest prefix match algorithm. Essentially, the most specific
+route, characterized by the longest subnet mask, is chosen. If you add a custom route specifying that `192.168.0.11/32`
+should be sent using eth1, traffic will flow through this interface instead, since the 32-bit subnet mask is longer than
+the 25-bit subnet mask:
+
+```
+[#] ip -4 route add 192.168.0.11/32 dev eth1
+[#] ip -4 route get 192.168.0.11
+192.168.0.11 dev eth1 src 192.168.0.12 uid 0
+    cache
+```
+
+This brings up an intriguing question: If we send traffic to the current host at `192.168.0.22`, how does the routing
+algorithm determine that the packets shouldn't leave the computer but instead be handled by local programs? The answer
+lies in another table that precedes the `main` table, known as the `local` table. The `local` table is consulted before
+the `main` table, and if a match is found, the packet is routed accordingly. The kernel also manipulated this table in
+response to our earlier `ip addr add` command.
+
+```
+[#] ip -4 route show table local
+
+local 127.0.0.0/8 dev lo proto kernel scope host src 127.0.0.1
+local 127.0.0.1 dev lo proto kernel scope host src 127.0.0.1
+broadcast 127.255.255.255 dev lo proto kernel scope link src 127.0.0.1
+local 192.168.0.22 dev eth0 proto kernel scope host src 192.168.0.22
+broadcast 192.168.0.127 dev eth0 proto kernel scope link src 192.168.0.22
+```
+
+The original ip addr add command added both a local route and a broadcast route. Specifically, the entry `local 192.168.0.22 dev eth0`
+stipulates that packets addressed to `192.168.0.22` should be "looped back" and delivered to sockets listening locally on `eth0`, or
+bound to the address `192.168.0.22`. Typically, IP traffic is unicast, meaning it originates with one host and is directed at another.
+The `broadcast` rule informs the kernel that `192.168.0.127` is a broadcast address. By default, the kernel utilizes the highest IP
+address in the subnet as the broadcast address.
+
+The above overview offers almost a complete picture, but there's another crucial layer of indirection in play: the Routing Policy Database
+(RPDB). The RPDB acts as a guide, specifying how routing tables are selected and ordered. This can be queried with the ip rule command, and
+the initial state of the RPDB might look something like this:
+
+```
+[#] ip rule
+
+0:	from all lookup local
+32766:	from all lookup main
+32767:	from all lookup default
+```
+
+
+Quoting directly from the manual provides a comprehensive explanation:
+
+> Each policy routing rule consists of a selector and an action predicate.  The RPDB is scanned in order of decreasing priority (note that a lower number means
+higher priority, see the description of PREFERENCE below). The selector of each rule is applied to {source address, destination address, incoming interface,
+tos, fwmark} and, if the selector matches the packet, the action is performed. The action predicate may return with success.  In this case, it will either give
+a route or failure indication and the RPDB lookup is terminated. Otherwise, the RPDB program continues with the next rule.
+>
+> Semantically, the natural action is to select the nexthop and the output device.
+>
+> At startup time the kernel configures the default RPDB consisting of three rules:
+>
+> 1. Priority: 0, Selector: match anything, Action: lookup routing table local (ID 255).  The local table is a special routing table containing high priority
+> control routes for local and broadcast addresses.
+> 2. Priority:  32766,  Selector: match anything, Action: lookup routing table main (ID 254).  The main table is the normal routing table containing all non-
+>  policy routes. This rule may be deleted and/or overridden with other ones by the administrator.
+> 3. Priority: 32767, Selector: match anything, Action: lookup routing table default (ID 253).  The default table is empty. It is reserved for some post-pro‐
+ cessing if no previous default rules selected the packet.  This rule may also be deleted.
+>
+> \- ip-rule(8)
+
+If you've been following along, you now understand that when a socket binds or connects to an address, the kernel
+selects an appropriate route by querying the routing tables. This query is guided by the rules specified in the
+routing policy database (RPDB). When a table contains multiple routes, the longest prefix match algorithm is used
+to determine the most specific route, and that is the one selected.
+
+_Note:_ Policy routing can be bypassed using the `SO_BINDTODEVICE` option. This allows you to bind a socket directly
+to a specific device, effectively sidestepping the standard routing process.
+
+### Bringing Up a Site-to-Site-Style Tunnel with `wg-quick(8)`
+
+> Use up to add and set up an interface, and use down to tear down and remove an interface. Running up
+adds a WireGuard interface, brings up the interface with the supplied IP addresses, sets up mtu and
+routes, and optionally runs pre/post up scripts.
+>
+> \- wg-quick(8)
+
+The command `wg-quick` first searches for a configuration file. If the first argument to `wg-quick up` matches
+the pattern `[a-zA-Z0-9_=+.-]{1,15}`, which represents a valid interface name on Linux, the file is assumed
+to exist in `/etc/wireguard` with the provided name and a `.conf` extension. Once a suitable file is found,
+its contents are read. For example, it might read the following file, `wg0.conf`:
+
+```
+[Interface]
+PrivateKey = yDdqzxdE66e64xy5Qu1PshT0ybQJLHbU9N+91PS1Dng=
+Address = 192.168.42.1/24
+
+[Peer]
+PublicKey = o837llPmQ4t9cN0rmiLasp6SF54dAzS0Ea1p71c1jFA=
+AllowedIPs = 192.168.42.0/32
+Endpoint = 19.216.242.139:16262
+
+[Peer]
+PublicKey = YIUKiCiw9+6an3HnDn7t3CwlF30ERQkhEQ6f3jRBUnk=
+AllowedIPs = 10.1.0.0/16
+Endpoint = 19.216.242.138:16263
+```
+
+The process begins identically to the steps taken in the quick start documentation. A WireGuard interface is
+added to the system with the interface name from the corresponding file:
+
+```
+ip link add dev wg0 type wireguard
+```
+
+Then, the WireGuard configuration is obtained by stripping out the `wg-quick`-specific sections, passing the
+rest to the `wg` command. This configuration can be produced using the `wg-quick strip` command. Running
+`wg-quick strip` on the above example removes the Address section, and wg parses the configuration to pass it
+on to the kernelspace driver [1].
+
+[1] It can also communicate this information to the userspace implementation, if available.
+
+```
+[#] wg-quick strip wg0.conf
+[Interface]
+PrivateKey = yDdqzxdE66e64xy5Qu1PshT0ybQJLHbU9N+91PS1Dng=
+
+[Peer]
+PublicKey = o837llPmQ4t9cN0rmiLasp6SF54dAzS0Ea1p71c1jFA=
+AllowedIPs = 192.168.42.0/32
+Endpoint = 19.216.242.139:16262
+
+[Peer]
+PublicKey = YIUKiCiw9+6an3HnDn7t3CwlF30ERQkhEQ6f3jRBUnk=
+AllowedIPs = 10.1.0.0/16
+Endpoint = 19.216.242.138:16263
+```
+
+As the official documentation states:
+
+> The configuration file adds a few extra configuration values to the format understood by wg(8) in order
+to configure additional attributes of an interface. It handles the values that it understands, and then
+it passes the remaining ones directly to wg(8) for further processing.
+>
+> \- wg-quick(8)
+
+The way the interface configuration affects packet routing is well-covered by the
+[original documentation](https://www.wireguard.com/#simple-network-interface). If you haven't read it, you
+should explore the "Simple Network Interface" and "Cryptokey Routing" sections before continuing.
+
+```
+[#] wg-quick strip wg0.conf > wg0-stripped.conf
+[#] ip setconf wg0 wg0-stripped.conf
+```
+
+Next, the IP addresses specified in Addresses are added to the interface. For the above configuration,
+it assigns the IP address `192.168.42.1` to the WireGuard interface. This becomes the source IP address
+for packets traveling to the peer VPN endpoint [3]. The system also automatically creates a prefix route
+directing traffic from any IP address matching `192.168.42.0/24` to the interface `wg0`, and a local route
+for `192.168.42.1`.
+
+[3] The source IP address, as defined in the Addresses section of the configuration, serves as the originating
+address for packets sent to the peer VPN endpoint. However, this can be overridden using a "raw socket," in which
+an application has the ability to define all fields of a packet, including the source IP. While this introduces
+significant security considerations, WireGuard's Cryptorouting scheme substantially mitigates the risks. Malicious
+peers are restricted to spoofing only those addresses listed in the `AllowedIPs` section of the `[Peer]` configuration,
+and all unauthorized packets are promptly dropped. This built-in mechanism aids in containing potential threats.
+
+```
+[#] ip -4 addr add 192.168.42.1/24 dev wg0
+```
+
+Afterward, the link is brought up, and the MTU (Maximum Transmission Unit) is set. The MTU represents the maximum size
+of a packet that can be communicated on a link. If unspecified, the MTU of the underlying link is obtained, and the MTU
+of the WireGuard tunnel is reduced by 80 bytes to exclude the overhead of the WireGuard encapsulation packets. I looked
+into this and am still unsure as to why an 80 byte MTU reduction was chosen. My working theory is that this value was
+chosen to cover both IPv4 and IPv6 with a factor of safety [4].
+
+[4] The encapsulation method depends on whether the tunnel endpoint is an IPv4 address or an IPv6 address. The maximum
+size of an IPv4 packet is 60 bytes. IPv6 packets are more challenging to quantify since they can have any number of
+arbitrary header extensions. The base IPv6 header is only 40 bytes but additional headers can add up. Accordingly, 80
+bytes would cover an IPv6 header with a few extensions.
+
+
+```
+[#] ip link set mtu up 1420 dev wg0
+```
+
+Finally, routes are added for all the entries of `AllowedIPs` to the `main` routing table:
+
+```
+[#] ip -4 route add 192.168.42.0/32 dev wg0
+[#] ip -4 route add 10.1.0.0/16 dev wg0
+```
+
+### Default-Route Handling
+
+The above example illustrates how WireGuard establishes static routes for specific segments of the IP space, which we
+specified in `AllowedIPs`. However, these previous examples assumed that the peer endpoint falls outside any of the
+`AllowedIP` ranges. If this were not true, the routes would create a routing loop, with packets exiting the WireGuard
+interface being routed back into it.
+
+One common use case for a VPN is to route all traffic to an endpoint which functions as a NAT router. (If you are unfamiliar
+with NAT, picture your home router home router.) This can enhance privacy, reduce the specificity of a user's public IP address
+in fingerprinting systems, prevent ISPs from selling data to advertisers, or obscure the regional ISP an individual is using.
+To route all traffic, we need a default route `0.0.0.0/0` and `::0/0` which match all destination IPs. This creates an issue
+since our endpoint's IP will fall into this range. Fortunately, there are methods to make default routes work as intended.
+
+Linux policy routing can be used in various ways to solve this problem, and the
+[Wireguard Routing and Namespace Documentation](https://www.wireguard.com/netns/#routing-all-your-traffic) outlines a few potential
+solutions. `wg-quick` elegantly accomplishes this with the following rules, which require some explanation:
+
+
+```
+[#] wg set wg0 fwmark 51820
+[#] ip -4 route add 0.0.0.0/0 dev wg0 table 51820
+[#] ip -4 rule add not fwmark 51820 table 51820
+[#] ip -4 rule add table main suppress_prefixlength 0
+```
+
+The Linux kernel routing system features `fwmark`, an integer marker ranging from `0` to `2^32 - 1` which can be attached to a packet.
+It designates that the packet should be routed or filtered according to special rules. Packets with this mark can either be routed to
+a specific table using policy routing (`ip-rule`) or filtered with the `nftables` framework. The `fwmark` can be set either within the
+`netfilter` subsystem or by a program when making a network connection [4].
+
+[4] `setsockopt` can be used with `SO_MARK` to set the outgoing mark as so long as the process has the `CAP_NET_ADMIN` capability.
+
+In this instance, wg-quick marks all packets leaving the tunnel with the `fwmark` 51820:
+
+```
+[#] wg set wg0 fwmark 51820
+```
+
+Recall our previous discussion of routing tables. `wg-quick` creates a new routing table within which the default route directs all
+traffic to the `wg0` interface, effectively serving as a "default gateway." With none of the mask bits set, all traffic is routed to `wg0`:
+
+```
+[#] ip -4 route add 0.0.0.0/0 dev wg0 table 51820
+```
+
+Traffic must then be directed to this routing table. Here, all traffic that has not exited the VPN interface (and thus does not have
+this fwmark) is sent to the table with the default route:
+
+```
+[#] ip -4 rule add not fwmark 51820 table 51820
+```
+
+By default, the IP command assigns this rule a higher priority than the rule querying the main table.
+
+```
+[#] ip rule
+0:	from all lookup local
+32765:	not from all fwmark 0xca6c lookup 51820
+32766:	from all lookup main
+32767:	from all lookup default
+```
+
+We have established that traffic will be directed through the Wireguard interface if it does not match any local IP ranges. It will
+then be sent through `wg0` before being routed according to the `main` table (and likely exit through a default gateway.)
+
+The `ip rule` command prints the mark in hex as `0xca6c`.
+
+#### Handling Local Network Traffic
+
+While VPN traffic will flow as expected, this configuration may have unintended consequences. All local LAN traffic will be directed
+to the tunnel, preventing access to the local network (except for encrypted Wireguard packets directed to the default gateway).
+Policy routing has one more trick:
+
+```
+[#] ip -4 rule add table main suppress_prefixlength 0
+```
+
+The command `suppress_prefixlength` rejects all routes with prefixes equal to or less than the specified length. So, `suppress_prefixlength 0`
+rejects all default gateways, causing the routing algorithm to query the main table first, which typically contains LAN routes but can also
+contain routes setup by virtualisation software.
+
+These rules are set whenever the default IPv4 `0.0.0.0/0` or `IPv6 ::/0` routes appear in the `AllowedIPs`. In the case of IPv6, `ip -6` rules
+are added as well. Finally, if `FwMark` is not specified, `wg-quick` searches for the next available mark, stopping when an empty routing table
+is found. Finally, the `FwMark` is set to the routing table number.
+
+### The Default Firewall
+
+wg-quick configures a firewall if nftables is installed and a default route is specified. The following firewall rules are
+setup when an IPv4 endpoint is specified:
+
+```
+table ip wg-quick-wg0 {
+	chain preraw {
+		type filter hook prerouting priority raw; policy accept;
+		iifname != "wg0" ip daddr 192.168.42.1 fib saddr type != local drop
+	}
+
+	chain premangle {
+		type filter hook prerouting priority mangle; policy accept;
+		meta l4proto udp meta mark set ct mark
+	}
+
+	chain postmangle {
+		type filter hook postrouting priority mangle; policy accept;
+		meta l4proto udp meta mark 0x0000ca6c ct mark set meta mark
+	}
+}
+```
+
+The first rule in the preraw chain mitigates a potential vulnerability that could allow a network attacker to access servers
+listening on `wg0`. It's easy to assume that local services listening on the WireGuard IP address are safe since they're only
+accessible to those connected to the tunnel. However, this is not the case.
+
+Imagine an attacker connected on `eth0`, an adjacent ethernet interface, attempting to access the address assigned to our WireGuard
+interface, `192.168.42.1`. Since a route for this address is in the `local` table, the attacker can send packets to `192.168.42.1`
+and receive responses, even if the requests originate from another subnet. This could enable the attacker to exfiltrate sensitive
+data or inject malicious packets. Therefore, the first rule enforces that services on `wg0` can only be accessed through addresses on
+the same interface.
+
+#### Reverse Path Forwarding
+
+The last two rules in the code snippet above pertain to reverse path forwarding, a technique used to prevent spoofed packets from entering
+a network. Consider a router with forwarding enabled and two links:
+
+```
+172.30.1.0/31 dev eth-01 proto kernel scope link src 172.30.1.0
+172.30.2.0/31 dev eth-02 proto kernel scope link src 172.30.2.0
+```
+
+Now, think about a scenario where a router connected to `eth-02` with IP `172.30.2.1` and an attacker connected to this router attempt to perform
+a denial-of-service attack against `1.1.1.1` by spoofing network ICMP packets with random destination IPs and the source address of their victim.
+Classically, if one of these spoofed packets "from" `1.1.1.1` destined for `172.30.2.1` arrives on `eth-01`, it would be forwarded. However, this
+would be suspicious since a packet from `172.30.2.1` destined for `1.1.1.1` would be dropped, not forwarded through `eth-02`. By considering if a
+routable path exists in the reverse direction, a router can automatically drop spoofed packets. This concept is known as reverse path forwarding,
+as defined by RFC 3704, known as "strict reverse path forwarding."
+
+To enable strict reverse path filtering in the Linux kernel, you can use the following sysctl switch:
+
+```
+[#] sysctl net.ipv4.conf.INTERFACE_NAME.rp_filter=1
+```
+
+Most Linux distributions default to Loose Reverse Path Forwarding. In strict mode, traffic from `172.30.1.1` on eth-02 would be dropped, as it should
+have routed through `eth-01`. This enforces a symmetrical routing policy but can disrupt asymmetric routing configurations. Loose Reverse Path Forwarding,
+conversely, processes traffic if routable through any interface.
+
+Why does this matter for WireGuard? A firewall's secondary set of rules ensures that strict reverse path forwarding operates accurately. The `fwmark` is
+set by the traffic traversing the reverse path, working in collaboration with Linux's conntrack subsystem, which persistently associates incoming traffic
+with its corresponding outgoing traffic [5]. The second rule sets the "connection mark" labeled `ct mark` as the `fwmark` during connection establishment,
+while the third rule copies it back when packets are received.
+
+`wg-quick` then instructs the kernel to use the `fwmark` for reverse path forwarding, since this is not enabled by default:
+
+```
+[#] sysctl -q net.ipv4.conf.all.src_valid_mark=1
+```
+
+[5] For example, in tracking a UDP stream, both IPs (source and destination) and L4 headers (source and destination ports) can be tracked to identify
+a connection.
+
+## Additional Thoughts
+
+When researching WireGuard and reading through the documentation, I found there were a few non-obvious
+technical details that seemed undocumented, although potentially important.
+
+### UDP Socket Parameters
+
+WireGuard permits users to modify the UDP port on which an interface listens using `ListenPort`. Although,
+it always binds its internal UDP socket to all available interfaces using `INADDR_ANY` [6]. This is an
+important consideration reasoning about packet flows and writing netfilter rules.
+
+### Broadcast and Multicast Traffic
+
+Broadcast and multicast traffic are used in standard protocols, notably service autodiscovery. When considering how
+to configure effective firewalls, I was led to ask whether WireGuard carried multicast traffic. Short answer: yes and
+no. If the multicast ip range `224.0.0.0/4` or `ff00::/8` appear in the `AllowedIPs` for the tunnel, multicast traffic
+could theoretically be broadcast from the other peer. Although, this works with at most two peers. Internally, WireGuard
+uses a single prefix tree to select the endpoint to which a packet is sent. If the same `AllowedIPs` appear within
+the configuration of multiple peers, the last peer configuration overwrites the routes configured on other peers [7].
+Thus Mutlicast traffic can be directed to, at most, one peer. Thus, if you want to pass broadcast or multicast traffic,
+a secondary encapsulation method must be used on top of WireGuard. This does not mean peers with default routes in their
+`AllowedIPs` may leak Multicast traffic. This seems to be technically possible.
+
+In practice, the interface flags are used by programs like `avahi` to determine on which interfaces they should broadcast [8].
+WireGuard is not started with the `IFF_MULTICAST` or `IFF_BROADCAST` flags [8]. According to comments in the Linux kernel,
+links without `IFF_MULTICAST` can perform multicast but point-to-point devices cannot broadcast [9]. The exact meaning of these
+flags seem ambiguous from the limited documentation, and I wouldn't be surprised if the kernel and userspace developers were
+on different pages as to their exact technical meaning.
+
+> `IFF_MULTICAST` means that this media uses special encapsulation for multicast frames. Apparently, all `IFF_POINTOPOINT` and
+`IFF_BROADCAST` devices are able to use multicasts too.
+>
+> \- [9]
+
+[6] [Kernel cGit](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/net/wireguard/socket.c?id=e74216b8def3803e98ae536de78733e9d7f3b109#n361)
+    [Github](https://github.com/torvalds/linux/blob/89bf6209cad66214d3774dac86b6bbf2aec6a30d/drivers/net/wireguard/socket.c#L361)
+
+[7] [Github](https://github.com/lathiat/avahi/blob/55d783d9d11ced838d73a2757273c5f6958ccd5c/avahi-core/iface-linux.c#L104)
+
+[8] [Kernel cGit](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/net/wireguard/device.c?id=b5cc3833f13ace75e26e3f7b51cd7b6da5e9cf17#n292)
+    [Github](https://github.com/torvalds/linux/blob/b5cc3833f13ace75e26e3f7b51cd7b6da5e9cf17/drivers/net/wireguard/device.c#L292)
+
+[9] [Kernel cGit](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/if_link.h?id=706a741595047797872e669b3101429ab8d378ef#n423)
+    [Github](https://github.com/torvalds/linux/blob/706a741595047797872e669b3101429ab8d378ef/include/uapi/linux/if_link.h#L423)
+
diff --git a/posts/wg-quick-deep-dive/meta.json b/posts/wg-quick-deep-dive/meta.json
new file mode 100644
index 0000000..226796e
--- /dev/null
+++ b/posts/wg-quick-deep-dive/meta.json
@@ -0,0 +1,4 @@
+{
+    "name": "wg-quick(8) on Linux - a deep dive",
+    "lastUpdated": "2023-09-08"
+}
diff --git a/public/img/results.gif b/public/img/results.gif
new file mode 100644
index 0000000..33f334c
--- /dev/null
+++ b/public/img/results.gif