Select Page
Setup a Secure Torrent Client

Setup a Secure Torrent Client

Setup a Secure Torrent Client with AirVPN


 Keep yourself safe with all traffic leaving your Raspberry Pi using end to end encryption via AirVPN.

  • Download and upload peer 2 peer files with anonymity.
  • Increase your privacy from your ISP
  • Protect your net neutrality

This guide is aimed at Raspberry Pis, but will work for any Debian based OS. E.g. Ubuntu 18.04 server, so just use what suits you. I’ve chosen a Raspberry Pi as it makes for a great low power, always on torrent client.

There is nothing too complicated, but it is a long guide. Setup time could be a couple of hours.


This tutorial is provided with the intention of protecting your identity and for use with strictly legal torrent files.

I do not in any way, shape or form condone or support the downloading of illegal or copyrighted material.

Technical Jargon


VPN stands for virtual private network. VPN secures your computer’s internet connection by ensuring all of the data being sent and recieved is encrypted and secure from prying eyes.

Click here for a full detailed description of VPN.

Port Forwarding

Port forwarding allows remote computers to connect to a specific computer within a LAN. When a router sees an incoming connection on a set port it will forward all that traffic to the computer named in the port forwarding rules.

Click here for a full detailed description of Port Forwarding.


Samba is a network protocol to allow Windows clients to share files, printers and access other Windows services such as Active Directory.

Click here for a full detailed description of Samba.


SSH stands for secure shell. SSH is an encrypted connection established between two computer programs. On the server side (the computer being connected to) a service is running that listens for another computer trying to contact it via SSH.

Click here for a full detailed description of SSH.

What you’ll need

  • A Raspberry Pi  4 Model B (for better ethernet).
  • A powered USB hard drive.
  • An active account with AirVPN.

Note Other VPN services will work, but this guide will concentrate on AirVPN. If you chose another provider ensure they are reputable, do not keep logs and are pro net neutrality. Often you get what you pay for.

How to Setup a Secure Torrent Client

We’re going to split this tutorial into 5 parts:

  • Install and configure the OpenVPN client.
  • Install qBittorrent.
  • Configure qBittorrent.
  • Configure port forwarding.
  • Creating a network share to access the downloaded content.


This guide assumes you have a fresh install of Raspbian on a headless server.

This guide assumes you have set a static IP address.

This guide assumes you have mounted an external USB hard drive

This guide assumes your Raspberry Pi is able to use any DNS server it choses. If it can’t, you’ll need to make an exception in your firewall.

Install the VPN Client

Before we start we’re going to ensure the Raspberry Pi is up to date. Run the following commands to grab and install the latest packages:

sudo apt-get update
sudo apt-get upgrade -y

Now we’re ready to install our VPN client, which for this guide will be OpenVPN. Install using:

sudo apt-get install openvpn -y

Once OpenVPN has been installed you’ll notice a new folder at /etc/openvpn.

This is where we’re going to do the next few bits so lets cd into it:

cd /etc/openvpn

Before we start thinking about connecting to AirVPN we’re going to create 2 files.

  • – To divert all traffic to AirVPN once a connection is established.
  • – Remove the divert rule and restore normal routing.

Create the file called that will divert all traffic to AirVPN:

sudo nano

Now add the instruction to route all traffic over the VPN connection:

# replace /etc/resolv.conf with special version for AirVPN
rm /etc/resolv.conf
cp /etc/resolv.conf.airvpn /etc/resolv.conf

Press Ctrl+x to exit and you’ll be prompted to Save modified. Type Y and then return to save the file.

Create the file called that will reverse the actions of

sudo nano

Now add the instruction to stop routing traffic over the VPN connection:

# restore default resolv.conf
rm /etc/resolv.conf
cp /etc/resolv.conf.original /etc/resolv.conf

Press Ctrl+x to exit and you’ll be prompted to Save modified. Type Y and then return to save the file.

Now let’s give them the correct permissions, we want only the owner (root) to be able to read, write and execute the files:

sudo chmod 700
sudo chmod 700

If it’s all gone to plan, our folder should look like this. To check file permissions use:

ls -al

You’ll have noticed that we referenced some files that don’t currently exist:

  • update-systemd-resolved
  • /etc/resolve.conf.original
  • /etc/resolve.confairvpn

These files are used to ensure we don’t get any DNS leakage and this will help keep our connection more secure and private.

Let’s grab a copy of update-systemd-resolved from github:

sudo wget -P /etc/openvpn/

Once it’s downloaded we need to give it the correct permissions:

sudo chmod +x /etc/openvpn/update-systemd-resolved

