Inicio/Blog/Investigación de vulnerabilidades
Investigación de vulnerabilidadesPublicado · Actualizado ⚡ 15 min de lectura

Buenas prácticas de seguridad de API: cómo proteger endpoints REST y GraphQL [guía 2026]

Deja de publicar API rotas. Esta es la verdad sin adornos sobre cómo proteger endpoints REST y GraphQL antes de que tu startup acabe en un titular.

VG
Vladyslav Gusarov
Responsable de DevSecOps en Bryxe
Buenas prácticas de seguridad de API: cómo proteger endpoints REST y GraphQL [guía 2026]

Mira, estoy harto de ver los mismos errores básicos de seguridad de API en 2026. Publicas un endpoint nuevo. Crees que es seguro. Y entonces algún script kiddie vuelca toda tu tabla de usuarios porque olvidaste implementar una autorización básica a nivel de objeto.

Dejemos una cosa clara. Las buenas prácticas de seguridad de API no son solo un checklist. Son lo único que se interpone entre tu producto y una brecha de datos catastrófica.

Vamos a desmontar la seguridad de las API REST y a meternos de lleno en las vulnerabilidades de seguridad de GraphQL. Sin relleno. Solo la verdad cruda y fea sobre cómo te están pwneando las API por debajo.

Baño de realidad con el OWASP API Top 10

El OWASP API Top 10 no es una sugerencia. Es una lista de las formas exactas en que te van a vulnerar.

Mira, esto lo he visto cien veces. BOLA (Broken Object Level Authorization) sigue siendo el rey. Pasas un ID en la URL. No compruebas si el usuario autenticado es realmente el dueño de ese ID. Bum. Datos perdidos.

¿Mass assignment? Ni me hagas hablar. Vinculas a ciegas el JSON entrante a tus modelos de base de datos. Los atacantes meten {"is_admin": true} en el payload. Ahora tienen root. Es la forma perfecta de pegarte un tiro en el pie.

Fíjate en CVE-2023-37466 en ese popular ORM de Node.js. Vulnerabilidad de mass assignment de serie. Los desarrolladores lo llevaron a producción. Millones de registros expuestos.

Necesitas una validación estricta del payload. Elimina sin contemplaciones cualquier campo que no permitas explícitamente.

Autenticación rota: REST frente a GraphQL

Las buenas prácticas de autenticación de API no han cambiado mucho, pero la forma en que los desarrolladores las estropean sí.

Estoy harto de ver esto en las PR. Con REST suele ser predecible. Tienes endpoints como /api/login o /api/users/me. Les pones un middleware delante. Listo.

¿Y GraphQL? GraphQL es otra bestia. Tienes un único endpoint /graphql. Tu típico middleware de Express comprueba si el usuario ha iniciado sesión. ¿Pero qué pasa si la query llega a una mutation concreta que requiere permisos de administrador?

No basta con autorizar en el borde. Tienes que autorizar a nivel de resolver. La mayoría de los desarrolladores no lo hace. Dejan los resolvers abiertos de par en par.

Corrección de la autenticación REST en Express.js

Aquí tienes una ruta chapucera de Express.js con BOLA:

javascriptCódigo fuente
// DO NOT DO THIS
app.get('/api/users/:id', authenticate, async (req, res) => {
  const user = await db.Users.findByPk(req.params.id);
  res.json(user); // Any authenticated user can read ANY user's data. 
});

Seamos realistas. Arréglalo. Comprueba quién es el propietario.

javascriptCódigo fuente
// BETTER
app.get('/api/users/:id', authenticate, async (req, res) => {
  if (req.user.id !== req.params.id && !req.user.isAdmin) {
    return res.status(403).json({ error: 'Access denied. Nice try.' });
  }
  const user = await db.Users.findByPk(req.params.id);
  res.json(user);
});

Vulnerabilidades de seguridad de GraphQL: ataques de profundidad de query

GraphQL le da al cliente el poder de pedir exactamente lo que quiere. Eso es una forma enorme de pegarte un tiro en el pie.

Los atacantes pueden construir queries profundamente anidadas que ponen tu base de datos de rodillas. Es un ataque DoS clásico.

graphqlCódigo fuente
query {
  author(id: 1) {
    posts {
      author {
        posts {
          author {
            name
          }
        }
      }
    }
  }
}

Si no limitas la profundidad de las queries, tu servidor intentará resolver esto hasta quedarse sin memoria. Acaba con ello usando graphql-depth-limit.

Mira, esto lo he visto cien veces. En resumen: nunca confíes en las queries del cliente.

Rate limiting de API

El rate limiting de API no sirve solo para prevenir DoS. Sirve para frenar la fuerza bruta y el credential stuffing.

Si tu endpoint /login permite 1000 solicitudes por minuto, básicamente estás invitando a los atacantes a sacar por fuerza bruta las contraseñas de tus usuarios.

Implementa límites estrictos por IP y por ID de usuario. Usa Redis.

Aquí tienes un rate limiter básico para una ruta de API de Next.js con upstash/ratelimit:

typescriptCódigo fuente
import { Ratelimit } from '@upstash/ratelimit';
import { Redis } from '@upstash/redis';
import { NextResponse } from 'next/server';

const redis = new Redis({
  url: process.env.UPSTASH_REDIS_REST_URL,
  token: process.env.UPSTASH_REDIS_REST_TOKEN,
});

// Limit to 5 requests per 10 seconds
const ratelimit = new Ratelimit({
  redis: redis,
  limiter: Ratelimit.slidingWindow(5, '10 s'),
});

export async function POST(request: Request) {
  const ip = request.headers.get('x-forwarded-for') ?? '127.0.0.1';
  const { success } = await ratelimit.limit(ip);

  if (!success) {
    return NextResponse.json({ error: 'Too many requests. Chill.' }, { status: 429 });
  }

  // Handle auth logic...
  return NextResponse.json({ success: true });
}

API Key frente a OAuth2 frente a JWT: la comparativa

La dura verdad es esta. La gente se equivoca con esto constantemente. Vamos a desglosar el ROI y los casos de uso.

MétodoIdeal paraRiesgo de seguridadCoste de implementación
API KeyServidor a servidor, scripts sencillosAlto. Las claves se filtran en repos de GitHub constantemente.Bajo. Es literalmente una cadena en una cabecera.
JWTAutenticación stateless para SPA/móvilMedio. Si el secreto es débil, los atacantes falsifican tokens. No hay una revocación sencilla.Bajo-medio. Hay librerías, pero los casos límite son un horror.
OAuth2Delegación a terceros, SSOBajo (si se hace bien). Alto (si los desarrolladores la lían con los parámetros state).Alto. Flujos complejos, muchas piezas móviles.

Si estás construyendo un SaaS B2B, usa OAuth2 para la autenticación de usuarios y API Keys (con allowlist de IP y scopes ajustados) para el acceso programático. No los mezcles.

Cerrando este desastre

Mira. Proteger endpoints no tiene glamour. Es trabajo pesado. Pero es la única forma de sobrevivir.

Valídalo todo. Autoriza a nivel de objeto. Limita la tasa de solicitudes. Deja de confiar a ciegas en el JSON.

La dura verdad es esta. Ponte las pilas antes de la próxima auditoría.

En profundidad: anatomía de un exploit de mass assignment

Veamos exactamente cómo te quema el mass assignment. Imagina que tienes un endpoint REST para el registro de usuarios. Tomas el req.body entero y se lo pasas al método create de tu ORM.

Crees que el cliente solo envía email y password. Pero el atacante intercepta la solicitud y añade "role": "admin". Si tu modelo tiene un campo role y no filtras la entrada explícitamente, enhorabuena: acabas de darle acceso de administrador a un script kiddie cualquiera.

Esto pasa constantemente. Los desarrolladores se vuelven perezosos. No quieren escribir uno por uno los campos que esperan. Toman atajos. Y los atajos acaban en CVE.

La dura verdad es esta. ¿El ROI de arreglarlo? Enorme. Un solo bug de mass assignment puede comprometer toda tu base de datos. La corrección lleva cinco minutos. Escribe un DTO. Usa una librería de validación como Zod o Joi. Elimina las claves desconocidas. Así de simple.

La pesadilla de revocar JWT

A los desarrolladores les encantan los JWT porque son stateless. No tienes que consultar la base de datos para verificarlos. ¿Pero qué pasa cuando la cuenta de un usuario se ve comprometida? ¿Cómo revocas un token stateless?

No puedes. Al menos no fácilmente. Acabas construyendo una blocklist de tokens en Redis, lo que echa por tierra todo el sentido de ser stateless. Acabas de construir un sistema de cookies de sesión con pasos extra y peor seguridad.

Si usas JWT, mantén una expiración corta. 15 minutos como máximo. Usa refresh tokens guardados en cookies HTTP-only y secure para obtener nuevos JWT. Nunca guardes JWT en local storage. Un XSS te los robará en milisegundos.

Introspección de GraphQL: todo a la vista

Sinceramente, es una pesadilla. Por defecto, la mayoría de los servidores GraphQL tienen la introspección habilitada. Eso significa que cualquiera puede consultar el servidor y obtener un mapa completo de todo el esquema de tu API. Cada tipo, cada query, cada mutation. Es el sueño de cualquier atacante.

Les estás entregando los planos de tu aplicación. En producción, desactiva la introspección. Sin excepciones.

Pero espera, que la cosa empeora. Incluso con la introspección desactivada, herramientas como Clairvoyance pueden aprovechar las sugerencias de campos (cuando el servidor responde 'Did you mean X?') para sacar el esquema por fuerza bruta. Desactiva también las sugerencias en producción.

Webhooks y Server-Side Request Forgery (SSRF)

Construyes una API que permite a los usuarios registrar webhooks. El usuario te da una URL y, cuando ocurre un evento, tu servidor envía una solicitud POST a esa URL. Parece inofensivo.

Sinceramente, es una pesadilla. Hasta que el usuario registra un webhook que apunta a http://169.254.169.254/latest/meta-data/ en AWS. Ahora tu servidor está consultando el servicio de metadatos de EC2 y enviándole las credenciales de la nube al atacante.

El SSRF es muy traicionero. Tienes que validar las URL de los webhooks. Bloquea los rangos de IP internos. Bloquea localhost. Bloquea la IP de metadatos de la nube. Usa un proxy de salida si hace falta.

Deja de confiar en la entrada: el verdadero problema

En el fondo, todos los problemas de seguridad de API se reducen a confiar en la entrada. Confías en los parámetros de la URL. Confías en el cuerpo JSON. Confías en la estructura de la query de GraphQL. Deja de hacerlo.

Trata cada dato que llega del cliente como si fuera altamente radiactivo. Parsea, no valides. Si no encaja exactamente con el esquema que esperas, descarta la solicitud. Regístralo, lanza una alerta y sigue adelante.

En resumen

La dura verdad es esta. La seguridad es un trabajo constante y pesado. Los atacantes son cada vez más listos y nuestros stacks, cada vez más complejos. Haz bien lo básico y mitigarás el 99 % del ruido. Ignóralo y estarás escribiendo un post mortem público el próximo trimestre.

En profundidad: anatomía de un exploit de mass assignment

Veamos exactamente cómo te quema el mass assignment. Imagina que tienes un endpoint REST para el registro de usuarios. Tomas el req.body entero y se lo pasas al método create de tu ORM.

Crees que el cliente solo envía email y password. Pero el atacante intercepta la solicitud y añade "role": "admin". Si tu modelo tiene un campo role y no filtras la entrada explícitamente, enhorabuena: acabas de darle acceso de administrador a un script kiddie cualquiera.

Esto pasa constantemente. Los desarrolladores se vuelven perezosos. No quieren escribir uno por uno los campos que esperan. Toman atajos. Y los atajos acaban en CVE.

Estoy harto de ver esto en las PR. ¿El ROI de arreglarlo? Enorme. Un solo bug de mass assignment puede comprometer toda tu base de datos. La corrección lleva cinco minutos. Escribe un DTO. Usa una librería de validación como Zod o Joi. Elimina las claves desconocidas. Así de simple.

La pesadilla de revocar JWT

A los desarrolladores les encantan los JWT porque son stateless. No tienes que consultar la base de datos para verificarlos. ¿Pero qué pasa cuando la cuenta de un usuario se ve comprometida? ¿Cómo revocas un token stateless?

No puedes. Al menos no fácilmente. Acabas construyendo una blocklist de tokens en Redis, lo que echa por tierra todo el sentido de ser stateless. Acabas de construir un sistema de cookies de sesión con pasos extra y peor seguridad.

Si usas JWT, mantén una expiración corta. 15 minutos como máximo. Usa refresh tokens guardados en cookies HTTP-only y secure para obtener nuevos JWT. Nunca guardes JWT en local storage. Un XSS te los robará en milisegundos.

Introspección de GraphQL: todo a la vista

La dura verdad es esta. Por defecto, la mayoría de los servidores GraphQL tienen la introspección habilitada. Eso significa que cualquiera puede consultar el servidor y obtener un mapa completo de todo el esquema de tu API. Cada tipo, cada query, cada mutation. Es el sueño de cualquier atacante.

Les estás entregando los planos de tu aplicación. En producción, desactiva la introspección. Sin excepciones.

Pero espera, que la cosa empeora. Incluso con la introspección desactivada, herramientas como Clairvoyance pueden aprovechar las sugerencias de campos (cuando el servidor responde 'Did you mean X?') para sacar el esquema por fuerza bruta. Desactiva también las sugerencias en producción.

Webhooks y Server-Side Request Forgery (SSRF)

Construyes una API que permite a los usuarios registrar webhooks. El usuario te da una URL y, cuando ocurre un evento, tu servidor envía una solicitud POST a esa URL. Parece inofensivo.

Sinceramente, es una pesadilla. Hasta que el usuario registra un webhook que apunta a http://169.254.169.254/latest/meta-data/ en AWS. Ahora tu servidor está consultando el servicio de metadatos de EC2 y enviándole las credenciales de la nube al atacante.

El SSRF es muy traicionero. Tienes que validar las URL de los webhooks. Bloquea los rangos de IP internos. Bloquea localhost. Bloquea la IP de metadatos de la nube. Usa un proxy de salida si hace falta.

Deja de confiar en la entrada: el verdadero problema

En el fondo, todos los problemas de seguridad de API se reducen a confiar en la entrada. Confías en los parámetros de la URL. Confías en el cuerpo JSON. Confías en la estructura de la query de GraphQL. Deja de hacerlo.

Trata cada dato que llega del cliente como si fuera altamente radiactivo. Parsea, no valides. Si no encaja exactamente con el esquema que esperas, descarta la solicitud. Regístralo, lanza una alerta y sigue adelante.

En resumen

Mira, esto lo he visto cien veces. La seguridad es un trabajo constante y pesado. Los atacantes son cada vez más listos y nuestros stacks, cada vez más complejos. Haz bien lo básico y mitigarás el 99 % del ruido. Ignóralo y estarás escribiendo un post mortem público el próximo trimestre.

En profundidad: anatomía de un exploit de mass assignment

Veamos exactamente cómo te quema el mass assignment. Imagina que tienes un endpoint REST para el registro de usuarios. Tomas el req.body entero y se lo pasas al método create de tu ORM.

Crees que el cliente solo envía email y password. Pero el atacante intercepta la solicitud y añade "role": "admin". Si tu modelo tiene un campo role y no filtras la entrada explícitamente, enhorabuena: acabas de darle acceso de administrador a un script kiddie cualquiera.

Esto pasa constantemente. Los desarrolladores se vuelven perezosos. No quieren escribir uno por uno los campos que esperan. Toman atajos. Y los atajos acaban en CVE.

La dura verdad es esta. ¿El ROI de arreglarlo? Enorme. Un solo bug de mass assignment puede comprometer toda tu base de datos. La corrección lleva cinco minutos. Escribe un DTO. Usa una librería de validación como Zod o Joi. Elimina las claves desconocidas. Así de simple.

La pesadilla de revocar JWT

A los desarrolladores les encantan los JWT porque son stateless. No tienes que consultar la base de datos para verificarlos. ¿Pero qué pasa cuando la cuenta de un usuario se ve comprometida? ¿Cómo revocas un token stateless?

No puedes. Al menos no fácilmente. Acabas construyendo una blocklist de tokens en Redis, lo que echa por tierra todo el sentido de ser stateless. Acabas de construir un sistema de cookies de sesión con pasos extra y peor seguridad.

Si usas JWT, mantén una expiración corta. 15 minutos como máximo. Usa refresh tokens guardados en cookies HTTP-only y secure para obtener nuevos JWT. Nunca guardes JWT en local storage. Un XSS te los robará en milisegundos.

Introspección de GraphQL: todo a la vista

Seamos realistas. Por defecto, la mayoría de los servidores GraphQL tienen la introspección habilitada. Eso significa que cualquiera puede consultar el servidor y obtener un mapa completo de todo el esquema de tu API. Cada tipo, cada query, cada mutation. Es el sueño de cualquier atacante.

Les estás entregando los planos de tu aplicación. En producción, desactiva la introspección. Sin excepciones.

Pero espera, que la cosa empeora. Incluso con la introspección desactivada, herramientas como Clairvoyance pueden aprovechar las sugerencias de campos (cuando el servidor responde 'Did you mean X?') para sacar el esquema por fuerza bruta. Desactiva también las sugerencias en producción.

Webhooks y Server-Side Request Forgery (SSRF)

Construyes una API que permite a los usuarios registrar webhooks. El usuario te da una URL y, cuando ocurre un evento, tu servidor envía una solicitud POST a esa URL. Parece inofensivo.

Sinceramente, es una pesadilla. Hasta que el usuario registra un webhook que apunta a http://169.254.169.254/latest/meta-data/ en AWS. Ahora tu servidor está consultando el servicio de metadatos de EC2 y enviándole las credenciales de la nube al atacante.

El SSRF es muy traicionero. Tienes que validar las URL de los webhooks. Bloquea los rangos de IP internos. Bloquea localhost. Bloquea la IP de metadatos de la nube. Usa un proxy de salida si hace falta.

Deja de confiar en la entrada: el verdadero problema

En el fondo, todos los problemas de seguridad de API se reducen a confiar en la entrada. Confías en los parámetros de la URL. Confías en el cuerpo JSON. Confías en la estructura de la query de GraphQL. Deja de hacerlo.

Trata cada dato que llega del cliente como si fuera altamente radiactivo. Parsea, no valides. Si no encaja exactamente con el esquema que esperas, descarta la solicitud. Regístralo, lanza una alerta y sigue adelante.

En resumen

Sinceramente, es una pesadilla. La seguridad es un trabajo constante y pesado. Los atacantes son cada vez más listos y nuestros stacks, cada vez más complejos. Haz bien lo básico y mitigarás el 99 % del ruido. Ignóralo y estarás escribiendo un post mortem público el próximo trimestre.

En profundidad: anatomía de un exploit de mass assignment

Veamos exactamente cómo te quema el mass assignment. Imagina que tienes un endpoint REST para el registro de usuarios. Tomas el req.body entero y se lo pasas al método create de tu ORM.

Crees que el cliente solo envía email y password. Pero el atacante intercepta la solicitud y añade "role": "admin". Si tu modelo tiene un campo role y no filtras la entrada explícitamente, enhorabuena: acabas de darle acceso de administrador a un script kiddie cualquiera.

Esto pasa constantemente. Los desarrolladores se vuelven perezosos. No quieren escribir uno por uno los campos que esperan. Toman atajos. Y los atajos acaban en CVE.

Sinceramente, es una pesadilla. ¿El ROI de arreglarlo? Enorme. Un solo bug de mass assignment puede comprometer toda tu base de datos. La corrección lleva cinco minutos. Escribe un DTO. Usa una librería de validación como Zod o Joi. Elimina las claves desconocidas. Así de simple.

La pesadilla de revocar JWT

A los desarrolladores les encantan los JWT porque son stateless. No tienes que consultar la base de datos para verificarlos. ¿Pero qué pasa cuando la cuenta de un usuario se ve comprometida? ¿Cómo revocas un token stateless?

No puedes. Al menos no fácilmente. Acabas construyendo una blocklist de tokens en Redis, lo que echa por tierra todo el sentido de ser stateless. Acabas de construir un sistema de cookies de sesión con pasos extra y peor seguridad.

Si usas JWT, mantén una expiración corta. 15 minutos como máximo. Usa refresh tokens guardados en cookies HTTP-only y secure para obtener nuevos JWT. Nunca guardes JWT en local storage. Un XSS te los robará en milisegundos.

