TOR Server in Docker Container auf dem VPS installieren

Version: 25.5.18

In diesem Tutorial zeige ich Ihnen, wie Sie einen Tor-Server als Mittelknoten auf einem VPS installieren. Gleichzeitig erstellen Sie einen Proxy-Server, über den man per Browser (z. B. Firefox) die Tor-Verbindung nutzen kann, um anonym im Internet zu surfen. Dabei vermischt sich das eigene Surfverhalten mit den Anfragen, die über den Server laufen.

🖥️ Was benötigen Sie?
1. einen VPS Server mit öffentlicher IPv4 Adresse im Internet mit genügend Bandbreite / freiem Traffic (2,5TB im Monat möglich nach der Konfiguration unten)
2. Linux und SSH-Kenntnisse (Terminal)
3. Docker und Docker-Compose sind installiert (es wird aber auch nochmal ein Installationsskript gezeigt)
4. Die Überzeugung gegen Zensur und Freiheitsbeschränkungen im Internet vorzugehen 😊

Wir starten und loggen uns auf den Server ein:

ssh Username@Server-IP

Wechseln Sie in Ihren Docker-Projekteordner, den ich in meinem Fall unter /home/ abgelegt habe.

cd /home/

Es wird ein Ordner Namens „tor“ erstellt:

mkdir tor

Und in diesen gewechselt:

cd tor

🐳 Falls Docker und Docker-Compose noch nicht installiert sind gibt es hier eine kurze Installationsanleitung. Diese kann auch gerne übersprungen werden:

Jetzt installieren Sie erst einmal Docker indem Sie im /home/tor/ Verzeichnis eine Datei Namens „install.sh“ erstellen:

nano /home/tor/install.sh

