CVE-2026-42945 - Analyse et reproduction de la vulnérabilité NGINX Rift

Vue d'ensemble

CVE-2026-42945 (nom de code « NGINX Rift ») est une vulnérabilité de dépassement de tampon de tas dans le module ngx_http_rewrite_module de NGINX, avec un score CVSS v4 de 9,2 (Critique).

Cette vulnérabilité a été découverte par l'équipe de recherche en sécurité depthfirst en avril 2026. Elle est restée latente pendant 18 ans depuis son introduction dans la version 0.6.27 de NGINX en 2008.

Périmètre impacté

• NGINX Open Source 0.6.27 ~ 1.30.0
• NGINX Plus R32 ~ R36
• NGINX Instance Manager 2.16.0 ~ 2.21.1
• F5 WAF for NGINX 5.9.0 ~ 5.12.1
• NGINX App Protect WAF 4.9.0 ~ 4.16.0 et 5.1.0 ~ 5.8.0
• NGINX Gateway Fabric 1.3.0 ~ 1.6.2 et 2.0.0 ~ 2.5.1
• NGINX Ingress Controller 3.5.0 ~ 3.7.2, 4.0.0 ~ 4.0.1, 5.0.0 ~ 5.4.1

Versions corrigées

• NGINX 1.31.0 (publié le 13 mai 2026)

Conditions de déclenchement

La vulnérabilité nécessite le modèle de configuration NGINX suivant pour être déclenchée :

location ~ ^/api/(.*)$ {
    rewrite ^/api/(.*)$ /internal?migrated=true;
    set $original_endpoint $1;
}

Conditions clés :

1. La chaîne de remplacement de la directive rewrite contient ? (point d'interrogation)
2. Une directive set ultérieure référence un groupe de capture d'expression régulière (comme $1)
3. L'URI de la requête contient des caractères échappables (comme +, &, %, etc.)

Analyse de la cause racine

Traitement en deux phases du moteur de scripts

Le moteur de scripts de NGINX utilise un traitement en deux phases pour exécuter les directives rewrite/set :

1. Première phase (calcul de la longueur) : calcule la taille mémoire nécessaire pour la chaîne finale
2. Deuxième phase (copie des données) : écrit les données réelles dans le tampon alloué

Dépassement dû à une incohérence d'état

Le cœur de la vulnérabilité réside dans une incohérence d'état du moteur entre les deux phases :

Phase 1 : rewrite définit le drapeau is_args

Lorsque la chaîne de remplacement de la directive rewrite contient ?, la fonction ngx_http_script_start_args_code définit :

void ngx_http_script_start_args_code(ngx_http_script_engine_t *e)
{
    e->is_args = 1;  // 永久设置，从不重置！
    e->args = e->pos;
    e->ip += sizeof(uintptr_t);
}

Phase 2 : le calcul de longueur de la directive set utilise un sous-moteur entièrement neuf

Lorsqu'une directive set ultérieure référence un groupe de capture, ngx_http_script_complex_value_code crée un sous-moteur entièrement à zéro :

void ngx_http_script_complex_value_code(ngx_http_script_engine_t *e)
{
    ngx_http_script_engine_t le;
    // ...
    ngx_memzero(&le, sizeof(ngx_http_script_engine_t)); // le.is_args = 0
    le.ip = code->lengths->elts;

Phase 3 : divergence entre le calcul de longueur et la copie réelle

Calcul de longueur (avec le sous-moteur le, is_args=0) :

// ngx_http_script_copy_capture_len_code
if ((e->is_args || e->quote) && (e->request->quoted_uri || e->request->plus_in_uri))
{
    // is_args=0，条件为 false，走 else 分支
    return cap[n + 1] - cap[n];  // 返回原始长度（未转义）
}

Copie réelle (avec le moteur principal e, is_args=1) :

// ngx_http_script_copy_capture_code
if ((e->is_args || e->quote) && (e->request->quoted_uri || e->request->plus_in_uri))
{
    // is_args=1，条件为 true，走 if 分支
    e->pos = (u_char *) ngx_escape_uri(pos, &p[cap[n]],
                                        cap[n + 1] - cap[n],
                                        NGX_ESCAPE_ARGS);
    // 每个可转义字符从 1 字节扩展为 3 字节！
}

Taille du dépassement

• Taille du tampon alloué : raw_size (longueur de capture d'origine)
• Taille réellement écrite : raw_size + 2 * N (N = nombre de caractères échappables)
• Quantité de dépassement = 2 * N octets

Par exemple, si l'URI contient 100 signes +, le dépassement est de 200 octets.

Méthodes d'exploitation

1. DoS (déni de service)

La méthode d'exploitation la plus simple : envoyer une requête contenant un grand nombre de caractères échappables suffit à provoquer le crash du processus worker :

GET /api/+++++++++++++++++++++++++++++++++++ HTTP/1.1
Host: target.com

2. RCE (exécution de code à distance)

Chaîne d'exploitation RCE complète (nécessite ASLR désactivé ou contourné) :

1. Contrôle de la disposition du tas : contrôle de la disposition du tas de ngx_pool_t via l'ordre des connexions
2. Écrasement du pointeur cleanup : le débordement atteint les structures adjacentes du pool mémoire
3. Spraying de structures cleanup falsifiées : injection via le corps de la requête POST de structures falsifiées contenant l'adresse de system()
4. Déclenchement de l'exécution : fermeture de la connexion victime, déclenchement du parcours de la liste chaînée cleanup par ngx_destroy_pool

L'architecture multiprocessus de NGINX rend l'exploitation plus fiable : après le crash d'un worker, le master crée un nouveau worker par fork avec une disposition mémoire identique.

Description des fichiers

• README.md - ce fichier, document d'analyse de la vulnérabilité
• Dockerfile - construit l'environnement NGINX vulnérable
• nginx.conf - configuration NGINX déclenchant la vulnérabilité
• poc_crash.py - PoC DoS (déclenche le crash du worker)
• docker-compose.yml - démarre l'environnement de test en une commande

Reproduction rapide

# 1. 构建并启动易受攻击的 NGINX
docker-compose up -d

# 2. 运行 DoS PoC
python3 poc_crash.py

# 3. 查看 NGINX 错误日志确认崩溃
docker-compose logs nginx

Références

• CHANGES officiel NGINX - annonce du correctif
• Rapport de recherche depthfirst - analyse technique du découvreur original de la vulnérabilité
• Bulletin de sécurité F5 K000160932 - bulletin de sécurité officiel

Avertissement

Ce document est fourni uniquement à des fins de recherche en sécurité et d'éducation. N'utilisez pas ces informations pour des attaques non autorisées.