Double check the file permissions and folder contents, it should look like:

ls -al

Finally let’s make sure OpenVPN uses the AirVPN DNS servers for all of its requests so nothing is leaked. This change will mean the Raspberry Pi will use AirVPNs DNS servers while the VPN connection is established and the default DNS servers when the VPN connection drops.

Let’s copy resolve.conf so we have an original to default back to when there is no VPN connection:

sudo cp /etc/resolv.conf /etc/resolv.conf.original

And now let;s create a new resolv.conf file that includes AirVPNs DNS servers. I’ve chosen two of their servers that work well for me, but feel free to check out their website if you want to use different servers:

sudo nano /etc/resolv.conf.airvpn

Inside this file paste the following:

# --- BEGIN PVE ---
search local.lan
# --- END PVE --

Press Ctrl+x to exit and you’ll be prompted to Save modified. Type Y and then return to save the file.

There is a risk here that if the VPN connection drops your traffic will be sent over your clear internet and will be fully visible to your internet provider. To remove this risk, follow the tutorial on setting up a VPN gateway server with dead man switch to ensure traffic is only sent over VPN.

We’re all sorted now and can go on to create the AirVPN config!

Create an AirVPN Config File

To be able to connect to AirVPN we need to generate a config from the Client Area. For a direct link to the generator click here.

  • Login to AirVPN.
  • Click Client Area from the tabs across the top.
  • Click Config Generator from the menu on the left hand side.
  • Select your operating system (RPi).
  • Select UDP protocol.
  • Choose a server – I’m using Europe.
  • Scroll to the bottom.
  • Diligently read the Terms of Service.
  • Accept both terms of services boxes.
  • Select Generate.
  • Download the .ovpn file.

If you open up the .ovpn file in a text editor (I recommend something like Visual Studio Code) you’ll see a comment about the file, some VPN parameters, two certificates, a private key and a static key. The top should look something like:

# --------------------------------------------------------
# Air VPN | | Sunday 24th of February 2019 09:50:09 PM
# OpenVPN Client Configuration
# AirVPN_Europe_UDP-443
# --------------------------------------------------------

dev tun
remote 443
resolv-retry infinite
route-delay 5
verb 3
explicit-exit-notify 5
remote-cert-tls server
cipher AES-256-CBC
comp-lzo no
proto udp
key-direction 1

We have chosen the UDP protocol on port 443, if you have issues connecting or have frequent dropouts your Internet Service Provider may be monitoring your connection a little more closely than mine. Some will throttle or not allow VPN traffic and if this is the case you will want to try using TCP instead of UDP. If you’ve had to do this change the line “proto udp” to “proto tcp” in the .ovpn file.

We need to add 7 more lines to the .ovpn file to make sure and are used when we establish or close the VPN connection. While the .ovpn file is open in your text editor add the following lines below “key-direction 1”:

dhcp-option DOMAIN-ROUTE .
script-security 2
setenv PATH /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
up /etc/openvpn/
down /etc/openvpn/

script-security 2 allows the execution of the two scripts and down-pre means that this line is executed before the connection is lost. I.e. no traffic is sent from the device before this line is executed in the event of the connection failing.

Configure AirVPN on the Raspberry Pi

We now have everything we need to connect our Raspberry Pi to AirVPN.

If you’ve left the directory, cd back into /etc/openvpn and create a new file called AirVPN.conf:

cd /etc/openvpn
sudo nano AirVPN.conf

Now paste the content of the .ovpn file you edited in the section above into AirVPN.conf before saving and exiting. Press Ctrl+x to exit and you’ll be prompted to Save modified. Type Y and then return to save the file.

Now ensure it has the right file permissions with:

sudo chmod 644 AirVPN.conf

If it’s all gone to plan, our folder should look like this:

Before we connect to the VPN lets make sure we know what our clear public IP address is.

wget -qO-

Make a note of the number returned to be confident your VPN connection works.

Auto Connect to AirVPN on Boot

There is no point having a headless secure torrent client that requires human input each time it reboots to make sure it connects to VPN server. This would make unexpected power outages a security nightmare. Let’s make sure OpenVPN connects using your AirVPN config every time the Raspberry Pi boots up.

Open the file responsible for default actions on OpenVPN:

sudo nano /etc/default/openvpn

Now scroll to the bottom and add:


Press Ctrl+x to exit and you’ll be prompted to Save modified. Type Y and then return to save the file.

This new line tells OpenVPN to use our AirVPN.conf config file each time it starts. Now go ahead and reboot the Raspberry Pi.

