So installierst du Padloc Password Manager auf Rocky Linux 8

Padloc ist eine Cloud-basierte Lösung zur Verwaltung von Passwörtern, mit der du auf deine gespeicherten Passwörter zugreifen und sie plattformübergreifend nutzen kannst. Padloc bietet eine einfache Benutzeroberfläche und kann deine Passwörter speichern sowie sensible Dokumente verschlüsseln und speichern. Es unterstützt auch die Speicherung von Zwei-Faktor-Authentifizierungs-Tokens und kann diese direkt von der Webseite aus hinzufügen.

Padloc bietet auch eine selbst gehostete Open-Source-Lösung, die du auf einem beliebigen Server installieren kannst, um die volle Kontrolle über deine Daten zu behalten. Allerdings gibt es dabei einen Haken an der Sache. Du kannst die selbst gehostete Anwendung nicht mit den Desktop- und Mobile-Apps verwenden. Das Gute daran ist, dass Padloc als PWA (Progressive Web App) angeboten wird, was bedeutet, dass du es als native Anwendung auf deinem Handy installieren und die Vorteile einiger seiner Funktionen nutzen kannst.

In diesem Tutorial erfährst du, wie du Padloc Password Manager auf einem Rocky Linux 8 basierten Server installierst.

Voraussetzungen

• Ein Server mit Rocky Linux 8 und mindestens 1 GB RAM.
• Ein Nicht-Root-Benutzer mit sudo-Rechten.
• Ein Fully Qualified Domain Name (FQDN), der auf den Server verweist, wie example.com. Wir gehen davon aus, dass du in diesem Lernprogramm nur einen Domainnamen für den Server verwendest.

Schritt 1 – Firewall

Der erste Schritt besteht darin, die Firewall zu konfigurieren. Rocky Linux verwendet die Firewalld Firewall. Überprüfe den Status der Firewall.

$ sudo firewall-cmd --state
running

Die Firewall arbeitet mit verschiedenen Zonen, wobei die öffentliche Zone die Standardzone ist, die wir verwenden werden. Liste alle Dienste und Ports auf, die auf der Firewall aktiv sind.

$ sudo firewall-cmd --permanent --list-services

Es sollte die folgende Ausgabe angezeigt werden.

cockpit dhcpv6-client ssh

Lasse HTTP- und HTTPS-Ports zu.

$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https

Überprüfe erneut den Status der Firewall.

$ sudo firewall-cmd --permanent --list-services

Du solltest eine ähnliche Ausgabe sehen.

cockpit dhcpv6-client http https ssh

Lade die Firewall neu, um die Änderungen zu aktivieren.

$ sudo firewall-cmd --reload

Schritt 2 – Docker installieren

Rocky Linux wird mit einer älteren Version von Docker ausgeliefert. Um die neueste Version zu installieren, installierst du zuerst das offizielle Docker-Repository.

$ sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

Installiere die neueste Version von Docker.

$ sudo dnf install docker-ce docker-ce-cli containerd.io

Aktiviere den Docker-Daemon und starte ihn.

$ sudo systemctl enable docker --now

Überprüfe, ob er läuft.

$ sudo systemctl status docker
? docker.service - Docker Application Container Engine
   Loaded: loaded (/usr/lib/systemd/system/docker.service; enabled; vendor preset: disabled)
   Active: active (running) since Sun 2022-04-09 22:43:21 UTC; 30s ago
     Docs: https://docs.docker.com
 Main PID: 43005 (dockerd)
    Tasks: 7
   Memory: 90.5M
   CGroup: /system.slice/docker.service
           ??43005 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
 ....

Standardmäßig benötigt Docker Root-Rechte. Wenn du vermeiden willst, dass du jedes Mal sudo verwendest, wenn du den Befehl docker ausführst, füge deinen Benutzernamen der Gruppe docker hinzu.

$ sudo usermod -aG docker $(whoami)

Um diese Änderung zu aktivieren, musst du dich vom Server abmelden und als derselbe Benutzer wieder anmelden.

Schritt 3 – Installiere Docker-Compose

Lade die neueste stabile Version von Docker Compose herunter.

$ sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Gib der Docker-Compose-Binärdatei die Berechtigung zum Ausführen.

$ sudo chmod +x /usr/local/bin/docker-compose

Teste die Installation.

$ docker-compose --version
docker-compose version 1.29.2, build 5becea4c

Installiere das Docker-Compose Bash Completion Script.

$ sudo curl \
    -L https://raw.githubusercontent.com/docker/compose/1.29.2/contrib/completion/bash/docker-compose \
    -o /etc/bash_completion.d/docker-compose

