Homelab VPN Isolation

Find Your VPN's DNS Server IP Open your ProtonVPN .conf file. Look for the DNS = line in the [Interface] block:

[Interface]
...
DNS = 10.2.0.1   ← this is the value you need

Note this IP: 10.2.0.1 Copy . You will use it in the Docker Compose file and the NAT rule below.

Create a DNS Hijack Rule via NAT Port Forward This rule intercepts any DNS query sent from your burner IP — including hard-coded DNS servers inside the container — and redirects it to the ProtonVPN DNS resolver. Navigate to Firewall → NAT → Port Forward → + Add:

Field	Value	Notes
Interface	LAN	The interface your Proxmox host is on
Protocol	TCP/UDP	DNS uses UDP 53 primarily, TCP 53 for large responses
Source (click Advanced)	Single host → BURNER_IP	Only redirect DNS from this specific host
Destination	any	Intercepts regardless of which DNS server the container tries to reach
Destination Port	53	Standard DNS port
Redirect Target IP	10.2.0.1	Your VPN DNS server from above
Redirect Target Port	53	—
NAT Reflection	Disable	Must be explicitly disabled with "Any" destination — leaving it on may cause a save error
Filter rule association	Add associated filter rule	Auto-creates the firewall PASS rule for the redirected traffic

Create the Policy Routing Firewall Rule Navigate to Firewall → Rules → LAN. Click + Add at the top of the list. pfSense rules are first-match wins — if a more general "allow LAN to any" rule fires first, the gateway override is ignored.

Field	Value	Notes
Action	Pass	—
Interface	LAN	—
Protocol	any	—
Source	Single host → BURNER_IP	Use the alias
Destination	any	—
Description	Route Burner via ProtonVPN	—

Before saving, expand Advanced Options:

Advanced Field	Value	Why
Gateway	PROTON_VPN_GW	This is the policy routing override — the core of this entire setup. Without it, traffic routes via WAN.
Disable reply-to	✅ Check this	Prevents pfSense from sending return traffic back out the wrong interface — asymmetric routing breaks TCP connections

Save and Apply. Drag this rule to the very top of the LAN list if it wasn't added there by default.

Add the Kill Switch Block Rule With the Pass rule in place, immediately add the Block rule directly below it. If the VPN tunnel goes down, pfSense falls through to this rule and drops all burner traffic instead of letting it leak out your real WAN. In Firewall → Rules → LAN, click + Add and position it directly below the Pass rule:

Field	Value	Notes
Action	Block	Silently drops packets — Reject would send a TCP RST back to the container
Interface	LAN	—
Protocol	any	—
Source	Single host → BURNER_IP	Same source as the Pass rule above
Destination	any	—
Description	Kill Switch — block burner if VPN down	—

Save and Apply Changes.

Create a Dedicated VM in Proxmox In the Proxmox web UI, click Create VM and work through the wizard: General tab:

Field	Value	Notes
Name	burner-browser	—

OS tab:

Field	Value	Notes
ISO Image	Debian 12 or Ubuntu 24.04 LTS	Minimal/server install — no desktop environment needed
Guest OS Type	Linux	—

System tab:

Field	Value	Notes
Machine	q35	Preferred for modern VMs
Qemu Agent	✅ Enabled	Install qemu-guest-agent inside the VM after OS install

Disks tab:

Field	Value	Notes
Disk size	10 GiB	Sufficient for OS, Docker, and the Firefox image
Discard	✅ Enabled	Enables TRIM if storage is SSD/NVMe-backed

CPU tab:

Field	Value	Notes
Cores	2	Sufficient for a single browser container
Type	host	Best performance — passes through host CPU flags

Memory tab:

Field	Value	Notes
Memory	2048 MiB	Firefox under noVNC uses ~1–1.5 GB under load

Network tab:

Field	Value	Notes
Bridge	vmbr0	Same bridge your LAN devices are on
Model	VirtIO (paravirt)	Best performance
Firewall	❌ Unchecked	Using pfSense for all firewall logic

After OS install, remove the stale CD-ROM apt source first (Debian adds the ISO as a package source by default):

Copynano /etc/apt/sources.list
# Delete the line beginning with: deb cdrom:[Debian GNU/Linux...

Then install the QEMU guest agent and Docker (running as root, no sudo needed):

