Authelia: Configuración con 2FA, LDAP, SSO e integración con Nginx Proxy Manager

La siguiente guía es de aquellas que ha costado elaborar hasta llegar a que todo funcione como debería. Con más motivo, me anima a compartirla con el resto de usuarios y de esta manera brindar la opción de poder aumentar la seguridad al acceder a nuestros servicios de Docker.

En el mundo de los contenedores existe una interminable amplitud de servicios, y es más que probable que que muchas de ellas no cuenten con autentificación de usuario y mucho menos 2FA, y aquí es donde entra en juego Authelia.

Con vemos en la demo de arriba, Authelia nos permitirá añadir un sistema de autentificación antes de acceder a cualquier servicio. En definitiva, podremos añadir una capa de seguridad extra, la cual nos va a permitir tres opciones:

1. Autentificación de 1 factor: Acceso mediante usuario y contraseña.
2. Autentificación de 2 factores (2FA): Accedo mediante 1 factor + código QR.
3. Bypass: No nos pedirá autentificación alguna.

Una vez que hayamos escogido que sistema de autentificación queremos para nuestro servicio, podemos limitar el acceso mediante:

1. Rangos de IP
2. Subdominios o dominios en concreto
3. Limitando o permitiendo acceso en Red Local o Externa
4. Según qué usuarios / grupos

Como podéis ver, las opciones de configuración son muy extensas. Y nos permite infinidad de combinaciones para cada uno de los servicios. En esta guía vamos a aprender a ponerlo todo en marcha.

Gracias a la utilización de LDAP, podremos tener SSO (inicio de sesión único). Es decir, con un único usuario podremos acceder o no, a todos los servicios que configuremos Authelia.

Además, podremos crear nuevos usuarios o grupo de usuarios cómodamente desde Synology para posteriormente restringir o permitir el acceso a los servicios. Por ejemplo: el usuario Pepito tendrá que usar autentificación 2FA para acceder a Plex, pero el usuario Maria no. Todas estas opciones y muchas más nos permite Authelia jugando con sus opciones de configuración.

Vamos a ello, para instalar el Servidor LDAP nos iremos a: Centro de paquetes y buscamos LDAP Server. Procedemos a instalarlo y vamos a configurarlo.

Abrimos la aplicación LDAP Server y en la pestaña Configuración, haremos clic en la casilla Habilitar servidor LDAP .

En la casilla FQDN introducimos el nombre de nuestro dominio principal y le asignamos una contraseña maestra al administrador.

Seguidamente, hacemos clic en Aplicar. En la parte inferior nos aparecerá en información de autenticación su Base DN y Bind DN, los necesitaremos más adelante para habilitar LDAP en Authelia.

Por último nos vamos a la pestaña Administrar usuarios y nos aseguramos que el usuario tiene una dirección de email válida. Nos hará falta para activar el 2FA.

Una vez tenemos el LDAP configurado en nuestro NAS, es hora de instalar toda la maquinaria que hay detrás de Authelia para su correcto funcionamiento.

Portainer: Guía de instalación y configuración

Herramienta estrella para la creación y gestión de Docker.

HDS+Joan Romero

Los primeros contenedores que nos harán falta para levantar Authelia es una base de datos MySQL y acceso a phpMyAdmin para la creación de la misma.

Primero crearemos una carpeta en /volume1/docker/ con el nombre de sql. Seguidamente crearemos y ejecutaremos el siguiente Stack en Portainer.

version: "3.5"

services:
  mysql:
    image: mysql:latest
    network_mode: "bridge"
    container_name: mysql
    volumes:
      - "/volume1/docker/sql:/var/lib/mysql"
    environment:
      - "MYSQL_ROOT_PASSWORD=my-secret-pw" #asignamos una password
    ports:
      - "3306:3306"
    restart: always
  
  phpmyadmin:
    image: phpmyadmin/phpmyadmin:latest
    network_mode: "bridge"
    container_name: phpmyadmin
    ports:
      - "6080:80"
    environment:
      - "PMA_PORT=3306"
      - "PMA_HOST=NASIP" #cambia el valor por la IP local de nuestro NAS
    restart: always

Una vez hayamos ejecutado el Stack entramos a phpMyAdmin mediante: http://IPNAS:6080 y deberíamos acceder correctamente.

Una vez dentro, crearemos una nueva base de datos con el nombre de authelia y con el formato utf8_bin. A continuación, necesitamos una cuenta de usuario con permisos asociada a la base de datos. Nos vamos a la pestaña Privilegios y, en la parte inferior, seleccione Agregar cuenta de usuario.

Establezca un nombre de usuario , contraseña, así como otorgar todos privilegios en la parte inferior y aplicamos para guardar los cambios.

Además de una base de datos, también necesitaremos REDIS, para ello ejecutamos el siguiente Stack en Portainer:

version: "3.5"

services:
  redis:
    image: redis:latest
    network_mode: "bridge"
    container_name: redis
    volumes:
      - "/volume1/docker/redis:/data" # change the local path to your NAS location where you want the DB data to live
    ports:
      - "6379:6379"
    restart: always