Introspección de GraphQL: todo a la vista

La dura verdad es esta. Por defecto, la mayoría de los servidores GraphQL tienen la introspección habilitada. Eso significa que cualquiera puede consultar el servidor y obtener un mapa completo de todo el esquema de tu API. Cada tipo, cada query, cada mutation. Es el sueño de cualquier atacante.

Les estás entregando los planos de tu aplicación. En producción, desactiva la introspección. Sin excepciones.

Pero espera, que la cosa empeora. Incluso con la introspección desactivada, herramientas como Clairvoyance pueden aprovechar las sugerencias de campos (cuando el servidor responde 'Did you mean X?') para sacar el esquema por fuerza bruta. Desactiva también las sugerencias en producción.

Webhooks y Server-Side Request Forgery (SSRF)

Construyes una API que permite a los usuarios registrar webhooks. El usuario te da una URL y, cuando ocurre un evento, tu servidor envía una solicitud POST a esa URL. Parece inofensivo.

Mira, esto lo he visto cien veces. Hasta que el usuario registra un webhook que apunta a http://169.254.169.254/latest/meta-data/ en AWS. Ahora tu servidor está consultando el servicio de metadatos de EC2 y enviándole las credenciales de la nube al atacante.

El SSRF es muy traicionero. Tienes que validar las URL de los webhooks. Bloquea los rangos de IP internos. Bloquea localhost. Bloquea la IP de metadatos de la nube. Usa un proxy de salida si hace falta.

Deja de confiar en la entrada: el verdadero problema

En el fondo, todos los problemas de seguridad de API se reducen a confiar en la entrada. Confías en los parámetros de la URL. Confías en el cuerpo JSON. Confías en la estructura de la query de GraphQL. Deja de hacerlo.

Trata cada dato que llega del cliente como si fuera altamente radiactivo. Parsea, no valides. Si no encaja exactamente con el esquema que esperas, descarta la solicitud. Regístralo, lanza una alerta y sigue adelante.

En resumen

Sinceramente, es una pesadilla. La seguridad es un trabajo constante y pesado. Los atacantes son cada vez más listos y nuestros stacks, cada vez más complejos. Haz bien lo básico y mitigarás el 99 % del ruido. Ignóralo y estarás escribiendo un post mortem público el próximo trimestre.

En profundidad: anatomía de un exploit de mass assignment

Veamos exactamente cómo te quema el mass assignment. Imagina que tienes un endpoint REST para el registro de usuarios. Tomas el req.body entero y se lo pasas al método create de tu ORM.

Crees que el cliente solo envía email y password. Pero el atacante intercepta la solicitud y añade "role": "admin". Si tu modelo tiene un campo role y no filtras la entrada explícitamente, enhorabuena: acabas de darle acceso de administrador a un script kiddie cualquiera.

Esto pasa constantemente. Los desarrolladores se vuelven perezosos. No quieren escribir uno por uno los campos que esperan. Toman atajos. Y los atajos acaban en CVE.

Mira, esto lo he visto cien veces. ¿El ROI de arreglarlo? Enorme. Un solo bug de mass assignment puede comprometer toda tu base de datos. La corrección lleva cinco minutos. Escribe un DTO. Usa una librería de validación como Zod o Joi. Elimina las claves desconocidas. Así de simple.

La pesadilla de revocar JWT

A los desarrolladores les encantan los JWT porque son stateless. No tienes que consultar la base de datos para verificarlos. ¿Pero qué pasa cuando la cuenta de un usuario se ve comprometida? ¿Cómo revocas un token stateless?

No puedes. Al menos no fácilmente. Acabas construyendo una blocklist de tokens en Redis, lo que echa por tierra todo el sentido de ser stateless. Acabas de construir un sistema de cookies de sesión con pasos extra y peor seguridad.

Si usas JWT, mantén una expiración corta. 15 minutos como máximo. Usa refresh tokens guardados en cookies HTTP-only y secure para obtener nuevos JWT. Nunca guardes JWT en local storage. Un XSS te los robará en milisegundos.

Introspección de GraphQL: todo a la vista

Sinceramente, es una pesadilla. Por defecto, la mayoría de los servidores GraphQL tienen la introspección habilitada. Eso significa que cualquiera puede consultar el servidor y obtener un mapa completo de todo el esquema de tu API. Cada tipo, cada query, cada mutation. Es el sueño de cualquier atacante.

Les estás entregando los planos de tu aplicación. En producción, desactiva la introspección. Sin excepciones.

Pero espera, que la cosa empeora. Incluso con la introspección desactivada, herramientas como Clairvoyance pueden aprovechar las sugerencias de campos (cuando el servidor responde 'Did you mean X?') para sacar el esquema por fuerza bruta. Desactiva también las sugerencias en producción.

Webhooks y Server-Side Request Forgery (SSRF)

Construyes una API que permite a los usuarios registrar webhooks. El usuario te da una URL y, cuando ocurre un evento, tu servidor envía una solicitud POST a esa URL. Parece inofensivo.

Seamos realistas. Hasta que el usuario registra un webhook que apunta a http://169.254.169.254/latest/meta-data/ en AWS. Ahora tu servidor está consultando el servicio de metadatos de EC2 y enviándole las credenciales de la nube al atacante.

El SSRF es muy traicionero. Tienes que validar las URL de los webhooks. Bloquea los rangos de IP internos. Bloquea localhost. Bloquea la IP de metadatos de la nube. Usa un proxy de salida si hace falta.

Deja de confiar en la entrada: el verdadero problema

En el fondo, todos los problemas de seguridad de API se reducen a confiar en la entrada. Confías en los parámetros de la URL. Confías en el cuerpo JSON. Confías en la estructura de la query de GraphQL. Deja de hacerlo.

Trata cada dato que llega del cliente como si fuera altamente radiactivo. Parsea, no valides. Si no encaja exactamente con el esquema que esperas, descarta la solicitud. Regístralo, lanza una alerta y sigue adelante.

En resumen

Estoy harto de ver esto en las PR. La seguridad es un trabajo constante y pesado. Los atacantes son cada vez más listos y nuestros stacks, cada vez más complejos. Haz bien lo básico y mitigarás el 99 % del ruido. Ignóralo y estarás escribiendo un post mortem público el próximo trimestre.

En profundidad: anatomía de un exploit de mass assignment

Veamos exactamente cómo te quema el mass assignment. Imagina que tienes un endpoint REST para el registro de usuarios. Tomas el req.body entero y se lo pasas al método create de tu ORM.

Crees que el cliente solo envía email y password. Pero el atacante intercepta la solicitud y añade "role": "admin". Si tu modelo tiene un campo role y no filtras la entrada explícitamente, enhorabuena: acabas de darle acceso de administrador a un script kiddie cualquiera.

