Cómo instalar Padloc Password Manager en Rocky Linux 8

Padloc es una solución de gestión de contraseñas basada en la nube que te permite acceder y utilizar tus contraseñas guardadas en múltiples plataformas. Ofrece una interfaz sencilla y se puede utilizar para guardar tus contraseñas y puede encriptar y almacenar documentos sensibles. También admite el almacenamiento de tokens de autenticación de dos factores y puede añadirlos directamente desde la página web.

Padloc también ofrece una solución de código abierto autoalojada que puedes instalar en cualquier servidor para mantener un control total sobre tus datos. Sin embargo, hay una advertencia. No puedes utilizar la aplicación autoalojada con sus aplicaciones de escritorio y móvil. El lado positivo es que Padloc se sirve como una PWA (Progressive web app), lo que significa que puedes instalarla como una aplicación nativa en el móvil y aprovechar varias de sus funciones.

En este tutorial, aprenderás a instalar Padloc Password Manager en un servidor basado en Rocky Linux 8.

Requisitos previos

• Un servidor con Rocky Linux 8 con un mínimo de 1 GB de RAM.
• Un usuario no root con privilegios sudo.
• Un Nombre de Dominio Completamente Cualificado (FQDN) que apunte al servidor como example.com. Supondremos que para este tutorial sólo utilizarás un nombre de dominio para este servidor.

Paso 1 – Cortafuegos

El primer paso es configurar el cortafuegos. Rocky Linux utiliza el cortafuegos Firewalld. Comprueba el estado del cortafuegos.

$ sudo firewall-cmd --state
running

El cortafuegos funciona con diferentes zonas, y la zona pública es la que utilizaremos por defecto. Enumera todos los servicios y puertos activos en el cortafuegos.

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

Debería mostrar el siguiente resultado.

cockpit dhcpv6-client ssh

Permite los puertos HTTP y HTTPS.

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

Vuelve a comprobar el estado del cortafuegos.

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

Deberías ver una salida similar.

cockpit dhcpv6-client http https ssh

Recarga el cortafuegos para activar los cambios.

$ sudo firewall-cmd --reload

Paso 2 – Instalar Docker

Rocky Linux viene con una versión antigua de Docker. Para instalar la última versión, primero instala el repositorio oficial de Docker.

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

Instala la última versión de Docker.

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

Activa y ejecuta el demonio Docker.

$ sudo systemctl enable docker --now

Comprueba que se está ejecutando.

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

Por defecto, Docker requiere privilegios de root. Si quieres evitar usar sudo cada vez que ejecutes el comando docker, añade tu nombre de usuario al grupo docker.

$ sudo usermod -aG docker $(whoami)

Tendrás que salir del servidor y volver a entrar como el mismo usuario para activar este cambio.

Paso 3 – Instalar Docker-Compose

Descarga la última versión estable de 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

Aplica los permisos de ejecución al archivo binario de Docker Compose.

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

Prueba la instalación.

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

Instala el script Docker-compose Bash Completion.

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

Recarga la configuración de tu perfil para que funcione el bash-completion.

$ source ~/.bashrc

Paso 4 – Crear directorios de datos

Crea un directorio para padloc.

$ mkdir ~/padloc

Cambia al directorio de padloc.

$ cd ~/padloc

Crea directorios para la base de datos de usuarios, los registros de la aplicación, los archivos adjuntos, la aplicación PWA y la configuración SSL.

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

Crea un directorio para los registros de Nginx.

$ mkdir logs/nginx

Paso 5 – Crear el archivo Docker Compose

Crea y abre el archivo ~/padloc/docker-compose.yml para editarlo.

$ nano docker-compose.yml

Pega en él el siguiente código.

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

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida.

Vamos a utilizar tres imágenes Docker para Padloc.

1. La imagen del servidor: contiene toda la lógica del backend de la aplicación. Se ejecuta en el puerto 3000 por defecto. Hemos descomentado la variable ports en nuestro archivo de composición para que el puerto sea invisible para el servidor. En su lugar, utilizamos la variable expose para exponer el puerto dentro del motor Docker al contenedor Nginx. Las variables de entorno de la imagen se configurarán más adelante. También hemos mapeado directorios para una base de datos de usuarios, archivos adjuntos y registros de la aplicación.

2. La imagen PWA – contiene el frontend de la aplicación. Se ejecuta en el puerto 8080 por defecto. En cuanto a la imagen del servidor, hemos ocultado la sección de puertos para esta imagen y hemos expuesto el puerto dentro del motor Docker. Hemos mapeado el directorio para la aplicación web.

3. La imagen Nginx – contiene la aplicación del servidor Nginx. Hemos asignado los puertos para HTTP(80) y HTTPS(443) al servidor para que sea accesible desde el exterior. Hemos mapeado varios directorios y archivos para que funcione.

   • El primer archivo es nginx.conf que contiene todas las configuraciones principales para que Nginx sirva la aplicación padloc.
   • Los dos siguientes archivos, cert.pem y key.pem son el certificado SSL y las claves que generaremos con Let’s encrypt.
   • El archivo ssl.conf contiene información adicional sobre el servicio de SSL a través de Nginx.
   • El archivo dhparam.pem es para servir el certificado de grupo Diffie-Hellman.
   • La última entrada es para mapear los registros de Nginx de vuelta al servidor para que puedas acceder a ellos fuera de Docker.