Una vez instalado, abrimos el Terminal de nuestro PC/Windows y nos conectamos vía SSH a nuestro NAS y ejecutamos los siguientes comandos:

docker exec -it redis /bin/bash

cd ..
chmod 777 -R /data
chmod 777 -R /etc

Ya tenemos todos los contenedores previos necesarios, ahora nos falta la parte más importante, y es la configuración e instalación de Authelia.

Lo primero que haremos será crear una nueva carpeta en /volume1/docker/ con el nombre de authelia .

A continuación nos descargamos la plantilla de configuración que he personalizado y la abrimos con un editor de texto válido como Brackets o Notepad++ para poder modificarlo.

Vamos a editar únicamente las partes que muestro a continuación para que podáis adaptarlo a vuestro caso.

.
.
.
jwt_secret: xxxxxxxxxxxx # Generar una key larga random de seguridad
.
default_redirection_url: https://auth.MIDOMINIO.com 
.
.
totp:
  issuer: midominio.com # Introduce tu dominio
.
.
.
authentication_backend:  
  ldap:
    implementation: custom
    url: ldap://yourNASIP # Introduce la IP local de nuestro NAS
    start_tls: false
    base_dn: dc=midominio,dc=com # Base DN de nuestro LDAP
    additional_users_dn: cn=users
    additional_groups_dn: cn=groups
    groups_filter: (&(uniquemember={dn})(objectclass=groupOfUniqueNames))
    user: uid=admin,cn=users,dc=midominio,dc=com # Valores Bind DN
    password: xxxxxxxxxxx # Contraseña maestra del Servidor LDAP (NAS)
.
.
.
access_control:
  default_policy: deny
  rules:
    - domain: 
        - "demo1.midominio.com"
        - "auth.midominio.com"
        - "demo2.midominio.com"
      policy: bypass
    - domain:
        - "*.midominio.com"
        - "midominio.com"
      policy: two_factor
.
.
.
session:
  name: authelia_session
  domain: midominio.com # Introducimos nuestro dominio
  same_site: lax
  secret: xxxxxxxx # Generar una key larga random de seguridad
.
.
.
  redis:
    host: NASIPAddres # Introducimos la IP local de nuestro NAS
    port: 6379
    database_index: 0
.
.
.
storage:
  mysql:
    host: yourNASIP # Introducimos la IP local de nuestro NAS
    port: 3306
    database: authelia
    username: authelia_user # Nuestro usuario de MySQL 
    password: xxxxxxxxxxxx # Nuestra contraseña de MySQL 
.
.
notifier:  
  smtp:
    username: usernameOfYourMail
    password: xxxxxx
    host: smtp.gmail.com 
    port: 587
    sender: sender@domain.com

Una vez lo hemos modificado, lo guardamos y lo subimos a: /volume1/docker/authelia/ .

Por poner otro ejemplo, si quisiéramos que para acceder a Plex nos pida autentificación 2FA solo al usuario pepito , lo haríamos de la siguiente manera:

 - domain: plex.midominio.com
      subject: "user:pepito"
      policy: two_factor

Autenticarse con usuario y contraseña en lugar de LDAP

Para aquellos usuarios que no quieran utilizar LDAP, pueden iniciar sesión en Authelia con un nombre y usuario. Para ello, nos bajamos el siguiente fichero y lo subimos dentro de la carpeta "authelia" que hemos creado anteriormente.

Después, en el archivo configuration.yml tendremos que suprimir el apartado de LDAP y lo especificaremos de la siguiente manera:

authentication_backend:
  password_reset:
    disable: false
  refresh_interval: 5m
  file:
    path: /config/users_database.yml 
    password:
      algorithm: argon2id
      iterations: 1
      key_length: 32
      salt_length: 16
      memory: 1024
      parallelism: 8

Dentro del fichero users_database.yml se tendrán que especificar los usuarios.

Para la creación de la contraseña se incluyen las instrucciones en el mismo fichero también.

Antes de seguir, deberemos de acceder a NPM y añadir el nuevo subdominio a nuestro Proxy Inverso y lo dejamos configurado de la siguiente manera. Activando las opciones Cache Assets y Block Common Exploits. Y apuntando la IP local del NAS al puerto donde ejecutaremos Authelia.

En la pestaña SSL crearemos un nuevo certificado y para finalizar, en la pestaña Advanced copiaremos el siguiente código:

     location / {
        set $upstream_authelia http://IPNAS:9091; 
        proxy_pass $upstream_authelia;
        client_body_buffer_size 128k;
 
        #Timeout if the real server is dead
        proxy_next_upstream error timeout invalid_header http_500 http_502 http_503;
 
        # Advanced Proxy Config
        send_timeout 5m;
        proxy_read_timeout 360;
        proxy_send_timeout 360;
        proxy_connect_timeout 360;
 
        # Basic Proxy Config
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-Host $http_host;
        proxy_set_header X-Forwarded-Uri $request_uri;
        proxy_set_header X-Forwarded-Ssl on;
        proxy_redirect  http://  $scheme://;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_cache_bypass $cookie_session;
        proxy_no_cache $cookie_session;
        proxy_buffers 64 256k;
 
        # If behind reverse proxy, forwards the correct IP
        set_real_ip_from 10.0.0.0/8;
        set_real_ip_from 172.0.0.0/8;
        set_real_ip_from 192.168.0.0/16;
        set_real_ip_from 192.168.1.0/16;
        set_real_ip_from fc00::/7;
        real_ip_header X-Forwarded-For;
        real_ip_recursive on;
    }

Ya estamos en el último paso del tutorial. Como siempre, crearemos otro Stack en Portainer con el siguiente Compose:

version: "3.5"

services:
  authelia:
    image: authelia/authelia
    network_mode: "bridge"
    container_name: authelia
    ports:
      - "9091:9091"
    volumes:
      - "/volume1/docker/authelia/:/config/"
    restart: always

Una vez ejecutado, si hemos configurado correctamente el configuration.yml, deberemos de poder acceder mediante: http://IPNAS:9091 . Introducimos el usuario de nuestro servidor LDAP y su contraseña para comprobar que funciona y seremos redirigidos a https://auth.midominio.com

Ya tenemos Authelia funcionando correctamente, y aunque en el archivo de configuración hayamos especificado que dominios o subdominios cumplan las reglas de bypass, one_factor o two_factor, hemos de indicarlo también en el NGINX Proxy Manager para que nos funcione.

Para ello tomaré como ejemplo el servicio Umami. Dentro de NPM me iré a las opciones de este Proxy Inverso y en la pestaña Advanced copiaré el siguiente código:

location /authelia {
    internal;
    set $upstream_authelia http://192.168.1.30:9091/api/verify; 
    proxy_pass_request_body off;
    proxy_pass $upstream_authelia;    
    proxy_set_header Content-Length "";
 
    # Timeout if the real server is dead
    proxy_next_upstream error timeout invalid_header http_500 http_502 http_503;
    client_body_buffer_size 128k;
    proxy_set_header Host $host;
    proxy_set_header X-Original-URL $scheme://$http_host$request_uri;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $remote_addr; 
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header X-Forwarded-Host $http_host;
    proxy_set_header X-Forwarded-Uri $request_uri;
    proxy_set_header X-Forwarded-Ssl on;
    proxy_redirect  http://  $scheme://;
    proxy_http_version 1.1;
    proxy_set_header Connection "";
    proxy_cache_bypass $cookie_session;
    proxy_no_cache $cookie_session;
    proxy_buffers 4 32k;
 
    send_timeout 5m;
    proxy_read_timeout 240;
    proxy_send_timeout 240;
    proxy_connect_timeout 240;
}
 
    location / {
        set $upstream_homer http://192.168.1.30:3999;  
        proxy_pass $upstream_homer;  #cambiar nombre servicio
 
		auth_request /authelia;
		auth_request_set $target_url $scheme://$http_host$request_uri;
		auth_request_set $user $upstream_http_remote_user;
		auth_request_set $groups $upstream_http_remote_groups;
		proxy_set_header Remote-User $user;
		proxy_set_header Remote-Groups $groups;
		error_page 401 =302 https://auth.hdsplus.co/?rd=$target_url; 
 
		client_body_buffer_size 128k;
 
		proxy_next_upstream error timeout invalid_header http_500 http_502 http_503;
 
		send_timeout 5m;
		proxy_read_timeout 360;
		proxy_send_timeout 360;
		proxy_connect_timeout 360;
 
		proxy_set_header Host $host;
		proxy_set_header X-Real-IP $remote_addr;
		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
		proxy_set_header X-Forwarded-Proto $scheme;
		proxy_set_header X-Forwarded-Host $http_host;
		proxy_set_header X-Forwarded-Uri $request_uri;
		proxy_set_header X-Forwarded-Ssl on;
		proxy_redirect  http://  $scheme://;
		proxy_http_version 1.1;
		proxy_set_header Connection "";
		proxy_cache_bypass $cookie_session;
		proxy_no_cache $cookie_session;
		proxy_buffers 64 256k;
 
		set_real_ip_from 192.168.1.0/16;
		real_ip_header X-Forwarded-For;
		real_ip_recursive on;
 
    }

Deberás de modificar cuatro valores:

1. set $upstream_authelia : Especificaremos la IP local de nuestro NAS.
2. set $upstream_homer : Especificaremos la IP local del NAS y el puerto del servicio, así como cambiar 'homer' por el nombre que le demos al servicio que estemos configurando.
3. proxy_pass $upstream_homer : Cambiaremos homer por un nombre que queramos para identificar el servicio.
4. set_real_ip_from : Cambiamos el rango de IPs, al asociado al de nuestro NAS.

Ya lo tendremos todo configurado. Si hemos hecho bien todo el proceso, si accedemos a https://umami.midominio.com (o al servicio que hayamos probado de configurar primero) nos redirigirá a la pantalla de Authelia en la cual nos pedirá la autentificación para acceder al servicio en cuestión.

Como hemos visto anteriormente, para aquellos servicios que hayamos escogido la autentificación por doble factor (2FA), además de introducir el usuario y contraseña, nos pedirá registrar un nuevo dispositivo el cual irá asociada la autentificaicón mediante un código QR.