Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
CVE2026-42926 — Laboratoire contrôlé d'injection de trames HTTP/2 NGINX pour la validation du correctif CVE-2026-42926 et la recherche défensive | Kitploit
Outils/GitHubGitHub/ikarolaborda/cve2026-42926
Outils DéfensifsAnalyse des VulnérabilitésAudit de ConfigurationSécurité WebApprentissage et ÉducationLabs et Pratique
GitHubikarolaborda/cve2026-42926

CVE2026-42926

Laboratoire contrôlé d'injection de trames HTTP/2 NGINX pour la validation du correctif CVE-2026-42926 et la recherche défensive

Voir le dépôt
4il y a 3 moisPas encore vérifié

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager

CVE-2026-42926 Laboratoire d'injection de trames HTTP/2 NGINX

Un laboratoire de cybersécurité contrôlé pour valider et comparer le comportement lié à CVE-2026-42926, un problème d'injection de trames HTTP/2 affectant des versions spécifiques de NGINX lorsqu'une configuration de proxy vulnérable est utilisée.

Ce dépôt est destiné uniquement à la recherche défensive, à la validation de correctifs, à l'audit de configuration et à la reproduction contrôlée en laboratoire.

Classification: injection de trames HTTP/2 Versions concernées : NGINX 1.29.4 à 1.30.0 Versions corrigées : NGINX 1.30.1+ / 1.31.0+

Avis de sécurité

Utilisez ce projet uniquement dans un environnement de laboratoire isolé que vous possédez ou pour lequel vous êtes explicitement autorisé à tester.

N'exécutez pas cela contre des systèmes tiers, des infrastructures publiques, des environnements partagés ou des services de production sans autorisation écrite.

Isolement recommandé :

  • Machine virtuelle locale
  • Conteneur jetable
  • Hôte de test privé
  • Réseau de laboratoire non routable

Ce que fait ce laboratoire

Le laboratoire vérifie si un binaire NGINX cible et sa configuration remplissent les conditions nécessaires pour reproduire le problème, envoie une requête conçue à l'emplacement de test et inspecte un enregistreur en amont contrôlé pour des preuves que des octets de type trame HTTP/2 injectés ont atteint le côté amont.

Le modèle de validation normal est :

  1. Exécutez la même configuration de proxy vulnérable avec une version vulnérable de NGINX.
  2. Exécutez la même configuration de proxy vulnérable avec une version corrigée de NGINX.
  3. Comparez les preuves en amont et les verdicts des scripts.

Résultat attendu :

  • Version vulnérable : des preuves d'injection peuvent être observées.
  • Version corrigée : aucune preuve d'injection ne devrait être observée.

Contenu du dépôt

FichierDescription
README.mdDocumentation du projet.
LICENSELicence MIT.
DockerfileConstruit une image de laboratoire autonome avec NGINX 1.29.4, PHP CLI/cURL, Python et les scripts du projet.
docker-compose.ymlDémarre le service NGINX vulnérable, l'enregistreur de trames en amont et un exécuteur de validation optionnel.
cve_2026_42926_lab.phpScript principal de validation du laboratoire. Il vérifie les préconditions de version/configuration, envoie la requête conçue, inspecte les journaux en amont et retourne un verdict.
nginx_vulnerable.confExemple de configuration NGINX contenant le motif de proxy vulnérable utilisé pour les exécutions de comparaison vulnérable et corrigée.
docker/nginx_vulnerable.docker.confConfiguration NGINX spécifique à Docker utilisant le même motif vulnérable et la découverte de service Compose.
nginx_config_verify.shUtilitaire qui vérifie si une configuration NGINX cible contient le motif de proxy vulnérable requis.
upstream_frame_logger.pyEnregistreur de trames HTTP/2 brutes contrôlé en amont utilisé pour capturer et inspecter les trames reçues de NGINX.
run_lab_comparison.shOrchestre les exécutions de comparaison vulnérable vs corrigée.
.dockerignoreEmpêche les journaux générés et les métadonnées IDE d'entrer dans le contexte de construction Docker.

Prérequis

  • Environnement shell Linux ou macOS
  • bash
  • python3
  • php
  • Extension PHP cURL
  • Binaires de test NGINX pour les versions que vous souhaitez comparer
  • Permission de lier le port d'écoute NGINX configuré