Lade deine Profileinstellungen neu, damit die Bash-Vervollständigung funktioniert.

$ source ~/.bashrc

Schritt 4 – Datenverzeichnisse erstellen

Erstelle ein Verzeichnis für padloc.

$ mkdir ~/padloc

Wechsle in das padloc-Verzeichnis.

$ cd ~/padloc

Erstelle Verzeichnisse für die Benutzerdatenbank, Anwendungsprotokolle, Anhänge, die PWA-App und die SSL-Konfiguration.

$ mkdir {attachments,db,logs,pwa,ssl}

Erstelle ein Verzeichnis für die Nginx-Protokolle.

$ mkdir logs/nginx

Schritt 5 – Docker Compose-Datei erstellen

Erstelle und öffne die Datei ~/padloc/docker-compose.yml zum Bearbeiten.

$ nano docker-compose.yml

Füge den folgenden Code in die Datei ein.

version: "3"
services:
    server:
        image: padloc/server
        container_name: padloc_server
        restart: unless-stopped
        #ports:
        #    - ${PL_SERVER_PORT:-3000}:3000
        expose:
            - 3000
        volumes:
            - ${PL_DB_DIR:-./db}:/data:Z
            - ${PL_ATTACHMENTS_DIR:-./attachments}:/docs:Z
            - ./logs:/logs:Z
        environment:
            - PL_PWA_URL
            - PL_EMAIL_SERVER
            - PL_EMAIL_PORT
            - PL_EMAIL_USER
            - PL_EMAIL_PASSWORD
            - PL_EMAIL_FROM
    pwa:
        image: padloc/pwa
        container_name: padloc_pwa
        restart: unless-stopped
        #ports:
        #    - ${PL_PWA_PORT:-8080}:8080
        expose:
            - 8080
        volumes:
            - ${PL_PWA_DIR:-./pwa}:/pwa:Z
        environment:
            - PL_SERVER_URL
    nginx:
        image: nginx
        container_name: nginx
        restart: unless-stopped
        volumes: 
            - ./nginx.conf:/etc/nginx/nginx.conf
            - ${PL_SSL_CERT:-./ssl/cert.pem}:/ssl/cert
            - ${PL_SSL_KEY:-./ssl/key.pem}:/ssl/key
            - ${PL_SSL_CONF:-./ssl/ssl.conf}:/ssl/ssl.conf
            - /etc/ssl/certs/dhparam.pem:/ssl/dhparam.pem
            - ./logs/nginx:/var/log/nginx:Z
        ports:
            - 80:80
            - 443:443

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Wir verwenden drei Docker-Images für Padloc.

1. Das Server-Image – enthält die gesamte Backend-Logik für die Anwendung. Es läuft standardmäßig auf Port 3000. Wir haben die Ports-Variable in unserer Compose-Datei auskommentiert, um den Port für den Server unsichtbar zu machen. Stattdessen verwenden wir die Variable expose, um den Port innerhalb der Docker-Engine für den Nginx-Container sichtbar zu machen. Die Umgebungsvariablen für das Image werden später konfiguriert. Wir haben auch Verzeichnisse für eine Benutzerdatenbank, Anhänge und Anwendungsprotokolle angelegt.
2. Das PWA-Image – enthält das Frontend der Anwendung. Es läuft standardmäßig auf Port 8080. Wie beim Server-Image haben wir den Ports-Bereich für dieses Image ausgeblendet und den Port innerhalb der Docker-Engine freigegeben. Wir haben das Verzeichnis für die Webanwendung gemappt.
3. Das Nginx-Image – enthält die Nginx-Serveranwendung. Wir haben die Ports für HTTP(80) und HTTPS(443) auf den Server gelegt, damit er von außen zugänglich ist. Wir haben mehrere Verzeichnisse und Dateien zugewiesen, damit er funktioniert.
   • Die erste Datei ist nginx.conf, die alle wichtigen Konfigurationen für Nginx enthält, um die padloc-Anwendung zu bedienen.
   • Die nächsten beiden Dateien, cert.pem und key.pem, sind das SSL-Zertifikat und die Schlüssel, die wir mit Let’s encrypt erzeugen werden.
   • Die Datei ssl.conf enthält zusätzliche Informationen zur Bereitstellung von SSL über Nginx.
   • Die Datei dhparam.pem dient der Bereitstellung des Diffie-Hellman-Gruppenzertifikats.
   • Der letzte Eintrag dient dazu, die Nginx-Protokolle zurück auf den Server zu mappen, damit du außerhalb von Docker auf sie zugreifen kannst.
