home.social

#http-2 — Public Fediverse posts

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

fetched live
  1. #PSA: If you are hosting a #GitLab instance, you should know that version 19.6.0, released yesterday, still contained a vulnerable Ruby version.

    GitLab version 19.6.1, released today, fixed Ruby but still contains a vulnerable #nginx version (1.31.7).

    So if you have to use GitLab's bundled webserver nginx, you should at least disable #http2 and TLS1.3:

    nginx.org/en/security_advisori

    #GitLabOmnibus #tls13 #nginx2root #ruby2shell #ruby2ßhell

  2. The Nginx update has finally landed, and features are now re-enabled. Go: #http3 * #http2 = #fasterweb with #Nginx.

  3. ----------------

    🔍 Vulnerability Research: nginx2root
    ===================

    Xint Research reports five nginx vulnerabilities and a separate Linux kernel bug, with a working exploit for each. The most severe nginx issue, CVE-2026-123007, affects HTTP/2 configurations and can potentially allow unauthenticated remote code execution. The supplied article reports a chain from an nginx worker to host root through the kernel bug; it does not report active exploitation.

    🔹 Technical Details

    The nginx issue is in HTTP/2 flow control. According to the cited advisory, processing undisclosed traffic can cause the flow control window to exceed its permitted threshold, potentially producing a heap buffer overflow. A worker segmentation fault is the typical result described. The issue affects the data plane, not the control plane.

    Remote code execution is conditional: the advisory states that ASLR must be disabled or bypassed. Xint describes corrupting worker memory, leaking memory addresses, and overwriting a cleanup-function pointer that runs when the connection closes. Commands can then execute with worker privileges, with output returned over an existing connection.

    The article lists nginx versions 1.9.5 through 1.31.8 as affected and says the fix landed in 1.31.9. It does not provide separate version ranges for NGINX Plus or describe the other four nginx flaws. It also does not identify the kernel bug with a CVE.

    🔹 Attack Chain Analysis
    • 🎣 Initial access: an unauthenticated remote attacker sends traffic to an affected nginx HTTP/2 configuration.
    • ⚙️ Worker execution: heap corruption, an address leak and a cleanup-pointer overwrite are used to execute commands under worker privileges, subject to the ASLR condition.
    • 🛡️ Privilege escalation: a second flaw in Linux kernel SCTP code is required to reach root. CIRCL also confirmed that the kernel flaw is necessary for root in this chain.

    Xint says it tested the chain on AWS, GCP and Azure, including systems accessible through public IP addresses. The article does not provide the kernel exploit prerequisites or reproduction details, so those test results should not be generalized to every deployment.

    🔹 Scope and Verification

    Censys CEO Zakir Durumeric estimated that nearly 10 million internet services run versions vulnerable to the nginx2root CVEs. A Shodan scan on November 10 found that 98.9% of nginx servers with a known version ran a vulnerable release. These are version-based figures, not counts of exploitable hosts: HTTP/2 may be disabled and vendor fixes may be present.

    The article supplies no detection rule, traffic signature or indicators of compromise. Version, HTTP/2 configuration and vendor patch status are the concrete checks supported by its account. At publication, no active attacks had been reported and CVE-2026-123007 was not listed in CISA's Known Exploited Vulnerabilities catalog.

    Xint attributes the initial discovery to an AI-assisted review of roughly 50,000 lines selected by a researcher. It reports a finding in 90 minutes and a working exploit derived from the reproduction steps in under ten more minutes. Those timings are Xint's account; the supplied article does not independently verify them.

    🔹 nginx #CVE_2026_123007 #HTTP2 #Linux

    🔗 Source: securityaffairs.com/203440/hac

  4. Je suis chez #OVH et je remarque (seulement maintenant) qu'aucun de mes sites hébergés chez eux n'est en HTTP/2. Je ne comprends pas.

    D'après ce que j'ai pu lire, il faut soit obligatoirement l'option CDN (!), soit avoir simplement son site en HTTPS (ils le sont), mais dans tous les cas, il n'y a aucun paramétrage disponible sur l'interface de gestion... Bref, ce n'est vraiment pas clair.

    Quelqu'un aurait une idée ?

    #http2 #apache

  5. F5 vydalo bezpečnostní aktualizaci NGINX, která opravuje dvě kritické chyby v implementaci HTTP/2. Útočník je může zneužít bez autentizace ke spuštění libovolného kódu na serveru. Obě mají v CVSS 4.0 skóre 9,2. CVE-2026-123007 je chyba v počítání flow control. Postihuje verze 1.9.5 až 1.31.8, je tedy v kódu už od roku 2015, a podle Wiz je zneužitelná i ve výchozí […]

    https://zdrojak.cz/zpravicky/dve-kriticke-zranitelnosti-v-http-2-umoznuji-vzdalene-spusteni-kodu-v-nginx/
  6. 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
  7. It might be time for me to walk the talk and switch to a Rust-based HTTP server, although there's a lot of convenience in Nginx's plug-and-play configuration and automatic updates via Debian packaging (even though that's not a panacea, as the Debian security track doesn't have particular SLAs about integrating upstream patches for vulnerabilities as far as I can tell).

    #Nginx #HTTP2 #Rust #webserver

  8. Heads up: I just disabled HTTP/2 on my website to mitigate vulnerabilities disclosed in Nginx: wiz.io/blog/nginx-http2-rce-vu. The impact should be minimal although my website might appear a few ms slower than usual.

    Debian stable/security hasn't yet picked up the patches: packages.debian.org/stable/ngi (last changelog entry was from October 15: metadata.ftp-master.debian.org).

    #Nginx #HTTP2 #webserver

  9. I am so glad I switched to Caddy as my Web server everywhere

    #Nginx #HTTP2 #Caddy #Caddyserver

  10. TIL: any old nginx virtual host enabling http2 leads to http2 being enabled for the whole server. #nginx #http2

  11. Two CVEs this morning affecting #nginx and allowing #RCE (remote code execution). Disabling HTTP/2 seems to be a temporary fix. Apparently this also affects the nginx #IngressController for #Kubernetes (if you're still using that). Long term fix here is to migrate to somthing like the #Traefik Ingress Controller.

    • CVE-2026-123633
    • CVE-2026-123007

    #CVE #HTTP #HTTP2

  12. NGINX2Root vulnerabilities hit nginx HTTP/2, HTTP/3, resolver and mail proxy. Update to 1.30.7 or 1.31.9, restart, and block SCTP until a kernel fix ships.

    #NGINX2Root #nginx #CyberSecurity #HTTP2 #LinuxKernel #F5

    dailytechnow.com/nginx2root-vu

  13. 📢 PoC publié pour CVE-2026-123007 : integer underflow dans NGINX HTTP/2 permettant un RCE non authentifié

    Ce dépôt contient des scripts de preuve de concept (PoC) pour la vulnérabilité CVE-2026-123007, accompagnés d'une analyse technique disponible sur le blog Rapid7.

    📖 cyberveille : cyberveille.ch/posts/2026-11-1
    🌐 source : github.com/sfewer-r7/CVE-2026-
    🟡 vérification factuelle moyenne
    #HTTP2 #NGINX #Cyberveille

  14. 📢 RCE non authentifiée dans NGINX : deux failles critiques HTTP/2 (CVE-2026-123633 et CVE-2026-123007)

    Cet article présente la divulgation coordonnée de deux vulnérabilités critiques dans NGINX, le serveur web open-source le plus utilisé au monde (plus de 225 millions de sites). Les chercheurs de Wiz Research, Ikotas Labs, Metnir, Rapid7 et Xint ont…

    📖 cyberveille : cyberveille.ch/posts/2026-11-1
    🌐 source : wiz.io/blog/nginx-http2-rce-vu
    🟢 vérification factuelle haute
    #HTTP2 #NGINX #Cyberveille

  15. CW: technikai részletek — 10 éve jelenlévő NGINX HTTP/2 hiba (CVE‑2026‑123007, „nginx2root”) hitelesítés nélkül kódfuttatást tesz lehetővé HTTP/2 engedélyezett szervereken; érintett: nyílt forrás 1.9.5–1.31.8. Javítva: 1.31.9 és 1.30.7. PoC nyilvános; ASLR megkerülése és konténerből való emelkedés lehetséges. Ellenőrizd az HTTP/2-t és frissíts. #NGINX #CVE2026 #HTTP2 #infosec #Linux
    linuxmint.hu/hir/2026/11/10-ev

  16. Server admins using #nginx, please take a look at this!

    nginx2root.com

    :boost_requested: :boost_animated:

    #http2 #http3

  17. Sigh.

    cd /etc/nginx/
    cp -a sites-available sites-available.backup
    sed -i -e 's/http2 on/http2 off/' sites-available/*
    sed -i -e 's/\(listen .*\) http2\(.*\)/\1\2/' sites-available/*
    diff -ur sites-available.backup sites-available|less
    nginx -t && systemctl restart nginx

    #nginx #HTTP2

  18. If you're operating a Tor WebTunnel bridge with nginx, please disable http2 ASAP!

    wiz.io/blog/nginx-http2-rce-vu

    #tor #privacy #foss #nginx #http2

  19. BREAKING: Two critical Nginx flaws in the HTTP/2 implementation let an unauthenticated attacker run code on the server. CVE-2026-123633 and CVE-2026-123007. Both have scored an astonishingly high score of CVSS 9.2 and researchers have demonstrated RCE and code execution that gets past ASLR. Researchers got RCE against a server which served only static files.

    One of these vulnerabilities of Nginx existed since 2015. The other one for nearly 6 years. Nginx runs more than 225 million websites online albeit not all are vulnerable but most are. The primary requirement is to have HTTP/2 enabled. Also, each flaw has additional conditions.

    Several research teams have found them independently. Nginx has released fixes in the versions 1.30.7 and 1.31.9. If you cannot patch and update right now, the only stopgap mitigation is disabling HTTP/2. Some have touted it as Nginx2Root.

    Full technical analysis, exploitation details, affected versions and mitigation steps: thecybersecguru.com/exploits/n

    #Nginx #CyberSecurity #Linux #HTTP2 #RCE

  20. 🚨 BREAKING: TWO CRITICAL NGINX VULNERABILITIES ALLOW HACKERS TO EXECUTE CODE ON WEB SERVERS WITHOUT AUTHENTICATION.

    Full technical breakdown, affected versions and mitigation steps ↓
    thecybersecguru.com/exploits/n

    Tracked as CVE-2026-123633 and CVE-2026-123007, both flaws carry a CVSS score of 9.2 and affect NGINX servers with HTTP/2 enabled.

    Security researchers have demonstrated remote code execution, including an ASLR bypass. One of the vulnerabilities has been hiding in NGINX since 2015, affecting code used by web servers for over a decade. The concerning part? Attackers don't need to exploit the website or application itself. Even an NGINX server hosting ordinary static files can be vulnerable.

    NGINX powers more than 225 million websites worldwide, although not all installations are affected. Security fixes are available in NGINX 1.30.7 and 1.31.9. Administrators unable to patch immediately should consider temporarily disabling HTTP/2.

    #NGINX #CyberSecurity #RCE #HTTP2 #Vulnerability

  21. Two serious NGINX flaws, CVE-2026-123633 and CVE-2026-123007, were disclosed on 18 November 2026.

    Both require NGINX to accept HTTP/2 connections, and exposure depends on version and configuration.

    Wiz demonstrated code execution for CVE-2026-123007 on NGINX serving static files alone; affected Open Source versions range from 1.9.5 to 1.30.6 and 1.31.0 to 1.31.8.

    Versions 1.30.7 and 1.31.9 fix both flaws.

    Use in attacks a…

    en.hacks.gr/dyo-sovara-provlim

    #NGINX #HTTP2 #CVE2026123633 #CVE2026123007

  22. 🚨 Critical RCE in Apache HTTP Server. Patch immediately.

    Apache has released HTTP Server 2.4.71 to fix CVE-2026-119618, a critical heap corruption vulnerability in its HTTP/2 module (mod_http2).

    The flaw is caused by a race condition in the assign_headers() function, where concurrent execution involving shared resources and improper synchronization can lead to remote code execution.

    Affected versions:
    Apache HTTP Server 2.4.55 through 2.4.70
    Standalone GitHub mod_h2 releases 2.0.8 through 2.0.42

    The vulnerability was independently reported by Anthropic's OSS Scanner and Google Cloud Vulnerability Research.

    ⚠️ Apache rates this vulnerability CRITICAL. Upgrade to Apache HTTP Server 2.4.71 immediately.

    If patching is delayed, disabling HTTP/2 can serve as a temporary risk-reduction measure, but it is not a substitute for upgrading.

    Full technical breakdown, vulnerability analysis and mitigation:
    thecybersecguru.com/news/apach

    #CyberSecurity #InfoSec #Apache #ApacheHTTPServer #HTTP2 #RCE #CVE2026119618 #VulnerabilityManagement

  23. Apache HTTP Server patches critical HTTP/2 remote code execution flaw

    bleepingcomputer.com/news/secu
    - - -
    Apache HTTP Server corrige une vulnérabilité critique d’exécution de code distant dans l’implémentation HTTP/2

    // Article en anglais //

    #Apache #HTTP2 #InfoSec #InformationSecurity #Cybersécurité

  24. «Kritische Sicherheitslücke in Apache2 ermöglicht Codeeinschleusung:
    Nur Server mit aktiviertem HTTP/2 sind betroffen, Updates sind angeraten. Ein Exploit ist möglich, aber schwierig.»

    Mist! Hoffentlich gehen dies alle Webdienstleister, die Apache2 einsetzen, dem nach gehen und beheben, updaten. Sehr viele Webserver beruhen sich meines Wussens darauf.

    💥 heise.de/news/Kritische-Sicher

    #apache2 #webserver #sicherheitslucke #apache #internet #web #itsicherheit #http2 #http2shell #code #http #schadcode

  25. Node.js has released security updates addressing 16 vulnerabilities affecting its built-in HTTP/2, HTTPS, and TLS software, with seven issues rated as high severity.

    The fixes arrive in versions 22.23.5, 24.22.3, and 26.13.1.

    The flaws include memory disclosures and potential server crashes, though no active exploitation has been reported.

    Older versions that have reached end-of-life do not receive patches.

    en.hacks.gr/epeigoysa-enimeros

    #Nodejs #TLS #HTTP2 #SecurityUpdate

  26. RE: social.tchncs.de/@sadmin/11760

    Soderle, erst mal HTTP2 disabled. Bei Apache2 unter Linux (Debian/Ubuntu) mit

    # a2dismod http2

    und dann

    # service apache2 restart

    #CVE #RCE #Apache #http2 #http2shell #serveradmin

Share on Mastodon

Enter the server where you have an account.