19. November 2026

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

Dieser Beitrag bezieht sich auch das docker-Image von „jlesage/nginx-proxy-manager:latest„
Stand: 19-11-2026

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 in
CVE-2026-123007HTTP/21.30.6 / 1.31.81.30.7 / 1.31.9
CVE-2026-123633HTTP/2 (mit Weiterleitung an ein Backend)1.30.6 / 1.31.81.30.7 / 1.31.9
CVE-2026-121810HTTP/31.30.6 / 1.31.81.30.7 / 1.31.9
CVE-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