4. Das :Z Flag am Ende der Ordnerzuordnungen zeigt an, dass auf diese Verzeichnisse nur von den jeweiligen Containern aus zugegriffen werden kann. Das wird gemacht, weil SELINUX auf unserem Server aktiviert ist. Wenn du kein SELinux verwendest, kannst du das Flag entfernen.

Schritt 6 – NGinx konfigurieren

Erstelle und öffne die Datei ~/padloc/nginx.conf zum Bearbeiten.

$ nano nginx.conf

Füge den folgenden Code in die Datei ein.

http {
    # This is required if you want to upload attachments
    client_max_body_size 10m;

    # Redirect all http traffic to https
    server {
        listen 80 default_server;
        listen [::]:80 default_server;
        server_name _;
        return 301 https://$host$request_uri;
    }

    server {
        # We don't need a host name here since we're only
        # dealing with one domain, but you may insert your domain here.
        server_name _;

        # Both server and pwa are served over https
        listen 443 ssl http2;
        listen [::]:443 ssl http2;

        # This will resolve to the server instance
        location /server/ {
            proxy_pass http://padloc_server:3000;
            rewrite ^/padloc_server(.*)$ $1 break;
        }

        # This will resolve to the web app
        location / {
            proxy_pass http://padloc_pwa:8080;
            rewrite ^/padloc_pwa(.*)$ $1 break;
        }

        # SSL certificate
        ssl_certificate /ssl/cert;
        # SSL private key
        ssl_certificate_key /ssl/key;

        # Add this file to add advanced ssl configuration
        include /ssl/ssl.conf;
    }
}

# This section is required by nginx
events {}

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Die obige Konfiguration leitet alle Anfragen des Containers padloc_server an den /server Standort des Domainnamens und alle Anfragen des Containers padlock_pwa an den Root weiter. Außerdem wird der gesamte HTTP-Verkehr auf HTTPS umgeleitet.Außerdem haben wir die Größe des Datei-Uploads für Anhänge auf 10 MB festgelegt. Du kannst die Größe nach deinen Bedürfnissen ändern. Die SSL-Einstellungen sind in einer externen Datei enthalten, die wir später konfigurieren werden.

Schritt 7 – Umgebungsdatei erstellen

Erstelle und öffne die Datei ~/padloc/.env zum Bearbeiten.

$ nano .env

Füge den folgenden Code in die Datei ein.

# GENERAL SETTINGS
# ================
# URL that will resolve to the server instance
PL_PWA_URL=https://example.com/
# URL that will resolve to the web app
PL_SERVER_URL=https://example.com/server/

# SERVER SETTINGS
# ===============
# Port the server instance will listen on
PL_SERVER_PORT=3000
# Directory where database files will be stored
PL_DB_DIR=./db
# Directory where attachment files will be stored
PL_ATTACHMENTS_DIR=./attachments

# PWA SETTINGS
# ============
# Port the web app will be served from
PL_PWA_PORT=8080
# Directory where the static code for the web app will be stored
PL_PWA_DIR=./pwa

# EMAIL SETTINGS
# =============
# SMTP host
PL_EMAIL_SERVER=smtp.example.com
# SMTP username
PL_EMAIL_USER=name@example.com
# SMTP port
PL_EMAIL_PORT=443
# SMTP password
PL_EMAIL_PASSWORD=your_smtp_password
# Always use TLS when sending emails
# PL_EMAIL_SECURE=false
# Email ID to send mails from
PL_EMAIL_FROM=admin@example.com

# SSL SETTINGS
# ============
# The path to your ssl certificate
PL_SSL_CERT=/etc/letsencrypt/live/example.com/fullchain.pem
# The path to your ssl private key
PL_SSL_KEY=/etc/letsencrypt/live/example.com/privkey.pem
# Advanced configuration file
PL_SSL_CONF=./ssl/ssl.conf

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Die meisten Einstellungen sind selbsterklärend. Die bestehende Nginx-Konfiguration erwartet, dass die App über die Hauptdomain und der Server über das Verzeichnis /server bedient wird. Die PL_PWA_DIR muss hier und in der Docker-Compose-Datei nicht zwingend eingestellt werden, aber da sie den Start des Containers beschleunigt, solltest du sie immer einstellen.

Padloc benötigt die Möglichkeit, E-Mails für Funktionen wie die Verifizierung neuer Benutzer, die Zwei-Faktor-Authentifizierung und das Zurücksetzen von Passwörtern zu versenden. Daher sind SMTP-Angaben obligatorisch.