Pour le flux de travail conteneurisé :

  • Docker
  • Docker Compose v2

La configuration exemple écoute sur le port 80, ce qui nécessite généralement des privilèges root. Pour un laboratoire local sans privilèges, remplacez listen 80; dans nginx_vulnerable.conf par un port élevé disponible tel que 8080, puis utilisez l'URL cible correspondante dans la commande PHP.

Configuration

Rendez les scripts shell exécutables :

root@kitploit:~
chmod +x nginx_config_verify.sh run_lab_comparison.sh

Confirmez que PHP prend en charge cURL :

root@kitploit:~
php -m | grep -i curl

Confirmez que chaque binaire NGINX peut afficher sa version :

root@kitploit:~
/path/to/nginx -V

Configuration du laboratoire

Le fichier nginx_vulnerable.conf fourni contient le motif de test requis :

root@kitploit:~
location /exploit {
    proxy_pass http://127.0.0.1:8081;
    proxy_http_version 2;
    proxy_set_body $request_body;
    proxy_set_header Host $host;
    proxy_set_header Content-Length $content_length;
}

Détails importants :

  • proxy_http_version 2 active le proxy HTTP/2 vers l'enregistreur amont.
  • proxy_set_body $request_body utilise un corps de requête contrôlé par le client.
  • client_max_body_size 20m permet le corps de requête de 16 Mio conçu utilisé par le script de validation.
  • L'enregistreur amont écoute sur 127.0.0.1:8081 par défaut.

La configuration spécifique à Docker dans docker/nginx_vulnerable.docker.conf conserve le même motif de proxy vulnérable mais écoute sur le port 8080 du conteneur et proxy vers le nom de service Compose upstream:8081.

Démarrage rapide Docker : Laboratoire NGINX 1.29.4

Le Dockerfile construit NGINX 1.29.4 à partir des sources et installe les outils PHP/Python requis par le laboratoire. Compose exécute ensuite trois services à partir de la même image :

  • upstream : enregistreur de trames HTTP/2 brutes
  • nginx : NGINX 1.29.4 vulnérable utilisant docker/nginx_vulnerable.docker.conf
  • runner : commande de validation PHP unique

Construisez l'image du laboratoire :

root@kitploit:~
docker compose build

Démarrez l'enregistreur amont et NGINX vulnérable :

root@kitploit:~
docker compose up -d upstream nginx

Confirmez la version de NGINX intégrée :

root@kitploit:~
docker compose exec nginx nginx -V

Exécutez le script de validation dans le réseau Compose :

root@kitploit:~
docker compose --profile run run --rm runner

L'exécuteur utilise ces arguments dans le conteneur :

root@kitploit:~
php /lab/cve_2026_42926_lab.php \
  http://nginx:8080/exploit \
  /lab/upstream_logs \
  /lab/nginx_config_verify.sh \
  /usr/local/nginx/sbin/nginx \
  /lab/docker/nginx_vulnerable.docker.conf \
  /exploit

Les journaux en amont générés sont écrits dans le répertoire hôte :

root@kitploit:~
./upstream_logs/

Le service NGINX est également exposé sur l'hôte à :

root@kitploit:~
http://localhost:8080/version

Arrêtez et supprimez les conteneurs du laboratoire :

root@kitploit:~
docker compose down

Démarrage rapide : Exécution de validation unique

Démarrez l'enregistreur amont contrôlé :

root@kitploit:~
python3 upstream_frame_logger.py 8081 ./upstream_logs

Dans un autre terminal, démarrez NGINX avec la configuration exemple :

root@kitploit:~
/path/to/nginx -c "$PWD/nginx_vulnerable.conf"

Exécutez le script de validation :

root@kitploit:~
php cve_2026_42926_lab.php \
  http://localhost/exploit \
  ./upstream_logs \
  ./nginx_config_verify.sh \
  /path/to/nginx \
  "$PWD/nginx_vulnerable.conf" \
  /exploit

Arrêtez NGINX après l'exécution :

root@kitploit:~
/path/to/nginx -s stop

Si vous avez changé NGINX pour écouter sur un autre port, mettez à jour le premier argument. Par exemple :

