Detección de Shadow APIs

Definición

La Detección de Shadow APIs es la práctica especializada de identificar endpoints de APIs no documentados, no gestionados o no autorizados en entornos de producción utilizando herramientas automatizadas, análisis de tráfico y técnicas de escaneo de seguridad. Combina métodos de API Discovery con análisis enfocado en seguridad para encontrar APIs que representan riesgo inmediato.

Mientras que API Discovery responde ampliamente “¿qué APIs existen?”, la Detección de Shadow APIs se dirige específicamente a “¿qué APIs existen que no deberían?” o “¿qué APIs existen sin controles de seguridad apropiados?” Las herramientas de detección buscan activamente patrones peligrosos: endpoints no autenticados que procesan datos sensibles, APIs obsoletas que aún reciben tráfico, o SDKs de terceros que hacen llamadas externas no autorizadas.

La detección es el primer paso en la remediación: no puedes arreglar lo que no sabes que existe. La detección efectiva combina múltiples enfoques (análisis de tráfico, escaneo de código, escaneo de infraestructura y sondeo activo) para construir una imagen completa de la verdadera superficie de ataque de APIs de una organización.

Ejemplo

Detección en Acción:

Una empresa ejecuta herramientas de detección de Shadow APIs y descubre:

Análisis de Tráfico (Akto):

• 47 endpoints recibiendo tráfico de producción que no están en la documentación de APIs
• /api/internal/debug expuesto públicamente (debería ser solo interno)
• /v1/admin/users no tiene autenticación configurada

Escaneo de Código (Spectral):

• 23 rutas de API definidas en repositorios pero no registradas en el inventario
• 12 endpoints con claves de API o secretos embebidos en el código
• 8 endpoints usando métodos de autenticación obsoletos

Escaneo de Infraestructura (Scanner K8s personalizado):

• 34 servicios de Kubernetes con tipo LoadBalancer no registrados en el inventario
• 19 funciones de AWS Lambda con triggers HTTP y sin políticas IAM
• 7 etapas de API Gateway marcadas como “dev” pero recibiendo tráfico de producción

Resultado: 103 candidatos a Shadow API que requieren clasificación. Los elementos de alta prioridad (endpoints públicos de administración, acceso a PII sin autenticación) escalados inmediatamente.

Analogía

La Auditoría de Seguridad: Imagina auditar un edificio grande en busca de puntos de acceso no autorizados. Verificarías puertas (entradas oficiales), ventanas (entradas potenciales) y pasajes ocultos (entradas no autorizadas). La Detección de Shadow APIs es esta auditoría para tu infraestructura: verificar sistemáticamente cada punto de entrada posible, comparar lo documentado vs. lo que realmente existe y marcar discrepancias para investigación.

El Inventario Forestal: Un servicio forestal no solo confía en mapas antiguos—vuelan drones, usan imágenes satelitales y envían topógrafos a pie para contar árboles reales. La Detección de Shadow APIs usa enfoques multi-método similares: logs (vista aérea), código (imágenes satelitales) y escaneo de infraestructura (botas en el terreno) para encontrar la realidad completa.

Ejemplo de Código

Script de Detección (Análisis de Tráfico + Escaneo de Código):

#!/bin/bash
# shadow-api-detect.sh
# Detección comprehensiva de Shadow APIs

echo "=== Detección de Shadow APIs ==="

# 1. Análisis de Tráfico: Extraer endpoints únicos de logs
echo "[1/5] Analizando logs de tráfico..."
cat /var/log/api-gateway/*.log \
  | grep "HTTP/1.1" \
  | awk '{print $7}' \
  | sort -u > detected-traffic.txt
echo "Se encontraron $(wc -l < detected-traffic.txt) endpoints únicos en el tráfico"

# 2. Escaneo de Código: Encontrar rutas de API en código fuente
echo "[2/5] Escaneando código fuente en busca de rutas de API..."
# Rutas Express.js
grep -rh "app\.\(get\|post\|put\|delete\|patch\)" --include="*.js" . \
  | grep -oP '["'\'']\/api\/[^"'\'']+' \
  | sort -u > detected-code.txt
echo "Se encontraron $(wc -l < detected-code.txt) rutas de API en el código"

# 3. OpenAPI Spec: Cargar endpoints documentados
echo "[3/5] Cargando endpoints documentados desde especificación OpenAPI..."
yq '.paths | keys | .[]' openapi.yaml | sort -u > documented.txt
echo "Se encontraron $(wc -l < documented.txt) endpoints documentados"

# 4. Identificar Shadow APIs
echo "[4/5] Comparando tráfico y código contra documentación..."

# Shadow APIs basadas en tráfico
comm -23 detected-traffic.txt documented.txt > shadow-from-traffic.txt
echo "  Análisis de tráfico: $(wc -l < shadow-from-traffic.txt) Shadow APIs"

# Shadow APIs basadas en código
comm -23 detected-code.txt documented.txt > shadow-from-code.txt
echo "  Análisis de código: $(wc -l < shadow-from-code.txt) Shadow APIs"

# Combinar y deduplicar
cat shadow-from-traffic.txt shadow-from-code.txt | sort -u > shadow-apis.txt
TOTAL=$(wc -l < shadow-apis.txt)
echo "  TOTAL: $TOTAL candidatos a Shadow API"

# 5. Puntuación de Riesgo
echo "[5/5] Puntuando Shadow APIs por riesgo..."
> shadow-apis-scored.txt

while IFS= read -r endpoint; do
  RISK="MEDIUM"
  REASON=""

  # Alto riesgo: Endpoints de administración
  if echo "$endpoint" | grep -qi "admin"; then
    RISK="HIGH"
    REASON="$REASON [Endpoint admin]"
  fi

  # Alto riesgo: Endpoints debug/internal
  if echo "$endpoint" | grep -qiE "debug|internal|test"; then
    RISK="HIGH"
    REASON="$REASON [Debug/internal]"
  fi

  # Crítico: Endpoints de datos de usuario/cliente
  if echo "$endpoint" | grep -qiE "user|customer|account|profile"; then
    RISK="CRITICAL"
    REASON="$REASON [Datos de usuario]"
  fi

  # Medio: v1 (potencialmente obsoleta)
  if echo "$endpoint" | grep -q "/v1/"; then
    RISK="MEDIUM"
    REASON="$REASON [Versión legacy]"
  fi

  echo "$RISK | $endpoint | $REASON" >> shadow-apis-scored.txt
done < shadow-apis.txt

# Ordenar por riesgo (CRITICAL > HIGH > MEDIUM)
sort -t'|' -k1,1 shadow-apis-scored.txt

echo ""
echo "=== Resumen ==="
echo "CRITICAL: $(grep -c "^CRITICAL" shadow-apis-scored.txt)"
echo "HIGH:     $(grep -c "^HIGH" shadow-apis-scored.txt)"
echo "MEDIUM:   $(grep -c "^MEDIUM" shadow-apis-scored.txt)"
echo ""
echo "Reporte completo: shadow-apis-scored.txt"

Detección con Akto (Herramienta Open Source):

# Instalar Akto
docker run -d -p 8080:8080 aktosecurity/akto

# Apuntar Akto a la fuente de tráfico
# Opción 1: Duplicar tráfico desde API Gateway
kubectl apply -f akto-traffic-mirror.yaml

# Opción 2: Analizar logs existentes
curl -X POST http://localhost:8080/api/analyze-logs \
  -H "Content-Type: application/json" \
  -d '{
    "logSource": "s3://my-bucket/api-gateway-logs/",
    "timeRange": "7d"
  }'

# Ver APIs detectadas
curl http://localhost:8080/api/endpoints | jq '.[] | select(.isDocumented == false)'

# Output: Lista de Shadow APIs con puntuaciones de riesgo

Diagrama

graph TB
    A[Detección de Shadow APIs] --> B[Análisis de Tráfico]
    A --> C[Escaneo de Código]
    A --> D[Escaneo de Infraestructura]
    A --> E[Sondeo Activo]

    B --> B1[Logs API Gateway]
    B --> B2[Logs Load Balancer]
    B --> B3[Logs WAF]

    C --> C1[Repositorios Git]
    C --> C2[Specs OpenAPI]
    C --> C3[Templates IaC]

    D --> D1[Kubernetes]
    D --> D2[Cloud Functions]
    D --> D3[Contenedores]

    E --> E1[OWASP ZAP]
    E --> E2[Burp Suite]
    E --> E3[Nuclei]

    B1 --> F[Endpoints Detectados]
    B2 --> F
    B3 --> F
    C1 --> F
    C2 --> F
    C3 --> F
    D1 --> F
    D2 --> F
    D3 --> F
    E1 --> F
    E2 --> F
    E3 --> F

    F --> G[Comparar con APIs Documentadas]
    G --> H[Candidatos a Shadow API]
    H --> I[Puntuación de Riesgo]
    I --> J[Remediación Priorizada]

    style A fill:#bbdefb
    style F fill:#fff9c4
    style H fill:#ffcdd2
    style J fill:#c8e6c9

Notas de Seguridad

Métodos de Detección Comparados

Recomendado: Combinar los cuatro métodos para detección comprehensiva.

Errores Comunes

Error 1: Escaneo único Las Shadow APIs aparecen constantemente. La detección debe ser continua (diaria/semanal), no una auditoría única.

Error 2: Sin proceso de clasificación Encontrar 200 Shadow APIs es inútil sin priorización. ¿Cuáles son CRÍTICAS? ¿Cuáles pueden esperar? Implementa puntuación de riesgo.

Error 3: Detección sin plan de remediación Descubrir Shadow APIs es el paso 1. También necesitas: asignación de propietarios, proceso de revisión de seguridad y plan de migración/retirada.

Error 4: Usar solo análisis de tráfico El análisis de tráfico pierde Shadow APIs no utilizadas. Un endpoint vulnerable con cero tráfico sigue siendo un riesgo—los atacantes lo encontrarán.

Error 5: Ignorar falsos positivos No todos los endpoints detectados son Shadow APIs. Verificaciones de salud, endpoints de métricas y rutas CDN pueden aparecer como no documentados pero ser intencionados. Revisa manualmente.

Framework de Puntuación de Riesgo

Puntúa Shadow APIs usando esta rúbrica:

Riesgo = (Sensibilidad de Datos × Debilidad de Autenticación × Volumen de Tráfico) + Modificadores

Sensibilidad de Datos:
- Pública/no sensible: 1x
- Datos internos del negocio: 2x
- PII (información personal identificable): 3x
- PCI (datos de tarjetas de pago): 4x

Debilidad de Autenticación:
- OAuth2/JWT: 1x
- API Key: 2x
- Basic Auth: 3x
- Sin autenticación: 4x

Volumen de Tráfico:
- Cero tráfico: 1x
- <100 req/día: 1x
- 100-10K req/día: 2x
- >10K req/día: 3x

Modificadores:
- Endpoint admin: +2
- Keyword debug/internal: +2
- Versión obsoleta (v1, v2): +1
- Acceso externo (accesible desde internet): +2
- CVEs conocidos en dependencias: +3

Ejemplo:

• Endpoint /api/v1/admin/users
• Procesa PII (3x)
• Sin autenticación (4x)
• 5K solicitudes/día (2x)
• Endpoint admin (+2)
• Versión legacy (+1)
• Puntuación de Riesgo: (3 × 4 × 2) + 2 + 1 = 27 (CRÍTICO)

Herramientas para Detección de Shadow APIs

Open Source:

Akto (https://github.com/akto-api-security/akto)

• Análisis de tráfico desde logs, API Gateways, Kubernetes
• Detección automatizada de Shadow APIs
• Generación de specs OpenAPI desde tráfico

OWASP ZAP (https://www.zaproxy.org/)

• Escaneo activo de seguridad
• Descubrimiento de endpoints de API mediante spidering
• Detección automatizada de vulnerabilidades

Nuclei (https://github.com/projectdiscovery/nuclei)

• Escaneo basado en plantillas para patrones conocidos
• Escaneo rápido y paralelizado
• Plantillas contribuidas por la comunidad

Spectral (https://github.com/spectralops/spectral)

• Escaneo de código para definiciones de APIs y secretos
• Integración CI/CD
• Linting de OpenAPI

Enterprise (Comercial):

Salt Security

• Análisis de tráfico en tiempo real con ML
• Descubrimiento automatizado de Shadow APIs y puntuación de riesgo
• Detección de ataques a APIs

42Crunch

• Plataforma de seguridad de APIs con descubrimiento
• Protección en tiempo de diseño y ejecución
• Escaneo de vulnerabilidades

Traceable AI

• Descubrimiento de APIs impulsado por ML
• Detección y bloqueo de amenazas
• Monitoreo de cumplimiento

Noname Security

• Plataforma comprehensiva de seguridad de APIs
• Detección de Shadow APIs e inventario
• Protección en tiempo de ejecución

Flujo de Trabajo de Clasificación

Paso 1: Detectar (automatizado diario)

• Ejecutar análisis de tráfico, escaneo de código, escaneo de infraestructura
• Generar lista de candidatos a Shadow API

Paso 2: Puntuar (automatizado)

• Aplicar framework de puntuación de riesgo
• Ordenar por CRÍTICO > ALTO > MEDIO

Paso 3: Validar (manual, 1-2 horas)

• Revisar hallazgos CRÍTICOS manualmente
• Eliminar falsos positivos (verificaciones de salud, endpoints solo internos)
• Confirmar Shadow APIs reales

Paso 4: Asignar Propietarios (manual, 1 hora)

• Cruzar referencias con repositorios de código
• Identificar equipo/desarrollador que desplegó el endpoint
• Asignar propiedad en inventario de APIs

Paso 5: Remediar (varía)

• CRÍTICO: Acción inmediata (deshabilitar o asegurar en 24 horas)
• ALTO: Revisión de seguridad y plan en 7 días
• MEDIO: Registrar en inventario, programar deprecación

Mejores Prácticas

1. Automatizar detección: Análisis de tráfico diario, escaneos de código semanales
2. Combinar métodos: Tráfico + Código + Infraestructura para cobertura completa
3. Puntuar por riesgo: Priorizar hallazgos CRÍTICOS primero
4. Clasificar rápidamente: Shadow APIs CRÍTICAS necesitan respuesta en horas, no semanas
5. Rastrear en el tiempo: Dashboard mostrando nuevas Shadow APIs descubiertas cada semana
6. Integrar con inventario: Auto-registrar APIs detectadas para gestión continua
7. Medir éxito: Meta = cero Shadow APIs CRÍTICAS, <10 ALTAS en cualquier momento

Herramienta de Evaluación

Empieza aquí: Herramienta de Detección de Shadow APIs

Esta herramienta interactiva te ayuda a:

• Evaluar el nivel de riesgo de Shadow APIs de tu organización
• Elegir el enfoque de detección correcto para tu infraestructura
• Obtener un plan de implementación de detección personalizado
• Estimar esfuerzo y timeline para el primer escaneo de detección

Lectura Adicional

📚 Libro: “Cómo Identificar Shadow APIs Con Herramientas Open Source”

Guía comprehensiva para la Detección de Shadow APIs con implementaciones prácticas de herramientas:

• 🇬🇧 English Edition
• 🇪🇸 Spanish Edition

Cobertura detallada:

• Capítulo 3: Análisis de Tráfico con Akto (configuración paso a paso)
• Capítulo 4: Escaneo de Código con Spectral y scripts personalizados
• Capítulo 5: Escaneo de Infraestructura (AWS, Azure, GCP, Kubernetes)
• Capítulo 9: Matriz de Comparación de Herramientas (20+ herramientas evaluadas)
• Capítulo 10: Construyendo un Pipeline de Detección (integración automatizada CI/CD)

Términos Relacionados