Copyapt-get update && apt-get install -y qemu-guest-agent
systemctl enable --now qemu-guest-agent
curl -fsSL https://get.docker.com | sh

Enable Promiscuous Mode on the Proxmox Bridge macvlan requires promiscuous mode so the Proxmox bridge passes all LAN frames to the VM's NIC. Without it, the container's macvlan packets are silently dropped at the bridge before reaching pfSense. The Promiscuous Mode option was removed from the Proxmox web UI. SSH into your Proxmox host and run:

Copyip link set vmbr0 promisc on

This takes effect immediately but won't survive a reboot. To make it persistent:

Copynano /etc/network/interfaces

Add a post-up line to your vmbr0 block:

Copyiface vmbr0 inet static
    address ...          # existing lines stay as-is
    ...
    post-up ip link set vmbr0 promisc on     # add this line

Verify it took effect:

Copyip link show vmbr0 | grep -i promisc

You should see PROMISC in the flags.

Find Your Host's Network Interface Name SSH into your Docker host:

Copyip route | grep default

Output example: default via 192.168.1.1 dev eth0 proto dhcp. The interface name (eth0, ens18, enp2s0, etc.) is needed for the parent: field in the Compose file. Do not blindly use eth0 — names vary by OS and kernel version. Also check your UID/GID for PUID/PGID fields:

Copyid

Create the Docker Compose File

Copymkdir ~/burner-browser && cd ~/burner-browser
nano compose.yaml

Paste the following, substituting your values:

Copyservices:
  firefox:
    image: lscr.io/linuxserver/firefox:latest
    container_name: burner_browser
    environment:
      - PUID=1000          # Replace with your uid from `id`
      - PGID=1000          # Replace with your gid from `id`
      - TZ=Etc/UTC         # Set to your timezone
    networks:
      macvlan_net:
        ipv4_address: 192.168.1.50  # Must match BURNER_IP alias in pfSense
    dns:
      - 10.2.0.1           # ProtonVPN DNS from your .conf file
    restart: unless-stopped
    mem_limit: 2g
    cpus: 2

networks:
  macvlan_net:
    driver: macvlan
    driver_opts:
      parent: eth0         # Replace with your interface from `ip route`
    ipam:
      config:
        - subnet: 192.168.1.0/24
          gateway: 192.168.1.1  # Your pfSense LAN IP

Start the Container

Copydocker compose up -d
docker compose logs -f

A healthy start shows the LinuxServer init completing with no errors. The Firefox UI takes 15–20 seconds to initialize on first boot.

Access the Containerized Browser From any machine on your LAN (not the Docker host itself, due to macvlan isolation), navigate to:

http://192.168.1.50:3000

You should see a full desktop Firefox browser running inside a noVNC web interface. If it doesn't load:

• docker compose ps — is the container in "Up" state?
• Can you ping 192.168.1.50 from another LAN machine? If not, check Proxmox promiscuous mode.
• docker inspect burner_browser | grep IPAddress

Verify VPN IP and DNS (No Leaks) Inside the containerized Firefox, navigate to ipleak.net. Verify:

• ✅ Your IP address shows a ProtonVPN endpoint address, not your real ISP IP.
• ✅ DNS Addresses shows ProtonVPN-owned servers only. If you see your ISP's servers, you have a DNS leak — revisit Phase 2.
• ✅ No WebRTC leak — should show nothing or the same VPN IP.

Test the Kill Switch

1. In the containerized browser, keep a page loading (e.g., ipleak.net refreshing).
2. In pfSense, go to VPN → WireGuard → Tunnels and click Disable on your ProtonVPN tunnel.
3. Within seconds, all internet access from the container should stop. The browser should show connection errors — not fall back to your real IP.
4. Re-enable the tunnel. Traffic should resume once the WireGuard handshake re-establishes (~30 seconds).

Execute Your Session Your environment is verified. Proceed with your session:

• Use an email alias service (SimpleLogin, AnonAddy, or a Gmail +address) — never your primary email address.
• Avoid logging into any account you use on your real browser.
• Treat the container as fully disposable — anything you do inside it should be assumable by an adversary who sees the VPN exit node's traffic.

Teardown After Use When your session is complete, destroy the container to clear all cookies, cached data, and session storage:

Copycd ~/burner-browser
docker compose down
docker volume prune -f

On your next use, docker compose up -d spins up a clean, stateless instance. The pfSense rules remain in place permanently — only the container is ephemeral.