Esto pasa constantemente. Los desarrolladores se vuelven perezosos. No quieren escribir uno por uno los campos que esperan. Toman atajos. Y los atajos acaban en CVE.

Seamos realistas. ¿El ROI de arreglarlo? Enorme. Un solo bug de mass assignment puede comprometer toda tu base de datos. La corrección lleva cinco minutos. Escribe un DTO. Usa una librería de validación como Zod o Joi. Elimina las claves desconocidas. Así de simple.

La pesadilla de revocar JWT

A los desarrolladores les encantan los JWT porque son stateless. No tienes que consultar la base de datos para verificarlos. ¿Pero qué pasa cuando la cuenta de un usuario se ve comprometida? ¿Cómo revocas un token stateless?

No puedes. Al menos no fácilmente. Acabas construyendo una blocklist de tokens en Redis, lo que echa por tierra todo el sentido de ser stateless. Acabas de construir un sistema de cookies de sesión con pasos extra y peor seguridad.

Si usas JWT, mantén una expiración corta. 15 minutos como máximo. Usa refresh tokens guardados en cookies HTTP-only y secure para obtener nuevos JWT. Nunca guardes JWT en local storage. Un XSS te los robará en milisegundos.

Introspección de GraphQL: todo a la vista

La dura verdad es esta. Por defecto, la mayoría de los servidores GraphQL tienen la introspección habilitada. Eso significa que cualquiera puede consultar el servidor y obtener un mapa completo de todo el esquema de tu API. Cada tipo, cada query, cada mutation. Es el sueño de cualquier atacante.

Les estás entregando los planos de tu aplicación. En producción, desactiva la introspección. Sin excepciones.

Pero espera, que la cosa empeora. Incluso con la introspección desactivada, herramientas como Clairvoyance pueden aprovechar las sugerencias de campos (cuando el servidor responde 'Did you mean X?') para sacar el esquema por fuerza bruta. Desactiva también las sugerencias en producción.

Webhooks y Server-Side Request Forgery (SSRF)

Construyes una API que permite a los usuarios registrar webhooks. El usuario te da una URL y, cuando ocurre un evento, tu servidor envía una solicitud POST a esa URL. Parece inofensivo.

Estoy harto de ver esto en las PR. Hasta que el usuario registra un webhook que apunta a http://169.254.169.254/latest/meta-data/ en AWS. Ahora tu servidor está consultando el servicio de metadatos de EC2 y enviándole las credenciales de la nube al atacante.

El SSRF es muy traicionero. Tienes que validar las URL de los webhooks. Bloquea los rangos de IP internos. Bloquea localhost. Bloquea la IP de metadatos de la nube. Usa un proxy de salida si hace falta.

Deja de confiar en la entrada: el verdadero problema

En el fondo, todos los problemas de seguridad de API se reducen a confiar en la entrada. Confías en los parámetros de la URL. Confías en el cuerpo JSON. Confías en la estructura de la query de GraphQL. Deja de hacerlo.

Trata cada dato que llega del cliente como si fuera altamente radiactivo. Parsea, no valides. Si no encaja exactamente con el esquema que esperas, descarta la solicitud. Regístralo, lanza una alerta y sigue adelante.

En resumen

Mira, esto lo he visto cien veces. La seguridad es un trabajo constante y pesado. Los atacantes son cada vez más listos y nuestros stacks, cada vez más complejos. Haz bien lo básico y mitigarás el 99 % del ruido. Ignóralo y estarás escribiendo un post mortem público el próximo trimestre.

En profundidad: anatomía de un exploit de mass assignment

Veamos exactamente cómo te quema el mass assignment. Imagina que tienes un endpoint REST para el registro de usuarios. Tomas el req.body entero y se lo pasas al método create de tu ORM.

Crees que el cliente solo envía email y password. Pero el atacante intercepta la solicitud y añade "role": "admin". Si tu modelo tiene un campo role y no filtras la entrada explícitamente, enhorabuena: acabas de darle acceso de administrador a un script kiddie cualquiera.

Esto pasa constantemente. Los desarrolladores se vuelven perezosos. No quieren escribir uno por uno los campos que esperan. Toman atajos. Y los atajos acaban en CVE.

Seamos realistas. ¿El ROI de arreglarlo? Enorme. Un solo bug de mass assignment puede comprometer toda tu base de datos. La corrección lleva cinco minutos. Escribe un DTO. Usa una librería de validación como Zod o Joi. Elimina las claves desconocidas. Así de simple.

La pesadilla de revocar JWT

A los desarrolladores les encantan los JWT porque son stateless. No tienes que consultar la base de datos para verificarlos. ¿Pero qué pasa cuando la cuenta de un usuario se ve comprometida? ¿Cómo revocas un token stateless?

No puedes. Al menos no fácilmente. Acabas construyendo una blocklist de tokens en Redis, lo que echa por tierra todo el sentido de ser stateless. Acabas de construir un sistema de cookies de sesión con pasos extra y peor seguridad.

Si usas JWT, mantén una expiración corta. 15 minutos como máximo. Usa refresh tokens guardados en cookies HTTP-only y secure para obtener nuevos JWT. Nunca guardes JWT en local storage. Un XSS te los robará en milisegundos.

Introspección de GraphQL: todo a la vista

Sinceramente, es una pesadilla. Por defecto, la mayoría de los servidores GraphQL tienen la introspección habilitada. Eso significa que cualquiera puede consultar el servidor y obtener un mapa completo de todo el esquema de tu API. Cada tipo, cada query, cada mutation. Es el sueño de cualquier atacante.

Les estás entregando los planos de tu aplicación. En producción, desactiva la introspección. Sin excepciones.

Pero espera, que la cosa empeora. Incluso con la introspección desactivada, herramientas como Clairvoyance pueden aprovechar las sugerencias de campos (cuando el servidor responde 'Did you mean X?') para sacar el esquema por fuerza bruta. Desactiva también las sugerencias en producción.

Webhooks y Server-Side Request Forgery (SSRF)

Construyes una API que permite a los usuarios registrar webhooks. El usuario te da una URL y, cuando ocurre un evento, tu servidor envía una solicitud POST a esa URL. Parece inofensivo.

Estoy harto de ver esto en las PR. Hasta que el usuario registra un webhook que apunta a http://169.254.169.254/latest/meta-data/ en AWS. Ahora tu servidor está consultando el servicio de metadatos de EC2 y enviándole las credenciales de la nube al atacante.

El SSRF es muy traicionero. Tienes que validar las URL de los webhooks. Bloquea los rangos de IP internos. Bloquea localhost. Bloquea la IP de metadatos de la nube. Usa un proxy de salida si hace falta.

Deja de confiar en la entrada: el verdadero problema

En el fondo, todos los problemas de seguridad de API se reducen a confiar en la entrada. Confías en los parámetros de la URL. Confías en el cuerpo JSON. Confías en la estructura de la query de GraphQL. Deja de hacerlo.

