Um einen sicheren Zugriff auf SmartHomeNG und die smartVISU von außen (ohne VPN) zu ermöglichen, empfiehlt es sich, die Software NGINX als ReverseProxy mit Basic Authentication oder Clientzertifikaten zu nutzen.

Die Idee hinter einem ReverseProxy ist, dass man einen einzigen sicheren Eintrittspunkt in das Heimnetzwerk hat, ohne ein VPN nutzen zu müssen. Der ReverseProxy hängt direkt hinter dem Router und wird von dort via Portforwarding angesprochen. Üblicherweise wird der HTTPS Port 443 vom Router auf den ReverseProxy umgeleitet. Für die Installation ist temporär auch der HTTP Port 80 notwendig, damit ein SSL Serverzertfikat, bspw. von Let’s Encrypt, für die hinterlegte DynDNS URL installiert werden kann.

Im ReverseProxy kann ein Zugriffsschutz implementiert werden, der via Basic Authentication oder Clientzertifikate realisiert wird. Beides wird in diesem Artikel erklärt. Es wird zudem auf weitere Sicherheitsmaßnahmen, wie das Blockieren von Requests aus nicht vertrauenswürdigen Ländern, eingegangen.

Je nach angesprungenem Kontextpfad (also bspw. /smartVISU oder /alexa) wird dann in Richtung des Hauptservers und des jeweiligen Ports weitergeleitet. Das folgende Bild illustriert das schematisch:

Die folgende Dokumentation beschreibt eine Installation von NGINX als ReverseProxy auf eigenständiger Hardware unter Raspbian Stretch Lite. Dieser ReverseProxy ist bspw. auch für das Alexa Plugin oder die Nutzung von SmartHomeNG mit „EgiGeoZone“ / „Geofency“ notwendig, damit ein sicherer Zugriff aus dem Internet auf die SmartHomeNG Instanz erfolgen kann.

Annahmen

Diese Anleitung beruht auf folgenden Annahmen

  • NGINX wird auf einem frisch aufgesetzten RaspberryPi mit „Raspbian Stretch Lite“ installiert.
  • Der RaspberryPi dient ausschliesslich der Funktion als ReverseProxy
  • Der Standarduser heißt weiterhin „pi“
  • Eine DynDNS (o.ä.) Domain ist vorhanden und leitet auf die aktuelle Internet IP
  • SmartHomeNG und smartVISU sind auf einem separaten Rechner im gleichen LAN installiert.

Basiskonfiguration

  • Deutsches Keyboard festlegen: /etc/default/keyboard editieren und in der Zeile XKBLAYOUT="..." ein „de“ eintragen. Danach sudo reboot now eingeben, um neu zu starten.
  • Aus Sicherheitsgründen das Standard-Passwort für „pi“ ändern: Als User „pi“ mit Standard-Passwort einloggen und mit passwd ein neues Passwort setzen.

NGINX installieren:

sudo apt-get update
sudo apt-get install nginx-full

GeoIP installieren:

Über GeoIP kann mittels der anfragenden IP herausgefunden werden, aus welchem Land eine Anfrage kommt. Darüber lassen sich bspw. Requests aus Risikoländern blockieren.

sudo apt-get install geoip-database libgeoip1
cd /usr/share/GeoIP/
sudo wget http://geolite.maxmind.com/download/geoip/database/GeoLiteCountry/GeoIP.dat.gz
sudo gunzip GeoIP.dat.gz

Let’s Encrypt Server-Zertifikate

