Ricerca nel sito web

Come installare Padloc Password Manager su Rocky Linux 8

Su questa pagina

  1. Prerequisiti
  2. Passaggio 1 - Firewall
  3. Passaggio 2 - Installa Docker
  4. Passaggio 3 - Installa Docker-Compose
  5. Passaggio 4: creazione di directory di dati
  6. Passaggio 5 - Crea il file di composizione Docker
  7. Passaggio 6 - Configura NGinx
  8. Passaggio 7 - Crea file di ambiente
  9. Passaggio 8 - Installa SSL
  10. Passaggio 9 - Configura SSL
  11. Passaggio 10 - Esegui Padloc
  12. Passaggio 11 - Accedi e configura Padloc
  13. Passaggio 12 - Aggiorna Padloc
  14. Conclusione

Padloc è una soluzione di gestione delle password basata su cloud che ti consente di accedere e utilizzare le tue password salvate su più piattaforme. Offre un'interfaccia semplice e può essere utilizzato per salvare le password e può crittografare e archiviare documenti sensibili. Supporta anche la memorizzazione di token di autenticazione a due fattori e può aggiungerli direttamente dalla pagina web.

Padloc offre anche una soluzione self-hosted open source che puoi installare su qualsiasi server per mantenere il controllo completo sui tuoi dati. Tuttavia, c'è un avvertimento a questo. Non è possibile utilizzare l'applicazione self-hosted con le sue app desktop e mobili. Il lato positivo è che Padloc è servito come PWA (Progressive web app), il che significa che puoi installarlo come applicazione nativa su dispositivi mobili e sfruttare molte delle sue funzionalità.

In questo tutorial imparerai come installare Padloc Password Manager su un server basato su Rocky Linux 8.

Prerequisiti

  • Un server che esegue Rocky Linux 8 con un minimo di 1 GB di RAM.
  • Un utente non root con privilegi sudo.
  • Un nome di dominio completo (FQDN) che punta al server come example.com. Supponiamo che utilizzerai solo un nome di dominio per questo server per questo tutorial.

Passaggio 1: firewall

Il primo passo è configurare il firewall. Rocky Linux utilizza Firewalld Firewall. Controlla lo stato dei firewall.

$ sudo firewall-cmd --state
running

Il firewall funziona con zone diverse e la zona pubblica è quella predefinita che utilizzeremo. Elenca tutti i servizi e le porte attive sul firewall.

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

Dovrebbe mostrare il seguente output.

cockpit dhcpv6-client ssh

Consenti porte HTTP e HTTPS.

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

Ricontrolla lo stato del firewall.

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

Dovresti vedere un output simile.

cockpit dhcpv6-client http https ssh

Ricarica il firewall per abilitare le modifiche.

$ sudo firewall-cmd --reload

Passaggio 2: installa Docker

Rocky Linux viene fornito con una versione precedente di Docker. Per installare l'ultima versione, per prima cosa installa il repository Docker ufficiale.

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

Installa l'ultima versione di Docker.

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

Abilita ed esegui il demone Docker.

$ sudo systemctl enable docker --now

Verificare che sia in esecuzione.

$ 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
 ....

Per impostazione predefinita, Docker richiede i privilegi di root. Se vuoi evitare di usare sudo ogni volta che esegui il comando docker, aggiungi il tuo nome utente alla docker gruppo.

$ sudo usermod -aG docker $(whoami)

Sarà necessario disconnettersi dal server e riconnettersi come lo stesso utente per abilitare questa modifica.

Passaggio 3: installa Docker-Compose

Scarica l'ultima versione stabile di Docker Compose.

$ 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

Applicare le autorizzazioni eseguibili al file binario Docker Compose.

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

Testare l'installazione.

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

Installa lo script Bash Completion di Docker-compose.

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

Ricarica le impostazioni del tuo profilo per far funzionare il completamento di bash.

$ source ~/.bashrc

Passaggio 4: creare directory di dati

Crea una directory per padloc.

$ mkdir ~/padloc

Passa alla directory padloc.

$ cd ~/padloc

Crea directory per il database utente, i registri dell'applicazione, gli allegati, l'app PWA e la configurazione SSL.

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

Crea una directory per i log Nginx.

$ mkdir logs/nginx

Passaggio 5: crea il file di composizione Docker

Crea e apri il file ~/padloc/docker-compose.yml per la modifica.

$ nano docker-compose.yml

Incolla il seguente codice al suo interno.

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

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Stiamo usando tre immagini Docker per Padloc.

  1. L'immagine del server: contiene tutta la logica di back-end per l'applicazione. Funziona sulla porta 3000 per impostazione predefinita. Abbiamo decommentato la variabile delle porte nel nostro file di composizione per rendere la porta invisibile al server. Invece, usiamo la variabile di esposizione per esporre la porta all'interno del motore Docker al contenitore Nginx. Le variabili di ambiente per l'immagine verranno configurate successivamente. Abbiamo anche mappato le directory per un database utente, allegati e registri delle applicazioni.
  2. L'immagine PWA: contiene il frontend dell'applicazione. Funziona sulla porta 8080 per impostazione predefinita. Per quanto riguarda l'immagine del server, abbiamo nascosto la sezione delle porte per questa immagine ed esposto la porta all'interno del motore Docker. Abbiamo mappato la directory per l'app Web.
  3. L'immagine Nginx: contiene l'applicazione server Nginx. Abbiamo le porte per HTTP(80) e HTTPS(443) al server per renderlo accessibile dall'esterno. Abbiamo mappato diverse directory e file per farlo funzionare.
    • Il primo file è nginx.conf che contiene tutte le configurazioni principali per Nginx per servire l'applicazione padloc.
    • I prossimi due file, cert.pem e key.pem sono il certificato SSL e le chiavi che genereremo utilizzando Lets encrypt.
    • Il file ssl.conf contiene informazioni aggiuntive relative al servizio SSL tramite Nginx.
    • Il file dhparam.pem serve il certificato del gruppo Diffie-Hellman.
    • L'ultima voce è mappare i log Nginx sul server in modo da potervi accedere al di fuori di Docker.
  4. Il flag :Z alla fine delle mappature delle cartelle indica che tali directory saranno accessibili solo dai rispettivi contenitori. Questo viene fatto poiché SELINUX è abilitato sul nostro server. Se non stai usando SELinux, puoi rimuovere il flag.