Trata cada dato que llega del cliente como si fuera altamente radiactivo. Parsea, no valides. Si no encaja exactamente con el esquema que esperas, descarta la solicitud. Regístralo, lanza una alerta y sigue adelante.

En resumen

Seamos realistas. La seguridad es un trabajo constante y pesado. Los atacantes son cada vez más listos y nuestros stacks, cada vez más complejos. Haz bien lo básico y mitigarás el 99 % del ruido. Ignóralo y estarás escribiendo un post mortem público el próximo trimestre.

En profundidad: anatomía de un exploit de mass assignment

Veamos exactamente cómo te quema el mass assignment. Imagina que tienes un endpoint REST para el registro de usuarios. Tomas el req.body entero y se lo pasas al método create de tu ORM.

Crees que el cliente solo envía email y password. Pero el atacante intercepta la solicitud y añade "role": "admin". Si tu modelo tiene un campo role y no filtras la entrada explícitamente, enhorabuena: acabas de darle acceso de administrador a un script kiddie cualquiera.

Esto pasa constantemente. Los desarrolladores se vuelven perezosos. No quieren escribir uno por uno los campos que esperan. Toman atajos. Y los atajos acaban en CVE.

Seamos realistas. ¿El ROI de arreglarlo? Enorme. Un solo bug de mass assignment puede comprometer toda tu base de datos. La corrección lleva cinco minutos. Escribe un DTO. Usa una librería de validación como Zod o Joi. Elimina las claves desconocidas. Así de simple.

La pesadilla de revocar JWT

A los desarrolladores les encantan los JWT porque son stateless. No tienes que consultar la base de datos para verificarlos. ¿Pero qué pasa cuando la cuenta de un usuario se ve comprometida? ¿Cómo revocas un token stateless?

No puedes. Al menos no fácilmente. Acabas construyendo una blocklist de tokens en Redis, lo que echa por tierra todo el sentido de ser stateless. Acabas de construir un sistema de cookies de sesión con pasos extra y peor seguridad.

Si usas JWT, mantén una expiración corta. 15 minutos como máximo. Usa refresh tokens guardados en cookies HTTP-only y secure para obtener nuevos JWT. Nunca guardes JWT en local storage. Un XSS te los robará en milisegundos.

Introspección de GraphQL: todo a la vista

Mira, esto lo he visto cien veces. Por defecto, la mayoría de los servidores GraphQL tienen la introspección habilitada. Eso significa que cualquiera puede consultar el servidor y obtener un mapa completo de todo el esquema de tu API. Cada tipo, cada query, cada mutation. Es el sueño de cualquier atacante.

Les estás entregando los planos de tu aplicación. En producción, desactiva la introspección. Sin excepciones.

Pero espera, que la cosa empeora. Incluso con la introspección desactivada, herramientas como Clairvoyance pueden aprovechar las sugerencias de campos (cuando el servidor responde 'Did you mean X?') para sacar el esquema por fuerza bruta. Desactiva también las sugerencias en producción.

Webhooks y Server-Side Request Forgery (SSRF)

Construyes una API que permite a los usuarios registrar webhooks. El usuario te da una URL y, cuando ocurre un evento, tu servidor envía una solicitud POST a esa URL. Parece inofensivo.

Mira, esto lo he visto cien veces. Hasta que el usuario registra un webhook que apunta a http://169.254.169.254/latest/meta-data/ en AWS. Ahora tu servidor está consultando el servicio de metadatos de EC2 y enviándole las credenciales de la nube al atacante.

El SSRF es muy traicionero. Tienes que validar las URL de los webhooks. Bloquea los rangos de IP internos. Bloquea localhost. Bloquea la IP de metadatos de la nube. Usa un proxy de salida si hace falta.

Deja de confiar en la entrada: el verdadero problema

En el fondo, todos los problemas de seguridad de API se reducen a confiar en la entrada. Confías en los parámetros de la URL. Confías en el cuerpo JSON. Confías en la estructura de la query de GraphQL. Deja de hacerlo.

Trata cada dato que llega del cliente como si fuera altamente radiactivo. Parsea, no valides. Si no encaja exactamente con el esquema que esperas, descarta la solicitud. Regístralo, lanza una alerta y sigue adelante.

En resumen

Sinceramente, es una pesadilla. La seguridad es un trabajo constante y pesado. Los atacantes son cada vez más listos y nuestros stacks, cada vez más complejos. Haz bien lo básico y mitigarás el 99 % del ruido. Ignóralo y estarás escribiendo un post mortem público el próximo trimestre.

En profundidad: anatomía de un exploit de mass assignment

Veamos exactamente cómo te quema el mass assignment. Imagina que tienes un endpoint REST para el registro de usuarios. Tomas el req.body entero y se lo pasas al método create de tu ORM.

Crees que el cliente solo envía email y password. Pero el atacante intercepta la solicitud y añade "role": "admin". Si tu modelo tiene un campo role y no filtras la entrada explícitamente, enhorabuena: acabas de darle acceso de administrador a un script kiddie cualquiera.

Esto pasa constantemente. Los desarrolladores se vuelven perezosos. No quieren escribir uno por uno los campos que esperan. Toman atajos. Y los atajos acaban en CVE.

Seamos realistas. ¿El ROI de arreglarlo? Enorme. Un solo bug de mass assignment puede comprometer toda tu base de datos. La corrección lleva cinco minutos. Escribe un DTO. Usa una librería de validación como Zod o Joi. Elimina las claves desconocidas. Así de simple.

La pesadilla de revocar JWT

A los desarrolladores les encantan los JWT porque son stateless. No tienes que consultar la base de datos para verificarlos. ¿Pero qué pasa cuando la cuenta de un usuario se ve comprometida? ¿Cómo revocas un token stateless?

No puedes. Al menos no fácilmente. Acabas construyendo una blocklist de tokens en Redis, lo que echa por tierra todo el sentido de ser stateless. Acabas de construir un sistema de cookies de sesión con pasos extra y peor seguridad.

Si usas JWT, mantén una expiración corta. 15 minutos como máximo. Usa refresh tokens guardados en cookies HTTP-only y secure para obtener nuevos JWT. Nunca guardes JWT en local storage. Un XSS te los robará en milisegundos.

Introspección de GraphQL: todo a la vista

La dura verdad es esta. Por defecto, la mayoría de los servidores GraphQL tienen la introspección habilitada. Eso significa que cualquiera puede consultar el servidor y obtener un mapa completo de todo el esquema de tu API. Cada tipo, cada query, cada mutation. Es el sueño de cualquier atacante.

Les estás entregando los planos de tu aplicación. En producción, desactiva la introspección. Sin excepciones.

Pero espera, que la cosa empeora. Incluso con la introspección desactivada, herramientas como Clairvoyance pueden aprovechar las sugerencias de campos (cuando el servidor responde 'Did you mean X?') para sacar el esquema por fuerza bruta. Desactiva también las sugerencias en producción.

Webhooks y Server-Side Request Forgery (SSRF)