(nach https://goneuland.de/debian-9-stretch-lets-encrypt-zertifikate-mit-certbot-erstellen/)

Über Let’s Encrypt lassen sich kostenlos SSL Zertifikate, bspw. für dyndns-Domains, ausstellen.

Certbot installieren:

sudo apt-get install certbot

Nun die Datei /etc/nginx/snippets/letsencrypt.conf bearbeiten:

sudo nano /etc/nginx/snippets/letsencrypt.conf

Dort folgenden Inhalt einfügen, damit certbot die Identität überprüfen kann.:

location ^~ /.well-known/acme-challenge/ {
 default_type "text/plain";
 root /var/www/letsencrypt;
}
sudo mkdir -p /var/www/letsencrypt/.well-known/acme-challenge
sudo nano /etc/nginx/sites-available/default

Dort unterhalb von listen [::]:80 default_server; die Zeile include /etc/nginx/snippets/letsencrypt.conf; einhängen:

server {
        listen 80 default_server;
        listen [::]:80 default_server;
        include /etc/nginx/snippets/letsencrypt.conf;
[...]
sudo service nginx restart

Temporär Port 80 im Router auf den RaspberryPi weiterleiten !

sudo certbot certonly --rsa-key-size 4096 --webroot -w /var/www/letsencrypt -d <mydomain>.<myds>.<me> 

Nachdem man seine E-Mail eingegeben hat, sollte die Generierung erfolgreich durch laufen und mit

Generating key (4096 bits): /etc/letsencrypt/keys/0000_key-certbot.pem
Creating CSR: /etc/letsencrypt/csr/0000_csr-certbot.pem

enden.

Port 80 im Browser wieder schließen, dafür Port 443 (https) entsprechend auf den ReverseProxy-RaspberryPi weiterleiten!

NGINX Konfiguration

/etc/nginx/nginx.conf bearbeiten und direkt im „http“ Block die GeoIP Einstellungen hinzufügen. Unter der Konfiguration der „virtual hosts“ noch einen Block als Schutz gegen Denial of Service Angriffe ergänzen:

http {
    ##
    # GeoIP Settings
    # Nur Länder aus erlaubten IP Bereichen dürfen den ReverseProxy
    # passieren!
    # https://www.howtoforge.de/anleitung/nginx-besucher-mit-dem-geoip-modul-nach-landern-blocken-debianubuntu/
    ##
    geoip_country /usr/share/GeoIP/GeoIP.dat;
    map $geoip_country_code $allowed_country {
        default yes;
        BY no;
        BR no;
        KP no;
        KR no;
        RS no;
        RO no;
        RU no;
        CN no;
        CD no;
        NE no;
        GH no;
        IQ no;
        IR no;
        SY no;
        UA no;
    }
[...]
    ##
    # Virtual Host Configs
    ##

    include /etc/nginx/conf.d/*.conf;
    include /etc/nginx/sites-enabled/*;

    ##
    # Harden nginx against DDOS
    ##

    client_header_timeout 10;
    client_body_timeout   10;
}

NGINX mit sudo service nginx restart neu starten.

/etc/nginx/conf.d/<mydomain>.<myds>.<me>.conf erstellen

server {
    server_tokens off;
    
    ## Blocken, wenn Zugriff aus einem nicht erlaubten Land erfolgt ##
    if ($allowed_country = no) {
        return 403;
    }    
    
    # https://www.cyberciti.biz/tips/linux-unix-bsd-nginx-webserver-security.html
    ## Block download agents ##
    if ($http_user_agent ~* LWP::Simple|BBBike|wget) {
        return 403;
    }

    ## Block some robots ##
    if ($http_user_agent ~* msnbot|scrapbot) {
        return 403;
    }

    ## Deny certain Referers ##
    if ( $http_referer ~* (babes|forsale|girl|jewelry|love|nudit|organic|poker|porn|sex|teen) )
    {
        return 403;
    }

    listen 443 ssl default_server;
    server_name <mydomain>.<myds>.<me>;

    ##
    # SSL
    ##
    
    ## Activate SSL, setze SERVER Zertifikat Informationen ## 
    # Generiert via Let's Encrypt! 
    ssl on;
    ssl_certificate /etc/letsencrypt/live/<mydomain>.<myds>.<me>/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/<mydomain>.<myds>.<me>/privkey.pem;
    ssl_session_cache builtin:1000 shared:SSL:10m;
    ssl_prefer_server_ciphers on;
    # unsichere SSL Ciphers deaktivieren!
    ssl_ciphers    HIGH:!aNULL:!eNULL:!LOW:!3DES:!MD5:!RC4;
    
    ##
    # HSTS
    ##

    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

    ##
    # global
    ##

    root /var/www/<mydomain>.<myds>.<me>;
    index index.php index.htm index.html;
    
    # Weiterleitung zu SmartHomeNG (Websocket Schnittstelle) mit Basic Auth
    # Nur Verbindungen gegen "/" durchlassen! Also weder auf Dateien noch Verzeichnisse (= nur Websocket Connects)
    location = / {
        auth_basic "Restricted Area: smartVISU";
        auth_basic_user_file /etc/nginx/.smartvisu;      
        proxy_pass http://<SmartHomeNG LAN IP>:<Websocket Port>;        
    }

    # Zugriff auf die smartVISU mit Basic Auth
    location /smartVISU {      
        auth_basic "Restricted Area: smartVISU";
        auth_basic_user_file /etc/nginx/.smartvisu;
        proxy_pass http://<smartVISU Server LAN IP>/smartVISU;
        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;
    }
    
    # Alexa Plugin Weiterleitung
    location /alexa {
        auth_basic "Restricted Area: Alexa";
        auth_basic_user_file /etc/nginx/.alexa;
        proxy_pass http://<SmartHomeNG LAN IP>:<Alexa Plugin Port>/;
        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;
    }

    # Network Plugin Weiterleitung
    location /shng {
        auth_basic "Restricted Area: SmartHomeNG";
        auth_basic_user_file /etc/nginx/.shng;
        proxy_pass http://<SmartHomeNG LAN IP>:<Network Plugin Port>/;
        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;
    }
}

NGINX reloaden:

/etc/init.d/nginx reload

Passwort-Files für unterschiedliche User für smartVISU, Alexa, Network Plugin erstellen

sudo apt-get install apache2-utils

sudo htpasswd -c /etc/nginx/.smartvisu <username>
sudo htpasswd -c /etc/nginx/.alexa <username>
sudo htpasswd -c /etc/nginx/.shng <username>

Dann ein Passwort vergeben.

Der Zugriff auf https://../smartVISU sollte nun klappen.

Nacharbeiten: Port 80 in NGINX deaktivieren

Da NGINX im LAN aktuell noch auf Port 80 konfiguriert ist, sollte man in der /etc/nginx/sites-available/default noch ein return 403 ergänzen und NGINX neu starten:

server {
        listen 80 default_server;
        listen [::]:80 default_server;

        return 403;

        include /etc/nginx/snippets/letsencrypt.conf;
/etc/init.d/nginx reload

Client Zertifikate erstellen (optional)

openssl.cnf editieren

sudo nano /etc/ssl/openssl.cnf

Folgende Zeilen anpassen:

dir = /etc/ssl/ca                       # Directory where everything is kept
[...]
new_certs_dir = $dir/certs               # default place for new certs.
[...]
certificate = $dir/ca.crt               # The CA certificate
[...]
crl = $dir/crl.pem                      # The current CRL
private_key = $dir/private/ca.key       # The private key
[...]
default_md = sha1 # use public key default MD

Drei neue Verzeichnisse und drei Dateien anlegen:

sudo mkdir -p /etc/ssl/ca/certs/users
sudo mkdir -p /etc/ssl/ca/crl
sudo mkdir -p /etc/ssl/ca/private

sudo touch /etc/ssl/ca/index.txt
sudo touch /etc/ssl/ca/index.txt.attr

In der Datei crlnumber den Wert „01“ eintragen und speichern.

sudo nano /etc/ssl/ca/crlnumber

Zertifikat für Certification Authority (CA) erstellen, Passwort für die CA wählen und eigene Daten eingeben:

sudo openssl genrsa -des3 -out /etc/ssl/ca/private/ca.key 4096
sudo openssl req -new -x509 -days 1095 -key /etc/ssl/ca/private/ca.key -out /etc/ssl/ca/certs/ca.crt
sudo openssl ca -name CA_default -gencrl -keyfile /etc/ssl/ca/private/ca.key -cert /etc/ssl/ca/certs/ca.crt -out /etc/ssl/ca/private/ca.crl -crldays 1095

Client Zertifikat für einen User erstellen und ein Passwort für das Client Zertifikat vergeben:

sudo openssl genrsa -des3 -out /etc/ssl/ca/certs/users/<USERNAME>.key 1024
sudo openssl req -new -key /etc/ssl/ca/certs/users/<USERNAME>.key -out /etc/ssl/ca/certs/users/<USERNAME>.csr

Bei folgendem Schritt das Passwort für die CA eingeben:

sudo openssl x509 -req -days 1095 -in /etc/ssl/ca/certs/users/<USERNAME>.csr -CA /etc/ssl/ca/certs/ca.crt -CAkey /etc/ssl/ca/private/ca.key -CAserial /etc/ssl/ca/serial -CAcreateserial -out /etc/ssl/ca/certs/users/<USERNAME>.crt

Bei folgendem Schritt mit dem Passwort für das Client Zertifikat bestätigen und ein Export Passwort wählen:

sudo openssl pkcs12 -export -clcerts -in /etc/ssl/ca/certs/users/<USERNAME>.crt -inkey /etc/ssl/ca/certs/users/<USERNAME>.key -out /etc/ssl/ca/certs/users/<USERNAME>.p12 

<USERNAME>.p12 File herunterladen:

sudo cp /etc/ssl/ca/certs/users/<USERNAME>.p12 /home/pi
cd /home/pi/
sudo chown pi <USERNAME>.p12

Bspw. nun via SFTP ziehen und aufs Datei aufs Android Handy übertragen und ausführen oder im Browser unter Zertifikate“ importieren. Dabei muss es mit Export Passwort bestätigt werden.

Client Zertifikate in NGINX nutzen (optional)

Anleitung nach https://arcweb.co/securing-websites-nginx-and-client-side-certificate-authentication-linux/

/etc/nginx/conf.d/<mydomain>.<myds>.<me>.conf bearbeiten und die Zeilen im SSL Block ergänzen („ab Client Zertifikat spezifisch“)

    ##
    # SSL
    ##

    ## Activate SSL, setze SERVER Zertifikat Informationen ##
    # Generiert via Let's Encrypt!    
    ssl on;
    ssl_certificate /etc/letsencrypt/live/<mydomain>.<myds>.<me>/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/<mydomain>.<myds>.<me>/privkey.pem;
    ssl_session_cache builtin:1000 shared:SSL:10m;
    ssl_prefer_server_ciphers on;
    # unsichere SSL Ciphers deaktivieren!
    ssl_ciphers    HIGH:!aNULL:!eNULL:!LOW:!3DES:!MD5:!RC4;

    # Client Zertifikat spezifisch
    ssl_client_certificate /etc/ssl/ca/certs/ca.crt;
    ssl_crl /etc/ssl/ca/private/ca.crl;
    ssl_verify_client optional;
    ssl_session_timeout 5m;

Die smartVISU relevanten Teile könnten jetzt folgendermaßen über Clientzertifikate geschützt werden:

    # Weiterleitung zu SmartHomeNG (Websocket Schnittstelle) mit Clientzertifikat
    location = / {
        # Clientzertifikat gültig?
        if ($ssl_client_verify != SUCCESS) {
                return 403;
        }
        proxy_pass http://<SmartHomeNG LAN IP>:<Websocket Port>;      
    }

    # Zugriff auf die smartVISU mit Clientzertifikat
    location /smartVISU {  
        # Clientzertifikat gültig?    
        if ($ssl_client_verify != SUCCESS) {
                return 403;
        }
        proxy_pass http://<smartVISU Server LAN IP>/smartVISU;
        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;
    }

Wer es doppelt sicher haben möchte, kann die Basic Auth in den jew. Blöcken auch beibehalten.

Testbar ist das Ganze, wenn es im Browser ohne Zertifikat einen 403er Fehler gibt und mit Zertifikat die smartVISU aufbaut.

Erweiterung: Stärkere Diffie-Hellman-Parameter

Damit die Sicherheit „perfekt“ wird, sollten stärkere Diffie-Hellman-Schlüssel verwendet werden. Dazu muss ein neues .pem File generiert werden. Es empfiehlt sich, die Erzeugung dieses Files nicht direkt auf den Raspi, sondern auf einem PC mit stärkerer CPU durchzuführen. Ein Test auf einem Raspi3 dauerte 24 Stunden (!). Ein Intel 4790k brauchte hingegen nur 30 Minuten.

Folgendes ist zu tun:

cd /etc/ssl/certs
sudo openssl dhparam -out dhparam.pem 4096

Alternativ kann die Datei auch einfach in /etc/ssl/certs kopiert werden.

Danach ist in der SSL Konfiguration von NGINX folgende Zeile zu ergänzen und NGINX neu zu starten:

# Konfiguration editieren
sudo nano /etc/nginx/conf.d/\<mydomain\>.\<myds\>.\<me\>.conf 
## Dort folgende Zeile im Block SSL einfügen:

##
# SSL
##
[...]
ssl_dhparam /etc/ssl/certs/dhparam.pem;
[...]
## NGINX neu starten
sudo service nginx restart

Die Sicherheit der eigenen https-Domain kann nun unter https://www.ssllabs.com/ssltest/ getestet werden. Mit den oben genannten Maßnahmen sollte ein A+ erreicht werden.

Der versiertere Nutzer kann sich unter https://mozilla.github.io/server-side-tls/ssl-config-generator/ auch gleich eine eigene Konfiguration generieren lassen.

Wartung: Zertifikat nach 3 Monaten erneuern

Nach 3 Monaten muss das Let’s Encrypt Serverzertifikat erneuert werden. Damit das Erneuerungs-Skript funktioniert, muss Port 80 im NGINX freigegeben, bzw. über einen separaten server Block auf HTTPS umgeleitet werden:


server {
    listen 80 default_server;
    listen [::]:80 default_server;
    server_name _;
    return 301 https://$host$request_uri;
}

Die Erneuerung geht dann wie folgendermaßen:
sudo certbot certonly --rsa-key-size 4096 --webroot -w /var/www/letsencrypt -d <mydomain>.<myds>.<me>

Im nun folgenden Dialog Option 2 (2: Renew & replace the cert (limit ~5 per 7 days)) auswählen. Danach NGINX neu starten:
sudo service nginx restart

Der Test über https://www.ssllabs.com/ssltest/ oder der Aufruf im Browser gibt nun Aufschluß über die Laufzeit des verlängerten Zertifikats.

Tipp: Endet die Erneuerung mit einem Timeout, kann dies ggf. an einer fälschlicherweise an den DNS Server propagierten IPV6 Addresse liegen. In diesem Fall testweise bei den DynDNS Einstellungen diese deaktivieren.

(Die in diesem Artikel verwendeten Screenshots und Grafiken wurden selber erstellt. Verwendete Symbole und Icons stammen von https://openclipart.org. Das Titelbild ist unter der Creative Commons Zero (CC0) Lizenz veröffentlicht und wurde von www.pexels.com bezogen.)


18 Kommentare

Gian-Luca · 12. März 2020 um 16:25

Danke für die Anleitung. Hat wunderbar funktioniert und mein Alexa Plugin ist nun endlich geschützt. 🙂
Ein Kollege und ich nutzen für andere Websiten und das Cert renewal „dehydrated“. Ich werde das die Tage mal noch auf dem Reverse Proxy umsetzen, dann hab ich keine Probleme mehr damit. Eventuell könnt ihr das hier ja auch mal anschauen und ergänzen.
https://github.com/dehydrated-io/dehydrated

Mark · 30. September 2019 um 17:51

Ich habe eine alternative GeoIP Datenbank gefunden: https://www.miyuru.lk/geoiplegacy
Diese wird mit diesen Scripten in das alte Format konveniert: ttps://github.com/sherpya/geolite2legacy

Marc René Frieß · 27. März 2019 um 8:08

Kenne leider keine Alternative. Aber danke für die Info!

Sebastian · 25. März 2019 um 20:11

Der GeoIP Service von maxmind scheint jetzt kostenpflichtig zusein. Der Link geht auch nicht mehr. Gibt es eine alternative? Danke

Marc René Frieß · 29. November 2018 um 16:17

a) ist bei mir definitiv nicht so, wenn ich einen pfad zugreife, der auf clientzertifikate checkt und das Zertifikat im Browser auswähle.

evtl greifst du einen un- oder andersgeschützten pfad zu? der wird dann vermutlich geblockt, wenn das immer auf „on“ ist! Bei mir ist bspw /photo mit Basic Auth geschützt, da kriege ich wenn es auf on steht auch einen 400er – unter der Annahme dass ich das Zertifikat im Browser nicht auswähle beim ersten Request!

b) habe leider keinen Mac, daher keine Ahnung. Apple ist immer etwas speziell …

Hajo · 27. November 2018 um 22:24

Danke für die Anleitung. Konnte vieles bereist umsetzen.
Habe aber Probleme mit dem Client-Zertifikat.

a) Wenn ich den Parameter „ssl_verify_client“ von optional auf on setze, wird die Verbindung von nginx mit 400 Bad Request abgewiesen.

b) Die erstellte p12-Datei liefert beim importieren auf einem Mac einen Error „An error occurred. Unable to import the certificate.
Error: -26276“
Unter ubuntu kann ich die Datei nicht in die keychain importieren.
Hast Du irgendeine Idee?
LG

Thomas Creutz · 17. September 2018 um 1:26

Das mit der Port Weiterleitung geht besser, dazu einfach einen Zufallsport per tls_sni_01_port definieren und port 80 standardmäßig auf diesen Port weiter leiten. Antworten wird dann aber nur etwas, wenn der certbot ein neues Zertifikat generiert.
Dazu muss man diese Option in der Datei /etc/letsencrypt/renewal/mydomain.conf hinterlegen und es geht natürlich nur mit dem standalone module. Also setzten wir noch pref_challs = tls-sni-01, – evtl. schaut ihr mal hier rein: https://github.com/certbot/certbot/issues/2697

Andy · 16. August 2018 um 18:46

Das mit dem automatischen Restart nach Update hab ich getestet, könntest auch noch in die Anleitung nehmen:
nano /etc/letsencrypt/cli.ini
renew-hook = systemctl restart nginx.service

Ob und wie das mit dem auto-certbot funzt werden wir in paar Monaten sehen 😉

Marc René Frieß · 16. August 2018 um 17:49

Naja, die 80er Weiterleitung brauche ich ja auch nur für den Zertifikatekram. Alles andere muss nicht gehen, da ist HTTPS für den Zugriff immer die bessere Wahl.

Andy · 16. August 2018 um 17:36

Bei einem reinen return 301 ohne if Abfrage hatte ich folgende Probleme:
too many redirects, wenn ichs über der DYNDNS aufrufe
Weiterleitung auf https://_/smartVISU bzw. wenn ich beim Servername die IP eingebe, dann ein Zertifikatsfehler, da ja intern auch auf https umgeleitet wird.

Die if-Abfrage hat das Problem gelöst. Zusätzlich sicher ich jetzt noch mittels „ufw“ ab

Andy · 16. August 2018 um 17:32

Das mit dem automatischen Restart lässt sich wohl nobel lösen..:
https://gist.github.com/mrothNET/cb6f313e9cbe896f3e0fdec80ad2f3fa

Marc René Frieß · 16. August 2018 um 16:16

Ich hab das so gemacht:

server {
listen 80 default_server;
listen [::]:80 default_server;
server_name _;
return 301 https://$host$request_uri;
}

Habe das unter „Wartung“ ergänzt.

Andy · 16. August 2018 um 16:08

Also wenn ich beim default File folgende Zeile einfüge:
if ($http_x_forwarded_proto = „http“) {
return 301 https://$server_name$request_uri;
}
wird automatisch auf https umgeleitet. Soweit, so gut. Wenn ich andere redirects mache, kommt es zu „too many redirects“ (wenn im default-File server_name DYNDNS-domain angegeben ist) oder hässlichen SSL-Fehlern im Browser (wenn im default File als servername die lokale IP angegeben ist).

Vielleicht kannst du das in der Anleitung updaten? Vielleicht hab ich’s überlesen, aber oben wird Port 80 nur per se blockiert. Und es klingt auch nicht so, dass Port 80 vom Router weiterhin weitergeleitet wird. Es steht dort: Port 80 im Browser wieder schließen. Ich vermute Browser=Router? Zumindest steht weiter oben „temporär Port 80 weiterleiten“.
Wie auch immer, mit den obigen 3 Zeilen scheint soweit alles zu klappen. Hoff ich 😉

Wegen der Zertifikatserneuerung:

Das Cron-Script behauptet, dass das Zertifikat NUR dann erneuert wird, wenn es bald abläuft. Insofern müsst man hier wohl abwarten und schauen, was wirklich passiert. Va. ob das alles automatisch abläuft. Und dann bräuchte es wohl noch ein Cron-Script, das den Webserver neu startet, wenn das Zertifikatsfile bis zu 5 Minuten alt ist o.ä.

Marc René Frieß · 15. August 2018 um 5:35

und: habe den renew befehl gerade manuell ausprobiert, bei mir erneuert er so nichts. kriege das nur wie im artikel beschrieben hin?!

Marc René Frieß · 15. August 2018 um 5:34

achja: das zertifakateerneuern (ich habe den entry auch) dürfte ohne nginx restart wenig bringen

Marc René Frieß · 15. August 2018 um 5:25

@andy: was ist an der Portweiterleitung ärgernlich? Ich route HTTP zwar weiter, im NGINX leitet er das aber auf HTTPS um! Geht wunderbar, wenn das Zertifikat mal installiert ist!

Andy · 14. August 2018 um 11:32

Dem Cronfile in cron.d zufolge wird das Zertifikat mittels certbot automatisch aktualisiert:
# Upstream recommends attempting renewal twice a day
#
# Eventually, this will be an opportunity to validate certificates
# haven’t been revoked, etc. Renewal will only occur if expiration
# is within 30 days.
SHELL=/bin/sh
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

0 */12 * * * root test -x /usr/bin/certbot -a \! -d /run/systemd/system && perl -e ’sleep int(rand(3600))‘ && certbot -q renew

Ärgerlich ist nur das mit der Port-Weiterleitung…

René · 9. Mai 2018 um 17:30

Vielen Dank für die ausführliche Anleitung.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.