Skip to content

Instantly share code, notes, and snippets.

What would you like to do?
Force Torrent/user Traffic through VPN Split Tunnel on Ubuntu 18.04

Difference to Original:

  1. Add random VPN Land change on start/restart.
  2. Add IP Tables rules that avoid nginx reverse proxy usage.

Lets start

You have fullcontrol over which applications you want to route over VPN. You will have an Automatic Kill Switch implemented (using firewall rules) so if your VPN connection drops or breaks, your real IP address will not be revealed and torrent traffic will stop. DNS leaks are also prevented. Remote access to your Torrent client of choice (Transmission or Deluge) is possible.

Step 1. Install OpenVPN

If you are using Ubuntu Server 16.04 LTS we will install OpenVPN from the official OpenVPN repository. First import the public GPG key that is used to sign the packages.

wget -O - | sudo apt-key add -

Add the OpenVPN repository

echo "deb bionic main" | sudo tee -a /etc/apt/sources.list.d/openvpn.list

Install OpenVPN

sudo apt-get update
sudo apt-get install openvpn openvpn-systemd-resolved -y

Step 2. Create PIA Configuration File for Split Tunneling

The next step is to modify the configuration file provided by PIA to adjust it for the Split Tunneling. In this guide we will use the Sweden VPN server, but you can use any of the available servers – more on this later. For best VPN performance (especially for torrents) I strongly recommend using UDP protocol, and not TCP. Get the Required Certificates for PIA

If unzip is not installed on your server, just install with

sudo apt-get install unzip -y

Download the archive from PIA, we will need only the certificates

cd /tmp
sudo wget
sudo unzip

Copy the required PIA certificates

sudo cp crl.rsa.2048.pem ca.rsa.2048.crt /etc/openvpn/

Step 4. Create Modified PIA Configuration File for Split Tunneling

We make the following changes to the default PIA configuration file:

  • Add route-noexec to prevent the server from push “redirect-gateway” and make the client send all traffic over VPN by default.
    • This is required for Split Tunneling to work.
  • Add auth-nocache to prevent caching passwords in memory.
  • Add the call for login.txt file with the username and password to make automatic login possible.
  • Add script-security 2 to allow client to call externals scripts (up and down).
  • Call the first script,, to mark packets for the VPN user (OpenVPN allows only one up call).
  • Add down script, down /etc/openvpn/update-systemd-resolved, to restore DNS servers when disconnecting from VPN.

You can change the hostname highlighted in red to the server of your choice. For the list of available locations and hostnames look at PIA’s site and select the hostname of your choice.

We are editing the openvpn.conf file which is launched by the systemd service we created earlier (openvpn@openvpn.service). This way we ensure the up and down scripts we made are also executed with the OpenVPN systemd service is restarted.

Create the OpenVPN configuration file

sudo nano /etc/openvpn/openvpn.conf

Copy and paste the following, adjust the country you want to use by replacing In this example we will randomly connect CZ, NL ans SW networks on each start/restart.

dev tun
proto udp
remote 1198
remote 1198
remote 1198
resolv-retry infinite
cipher aes-128-cbc
auth sha1
remote-cert-tls server
auth-user-pass /etc/openvpn/login.txt
verb 1
reneg-sec 0
crl-verify /etc/openvpn/crl.rsa.2048.pem
ca /etc/openvpn/ca.rsa.2048.crt
script-security 2

# Debugging (Optional)
log /var/log/openvpn.log
verb 3

#up and down scripts to be executed when VPN starts or stops
up /etc/openvpn/
down /etc/openvpn/update-systemd-resolved
# Prevent DNS Leaks
dhcp-option DOMAIN-ROUTE .

Hit Ctrl+X, Y and Enter to Save and Exit.

Step 5. Make OpenVPN Auto Login on Service Start

The username and password for PIA will be stored in a login.txt file, this way OpenVPN can auto connect on service start. Create the txt file

sudo nano /etc/openvpn/login.txt

Enter your PIA username and password


Hit Ctrl+X, Y to Save and Exit.

Step 6. Configure VPN DNS Servers to Stop DNS Leaks

Next we are going to prevent DNS leak. DNS Leaks are often the main reason your real identity gets exposed even if using VPN. You can read more about DNS leaks here and test them here. The update-resolv-conf script that comes with OpenVPN will automatically apply the preferred DNS servers when OpenVPN connects.

This script will make sure that when using OpenVPN you are not subject to DNS leaks. We will use PIA’s DNS Servers ( and and Google’s ( as a third option. You are free to use the DNS servers you trust and prefer. It is advised to change the local DNS to a public even if you are not using VPN. If you are behind a router (and you probably are), it is also a good practice to configure public DNS address on the router too.

Note: make sure you are using a static IP on your machine or reserved DHCP also known as static DHCP. Do not configure the static IP on your server, as resolvconf will not work then. You should set the static IP from your router!

Open the update-resolv-conf file

sudo nano /etc/openvpn/update-resolv-conf

Locate this part

# foreign_option_1='dhcp-option DNS'
# foreign_option_2='dhcp-option DNS'
# foreign_option_3='dhcp-option DOMAIN'

Replace the part highlighted in red, make sure you uncomment (remove the # from beginning) these 3 lines, and pay attention to the third line where your need to replace DOMAIN with DNS.

It should look exactly like this

foreign_option_1='dhcp-option DNS'
foreign_option_2='dhcp-option DNS'
foreign_option_3='dhcp-option DNS'

Hit Ctrl+X, Y and Enter to Save.

Your DNS is configured for OpenVPN to prevent DNS leaks.

Split Tunneling with iptables and Routing Tables

We will use iptables to mark packets from a user (in our case the vpn user), and then use routing tables to route these marked packets through the OpenVPN interface, while allowing unmarked packets direct access to the Internet.

Step 7. Create vpn User

Create the user vpn. All of the applications you want tunneled over VPN will run as this user, especially your torrent client of choice (Transmission or Deluge). At the end of this guide you will see the links to our guides on how to configure Transmission and Deluge with Split Tunneling.

Create vpn user with no login option

sudo adduser --disabled-login vpn

I suggest to leave personal details blank, just proceed with Enter, and finally answer Y to create vpn user. We disabled login for the vpn user for security reasons, there is no need to log in to the system as the vpn user.

We are going to use the vpn user to run services (like Torrent client), it is recommended to add your regular user to the vpn group and vpn user to your regular user’s group to avoid any permission issues.

Replace username with the user you would like to add to the vpn group

sudo usermod -aG vpn username

Replace group with the group name of your regular user that you would like to add the vpn user to

sudo usermod -aG group vpn

Get Routing Information for the iptables Script

We need the local IP and the name of the network interface. Again, make sure you are using a static IP on your machine or reserved DHCP also known as static DHCP, but configured on your router!

ip route list

The output will be similar to this

default via dev eno1 proto dhcp src metric 100 dev eno1 proto kernel scope link src dev eno1 proto dhcp scope link src metric 100

en01 is the network interface (NETIF), and is the local IP address (LOCALIP). You will need to enter these two into the following script, which we are going to create now.

If the PIA login credentials are not correct, then OpenVPN will not establish the VPN connection, therefore the firewall rules are not applied (since OpenVPN will execute up scripts only on successful connection). The result is not having the kill switch enabled (iptables rules loaded) and vpn user has direct access to Internet. To prevent this scenario, we will implement a permanent firewall rule to block vpn user’s access to Internet until the OpenVPN tunnel is up and functional, and the required scripts are started. This will prevent any IP leaks even if no connection to PIA is possible for any reason.

Flush current iptables rules

sudo iptables -F

Add the following rule, which will block vpn user’s access to Internet (except the loopback device). Note, if you configured Split Tunnel with different user then vpn, then change vpn marked in red to the user you used.

sudo iptables -A OUTPUT ! -o lo -m owner --uid-owner vpn -j DROP

Now install iptables-persistent to save this single rule that will be always applied on each system start.

sudo apt-get install iptables-persistent -y

During the install, iptables-persistent will ask you to save current iptables rules to /etc/iptables/rules.v4 as seen on the screenshot, accept this with YES

Now when system starts, vpn user is not able to access Internet. If the OpenVPN service is started successfully, then this rule is flushed (only until the next system restart), and the Split Tunnel rules are applied.

Step 8. iptables Script for vpn User

The first script will mark the packets for vpn user, the second script will take care of proper routing.

Create the iptables script

sudo nano /etc/openvpn/

Copy the following to the script, and make sure you enter the network interface and the local IP we identified and marked with red and blue respectively.

You can see the comments for each section about the function of the given part of the script. If you are interested in more details about iptables, a good starting point is the Official Ubuntu Documentation.

Remember, this script will flush your existing iptables rules (UFW included), therefore you need to append your own rules into this script if you need any additional firewall rules.

#! /bin/bash

export INTERFACE="tun0"
export VPNUSER="vpn"
export LOCALIP=""
export NETIF="en01"

# flushes all the iptables rules, if you have other rules to use then add them into the script
iptables -F -t nat
iptables -F -t mangle
iptables -F -t filter

# mark packets from $VPNUSER
iptables -t mangle -A OUTPUT -j CONNMARK --restore-mark
iptables -t mangle -A OUTPUT ! --dest $LOCALIP -m owner --uid-owner $VPNUSER -j MARK --set-mark 0x1
iptables -t mangle -A OUTPUT --dest $LOCALIP -p udp --dport 53 -m owner --uid-owner $VPNUSER -j MARK --set-mark 0x1
iptables -t mangle -A OUTPUT --dest $LOCALIP -p tcp --dport 53 -m owner --uid-owner $VPNUSER -j MARK --set-mark 0x1
# Added Local Open Ports Like Aria2 RPC, Torrent GUI
iptables -t mangle -A OUTPUT --src $LOCALIP -p tcp -m tcp -m multiport --sports 6800,7777 -m owner --uid-owner $VPNUSER -j MARK --set-mark 0x0
# Continue marking
iptables -t mangle -A OUTPUT ! --src $LOCALIP -j MARK --set-mark 0x1
iptables -t mangle -A OUTPUT -j CONNMARK --save-mark

# allow responses
iptables -A INPUT -i $INTERFACE -m conntrack --ctstate ESTABLISHED -j ACCEPT

# block everything incoming on $INTERFACE to prevent accidental exposing of ports

# let $VPNUSER access lo and $INTERFACE
iptables -A OUTPUT -o lo -m owner --uid-owner $VPNUSER -j ACCEPT
iptables -A OUTPUT -o $INTERFACE -m owner --uid-owner $VPNUSER -j ACCEPT

# all packets on $INTERFACE needs to be masqueraded

# reject connections from predator IP going over $NETIF
iptables -A OUTPUT ! --src $LOCALIP -o $NETIF -j REJECT


# Start routing script

exit 0

Hit Ctrl+X, Y and Enter to save and exit.

Make the iptables script executable

sudo chmod +x /etc/openvpn/

In this script important line is

iptables -t mangle -A OUTPUT --src $LOCALIP -p tcp -m tcp -m multiport --sports 6800,7777 -m owner --uid-owner $VPNUSER -j MARK --set-mark 0x0

This will unmark whole traffic to ports 6800 und 7777, so you can run e.g. RPC, or torrent GUI on port 6800 and 7777 and you will be able to access them via network.

To limit it to the local network only, please added following lines after "ADD YOUR RULES HERE":

iptables -A INPUT -p tcp -m tcp -m multiport -j ACCEPT --dports 22,80,443
iptables -A INPUT -p tcp -m tcp -m multiport -m state --state ESTABLISHED,RELATED -j ACCEPT --sports 22,53,80,443,8080,6800,7777
iptables -A INPUT -s -j ACCEPT
iptables -A INPUT -p tcp -m tcp -s --dports 6800,7777 -j ACCEPT
iptables -A INPUT -j DROP

It will (line by line):

  1. open SSH and HTTP(S) connections
  2. enable answers on SSH, HTTP(S), DNS, your ports 6800 and 7777
  3. enable localhost traffic
  4. limit you ports to local network only (
  5. drop the rest.

Step 9. Routing Rules Script for the Marked Packets

With the routing rules we configure the route for the packets we just marked with the first script. You can read more about the routing tables at the following link.

Create the routing script

sudo nano /etc/openvpn/

Paste the following script which makes the default route after the VPN the loopback interface, effectively nulling the traffic if the VPN connection goes down.

#! /bin/bash
# Niftiest Software –
# Modified version by HTPC Guides –

GATEWAYIP=$(ip address show $VPNIF | egrep -o '([0-9]{1,3}\.){3}[0-9]{1,3}'         | egrep -v '255|(127\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})' | tail -n1)
if [[ `ip rule list | grep -c 0x1` == 0 ]]; then
ip rule add from all fwmark 0x1 lookup $VPNUSER
ip route replace default via $GATEWAYIP table $VPNUSER
ip route append default via dev lo table $VPNUSER
ip route flush cache

# run update-resolv-conf script to set VPN DNS

exit 0

Hit Ctrl+X, Y and Enter to Save and Exit.

Finally, make the script executable

sudo chmod +x /etc/openvpn/

Step 10. Configure Split Tunnel VPN Routing

We will need a routing table by adding the table name to the rt_tables file (in our case it is vpn). Open rt_tables

sudo nano /etc/iproute2/rt_tables

Add the vpn user table at the bottom of the file

200     vpn

It should look similar to this:

# reserved values
255     local
254     main
253     default
0       unspec
# local
#1      inr.ruhep
200     vpn

Hit Ctrl + X, Y and Enter to save and exit.

Step 11. Change Reverse Path Filtering

Finally, we need to change the default level of reverse path filtering to ensure the kernel routes the traffic correctly. By default it is set to value of 1 that is “strict mode”. It is not necessary to disable reverse path filtering completely (setting to “0”), but we need to set it to level 2, “loose mode”.

Create a reverse path filter file for the vpn user

sudo nano /etc/sysctl.d/9999-vpn.conf

Copy the following, make sure you use the correct network interface name in the third line marked with red (remember the ip route list command from before and the output, in our case it was en01)

net.ipv4.conf.all.rp_filter = 2
net.ipv4.conf.default.rp_filter = 2
net.ipv4.conf.en01.rp_filter = 2

Hit Ctrl + X, Y and Enter to save and exit.

To apply new sysctl rules run:

sudo sysctl --system

Get OpenVPN to start on boot

     sudo nano /etc/default/openvpn

Remove the "#" comment from the line AUTOSTART

Testing the VPN Split Tunnel

I recommend a system restart, and if everything was configured properly, you should have a running OpenVPN service enabled for the vpn user and all the other users on your server should have direct access to Internet. Now lets check if everything is correct.

Test OpenVPN service

Login as your regular user over SSH, and check OpenVPN service status

sudo systemd-resolve --status

This should return something like this

Link 4 (tun0)
  Current Scopes: DNS
  LLMNR setting: yes
MulticastDNS setting: no
  DNSSEC setting: no
DNSSEC supported: no
  DNS Servers:
  DNS Domain: ~

If the service is not running you can check if there is a log of the error in /var/log/syslog . For troubleshooting you can set output verbosity in the openvpn.conf file to a higher level. Set it to 3 and check the syslog again. You can always ask for help in the forum section. Remember to set verbosity level back to 1 if you don’t need more detailed logs anymore.

Check IP address

Using the SSH session for the regular user, check the IP address


It will return your IP and depending on how much information is provided, the country should be listed in each case. Obviously, it should be your ISP now and your location.

Now check the IP address of the vpn user with

sudo -u vpn -i -- curl

If everything went fine, it should return the IP address and the country of the VPN server you selected. If you used Sweden server, then the country should be “SE”. It is very important that the IP address for user vpn should be different then your regular user’s IP.

In my case for user vpn and using Sweden PIA server I have the following output

  "ip": "X.XXX.XXX.XX",
  "hostname": "No Hostname",
  "city": "",
  "region": "",
  "country": "SE",
  "loc": "59.3294,18.0686",
  "org": "AS57858 Inter Connects Inc"

Obviously, the “” part is my assigned VPN IP address which is different then my public IP, and you can see the country as SE which is Sweden.

Check DNS Server

Finally, check if the DNS for VPN is properly configured, type

sudo -u vpn -i -- cat /etc/resolv.conf

The output should be

# Dynamic resolv.conf(5) file for glibc resolver(3) generated by resolvconf(8)

If you see the above DNS servers then your DNS for VPN is configured correctly.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment