Zwei-Faktor-Authentifizierung mit Authelia

Autor / Redakteur: Mirco Lang / Stephan Augsten

2FA und TOTP, sprich Zwei-Faktor-Authentifizierung und Time-based One-time Password, sind bei Internet-Logins längst Standard – etwa beim Bezahlen im Netz. Mit Authelia lassen sich Web Apps sehr einfach schützen, auch mit Security Key oder nur per Passwort.

Firmen zum Thema

Mit Authelia lässt sich der Login recht einfach um eine Zwei-Faktor-Authentifizierung erweitern.
Mit Authelia lässt sich der Login recht einfach um eine Zwei-Faktor-Authentifizierung erweitern.
(© Song_about_summer - stock.adobe.com)

Faktor 1: Nutzername und Passwort.
Faktor 1: Nutzername und Passwort.
(Bild: Lang / Authelia)

Faktor 2: TOTP aus dem Google Authenticator.
Faktor 2: TOTP aus dem Google Authenticator.
(Bild: Lang / Authelia)

Auch YubiKey-USB-Sticks können als zweiter Faktor dienen.
Auch YubiKey-USB-Sticks können als zweiter Faktor dienen.
(Bild: Lang / Authelia)

Das bei GitHub gehostete Open-Source-Projekt Authelia, ist eine gute Anlaufstelle für 2FA. Es ist sehr aktiv, ordentlich dokumentiert, bietet einfache Einstiegsmöglichkeiten und unterstützt zwei der wichtigsten Clients zur Authentifizierung: das TOTP-Verfahren mit Google Authenticator sowie den Universal Second Factor (U2F) der YubiKey-USB-Sticks. Auch die Authentifizierung via Push-Mitteilungen über die Plattform Duo ist möglich.

Generell ist Authelia aktuell ein recht kleines Projekt mit drei Kernentwicklern und ohne unternehmerischen Hintergrund. Noch läuft die Authentifizierung über HTTP-Header, geplant ist aber auch der Weg über OpenID Connect. Auch grafische Backends für die Administration fehlen bislang.

Gerade durch diesen eher schlanken Funktionsumfang eignet sich Authelia allerdings perfekt für den 2FA-Einstieg. Auch für den produktiven Schutz Ihrer Webanwendungen ohne großen Aufwand bietet sich das Programm an, insbesondere in der Welt der Docker-Container. Ein containerisierter Webserver etwa lässt sich in einer halben Stunde absichern.

Im Folgenden geben wir zunächst einen kurzen Überblick über die Funktionsweise von Authelia. Dann zeigen wir anhand der einfachsten mitgelieferten Einrichtung auf Basis von Docker-Compose-Vorlagen, wie Sie eine beliebige Container-Anwendung schützen – am Beispiel des typischen httpd-Containers, also eines Apache-Servers.

Funktionsweise

Authelia-Architektur: Reverse Proxies als Vermittler.
Authelia-Architektur: Reverse Proxies als Vermittler.
(Bild: Authelia)

Authelia arbeitet mit Reverse Proxies zusammen, dokumentiert sind Traefik, Nginx und HAProxy. Anfragen, die über die Proxy-Server an einen Dienst gestellt werden, werden entsprechend an Authelia weitergeleitet. Authelia bestimmt dann, ob die Anfrage blockiert oder weitergeleitet wird. Wird sie wegen unzureichender Authentifizierung blockiert, landet der Nutzer auf einer Login- bzw. Registrierungsseite – Authelia läuft nämlich als sehr simples Webportal.

Authelia kann dabei auf drei Arten reagieren: Die Policy „bypass“ umschifft jegliche Authentifizierung, mit „one_factor“ wird ein Login mit Nutzername und Passwort erforderlich und „two_factor“ verlangt schließlich nach einem zusätzlichen zweiten Faktor. Die Registrierung dieses zweiten Faktors geschieht direkt über die Login-Seite, die Authelia bereitstellt.

Wie bereits erwähnt, gibt es keinerlei grafische Verwaltungsoberflächen. Nutzer können über eine externe Datenbank, LDAP oder ganz schlicht in einer puren Textdatei gepflegt werden, in der im Wesentlichen Nutzername und (gehashtes) Passwort hinterlegt werden. Authelia ist als Paket für Arch und FreeBSD, als Binary und natürlich für Docker direkt und Kubernetes verfügbar. Eine lauffähige lokale Testinstallation via Docker gelingt tatsächlich mit nur drei Zeilen.

Authelia aufsetzen

Authelia liefert zwei Docker-Compose-Konfigurationen aus: Local und Lite. Local ist dabei als Demoanwendung gedacht und erledigt die notwendigen Einstellungen über ein simples Installationsskript – und das ist auch der beste Einstieg, wenn man sich anschließend anschaut, welche Inhalte in welchen Dateien welche Aufgaben übernehmen.

Installieren Sie zunächst Docker und Docker Compose. Stand heute installieren Sie beides samt Abhängigkeiten etwa unter Ubuntu mit folgenden Befehlen:

sudo apt-get install apt-transport-https ca-certificates curl gnupg-agent software-properties-commoncurl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release - cs) stable"sudo apt-get updatesudo apt-get install docker-ce docker-ce-cli containerd.iocurl -L "https://github.com/docker/compose/releases/download/1.28.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-composesudo chmod +x /usr/local/bin/docker-compose

Die Installation und Einrichtung von Authelia beschränkt sich nun auf folgende drei Zeilen:

git clone https://github.com/authelia/authelia.gitcd authelia/compose/localsudo ./setup.sh

