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:
CVE Modul Betroffen bis Behoben in CVE-2026-123007 HTTP/2 1.30.6 / 1.31.8 1.30.7 / 1.31.9 CVE-2026-123633 HTTP/2 (mit Weiterleitung an ein Backend) 1.30.6 / 1.31.8 1.30.7 / 1.31.9 CVE-2026-121810 HTTP/3 1.30.6 / 1.31.8 1.30.7 / 1.31.9 CVE-2026-113425 Mail-Proxy 1.30.6 / 1.31.8 1.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:
NPM-Image aktualisieren und den Container neu erstellen (z. B. docker compose pull && docker compose up -d im Verzeichnis deines NPM-Stacks).
Mit docker exec <containername> nginx -v prüfen, ob die neue OpenResty-Version läuft und laut Release-Notes die CVEs behebt.
/root/check_http2.sh starten und 4 wählen.
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