home.social

#certat — Public Fediverse posts

Live and recent posts from across the Fediverse tagged #certat, aggregated by home.social.

  1. Nginx Proxy Manager: HTTP/2 wegen kritischer nginx-Lücken per Script abschalten

    Wer Nginx Proxy Manager (NPM) im Internet betreibt, sollte HTTP/2 vorerst abschalten. Hintergrund ist eine Warnung von CERT.at vom November 2026 zu kritischen Lücken in nginx. Für NPM gibt es noch kein repariertes Image. In diesem Beitrag zeige ich ein Bash-Script mit Menü, das HTTP/2 bei allen Hosts auf einmal prüft und abschaltet – und später auch wieder einschaltet.

    Worum es geht

    F5 hat vier Lücken in nginx Open Source und NGINX Plus veröffentlicht. Für uns als Reverse-Proxy-Betreiber zählen vor allem zwei:

    CVEModulBetroffen bisBehoben inCVE-2026-123007HTTP/21.30.6 / 1.31.81.30.7 / 1.31.9CVE-2026-123633HTTP/2 (mit Weiterleitung an ein Backend)1.30.6 / 1.31.81.30.7 / 1.31.9CVE-2026-121810HTTP/31.30.6 / 1.31.81.30.7 / 1.31.9CVE-2026-113425Mail-Proxy1.30.6 / 1.31.81.30.7 / 1.31.9

    Im schlimmsten Fall stürzen Worker-Prozesse ab oder der Speicher wird beschädigt. Ist ASLR aus oder wird es umgangen, ist laut F5 sogar das Ausführen von fremdem Code möglich. Die Bewertung liegt bei CVSS 8.1 (v3.1) bzw. 9.2 (v4.0). Für die HTTP/2-Lücken nennt F5 keinen Workaround.

    HTTP/3 ist in NPM normalerweise nicht aktiv, und den Mail-Proxy nutzt NPM gar nicht. Bleibt HTTP/2 – und das ist in NPM bei fast jedem Host eingeschaltet.

    Warum NPM betroffen ist

    NPM bringt kein normales nginx mit, sondern OpenResty. Das ist ein nginx-Kern, in den die Sicherheitsfixes nachträglich eingebaut werden. Die aktuellen NPM-Images laufen mit openresty/1.29.2.5. Diese Version ist vom Mai 2026 und enthält die neuen HTTP/2-Fixes noch nicht.

    Ein Image-Update hilft deshalb im Moment nicht. Erst muss OpenResty die Fixes einbauen, dann müssen die NPM-Images darauf neu gebaut werden. Wie lange das dauert, ist offen.

    Bis dahin ist der einzige wirksame Schutz, HTTP/2 auszuschalten. Dann laufen alle Verbindungen über HTTP/1.1, und die angreifbaren HTTP/2-Funktionen sind nicht mehr erreichbar. Für eine private Homelab-Nutzung ist der Geschwindigkeitsunterschied kaum spürbar.

    So arbeitet das Script

    HTTP/2 lässt sich in der NPM-Oberfläche pro Host abschalten. Bei 30 Hosts auf mehreren Servern ist das mühsam. Das Script erledigt das über die API von NPM, also über denselben Weg, den auch die Weboberfläche nutzt.

    Das hat einen Vorteil: NPM schreibt nach jeder Änderung die nginx-Konfiguration selbst neu und lädt nginx neu. Es wird nichts direkt in der Datenbank oder im Container geändert. Würde man nur die Datenbank anpassen, bliebe die alte Konfiguration aktiv.

    Macht es einen Unterschied, ob NPM im Docker läuft? Nein. Das Script spricht nur mit dem Port der Weboberfläche (meist 81). Ob das Image von jc21 oder jlesage stammt, ist egal.

    Das Script kann:

    • den HTTP/2-Status aller Proxy-, Redirection- und 404-Hosts anzeigen,
    • HTTP/2 bei allen oder bei ausgewählten Hosts abschalten,
    • vor jeder Änderung eine Sicherung anlegen (~/npm-http2-backups/),
    • HTTP/2 aus einer Sicherung wieder einschalten.

    Voraussetzungen: ein Linux-Rechner mit bash, curl und jq, der den NPM-Port erreicht, und ein NPM-Benutzer mit Admin-Rechten. Am einfachsten läuft das Script direkt auf dem Docker-Host, auf dem NPM läuft.

    Schritt für Schritt

    Alle Schritte führst du auf dem Docker-Host aus, auf dem NPM läuft, als root. Hast du mehrere NPM-Instanzen, wiederholst du die Schritte auf jedem Server.

    Schritt 1: OpenResty-Version prüfen

    Zuerst finde den Namen des NPM-Containers:

    docker ps --format '{{.Names}}\t{{.Image}}' | grep -i nginx

    Dann die Version abfragen (Containername einsetzen):

    docker exec <containername> nginx -v

    Steht dort openresty/1.29.2.5 oder älter, ist die Instanz angreifbar. Mach mit Schritt 2 weiter.

    Schritt 2: Script ablegen

    Installiere die beiden benötigten Werkzeuge:

    apt install -y curl jq

    Leg das Script (ganz unten im Beitrag) unter /root/check_http2.sh ab, zum Beispiel mit nano /root/check_http2.sh. Danach ausführbar machen:

    chmod +x /root/check_http2.sh

    Schritt 3: Script starten und anmelden

    /root/check_http2.sh

    Das Script fragt nach der NPM-Adresse. Läuft es auf demselben Host und ist die Weboberfläche auf Port 81 veröffentlicht, drückst du einfach Enter (http://127.0.0.1:81). Danach meldest du dich mit E-Mail und Passwort deines NPM-Admins an. Ist bei dir die Zwei-Faktor-Anmeldung aktiv, fragt das Script zusätzlich nach dem Code.

    Nach der Anmeldung erscheint das Menü:

    Schritt 4: Status anzeigen

    Wähle 1. Das Script listet alle Hosts mit Typ, ID, HTTP/2-Status, SSL und Domain. Darunter steht, bei wie vielen Hosts HTTP/2 aktiv ist. Bei mir waren es 25 von 30:

    Schritt 5: HTTP/2 abschalten

    Wähle 2, um HTTP/2 bei allen Hosts abzuschalten. Willst du erst einzelne Hosts testen, nimm 3 und gib die Nummern aus der Liste ein, z. B. 1 3 5.

    Das Script zeigt die betroffenen Domains und fragt nach einer Bestätigung (j). Dann legt es eine Sicherung an und ändert die Hosts nacheinander. Jeder Host bekommt ein OK oder eine Fehlermeldung.

    Schritt 6: Prüfen

    Wähle noch einmal 1. Jetzt sollte überall aus stehen und unten HTTP/2 aktiv bei 0 von 30 Hosts.

    Zusätzlich kannst du von einem beliebigen Rechner aus testen, welches Protokoll eine Domain spricht:

    curl -sI --http2 https://deine-domain.tld | head -1

    Kommt HTTP/1.1 200 (oder ein anderer Statuscode mit HTTP/1.1) zurück, ist HTTP/2 aus. Ruf danach ein paar Seiten im Browser auf, um sicherzugehen, dass alles normal lädt.

    Schritt 7: Weitere Server

    Hast du NPM auf mehreren Servern, wiederhole Schritt 1 bis 6 auf jedem davon. Mit 5 beendest du das Script.

    Wenn das Update da ist: HTTP/2 wieder einschalten

    Sobald ein NPM-Image mit repariertem OpenResty erscheint, gehst du so vor:

    1. NPM-Image aktualisieren und den Container neu erstellen (z. B. docker compose pull && docker compose up -d im Verzeichnis deines NPM-Stacks).
    2. Mit docker exec <containername> nginx -v prüfen, ob die neue OpenResty-Version läuft und laut Release-Notes die CVEs behebt.
    3. /root/check_http2.sh starten und 4 wählen.
    4. Die passende Sicherung aus ~/npm-http2-backups/ auswählen und bestätigen.

    Das Script schaltet HTTP/2 dann genau bei den Hosts wieder ein, bei denen es vorher aktiv war. Hosts, bei denen du HTTP/2 schon vorher bewusst aus hattest, bleiben aus.

    Das komplette Script

    Speichere den folgenden Inhalt als /root/check_http2.sh.

    #!/usr/bin/env bash
    # =============================================================================
    # check_http2.sh – HTTP/2 in Nginx Proxy Manager prüfen und (de)aktivieren
    #
    # Arbeitet über die NPM-API (Port der Weboberfläche, z. B. :81). NPM schreibt
    # danach die nginx-Konfiguration selbst neu und lädt nginx neu – es wird also
    # nichts im Container oder in der Datenbank direkt angefasst.
    #
    # Betrifft: Proxy Hosts, Redirection Hosts und 404 Hosts.
    # Vor jeder Änderung wird eine Sicherung angelegt (Wiederherstellung im Menü).
    #
    # Voraussetzungen: bash, curl, jq
    # =============================================================================
    set -uo pipefail
    
    TYPES=(proxy-hosts redirection-hosts dead-hosts)
    declare -A TYPE_LABEL=([proxy-hosts]="Proxy" [redirection-hosts]="Redirect" [dead-hosts]="404")
    BACKUP_DIR="${BACKUP_DIR:-$HOME/npm-http2-backups}"
    
    API=""
    TOKEN=""
    HOSTS="[]"
    HTTP_CODE=""
    BODY=""
    
    need() { command -v "$1" >/dev/null 2>&1 || { echo "Fehlt: $1  ->  apt install $1"; exit 1; }; }
    need curl
    need jq
    
    # --- API-Hilfsfunktionen ------------------------------------------------------
    call() { # call METHOD PFAD [JSON]
      local m=$1 p=$2 d=${3:-} out
      if [[ -n $d ]]; then
        out=$(curl -sS -X "$m" -H "Authorization: Bearer $TOKEN" \
              -H "Content-Type: application/json" -d "$d" -w $'\n%{http_code}' "$API$p") || return 1
      else
        out=$(curl -sS -X "$m" -H "Authorization: Bearer $TOKEN" -w $'\n%{http_code}' "$API$p") || return 1
      fi
      HTTP_CODE=${out##*$'\n'}
      BODY=${out%$'\n'*}
      [[ $HTTP_CODE == 2* ]]
    }
    
    err_msg() { jq -r '.error.message // .' <<<"$BODY" 2>/dev/null || echo "$BODY"; }
    
    # --- Anmeldung ----------------------------------------------------------------
    login() {
      local url m user pw resp="" code challenge
      read -rp "NPM-Adresse [http://127.0.0.1:81]: " url
      url=${url:-http://127.0.0.1:81}
      API="${url%/}/api"
    
      echo "  1) Anmelden mit E-Mail und Passwort"
      echo "  2) Vorhandenen API-Token einfügen"
      read -rp "Auswahl [1]: " m
      if [[ ${m:-1} == 2 ]]; then
        read -rsp "Token: " TOKEN; echo
      else
        read -rp "E-Mail: " user
        read -rsp "Passwort: " pw; echo
        resp=$(curl -sS -X POST -H "Content-Type: application/json" \
          -d "$(jq -n --arg i "$user" --arg s "$pw" '{identity:$i, secret:$s}')" "$API/tokens")
        TOKEN=$(jq -r '.token // empty' <<<"$resp" 2>/dev/null)
    
        # Zwei-Faktor-Anmeldung (NPM >= 2.13.6). Falls das bei deiner Version
        # anders läuft: Option 2 (Token einfügen) verwenden.
        if [[ -z $TOKEN ]] && jq -e '.requires_2fa // false' <<<"$resp" >/dev/null 2>&1; then
          challenge=$(jq -r '.challenge_token // empty' <<<"$resp")
          read -rp "2FA-Code: " code
          resp=$(curl -sS -X POST -H "Content-Type: application/json" \
            -d "$(jq -n --arg c "$challenge" --arg k "$code" '{challenge_token:$c, code:$k}')" "$API/tokens/2fa")
          TOKEN=$(jq -r '.token // empty' <<<"$resp" 2>/dev/null)
        fi
      fi
    
      if [[ -z $TOKEN ]] || ! call GET /users/me; then
        echo "Anmeldung fehlgeschlagen. Antwort: ${resp:-$BODY}"
        exit 1
      fi
      echo "Angemeldet als: $(jq -r '.email // .name' <<<"$BODY")"
    }
    
    # --- Hosts laden und anzeigen -------------------------------------------------
    load_hosts() {
      HOSTS="[]"
      local t
      for t in "${TYPES[@]}"; do
        if ! call GET "/nginx/$t"; then
          echo "Fehler beim Laden von $t ($HTTP_CODE): $(err_msg)"
          continue
        fi
        HOSTS=$(jq --arg t "$t" --argjson h "$HOSTS" '
          $h + [ .[] | {
            type: $t,
            id: .id,
            domains: (.domain_names | join(", ")),
            http2: (.http2_support == true or .http2_support == 1),
            ssl: ((.certificate_id // 0) != 0),
            enabled: (.enabled == true or .enabled == 1)
          } ]' <<<"$BODY")
      done
    }
    
    show() {
      load_hosts
      echo
      printf '%-4s %-9s %-5s %-7s %-5s %-7s %s\n' Nr Typ ID HTTP/2 SSL Aktiv Domains
      printf '%s\n' "-------------------------------------------------------------------------------"
      jq -r 'to_entries[] | [
          (.key + 1),
          .value.type,
          .value.id,
          (if .value.http2 then "AN" else "aus" end),
          (if .value.ssl then "ja" else "nein" end),
          (if .value.enabled then "ja" else "nein" end),
          .value.domains ] | @tsv' <<<"$HOSTS" |
      while IFS=$'\t' read -r n t id h s e d; do
        printf '%-4s %-9s %-5s %-7s %-5s %-7s %s\n' "$n" "${TYPE_LABEL[$t]}" "$id" "$h" "$s" "$e" "$d"
      done
      echo
      echo "HTTP/2 aktiv bei $(jq '[.[] | select(.http2)] | length' <<<"$HOSTS") von $(jq 'length' <<<"$HOSTS") Hosts."
      echo "(HTTP/2 wirkt nur bei Hosts mit SSL – abgeschaltet wird trotzdem überall.)"
    }
    
    # --- Ändern -------------------------------------------------------------------
    backup() { # backup JSON-LISTE
      mkdir -p "$BACKUP_DIR"
      local f="$BACKUP_DIR/http2-$(date +%Y%m%d-%H%M%S).json"
      jq --arg api "$API" '{api: $api, hosts: [ .[] | {type, id, domains} ]}' <<<"$1" > "$f"
      echo "Sicherung angelegt: $f"
    }
    
    apply_list() { # apply_list JSON-LISTE true|false
      local list=$1 val=$2 t id d ok=0 fail=0
      while IFS=$'\t' read -r t id d; do
        if call PUT "/nginx/$t/$id" "{\"http2_support\": $val}"; then
          echo "  OK     [${TYPE_LABEL[$t]} $id] $d"; ok=$((ok + 1))
        else
          echo "  FEHLER [${TYPE_LABEL[$t]} $id] $d  ($HTTP_CODE): $(err_msg)"; fail=$((fail + 1))
        fi
      done < <(jq -r '.[] | [.type, .id, .domains] | @tsv' <<<"$list")
      echo "Fertig: $ok geändert, $fail Fehler."
    }
    
    confirm() { local a; read -rp "$1 [j/N]: " a; [[ $a == [jJyY]* ]]; }
    
    disable_all() {
      load_hosts
      local list
      list=$(jq '[ .[] | select(.http2) ]' <<<"$HOSTS")
      if [[ $(jq 'length' <<<"$list") -eq 0 ]]; then echo "Bei keinem Host ist HTTP/2 aktiv."; return; fi
      echo "HTTP/2 wird bei diesen Hosts abgeschaltet:"
      jq -r '.[] | "  - " + .domains' <<<"$list"
      confirm "Fortfahren?" || return
      backup "$list"
      apply_list "$list" false
    }
    
    disable_some() {
      show
      local nums list
      read -rp "Nummern der Hosts (mit Leerzeichen getrennt, z. B. 1 3 5): " nums
      [[ -z $nums ]] && return
      list=$(jq --arg n "$nums" '
        ($n | split(" ") | map(select(length > 0) | tonumber - 1)) as $idx
        | [ to_entries[] | select(.key as $k | $idx | index($k)) | .value | select(.http2) ]' <<<"$HOSTS") \
        || { echo "Ungültige Eingabe."; return; }
      if [[ $(jq 'length' <<<"$list") -eq 0 ]]; then echo "Bei den gewählten Hosts ist HTTP/2 nicht aktiv."; return; fi
      echo "HTTP/2 wird bei diesen Hosts abgeschaltet:"
      jq -r '.[] | "  - " + .domains' <<<"$list"
      confirm "Fortfahren?" || return
      backup "$list"
      apply_list "$list" false
    }
    
    restore() {
      shopt -s nullglob
      local files=("$BACKUP_DIR"/http2-*.json) f
      shopt -u nullglob
      if [[ ${#files[@]} -eq 0 ]]; then echo "Keine Sicherungen in $BACKUP_DIR."; return; fi
      echo "HTTP/2 wieder einschalten – Sicherung wählen:"
      select f in "${files[@]}" "Abbrechen"; do
        [[ $f == "Abbrechen" || -z $f ]] && return
        break
      done
      if [[ $(jq -r '.api' "$f") != "$API" ]]; then
        echo "Achtung: Sicherung stammt von $(jq -r '.api' "$f"), angemeldet bist du an $API."
        confirm "Trotzdem verwenden?" || return
      fi
      jq -r '.hosts[] | "  - " + .domains' "$f"
      confirm "HTTP/2 bei diesen Hosts wieder einschalten?" || return
      apply_list "$(jq '.hosts' "$f")" true
    }
    
    # --- Hauptmenü ----------------------------------------------------------------
    login
    while true; do
      echo
      echo "=========== NPM HTTP/2 ($API) ==========="
      echo "  1) Status anzeigen"
      echo "  2) HTTP/2 bei ALLEN Hosts abschalten"
      echo "  3) HTTP/2 bei ausgewählten Hosts abschalten"
      echo "  4) HTTP/2 aus Sicherung wieder einschalten"
      echo "  5) Beenden"
      read -rp "Auswahl: " c
      case $c in
        1) show ;;
        2) disable_all ;;
        3) disable_some ;;
        4) restore ;;
        5|q) exit 0 ;;
        *) echo "Ungültige Auswahl." ;;
      esac
    done

    Fazit

    Mit dem Script ist HTTP/2 auf allen NPM-Instanzen in wenigen Minuten aus, und die Sicherung macht das Zurückschalten genauso schnell. Behalte die Release-Notes von OpenResty und Nginx Proxy Manager im Blick: Sobald ein Image mit den Fixes erscheint, aktualisieren und HTTP/2 wieder einschalten.

    Quellen

    PDF | Print | eMail #BashScript #CERTAt #CVE2026113425 #CVE2026121810 #CVE2026123007 #CVE2026123633 #docker #homelab #http2 #linux #nginx #NginxProxyManager #openrestry #ReverseProxy #selfhosting #Sicherheitslücke
Share on Mastodon

Enter the server where you have an account.