root@kitploit:~
php cve_2026_42926_lab.php http://localhost:8080/exploit ./upstream_logs ./nginx_config_verify.sh /path/to/nginx "$PWD/nginx_vulnerable.conf" /exploit

Démarrage rapide : Comparaison vulnérable vs corrigé

Définissez les chemins vers les deux binaires NGINX et exécutez le harnais de comparaison :

root@kitploit:~
VULNERABLE_NGINX=/usr/local/nginx_1.29.4/sbin/nginx \
PATCHED_NGINX=/usr/local/nginx_1.30.1/sbin/nginx \
bash run_lab_comparison.sh

Remplacements de configuration optionnels :

root@kitploit:~
VULNERABLE_NGINX=/path/to/vulnerable/nginx \
PATCHED_NGINX=/path/to/patched/nginx \
VULNERABLE_CONFIG="$PWD/nginx_vulnerable.conf" \
PATCHED_CONFIG="$PWD/nginx_vulnerable.conf" \
bash run_lab_comparison.sh

Le script de comparaison écrit :

  • vulnerable_result.txt
  • patched_result.txt
  • upstream_logs_vulnerable/
  • upstream_logs_patched/

Vérification manuelle de la configuration

Utilisez nginx_config_verify.sh directement lorsque vous souhaitez simplement inspecter si une configuration contient le motif vulnérable :

root@kitploit:~
./nginx_config_verify.sh /path/to/nginx "$PWD/nginx_vulnerable.conf" /exploit

L'utilitaire vérifie :

  • proxy_http_version 2
  • proxy_set_body avec une variable
  • client_max_body_size d'au moins 16 Mio

Arguments du script

cve_2026_42926_lab.php accepte des arguments positionnels :

root@kitploit:~
php cve_2026_42926_lab.php <target_url> <upstream_log_dir> <config_script> <nginx_binary> <nginx_config> <location> [version_url]

Valeurs par défaut :

ArgumentDéfaut
target_urlhttp://localhost/exploit
upstream_log_dir./upstream_logs
config_script./nginx_config_verify.sh
nginx_binarynginx
nginx_config/etc/nginx/nginx.conf
location/exploit
version_urlhttp://localhost/version

Verdicts et codes de sortie

cve_2026_42926_lab.php retourne l'un des trois verdicts :

VerdictSignificationCode de sortie
positiveUne preuve d'injection de trame a été observée et corrélée à l'exécution.0
negativeLes préconditions ont été remplies et aucune preuve d'injection n'a été observée.1
inconclusiveUne ou plusieurs préconditions ou vérifications de preuve ont échoué.2

Une preuve positive nécessite que le script corrèle le marqueur d'exécution, l'en-tête de trame en amont observé, le drapeau de trame injectée et la version de NGINX affectée.

Artefacts de sortie

L'enregistreur amont écrit des fichiers JSON nommés comme :

root@kitploit:~
frames_<timestamp>.json

Chaque journal contient des métadonnées de trame HTTP/2 analysées, des extraits de charge utile, des décalages d'octets, des drapeaux de détection d'injection et des champs de corrélation d'exécution.

Le harnais de comparaison stocke des répertoires de journaux séparés pour les exécutions vulnérable et corrigée afin que les preuves des deux exécutions ne se mélangent pas.

Dépannage

Si le script PHP signale que l'utilitaire de configuration n'est pas exécutable, exécutez :

root@kitploit:~
chmod +x nginx_config_verify.sh

Si la requête retourne 413 Request Entity Too Large, augmentez client_max_body_size à au moins 16m ; la configuration exemple utilise 20m.

Si aucun journal en amont n'est créé, vérifiez que :

  • upstream_frame_logger.py est en cours d'exécution.
  • NGINX proxy vers 127.0.0.1:8081.
  • L'URL cible pointe vers l'écouteur NGINX configuré.
  • La requête a atteint l'emplacement /exploit.

Si NGINX ne parvient pas à lier le port 80, exécutez-le avec les privilèges appropriés dans un environnement de laboratoire ou modifiez la configuration pour un port élevé tel que 8080.

Si le résultat de la comparaison est non concluant, inspectez vulnerable_result.txt, patched_result.txt et les répertoires de journaux en amont correspondants pour la précondition qui a échoué.

Licence

Ce projet est sous licence MIT. Voir LICENSE pour plus de détails.

Télécharger l’outil