Das Skript legt einen Nutzer an sowie drei zu schützende Domains:

  • public.example.com – leitet ohne Authentifizierung auf eine WhoAmI-Anwendung weiter.
  • traefik.example.com – leitet auf das Traefik-Dashboard mit Passwort-Login weiter.
  • secure.example.com – leitet ebenfalls auf die Login-Seite weiter, verlangt aber nach einem zweiten Faktor.

Da alles über HTTPS läuft: Beim ersten Besuch einer der Domains müssen Sie im Browser die Warnmeldung bezüglich eines unsicheren Zertifikats übergehen – schließlich handelt es sich hier um selbstsignierte Zertifikate.

Auf der secure.example.com können Sie nun ein Gerät registrieren. Wählen Sie hier einfach TOTP und scannen Sie den QR-Code mit der Google-Authenticator-App auf dem Smartphone. Zur Bestätigung müssten Sie nun eigentlich einen Link in einer Mail anklicken.

Da es sich aber um eine Testinstallation mit example.com-Domain handelt, finden Sie den Link in der Datei „authelia/compose/local/authelia/notification.txt“. Wenn Sie diesen im Browser aufrufen, müssen und können Sie erstmalig den TOTP-Code eingeben, den Google Authenticator im 30-Sekunden-Takt neu generiert.

Was ist passiert?

Das Test-Installationsskript macht die Sache einfach, aber natürlich auch ein wenig undurchsichtig. Letztlich ist aber sehr übersichtlich, was hier genau passiert:

  • Der Nutzer wird in der Datei user_database.yml eingetragen.
  • Die hosts-Datei leitet die drei example.com-Domains auf 127.0.0.1 um.
  • Authelias configuration.yml setzt die Policies für die Domains.
  • Die docker-compose.yml-Konfiguration startet und konfiguriert Authelia, Traefik und Whoami.

Nutzerdatenbank und hosts-Datei sind selbsterklärend, hier können Sie nach Belieben Domains und Nutzer eintragen.

Interessanter ist die Datei „authelia/compose/local/authelia/configuration.yml“, die pro geschützer Domain/Anwendung lediglich zwei spezifische Zeilen enthält:

-domain: secure.example.com
policy: two_factor

Auch hier können Sie wieder eigene Domains und zugehörige Policies nachtragen.

Die meiste Arbeit steckt freilich in der Datei „docker-compose.yml“. Diese startet neben Authelia selbst noch Redis als simple Speicherlösung für Sessions. Vor allem aber werden hier die einzelnen Services definiert, also beispielsweise der WhoAmI-Container, der über „secure.example.com“ ausgeliefert und über die Policy „two_factor“ geschützt wird:

   secure:
   image: whoami
   container_name: secure
   networks:
      - net
   labels:
      - 'traefik.enable=true'
      - 'traefik.http.routers.secure.rule=Host(`secure.example.com`)'
      - 'traefik.http.routers.secure.entrypoints=https'
      - 'traefik.http.routers.secure.tls=true'
      - 'traefik.http.routers.secure.tls.options=default'
      - 'traefik.http.routers.secure.middlewares=authelia@docker'
   expose:
      - 80
   restart: unless-stopped

Wenn Sie sich die Einträge der sonstigen Services der local-Beispielkonfiguration anschauen, sehen Sie, dass sich letztlich nur Image, Container-Name und gegebenenfalls der Port unterscheiden. Das gesamte Routing über den Reverse Proxy, standardmäßig Traefik, wird schlicht über die Labels konfiguriert.

Und genau zeigt sich die Einfachheit von Authelia: Sie können hier schlicht und einfach „whoami“ durch zum Beispiel „httpd“ ersetzen – und schon würde beim nächsten Compose-Durchlauf der Apache-Server-Container gestartet und per 2FA geschützt. Dafür wäre natürlich noch der letzte Befehl des Installationsskripts manuell zu wiederholen:

sudo docker-compose up -d

Im Browser werden Sie tendenziell nur eine Fehlermeldung sehen – die beim ersten Besuch aktzeptierten selbstsignierten Zertifikate für die HTTPS-Aufrufe müssen zunächst aus dem Browser gelöscht werden.

Neben dieser local-Beispielkonfiguration liefert Authelia für das Deployment noch die lite-Konfiguration, die für eine Single-Server-Umgebung empfohlen wird. Hier gibt es dann kein Installationsskript – aber es werden wieder nur die drei Dateien user_database.yml, configuration.yml und docker-compose.yml editiert.

Zwei größere Unterschiede gibt es zur local-Variante: Statt selbstsignierte Zertifikate für den lokalen LAN-Betriebe werden automatisch LetsEncrypt-Zertifikate konfiguriert und die Weiterleitungen laufen natürlich nicht über die lokale hosts-Datei, diese müssen Sie selbst setzen.

Erst wenn Authelia ordentlich skalieren soll, müssen Sie ein wenig mehr Arbeit investieren. Im Wesentlichen würden noch LDAP und eine größere SQL-Speicherlösung hinzukommen. Andererseits: Viel Aufwand ist auch das nicht, die Standardlösung ist SQLite und dessen Konfiguration beschränkt sich auf …

storage:
   local:
   path: /config/db.sqlite3

… in Authelias configuration.yml – für einen MySQL-Server müssten lediglich dessen Zugangsdaten eingetragen werden.

Authelia ist eine schlanke und sehr gut nachvollziehbare 2FA-Lösung. Wenn Sie 2FA beispielsweise rein intern zur Absicherung kritischer Eigenentwicklungen nutzen möchten, könnten Sie dies wohl problemlos an einem Tag erledigen. Nun, zumindest, wenn Sie das rasende Container-Schiff nicht verpasst haben.

(ID:47284897)

Über den Autor

 Mirco Lang

Mirco Lang

Freier Journalist & BSIler