4. La bandera :Z al final de los mapeos de carpetas indica que esos directorios sólo serán accesibles desde los respectivos contenedores. Esto se hace porque SELINUX está activado en nuestro servidor. Si no utilizas SELinux, puedes eliminar la bandera.

Paso 6 – Configurar NGinx

Crea y abre el archivo ~/padloc/nginx.conf para editarlo.

$ nano nginx.conf

Pega en él el siguiente código.

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

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando te lo pida.

La configuración anterior reenvía todas las peticiones realizadas desde el contenedor padloc_server a la ubicación /server del nombre de dominio y cualquier petición realizada desde el contenedor padlock_pwa a la raíz. También redirige todo el tráfico HTTP a HTTPS. También hemos establecido el tamaño de subida de archivos a 10 MB para los adjuntos. Puedes cambiar el tamaño según tus necesidades. La configuración SSL se ha incluido a través de un archivo externo que configuraremos más adelante.

Paso 7 – Crear el archivo de entorno

Crea y abre el archivo ~/padloc/.env para editarlo.

$ nano .env

Pega en él el siguiente código.

# 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
[email protected]
# 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
[email protected]

# 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

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida. La mayoría de los ajustes se explican por sí mismos. La configuración existente de Nginx espera que la aplicación se sirva a través del dominio principal y el servidor a través del directorio /server. El PL_PWA_DIR no es obligatorio configurarlo aquí y en el archivo Docker-compose, pero tenerlo acelera el arranque del contenedor y, por tanto, deberías configurarlo siempre.

Padloc requiere la capacidad de enviar correos electrónicos para funciones como la verificación de nuevos usuarios, la autenticación de dos factores y el restablecimiento de contraseñas. Por lo tanto, los datos SMTP son obligatorios.

Para la función SSL, utilizamos los directorios por defecto de Let’s Encrypt donde se encuentran los certificados. La configuración adicional de SSL se proporcionará a través del archivo /ssl/ssl.conf.

Paso 8 – Instalar SSL

Para instalar un certificado SSL utilizando Let’s Encrypt, necesitamos instalar la herramienta Certbot.

En primer lugar, necesitas descargar e instalar el repositorio EPEL.

$ sudo dnf install epel-release

Ejecuta los siguientes comandos para instalar Certbot.

$ sudo dnf install certbot

Generar el certificado SSL.

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

El comando anterior descargará un certificado en el directorio /etc/letsencrypt/live/example.com de tu servidor.

Genera un certificado de grupo Diffie-Hellman.

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

Crea un Cron Job para renovar el SSL. Se ejecutará cada semana para comprobar el certificado y renovarlo si es necesario. Para ello, primero crea el archivo /etc/cron.weekly/certbot-renew y ábrelo para editarlo.

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

Pega el siguiente código. Utilizamos los comandos Docker para iniciar, detener y reiniciar el contenedor Nginx en función del estado de renovación.

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

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando te lo pida.

Cambia los permisos del archivo de la tarea para que sea ejecutable.

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

Paso 9 – Configurar el SSL

Crea y abre el archivo ~/padloc/ssl/ssl.conf para editarlo.

$ nano ssl/ssl.conf

Pega en él el siguiente código.

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;

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida.

El archivo anterior introduce algunas configuraciones SSL recomendadas para que tu sitio sea más seguro. Restringe los protocolos TLS a las versiones v1.2 y v1.3 y activa el engrapado y la verificación del Protocolo de Estado de los Certificados en Línea (OCSP).

Paso 10 – Ejecuta Padloc

Ahora que has configurado todo, ejecuta Padloc con el siguiente comando.

$ docker-compose up -d

Comprueba el estado de los contenedores.

$ docker ps

Deberías obtener una salida similar.

Paso 11 – Accede y configura Padloc

Abre la URL https://example.com en tu navegador, y llegarás a su página de acceso.

Haz clic en el enlace Regístrate ahora para iniciar el registro.

Introduce tu nombre y dirección de correo electrónico, y pulsa el botón Continuar para seguir adelante.

Padloc te enviará un correo electrónico con un código de confirmación. Introduce el código de confirmación en la casilla de arriba y pulsa Continuar para seguir adelante.

Padloc generará automáticamente una contraseña maestra para ti. Pasa el ratón por encima de la casilla y cópiala. Pégala de nuevo en la casilla de abajo. También puedes elegir utilizar tu contraseña. Pulsa Continuar cuando hayas terminado.

Accederás a la página web de Padloc. Puedes empezar a guardar tus datos de acceso y documentos sensibles.

Paso 12 – Actualizar el Padloc

Actualizar el Padloc es un proceso de dos pasos. En primer lugar, pasa al directorio del Padloc.

$ cd ~/padloc

Apaga y elimina los contenedores de Padloc existentes.

$ docker-compose down --remove-orphans

Saca las últimas imágenes.

$ docker-compose pull

Vuelve a arrancar los contenedores.

$ docker-compose up -d

Conclusión

Con esto concluye nuestro tutorial sobre la instalación del gestor de contraseñas Padloc Self-hosted en un servidor Rocky Linux 8. Si tienes alguna pregunta, publícala en los comentarios de abajo.