In die Datei kommt folgender Inhalt rein (Danke an Patrick Asmus: https://git.techniverse.net/scriptos/public-linux-docker-installer)

#!/bin/bash
# Script Name:  docker-installer.v3.sh
# Beschreibung: Docker & Docker-Compose Installer für Ubuntu 22.04 Jammy und Ubuntu 24.04
# Aufruf:       bash ./docker-installer.v3.sh
# Autor:        Patrick Asmus
# Web:          https://www.techniverse.net
# Git-Reposit.: https://git.techniverse.net/scriptos/linux-docker-installer
# Version:      3.4.5
# Datum:        15.11.2024
# Modifikation: change docker-compose version
#####################################################

# Variablen:
COMPOSEVERSION="v2.30.3"

# Betriebssystem und Version prüfen
OS=$(lsb_release -is)
VERSION=$(lsb_release -rs)

if [ "$OS" != "Ubuntu" ] || { [ "$VERSION" != "22.04" ] && [ "$VERSION" != "24.04" ]; }; then
    echo "Dieses Script unterstützt nur Ubuntu 22.04 und Ubuntu 24.04. Installation abgebrochen."
    exit 1
fi

# Variablen
USER="root"
DOCKER_ROOT_DIR="/var/docker-bin"
COMPOSE_DIR="/home/docker-container"

# Docker installieren
sudo apt update
sudo apt install -y apt-transport-https ca-certificates curl software-properties-common

if [ "$VERSION" == "22.04" ]; then
    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
    echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
elif [ "$VERSION" == "24.04" ]; then
    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
    echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
fi

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io

sudo usermod -aG docker $USER

# Docker-Root-Verzeichnis ändern & Compose Verzeichnis erstellen
sudo systemctl stop docker
sudo mkdir -p $DOCKER_ROOT_DIR
echo "{\"data-root\": \"$DOCKER_ROOT_DIR\"}" | sudo tee /etc/docker/daemon.json > /dev/null
cp /var/lib/docker/* $DOCKER_ROOT_DIR -r
rm -R /var/lib/docker
sudo systemctl start docker

mkdir -p $COMPOSE_DIR

# Docker-compose installieren (gleicher Prozess für beide Versionen)
sudo apt install -y curl
sudo curl -L "https://github.com/docker/compose/releases/download/$COMPOSEVERSION/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

# Optional: Plugin für Oh my ZSH aktivieren
echo "OhMyZSH Plugin für Docker hinzufügen"
sudo sed -i 's/plugins=(git)/plugins=(git docker)/g' /root/.zshrc

# Überprüfen der Installation
docker --version
docker-compose --version

exit 0

Anschließend führen Sie die Datei aus:

cd /home/tor
bash install.sh

Nach Abschluss des Skripts sind Docker und Docker-Compose installiert.

📁 Nun widmen Sie sich dem Tor-Server und erstellen in dem Ordner /home/tor folgende Datei:

nano Dockerfile

In die Datei fügen Sie folgenden Inhalt ein und speichern diese ab – hierbei wird die aktuelle TorVersion 0.4.8.16 verwendet:

FROM debian:bullseye

# Basis-Tools installieren
RUN apt-get update && apt-get install -y \
    curl \
    gnupg2 \
    apt-transport-https \
    ca-certificates \
    python3 \
    python3-pip \
    git \
    locales \
    privoxy

# UTF-8 Locale setzen (für Nyx)
RUN sed -i '/en_US.UTF-8/s/^# //g' /etc/locale.gen && \
    locale-gen

ENV LANG=en_US.UTF-8
ENV LANGUAGE=en_US:en
ENV LC_ALL=en_US.UTF-8

# Offiziellen Tor-GPG-Schlüssel importieren
RUN curl -fsSL https://deb.torproject.org/torproject.org/A3C4F0F979CAA22CDBA8F512EE8CBC9E886DDD89.asc \
    | gpg --dearmor -o /usr/share/keyrings/tor-archive-keyring.gpg

# Tor-Repository einbinden
RUN echo "deb [signed-by=/usr/share/keyrings/tor-archive-keyring.gpg] https://deb.torproject.org/torproject.org bullseye main" \
    > /etc/apt/sources.list.d/tor.list

# Tor installieren
RUN apt-get update && apt-get install -y \
    tor \
    deb.torproject.org-keyring && \
    apt-get clean && rm -rf /var/lib/apt/lists/*

# Nyx installieren
RUN pip3 install nyx

# Konfigurationsdateien & Startskript kopieren
COPY privoxy.config /etc/privoxy/config
COPY start.sh /start.sh
RUN chmod +x /start.sh

# Ports freigeben
EXPOSE 9001 9030 8118

# Startkommando
CMD ["/start.sh"]

Angelegt wird eine neue Datei:

nano start.sh

Diese Datei sorgt dafür das Privoxy (unser Proxyserver über den Sie später über Port 8118 auf Tor zugreifen können) erst nach dem Start des Tor-Servers startet:

#!/bin/bash
set -e

# Starte Tor im Hintergrund
tor -f /etc/tor/torrc &

# Warte kurz, bis Tor initialisiert ist
sleep 5

# Wenn ein Terminal vorhanden ist, starte Nyx in einem neuen Prozess
if [ -t 1 ]; then
  echo "Starte Nyx zur Überwachung von Tor..."
  nyx &
fi

# Starte Privoxy im Vordergrund (wichtig für Docker!)
exec privoxy --no-daemon /etc/privoxy/config

Die nächste Datei die Sie anlegen:

nano torrc

Hier kommt folgender Inhalt hinein:

Nickname Nickname
ContactInfo contact@proton.me

ORPort 9001 IPv4Only
DirPort 9030
ControlPort 9051
CookieAuthentication 1
ExitRelay 0

DataDirectory /var/lib/tor

RelayBandwidthRate 1 MB
RelayBandwidthBurst 2 MB

Log notice stdout

#Address VPS-IP(optional)

Den Nickname Ihres Relays und die Kontakt-Emailadresse ändern Sie natürlich noch entsprechend ab. Das Tor Relay wird in unserem Beispiel nur als IPv4 Host betrieben, was einfacher umzusetzen ist.

Es folgt wieder eine neue Datei:

nano privoxy.config

Hierbei handelt es sich um die Konfigurationsdatei unseres Proxy-Servers:

listen-address  0.0.0.0:8118
forward-socks5t /               127.0.0.1:9050 .
logfile /dev/stdout

🚀 Nachdem Sie auch diese Datei erstellt haben, können Sie Ihr eigenes Docker-Image bauen (alles wird dabei in dem Pfad /home/tor/ abgespeichert und ausgeführt):

docker build -t tor-privoxy-nyx .

Sie haben nun Ihren eigenen Docker Container mit Tor-Privoxy erstellt. Das ganze kann mit dem Befehl „docker images“ überprüft werden. Hier müsste jetzt der entsprechende Container auftauchen:

⚙️ Basteln Sie noch die entsprechende Docker-Compose.yml um den Container gut und sicher zu starten:

nano docker-compose.yml

Die Datei wird im Ordner /home/tor gespeichert mit folgendem Inhalt:

version: '3.8'

services:
  tor-privoxy:
    build: .
    image: tor-privoxy-nyx
    container_name: tor-privoxy-nyx
    volumes:
      - ./torrc:/etc/tor/torrc
      - ./tor_data:/var/lib/tor
    ports:
      - "9001:9001"
      - "9030:9030"
      - "8118:8118"
    restart: always

Jetzt haben Sie alle Schritte erledigt um auf Ihrem VPS Server einen Tor Server als Mittelknoten laufen zu lassen. Nun können Sie den Container im Hintergrund starten:

docker compose up -d

Log-Dateien lassen Sie sich mit

docker logs -f tor-privoxy-nyx

anzeigen.

Wenn Sie in den Logs die „100%“ finden, haben Sie alles richtig gemacht:

Wichtig ist noch, dass die Ports 9001 und 9030 aus dem Internet erreichbar und in der Firewall freigegeben sind.

ACHTUNG: Port 8118 sollte aus Sicherheitsgründen entweder geblockt oder nur für Ihre eigene IP freigegeben werden. Das ist der Proxyserver.

🔍 Für den Proxyserver gibt es noch den folgenden Funkionstest:

curl --proxy http://localhost:8118 https://check.torproject.org/

Hier sollte eine Bestätigung erscheinen, dass eine Verbindung über TOR möglich war.

✅ Was haben Sie in dem Tutorial nun erreicht?

TOR läuft in der aktuellsten Version in einem Docker Container auf dem VPS Server
Privoxy und NYX sind mit installiert
Fingerprint und RSA Schlüssel werden außerhalb des Containers gespeichert
Der Tor Server ist öffentlich erreichbar über die Ports TCP Ports 9001 und 9030
Der Proxyserver, der Tor verwendet, ist über IP:8118 erreichbar und kann so z.B. im Browser als Proxy angegeben werden (ACHTUNG: Nur für die eigene IP am besten freigeben!)
Sie setzen sich aktiv für Freiheit im Internet ein 😊

Statistiken (NYX) können Sie mit folgenden Befehlen abrufen: