• https://cwe.mitre.org/data/definitions/1357.html

Es cuando una API confía ciegamente en los datos o servicios de otras APIs (propias o de terceros) sin aplicar las validaciones y controles de seguridad adecuados.

El Problema Fundamental: "Confiamos en esta API porque es nuestra/oficial/de un partner" → Relajamos seguridad → Vulnerabilidades en cadena

Flujo del Problema:

API Maliciosa/Comprometida → Datos Tóxicos → Tu API (confiada) → Tu Sistema (infectado)

La comunicación entre API puede dar lugar a varias vulnerabilidades críticas:

• Transmisión de datos insegura: las API que se comunican a través de canales no cifrados exponen los datos confidenciales a la interceptación, lo que compromete la confidencialidad y la integridad.
• Validación de datos inadecuada: si no se validan y limpian adecuadamente los datos recibidos de API externas antes de procesarlos o reenviarlos a componentes posteriores, se pueden producir ataques de inyección, corrupción de datos o incluso ejecución remota de código.
• Autenticación débil: no implementar métodos de autenticación robustos al comunicarse con otras API puede dar lugar a un acceso no autorizado a datos confidenciales o funciones críticas.
• Limitación de velocidad insuficiente: una API puede saturar otra API enviando una avalancha continua de solicitudes, lo que puede provocar una denegación de servicio.
• Supervisión inadecuada: una supervisión insuficiente de las interacciones entre API puede dificultar la detección y la respuesta rápida a los incidentes de seguridad.

Ejemplos:

Cadena de Confianza Rota

// TU API confía en API de Tercero
app.get('/api/user-profile', async (req, res) => {
    // Confía ciegamente en la API de identidad
    const userData = await fetch('https://identity-provider.com/api/user/' + req.user.id);
    const user = await userData.json();
    
    // ¡Sin validar lo que recibió!
    res.json({
        name: user.name,
        email: user.email,
        role: user.role,  // ¿Y si el tercero envía "role": "admin"?
        preferences: user.preferences
    });
});

Inyección a Través de Otra API

# API interna procesa datos de API externa sin validar
@api.route('/api/process-order', methods=['POST'])
def process_order():
    order_data = request.json
    
    # Obtener información de producto de API de catálogo
    product_info = requests.get(
        f"https://catalog-api.internal/products/{order_data['product_id']}"
    ).json()
    
    # ¡Confía en los datos del catálogo!
    query = f"""
    INSERT INTO orders (product_name, price, user_id) 
    VALUES ('{product_info['name']}', {product_info['price']}, {user_id})
    """
    # SQL Injection si el catálogo fue comprometido!

Ataque de Supply Chain

// Tu API usa un servicio de pago de tercero
app.post('/api/payment', async (req, res) => {
    const paymentResult = await fetch('https://third-party-payment.com/process', {
        method: 'POST',
        body: JSON.stringify({
            amount: req.body.amount,
            card: req.body.card
        })
    });
    
    // Confía en la respuesta del servicio de pago
    const result = await paymentResult.json();
    
    if (result.status === 'approved') {
        // Marcar pedido como pagado - ¡PERO el pago podría ser falso!
        updateOrderStatus(req.body.order_id, 'paid');
    }
});

Vulnerabilidades Específicas

Insecure Data Transmission

# PELIGROSO: HTTP sin encriptación
response = requests.get('http://internal-api.company.com/users')

# SEGURO: Siempre HTTPS
response = requests.get('https://internal-api.company.com/users', 
                       verify='/path/to/certificate.pem')  # Verificar certificado

Inadequate Data Validation

// CONFIANZA PELIGROSA
public User processUserData(String externalApiData) {
    User user = objectMapper.readValue(externalApiData, User.class);
    
    // Asume que los datos ya fueron validados por la otra API
    userRepository.save(user);  // ¡Podría guardar datos maliciosos!
}

// ENFOQUE SEGURO
public User processUserData(String externalApiData) {
    User user = objectMapper.readValue(externalApiData, User.class);
    
    // Validar como si viniera directamente del usuario
    validateUserInput(user);
    sanitizeUserData(user);
    
    userRepository.save(user);
}

Weak Authentication Between APIs

# PELIGROSO: API Keys en URLs o sin rotación
https://internal-api.com/data?api_key=secret123

# PELIGROSO: Token estático en código
headers:
  Authorization: "Bearer static_long_lived_token"

# SEGURO: JWT con expiración corta + refresh
headers:
  Authorization: "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."

Insufficient Rate-Limiting

# Tu API llama a otra API sin límites
def call_external_api(data):
    for item in large_dataset:
        # Puede causar DoS a la API externa
        response = requests.post('https://external-api.com/process', 
                                json=item)

Inadequate Monitoring

No sabes:

• ¿Qué APIs estás consumiendo?
• ¿Qué datos estás recibiendo?
• ¿Hay patrones sospechosos?
• ¿Las APIs externas se comportan anormalmente?