Construyes una API que permite a los usuarios registrar webhooks. El usuario te da una URL y, cuando ocurre un evento, tu servidor envía una solicitud POST a esa URL. Parece inofensivo.

Sinceramente, es una pesadilla. Hasta que el usuario registra un webhook que apunta a http://169.254.169.254/latest/meta-data/ en AWS. Ahora tu servidor está consultando el servicio de metadatos de EC2 y enviándole las credenciales de la nube al atacante.

El SSRF es muy traicionero. Tienes que validar las URL de los webhooks. Bloquea los rangos de IP internos. Bloquea localhost. Bloquea la IP de metadatos de la nube. Usa un proxy de salida si hace falta.

Deja de confiar en la entrada: el verdadero problema

En el fondo, todos los problemas de seguridad de API se reducen a confiar en la entrada. Confías en los parámetros de la URL. Confías en el cuerpo JSON. Confías en la estructura de la query de GraphQL. Deja de hacerlo.

Trata cada dato que llega del cliente como si fuera altamente radiactivo. Parsea, no valides. Si no encaja exactamente con el esquema que esperas, descarta la solicitud. Regístralo, lanza una alerta y sigue adelante.

En resumen

Estoy harto de ver esto en las PR. La seguridad es un trabajo constante y pesado. Los atacantes son cada vez más listos y nuestros stacks, cada vez más complejos. Haz bien lo básico y mitigarás el 99 % del ruido. Ignóralo y estarás escribiendo un post mortem público el próximo trimestre.

En profundidad: anatomía de un exploit de mass assignment

Veamos exactamente cómo te quema el mass assignment. Imagina que tienes un endpoint REST para el registro de usuarios. Tomas el req.body entero y se lo pasas al método create de tu ORM.

Crees que el cliente solo envía email y password. Pero el atacante intercepta la solicitud y añade "role": "admin". Si tu modelo tiene un campo role y no filtras la entrada explícitamente, enhorabuena: acabas de darle acceso de administrador a un script kiddie cualquiera.

Esto pasa constantemente. Los desarrolladores se vuelven perezosos. No quieren escribir uno por uno los campos que esperan. Toman atajos. Y los atajos acaban en CVE.

Estoy harto de ver esto en las PR. ¿El ROI de arreglarlo? Enorme. Un solo bug de mass assignment puede comprometer toda tu base de datos. La corrección lleva cinco minutos. Escribe un DTO. Usa una librería de validación como Zod o Joi. Elimina las claves desconocidas. Así de simple.

La pesadilla de revocar JWT

A los desarrolladores les encantan los JWT porque son stateless. No tienes que consultar la base de datos para verificarlos. ¿Pero qué pasa cuando la cuenta de un usuario se ve comprometida? ¿Cómo revocas un token stateless?

No puedes. Al menos no fácilmente. Acabas construyendo una blocklist de tokens en Redis, lo que echa por tierra todo el sentido de ser stateless. Acabas de construir un sistema de cookies de sesión con pasos extra y peor seguridad.

Si usas JWT, mantén una expiración corta. 15 minutos como máximo. Usa refresh tokens guardados en cookies HTTP-only y secure para obtener nuevos JWT. Nunca guardes JWT en local storage. Un XSS te los robará en milisegundos.

Introspección de GraphQL: todo a la vista

La dura verdad es esta. Por defecto, la mayoría de los servidores GraphQL tienen la introspección habilitada. Eso significa que cualquiera puede consultar el servidor y obtener un mapa completo de todo el esquema de tu API. Cada tipo, cada query, cada mutation. Es el sueño de cualquier atacante.

Les estás entregando los planos de tu aplicación. En producción, desactiva la introspección. Sin excepciones.

Pero espera, que la cosa empeora. Incluso con la introspección desactivada, herramientas como Clairvoyance pueden aprovechar las sugerencias de campos (cuando el servidor responde 'Did you mean X?') para sacar el esquema por fuerza bruta. Desactiva también las sugerencias en producción.

Webhooks y Server-Side Request Forgery (SSRF)

Construyes una API que permite a los usuarios registrar webhooks. El usuario te da una URL y, cuando ocurre un evento, tu servidor envía una solicitud POST a esa URL. Parece inofensivo.

Mira, esto lo he visto cien veces. Hasta que el usuario registra un webhook que apunta a http://169.254.169.254/latest/meta-data/ en AWS. Ahora tu servidor está consultando el servicio de metadatos de EC2 y enviándole las credenciales de la nube al atacante.

El SSRF es muy traicionero. Tienes que validar las URL de los webhooks. Bloquea los rangos de IP internos. Bloquea localhost. Bloquea la IP de metadatos de la nube. Usa un proxy de salida si hace falta.

Deja de confiar en la entrada: el verdadero problema

En el fondo, todos los problemas de seguridad de API se reducen a confiar en la entrada. Confías en los parámetros de la URL. Confías en el cuerpo JSON. Confías en la estructura de la query de GraphQL. Deja de hacerlo.

Trata cada dato que llega del cliente como si fuera altamente radiactivo. Parsea, no valides. Si no encaja exactamente con el esquema que esperas, descarta la solicitud. Regístralo, lanza una alerta y sigue adelante.

En resumen

Sinceramente, es una pesadilla. La seguridad es un trabajo constante y pesado. Los atacantes son cada vez más listos y nuestros stacks, cada vez más complejos. Haz bien lo básico y mitigarás el 99 % del ruido. Ignóralo y estarás escribiendo un post mortem público el próximo trimestre.

En profundidad: anatomía de un exploit de mass assignment

Veamos exactamente cómo te quema el mass assignment. Imagina que tienes un endpoint REST para el registro de usuarios. Tomas el req.body entero y se lo pasas al método create de tu ORM.

Crees que el cliente solo envía email y password. Pero el atacante intercepta la solicitud y añade "role": "admin". Si tu modelo tiene un campo role y no filtras la entrada explícitamente, enhorabuena: acabas de darle acceso de administrador a un script kiddie cualquiera.

Esto pasa constantemente. Los desarrolladores se vuelven perezosos. No quieren escribir uno por uno los campos que esperan. Toman atajos. Y los atajos acaban en CVE.

La dura verdad es esta. ¿El ROI de arreglarlo? Enorme. Un solo bug de mass assignment puede comprometer toda tu base de datos. La corrección lleva cinco minutos. Escribe un DTO. Usa una librería de validación como Zod o Joi. Elimina las claves desconocidas. Así de simple.

La pesadilla de revocar JWT

A los desarrolladores les encantan los JWT porque son stateless. No tienes que consultar la base de datos para verificarlos. ¿Pero qué pasa cuando la cuenta de un usuario se ve comprometida? ¿Cómo revocas un token stateless?

No puedes. Al menos no fácilmente. Acabas construyendo una blocklist de tokens en Redis, lo que echa por tierra todo el sentido de ser stateless. Acabas de construir un sistema de cookies de sesión con pasos extra y peor seguridad.

Si usas JWT, mantén una expiración corta. 15 minutos como máximo. Usa refresh tokens guardados en cookies HTTP-only y secure para obtener nuevos JWT. Nunca guardes JWT en local storage. Un XSS te los robará en milisegundos.

Introspección de GraphQL: todo a la vista

Estoy harto de ver esto en las PR. Por defecto, la mayoría de los servidores GraphQL tienen la introspección habilitada. Eso significa que cualquiera puede consultar el servidor y obtener un mapa completo de todo el esquema de tu API. Cada tipo, cada query, cada mutation. Es el sueño de cualquier atacante.

Les estás entregando los planos de tu aplicación. En producción, desactiva la introspección. Sin excepciones.

Pero espera, que la cosa empeora. Incluso con la introspección desactivada, herramientas como Clairvoyance pueden aprovechar las sugerencias de campos (cuando el servidor responde 'Did you mean X?') para sacar el esquema por fuerza bruta. Desactiva también las sugerencias en producción.

Webhooks y Server-Side Request Forgery (SSRF)

Construyes una API que permite a los usuarios registrar webhooks. El usuario te da una URL y, cuando ocurre un evento, tu servidor envía una solicitud POST a esa URL. Parece inofensivo.

Sinceramente, es una pesadilla. Hasta que el usuario registra un webhook que apunta a http://169.254.169.254/latest/meta-data/ en AWS. Ahora tu servidor está consultando el servicio de metadatos de EC2 y enviándole las credenciales de la nube al atacante.

El SSRF es muy traicionero. Tienes que validar las URL de los webhooks. Bloquea los rangos de IP internos. Bloquea localhost. Bloquea la IP de metadatos de la nube. Usa un proxy de salida si hace falta.

Deja de confiar en la entrada: el verdadero problema

En el fondo, todos los problemas de seguridad de API se reducen a confiar en la entrada. Confías en los parámetros de la URL. Confías en el cuerpo JSON. Confías en la estructura de la query de GraphQL. Deja de hacerlo.

Trata cada dato que llega del cliente como si fuera altamente radiactivo. Parsea, no valides. Si no encaja exactamente con el esquema que esperas, descarta la solicitud. Regístralo, lanza una alerta y sigue adelante.

En resumen

Seamos realistas. La seguridad es un trabajo constante y pesado. Los atacantes son cada vez más listos y nuestros stacks, cada vez más complejos. Haz bien lo básico y mitigarás el 99 % del ruido. Ignóralo y estarás escribiendo un post mortem público el próximo trimestre.

En profundidad: anatomía de un exploit de mass assignment

Veamos exactamente cómo te quema el mass assignment. Imagina que tienes un endpoint REST para el registro de usuarios. Tomas el req.body entero y se lo pasas al método create de tu ORM.

Crees que el cliente solo envía email y password. Pero el atacante intercepta la solicitud y añade "role": "admin". Si tu modelo tiene un campo role y no filtras la entrada explícitamente, enhorabuena: acabas de darle acceso de administrador a un script kiddie cualquiera.

Esto pasa constantemente. Los desarrolladores se vuelven perezosos. No quieren escribir uno por uno los campos que esperan. Toman atajos. Y los atajos acaban en CVE.

Seamos realistas. ¿El ROI de arreglarlo? Enorme. Un solo bug de mass assignment puede comprometer toda tu base de datos. La corrección lleva cinco minutos. Escribe un DTO. Usa una librería de validación como Zod o Joi. Elimina las claves desconocidas. Así de simple.

La pesadilla de revocar JWT

A los desarrolladores les encantan los JWT porque son stateless. No tienes que consultar la base de datos para verificarlos. ¿Pero qué pasa cuando la cuenta de un usuario se ve comprometida? ¿Cómo revocas un token stateless?

No puedes. Al menos no fácilmente. Acabas construyendo una blocklist de tokens en Redis, lo que echa por tierra todo el sentido de ser stateless. Acabas de construir un sistema de cookies de sesión con pasos extra y peor seguridad.

Si usas JWT, mantén una expiración corta. 15 minutos como máximo. Usa refresh tokens guardados en cookies HTTP-only y secure para obtener nuevos JWT. Nunca guardes JWT en local storage. Un XSS te los robará en milisegundos.

Introspección de GraphQL: todo a la vista

Seamos realistas. Por defecto, la mayoría de los servidores GraphQL tienen la introspección habilitada. Eso significa que cualquiera puede consultar el servidor y obtener un mapa completo de todo el esquema de tu API. Cada tipo, cada query, cada mutation. Es el sueño de cualquier atacante.

Les estás entregando los planos de tu aplicación. En producción, desactiva la introspección. Sin excepciones.

Pero espera, que la cosa empeora. Incluso con la introspección desactivada, herramientas como Clairvoyance pueden aprovechar las sugerencias de campos (cuando el servidor responde 'Did you mean X?') para sacar el esquema por fuerza bruta. Desactiva también las sugerencias en producción.

Webhooks y Server-Side Request Forgery (SSRF)

Construyes una API que permite a los usuarios registrar webhooks. El usuario te da una URL y, cuando ocurre un evento, tu servidor envía una solicitud POST a esa URL. Parece inofensivo.

Sinceramente, es una pesadilla. Hasta que el usuario registra un webhook que apunta a http://169.254.169.254/latest/meta-data/ en AWS. Ahora tu servidor está consultando el servicio de metadatos de EC2 y enviándole las credenciales de la nube al atacante.

El SSRF es muy traicionero. Tienes que validar las URL de los webhooks. Bloquea los rangos de IP internos. Bloquea localhost. Bloquea la IP de metadatos de la nube. Usa un proxy de salida si hace falta.

Deja de confiar en la entrada: el verdadero problema

En el fondo, todos los problemas de seguridad de API se reducen a confiar en la entrada. Confías en los parámetros de la URL. Confías en el cuerpo JSON. Confías en la estructura de la query de GraphQL. Deja de hacerlo.

Trata cada dato que llega del cliente como si fuera altamente radiactivo. Parsea, no valides. Si no encaja exactamente con el esquema que esperas, descarta la solicitud. Regístralo, lanza una alerta y sigue adelante.

En resumen

Mira, esto lo he visto cien veces. La seguridad es un trabajo constante y pesado. Los atacantes son cada vez más listos y nuestros stacks, cada vez más complejos. Haz bien lo básico y mitigarás el 99 % del ruido. Ignóralo y estarás escribiendo un post mortem público el próximo trimestre.

DEFENSA AUTOMATIZADA

No esperes a un exploit para auditar tu código

Revisa los riesgos de código compatibles, los secretos expuestos y los hallazgos en dependencias con Bryxe Shield. Verifica las correcciones en tu aplicación antes del lanzamiento.

¿Necesitas un siguiente paso práctico? Explora las guías de seguridad o lee nuestra política editorial y de fuentes.

Investigación de seguridad recomendada