Passaggio 6: configurare NGinx

Crea e apri il file ~/padloc/nginx.conf per la modifica.

$ nano nginx.conf

Incolla il seguente codice al suo interno.

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 {}

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

La configurazione precedente inoltra tutte le richieste effettuate dal contenitore padloc_server alla posizione /server del nome di dominio e qualsiasi richiesta effettuata dal padlock_pwa alla radice. Reindirizza anche tutto il traffico HTTP su HTTPS. Abbiamo anche impostato la dimensione di caricamento del file su 10 MB per gli allegati. È possibile modificare le dimensioni in base alle proprie esigenze. Le impostazioni SSL sono state incluse tramite un file esterno che configureremo in seguito.

Passaggio 7: crea il file di ambiente

Crea e apri il file ~/padloc/.env per la modifica.

$ nano .env

Incolla il seguente codice al suo interno.

# 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

# 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


# 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

Salva il file premendo Ctrl + X e inserendo Y quando richiesto. La maggior parte delle impostazioni sono autoesplicative. La configurazione Nginx esistente prevede che l'app venga servita tramite il dominio principale e il server tramite la directory /server. Il PL_PWA_DIR non è obbligatorio da impostare qui e nel file Docker-compose, ma avendolo accelera l'avvio del contenitore, e quindi dovresti sempre impostarlo.

Padloc richiede la possibilità di inviare e-mail per funzionalità come la verifica di nuovi utenti, l'autenticazione a due fattori e il ripristino delle password. Pertanto, i dettagli SMTP sono obbligatori.

Per la funzionalità SSL, utilizziamo Lets Encrypt directory predefinite in cui si trovano i certificati. La configurazione SSL aggiuntiva verrà fornita tramite il file /ssl/ssl.conf.

Passaggio 8: installa SSL

Per installare un certificato SSL utilizzando Lets Encrypt, è necessario installare lo strumento Certbot.

Innanzitutto, devi scaricare e installare il repository EPEL.

$ sudo dnf install epel-release

Eseguire i seguenti comandi per installare Certbot.

$ sudo dnf install certbot

Genera il certificato SSL.

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

Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/example.com sul tuo server.

Genera un certificato di gruppo Diffie-Hellman.

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

Crea un Cron Job per rinnovare l'SSL. Verrà eseguito ogni settimana per controllare il certificato e rinnovarlo se necessario. Per questo, per prima cosa, crea il file /etc/cron.weekly/certbot-renew e aprilo per modificarlo.

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

Incolla il seguente codice. Utilizziamo i comandi Docker per avviare, arrestare e riavviare il container Nginx a seconda dello stato di rinnovo.

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

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Modificare le autorizzazioni sul file dell'attività per renderlo eseguibile.

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

Passaggio 9: configurare SSL

Crea e apri il file ~/padloc/ssl/ssl.conf per la modifica.

$ nano ssl/ssl.conf

Incolla il seguente codice al suo interno.

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;

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Il file precedente introduce alcune impostazioni SSL consigliate per rendere il tuo sito più sicuro. Limita i protocolli TLS a v1.2 e v1.3 e abilita la graffatura e la verifica del protocollo OCSP (Online Certificate Status Protocol).

Passaggio 10: eseguire Padloc

Ora che hai configurato tutto, esegui Padloc usando il seguente comando.

$ docker-compose up -d

Controlla lo stato dei contenitori.

$ docker ps

Dovresti ottenere un risultato simile.

Passaggio 11: accedere e configurare Padloc

Apri l'URL https://example.com nel tuo browser e raggiungerai la sua pagina di accesso.

Fare clic sul collegamento Iscriviti ora per avviare la registrazione.

Inserisci il tuo nome e indirizzo email e premi Continua per procedere.

Padloc ti invierà un'e-mail con un codice di conferma. Inserisci il codice di conferma nella casella in alto e premi Continua per procedere.

Padloc genererà automaticamente una password principale per te. Passa il mouse sopra la casella e copiala. Incollalo di nuovo nella casella sottostante. Puoi anche scegliere di utilizzare la tua password. Premi Continua quando hai finito.

Verrai indirizzato alla home page di Padloc. Puoi iniziare a salvare i tuoi dati di accesso e i documenti sensibili.

Passaggio 12: aggiorna Padloc

L'aggiornamento di Padloc è un processo in due fasi. Innanzitutto, passa alla directory Padloc.

$ cd ~/padloc

Arrestare e rimuovere i contenitori Padloc esistenti.

$ docker-compose down --remove-orphans

Estrai le immagini più recenti.

$ docker-compose pull

Riavvia i contenitori.

$ docker-compose up -d

Conclusione

Questo conclude il nostro tutorial sull'installazione del gestore di password self-hosted Padloc su un server Rocky Linux 8. Se hai domande, pubblicale nei commenti qui sotto.