Für die SSL-Funktion verwenden wir die Standardverzeichnisse von Let’s Encrypt, in denen sich die Zertifikate befinden. Die zusätzliche SSL-Konfiguration wird über die Datei /ssl/ssl.conf bereitgestellt.

Schritt 8 – SSL installieren

Um ein SSL-Zertifikat mit Let’s Encrypt zu installieren, müssen wir das Tool Certbot installieren.

Als erstes musst du das EPEL-Repository herunterladen und installieren.

$ sudo dnf install epel-release

Führe die folgenden Befehle aus, um Certbot zu installieren.

$ sudo dnf install certbot

Erstelle das SSL-Zertifikat.

$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d example.com

Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/example.com auf deinem Server heruntergeladen.

Erstelle ein Diffie-Hellman-Gruppenzertifikat.

$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048

Erstelle einen Cron Job zur Erneuerung des SSL-Zertifikats. Er wird jede Woche ausgeführt, um das Zertifikat zu prüfen und es bei Bedarf zu erneuern. Erstelle dazu zunächst die Datei /etc/cron.weekly/certbot-renew und öffne sie zur Bearbeitung.

$ sudo nano /etc/cron.weekly/certbot-renew

Füge den folgenden Code ein. Wir verwenden die Docker-Befehle, um den Nginx-Container je nach Status der Erneuerung zu starten, zu stoppen und neu zu starten.

#!/bin/sh
certbot renew --cert-name example.com --pre-hook "docker stop nginx" --post-hook "docker start nginx" --renew-hook "docker restart nginx"

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Ändere die Berechtigungen für die Aufgabendatei, um sie ausführbar zu machen.

$ sudo chmod +x /etc/cron.weekly/certbot-renew

Schritt 9 – SSL konfigurieren

Erstelle und öffne die Datei ~/padloc/ssl/ssl.conf zum Bearbeiten.

$ nano ssl/ssl.conf

Füge den folgenden Code in die Datei ein.

ssl_session_timeout 1d;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_prefer_server_ciphers off;

ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;

ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /ssl/dhparam.pem;
resolver 1.1.1.1 1.0.0.1 [2606:4700:4700::1111] [2606:4700:4700::1001] 8.8.8.8 8.8.4.4 [2001:4860:4860::8888] [2001:4860:4860::8844] valid=60s;
resolver_timeout 2s;

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

In der obigen Datei werden einige empfohlene SSL-Einstellungen vorgenommen, um deine Website sicherer zu machen. Sie schränkt die TLS-Protokolle auf v1.2 und v1.3 ein und aktiviert das Online Certificate Status Protocol (OCSP) für die Abheftung und Überprüfung.

Schritt 10 – Padloc ausführen

Nachdem du nun alles konfiguriert hast, führe Padloc mit folgendem Befehl aus.

$ docker-compose up -d

Überprüfe den Status der Container.

$ docker ps

Du solltest eine ähnliche Ausgabe erhalten.

Schritt 11 – Padloc aufrufen und konfigurieren

Öffne die URL https://example.com in deinem Browser und du gelangst zur Anmeldeseite.

Klicke auf den Link Jetzt anmelden, um die Registrierung zu starten.

Gib deinen Namen und deine E-Mail-Adresse ein und klicke auf Weiter, um fortzufahren.

Padloc schickt dir eine E-Mail mit einem Bestätigungscode. Gib den Bestätigungscode in das Feld oben ein und klicke auf Weiter, um fortzufahren.

Padloc generiert automatisch ein Master-Passwort für dich. Fahre mit der Maus über das Feld und kopiere es. Füge es wieder in das Feld darunter ein. Du kannst auch wählen, ob du dein Passwort verwenden willst. Drücke auf Weiter, wenn du fertig bist.

Du wirst auf die Padloc-Homepage weitergeleitet. Du kannst damit beginnen, deine Anmeldedaten und sensiblen Dokumente zu speichern.

Schritt 12 – Padloc aktualisieren

Die Aktualisierung von Padloc ist ein zweistufiger Prozess. Wechsle zunächst in das Padloc-Verzeichnis.

$ cd ~/padloc

Schließe die vorhandenen Padloc-Container und entferne sie.

$ docker-compose down --remove-orphans

Ziehe die neuesten Images.

$ docker-compose pull

Starte die Container erneut.

$ docker-compose up -d

Fazit

Damit ist unsere Anleitung zur Installation des selbst gehosteten Passwortmanagers Padloc auf einem Rocky Linux 8 Server abgeschlossen. Wenn du Fragen hast, schreibe sie unten in die Kommentare.