Once the Raspberry Pi has rebooted, check that is is now connected to the VPN:

wget -qO-

Compare the IP address shown now to the one taken before and if all things have gone to plan they should be different!

Check if DNS is Leaking

There is a commandline tool that will check if our DNS is leaking. For more information on the script we’re going to use see the authors GitHub page.

First make sure all dependencies are installed: 

sudo apt install curl jq -y

We’re going to download it to the opt folder:

cd /opt

Download using:

sudo wget

Let’s make it executable:

sudo chmod +x

To run the script from /opt use:


Or outside this folder use:


If everything is successful you should see something like the image below:

Install qBittorrent

qBittorrrent is available from the standard Raspbian packages so installation is a simple case of:

sudo apt-get install qbittorrent-nox -y

Now you may be wondering why we’ve used qbittorrent-nox for the install. The Nox edition is the headless version of qbittorrent so it’s perfect for our needs.

Once the install is complete it’s time to set everything up before we can access the web interface. We’re going to:

  • Create a new use to run qBittorrent.
  • Create a service.
  • Initialise the configuration of qBittorrent.
  • Disable the user from logging in via SSH.
  • Start the service.


It is recommended to run qBittorrent as its own user for security purposes. We’re going to create a new user with a password and leave all other options blank by just pressing return to continue:

sudo adduser qbtuser

When prompted with “Is the information correct? [Y/n]” type “y” and hit return to create the user.

Create a Service

 We’re going to create a file under /etc/systemd/system that will tell the Raspberry Pi how to handle qBittorrent and ensure it runs as a service:

sudo nano  /etc/systemd/system/qbittorrent.service

Now that we’ve created the file, paste the following into it:

Description=qBittorrent Daemon Service

ExecStop=/usr/bin/killall -w qbittorrent-nox


Press Ctrl+x to exit and you’ll be prompted to Save modified. Type Y and then return to save the file.

Initialise the Configuration

Before continuing we need to accept the disclaimer from when qBittorrent first runs, and to do this we need to run it manually. As it’s set to be run by qbtuser lets impersonate them:

sudo su qbtuser

Now lets start qBittorrent:


And accept the legal notice by pressing “y”.

Once done you’ll see an information readout with the default username, password and listening port:

  • User: admin
  • Password: adminadmin
  • Listening Port: 8080

To get back to the command line press Ctrl+C until you see “qbtuser@”.

Stop impersonating qbtuser by typing:


Improve Security

To improve security we’re going to disable qbtuser from logging in via SSH:

sudo usermod -s /usr/sbin/nologin qbtuser

Start the qBittorrent-nox Service

If everything has gone to plan we can start the service.

Start the service for the first time with:

sudo systemctl start qbittorrent

Check it all Works

Now we’ve finished installing qBittorrent and the service is running, lets check it all works by going to http://*Rasbperry Pi Ip Address*:8080 and we should see a login screen.

Login to qBittorrrent using the default username and password shown earlier in the guide, we will be updating these.

  • Username: admin
  • Password: adminadmin

You will see an empty interface that is ready to start downloading torrents. BUT we’re not at that point yet as we’ve got some configuration left and we need to make sure the qBittorrent automatically stops when we lose the VPN connection and starts when the connection returns.

Auto Start qBittorrent

We’re going to go back to the OpenVPN files so cd into /etc/openvpn:

cd /etc/openvpn

To auto start qBittorrent when the VPN connection is established we need to edit

sudo nano

And paste the following at the bottom of the file:

systemctl start qbittorrent

The file should look like:

# replace /etc/resolv.conf with special version for AirVPN
rm /etc/resolv.conf
cp /etc/resolv.conf.airvpn /etc/resolv.conf
systemctl start qbittorrent

 Press Ctrl+x to exit and you’ll be prompted to Save modified. Type Y and then return to save the file.

Auto Stop qBittorrent

To make sure no peer 2 peer traffic is sent over your clear internet connection we’re going to ensure the qBittorrent service is stopped before we lose our VPN connection.

To do this we’re going to add a line to

sudo nano

Paste the following on line 2, above /etc/openvpn/update-systemd-resolved:

systemctl stop qbittorrent

The contents of the file should look like:

systemctl stop qbittorrent
# replace /etc/resolv.conf with special version for AirVPN
rm /etc/resolv.conf
cp /etc/resolv.conf.airvpn /etc/resolv.conf

Press Ctrl+x to exit and you’ll be prompted to Save modified. Type Y and then return to save the file.

Reboot your Raspberry Pi to ensure all our changes are applied:

sudo reboot

Check Everything is Working

After the reboot lets check everything is working as we expect.

In your web browser navigate to the qBittorrent Web UI as you did earlier and make sure it loads.

Now in the command line of the Raspberry Pi make sure the VPN has started automatically:

wget -qO-

Confirm the IP address is different from your clear public address.

Now we’re going to stop the OpenVPN service, make sure it stops qBittorrent and that we are now accessing the internet via our clear IP address:

sudo systemctl stop openvpn

Back in your web browser refresh the qBittorrent Web UI page and it should be unavailable.

Now start OpenVPN back up and do one final check to make sure qBittorrent came back to life:

sudo systemctl start openvpn

Once we’ve confirmed everything is working as expected we can pat our selves on the back for a job well done on installing the basics of our secure torrent client.

Configure qBittorrent

We won’t be storing the active or completed torrent files on the Raspberry Pi’s microSD card, we’ll want these stored on the external hard drive so we want to make sure qbtuser has access to this external drive. 

I’m mounting the drive to /mnt/Torrents so let’s update that with the right owner:

sudo chown -R qbtuser:qbtuser /mnt/Torrents

This will now allow qBittorrent to create and delete files from this directory.

We’re going to store the active and completed torrent files in separate folder on our external drive, so let’s create those:

sudo mkdir /mnt/Torrents/Active
sudo mkdir /mnt/Torrents/Finished

Now we have our folders setup, let’s login to the qBittorrent web ui and get configuring some basics.

Once logged in, click the options button from the top bar (crossed spanner and screw driver), or go to Tools then Options to open the options dialog.

Note: Depending on the version installed, the options button may be a cog as seen below.

The Options dialog will open on the Downloads tab. From here we’re going to update where finished and active torrents are stored.

In Save files to location replace the default with:


Tick the box to the left of Keep incomplete torrents in, and update the textbox to be:


With the folder locations sorted now we want to update the port that qBittorrent listens on.

Click on theConnection tab at the top of the open dialog and at the top you will see Listening Port.

Lets update the Port used for incoming connections:

  • 165587

It can be anything (usually higher than 2048), but best to try and find something that is very rarely used as it will improve the odds of it being available when we request port forwarding from AirVPN.

Finally we want to change the default password for the Web UI.

Click on the Web UI tab at the top of the open dialog and scroll to the bottom.

In the Authentication section update the password to something secure that only you know and you’ll remember.

Port Forwarding

To be able to download torrents we need to do some port forwarding on our router and to get the best performance port forwarding for our VPN connection.

Port Forwarding AirVPN

To forward ports in AirVPN we do this from the Forwarded Ports section of the Client Area. For a direct link to Forwarded Ports click here.

    • Login to AirVPN.
    • Click Client Area from the tabs across the top.
    • Click Forwarded Ports from the menu on the left hand side.
    • In the large box at the top: 16587.
    • Protocol: TCP & UDP.
    • Local port: 16587.
    • Leave DDNS (?) blank.
    • Click Add.

If you get a message telling you the port is already reserved by another user, don’t worry, just keep trying others until you find one that works. Make sure to update qBittorrent as well.

Port Forwarding on Your Router

The principle of port forwarding is universal across all routers, but for this guide I’ll be showing how to do it with pfSense.

To add and apply the port forwarding follow the steps below:

  • Login to pfSense.
  • Firewall -> NAT -> Port Forward.
  • Add.
  • Interface – WAN.
  • Protocol – TCP/UDP.
  • Destination – WAN_Address.
  • Destination Port range – Other, 16587, Other, 16587.
  • Redirect target IP – Raspberry Pi IP (
  • Redirect target port – Other, 16587.
  • Description – qBittorrent Port Forward.
  • Save.
  • Apply Changes – At the top of the NAT page.

Your new NAT rule should like the one above before clicking save and applying the settings.

Once you’ve added and enabled the rule it should be visible on the page of NAT rules and look similar to the image above.

Firewall Rules

If you’re using pfSense you’ve most likely got everything locked down as much as possible. We’re going to need to open some ports to allow the torrent trackers to work. The trackers run on ports:

  • 1337.
  • 6969.

To enable these, let’s hop onto the firewall rules page, Firewall -> Rules -> LAN (or VLAN that the Raspberry Pi is on).

  • Firewall -> Rules -> LAN (or VLAN that the Raspberry Pi is on).
  • Add.
  • Action – Pass.
  • Interface – LAN (or VLAN that the Raspberry Pi is on).
  • Protocol TCP/UDP.
  • Source – Single host or alias (Raspberry Pi IP Address).
  • Destination *tick Invert match*, LAN Address (I have multiple LAN networks so have an alias setup).
  • Destinate Port Range – Other, 1337, Other, 1337.
  • Description – Torrent tracker port 1337.

Let’s create another rule for port 6969. We could add these to an alias so only one rule is required, but fow now it keeps it simple and clear.

  • Firewall -> Rules -> LAN (or VLAN that the Raspberry Pi is on).
  • Add.
  • Action – Pass.
  • Interface – LAN (or VLAN that the Raspberry Pi is on).
  • Protocol TCP/UDP.
  • Source – Single host or alias (Raspberry Pi IP Address).
  • Destination *tick Invert match*, LAN Address (I have multiple LAN networks so have an alias setup).
  • Destinate Port Range – Other, 6969, Other, 6969.
  • Description – Torrent tracker port 6969.

Once you’ve added and enabled the rules they should be visible on the page of firewall rules and look similar to the image below.


The port forwarding is now complete. We can check that everything is working as expected by logging into qBittorrent and at the bottom the connection should now be green instead of yellow.

Download First Torrent

Now that everything is configured and setup let’s download our first torrent.

I use qBittorrent to download all my Linux images, so that’s a good place to start to check everything is working. Head on over to the Raspbian download page again and download the torrent file (ending .torrent).

In qBittorrent click the green Plus icon in the top left to add a new torrent file.

In the dialog that opens click brows to find your torrent file and select it.

Confirm the download location is correct (This was setup earlier and will stay the default).

Click Upload Torrents to start downloading.

Once you’ve added the torrent file you’ll notice it starts downloading. The download speed will depend on a number of factors, total seeds, your connection speed, speed of the VPN connection and on very fast connections, the processing power of the Raspberry Pi may be the limiting factor to maximising connection speeds as it needs to encrypt and de-encrypt all the traffic.

Once the download is complete lets check the finished folder to make sure it’s saved in the right place and with the correct user and group.

ls -al /mnt/Torrents/Finished/


That’s it, we’ve finished setting up the secure torrent client. Now all downloads will be done via a VPN connection and it has a kill switch to stop any traffic being leaked if the connection drops.

One problem, how do we get the files off the Raspberry Pi now they’re downloaded? We’ll need to setup a network share!

Create a Network Share

 This guide assumes you’ll be connecting from a Windows computer so we are going to create a Samba share by installing the Samba server package:

sudo apt-get install samba -y

Once the package has installed we can configure the Samba server, this is done by editing the smb.conf file in /etc/samba/smb.conf.

Before we make any edits, lets make a backup of the original so we can always roll back:

sudo cp /etc/samba/smb.conf /etc/samba/smb.bak

Now to update smb.conf:

sudo nano /etc/samba/smb.conf

We’re going to enable WINS (Windows Internet Name Service) support.

Look for the line:

# wins support = no

And replace it with:

wins support = yes

Now to setup the Samba share, go to the end of the file and paste the following:

[FinishedTorrents] #This is the name of the share it will show up as when you browse
comment = Finished Torrents Folder
path = /mnt/Torrents/Finished
create mask = 0775
directory mask = 0775
read only = no
browseable = yes
public = yes
force user = qbtuser
valid users = qbtuser
only guest = no

Press Ctrl+x to exit and you’ll be prompted to Save modified. Type Y and then return to save the file.

We need to set a samba (memorable and secure) password for qbtuser, this will be used to connect to the share:

sudo smbpasswd -a qbtuser

Now we’ve finished setting it up lets restart the samba service:

sudo service smbd restart

Once the service has restarted let’s try and connect. If this fails, reboot your Raspberry Pi to ensure all settings have been updated.

The Raspberry Pi should be visible on your Network tab, but you can directly navigate to it using either the hostname or IP address of the Raspberry Pi in the address bar of a file explorer window.


Logging in

On the first time logging in you’ll need to provide the user details

  • username: qbtuser
  • password: *Setup earlier*

Ticking Remember my credentials means you won’t have to go through this process each time you try to access the Raspberry Pi’s file share.

It’s not recommended to remember credentials on a shared computer as anyone will be able to access the share.

With everything going to plan you’ll see all of your finished torrents and be able to copy them out.

Finished! – Fully this time

Congratulations! If you’ve stuck with me until now, you have successfully finished setting up a secure torrent client with Samba server.

Pat yourself on the back and enjoy downloading completely legal torrents over a secure connection.

Further Reading

A lot of people like to manage their torrents using Sonarr, Radarr and Lidar, if this is something that interests you, checkout my guides: