Introducción a la seguridad en las APIs REST
- precio, una vez
- 99 €
- de vídeo
- 68 min
- lecciones
- 8
- nivel
- iniciación
Todo estaba en verde la noche anterior
68 minutos sobre por qué los controles que protegen tu web no cubren tus APIs REST, qué te atacan en su lugar y qué defensas sirven de algo. Para quien ya tiene APIs en producción.
Te lo explico.
Tienes un WAF delante. ModSecurity con el CRS de OWASP cargado. Filtras por IP, aplicas throttling, haces fingerprinting y pasas análisis de código. El inventario de todo eso, si eres como la mayoría, lo llevas en una hoja de cálculo.
Y una mañana te levantas con la compañía comprometida.
Y resulta que una API y una web solo comparten el transporte. HTTP y para de contar. Se rompen por sitios que tu panel no vigila, y lo que hace falta para defenderlas no está en tu lista de controles. Lo que llevas años pagando se diseñó para páginas HTML que se montan en el servidor, y tu API no le devuelve HTML a nadie.
Por ahí es por donde te entran las cosas que nadie está mirando.
Quién te está contando esto
Me llamo Daniel Alfocea. Llevo veinte años en desarrollo y en seguridad. He trabajado para banca del IBEX 35 y para empresas de Estados Unidos, Reino Unido e India, y he dado charlas en Navaja Negra y en OWASP Madrid.
Lo que hay en este curso viene de una etapa concreta: fui responsable de producto en 42Crunch, una empresa dedicada solo a seguridad de APIs. Ahí vi por dentro qué se rompe en las APIs de compañías grandes, cuántas veces se repite el mismo fallo y qué defensas siguen en pie cuando alguien empuja de verdad.
Te lo digo por transparencia y no para colocarte nada. Dentro nombro herramientas, incluidas las de ellos, y también digo dónde no llegan. Si lo que buscabas era una demo comercial, esta no lo es.
Lo que te llevas
Cosas como estas:
El campo que alguien añade a un PUT y que le deja dentro como administrador, sin tocar una sola línea de tu código de permisos. Pasa por culpa de cómo está usado tu ORM, y es de lo más repetido que hay.
Lo que le estás contando a quien te está probando cada vez que respondes un código de estado. Le dices más de lo que crees, y casi siempre gratis.
Por qué una regla del CRS de OWASP nunca llega a ver el ataque, aunque venga dentro de la petición que la regla acaba de dejar pasar.
La pregunta que casi ninguna empresa sabe contestar en el momento: cuántas APIs tiene publicadas ahora mismo. Y la que escuece de verdad: cuántos endpoints hay vivos que nadie dio de alta.
Por qué servir un fichero estático desde tu API acaba apareciendo en la factura de autoescalado, y qué se pone en su lugar.
Qué código auditar de verdad, porque el agujero rara vez está en el que has escrito tú.
Los dos enfoques con los que un WAF pensado para APIs descubre lo que tienes publicado, en qué se diferencian y cuál te encaja según lo documentada que esté tu casa.
La comprobación de la respuesta que casi nadie hace: que devuelva esos campos y ni uno más.
Cómo sacar la definición de tu API cuando nadie la escribió nunca. Hay cuatro caminos, cada uno con su precio, y uno de ellos te va a dar resultados distintos cada vez que lo ejecutes.
Ninguna de las respuestas está en esta página. Están todas dentro del curso.
El temario, lección a lección
Son 68 minutos de vídeo repartidos en 8 lecciones, más el PDF con las diapositivas completas y un examen final con certificado.
1. Conceptos generales (4 lecciones, unos 21 minutos)
- Qué comparte una API con una web tradicional, que es menos de lo que parece.
- Desde dónde te lo cuento, incluida mi etapa en 42Crunch, y por qué esto no es una charla comercial.
- Anatomía de una brecha: todos los controles puestos, el WAF en verde y la compañía comprometida igual.
- Los ataques que sí aparecen en una API: mass assignment y la escalada de privilegios que trae detrás, lo que revelan los códigos de respuesta, por qué el SQL injection clásico tiene menos superficie aquí, dónde auditar de verdad, y qué pasa cuando tu API sirve ficheros.
2. Medidas de protección (2 lecciones, unos 25 minutos)
- Por qué un WAF tradicional no protege una API. Todo se decide en la deserialización del JSON, y en lo que le pasa a una regla del CRS cuando el objeto viene anidado.
- WAFs que sí entienden una API: los que deserializan y recorren el modelo nivel a nivel, sus dos formas de descubrir lo que tienes, la API key frente al filtrado por IP, qué esperar del análisis estático y qué revisar en la respuesta.
3. Buenas prácticas (2 lecciones, unos 22 minutos)
- Gobierno de APIs: saber cuántas tienes, el Shadow IT a nivel de endpoint, el repositorio aunque sea un Postman, el versionado y una política de deprecación que se pueda cumplir. Con el aviso de lo que cuesta ser el equipo que solo dice que no.
- Conseguir la especificación cuando nadie la tiene. RAML, Swagger, OpenAPI 3 y Postman, por qué OpenAPI 3 se ha quedado como el estándar de facto, y cómo deducir la tuya a partir de lo que ya está corriendo.
4. Recursos adicionales
Las diapositivas completas del curso en PDF, para consultarlas sin volver al vídeo.
5. Examen y certificado
Quince preguntas sobre lo que has visto. Se aprueba con un 70 y hay dos intentos. Al superarlo se emite el certificado con su código de verificación pública.
Qué cuesta y por qué
99 €, un pago, acceso de por vida. Cuando actualice el curso, la versión nueva la tienes sin volver a pagar.
Son 68 minutos y con esto no te conviertes en experto en seguridad de APIs. Quien te venda lo contrario por 99 € te está mintiendo. Esto es una introducción, y como tal está grabada.
Lo que te llevas por ese dinero es el mapa. Salir sabiendo por qué tus controles actuales no tapan lo que creías, qué te van a intentar, qué defensa hace algo de verdad y en qué orden conviene ponerse. Con eso dejas de pagar herramientas que miran donde no es.
Una hora de consultoría de seguridad te cuesta más de 99 €, y todavía no te ha dicho por dónde empezar. Un incidente cuesta bastante más que la consultoría.
Entras también en la comunidad, donde hay 250 personas resolviendo dudas que no caben en un vídeo. Y me escribes a mí si te atascas.
Si aun así te parece caro, no lo compres. Un curso que se compra a regañadientes se queda sin ver, y entonces sí que has tirado 99 euros.
Un abrazo,
Dani
P. D. Haz una prueba antes de decidir. Pregunta ahora mismo en tu empresa cuántas APIs hay publicadas a nombre vuestro. Si tienes que preguntárselo a tres personas y aun así te quedas sin el número, la séptima lección va exactamente de eso, y es la que peor sienta de las ocho.
Dudas
¿68 minutos valen 99 €?
Depende de con qué lo compares.
Una hora de consultoría de seguridad cuesta más que esto, y al salir todavía no tienes claro por dónde empezar. Aquí sales sabiendo qué de lo que ya pagas no te está cubriendo la API, qué te van a intentar y en qué orden conviene ponerse.
Lo que no vas a encontrar es un curso largo con laboratorios y veinte ejemplos por técnica. Son 68 minutos al grano. Si lo que buscas es una formación de treinta horas con prácticas guiadas, este no es el sitio.
¿Salgo de aquí siendo experto en seguridad de APIs?
No, y prefiero decírtelo antes de que pagues. Es una introducción y así está grabada.
Lo que te llevas es el mapa: por qué falla lo que tienes puesto, qué ataques aparecen de verdad en una API, qué defensas hacen algo y cuáles solo lo aparentan. El trabajo fino viene después, pero al menos sabes hacia dónde cavar.
¿Esto es publicidad de 42Crunch?
No, y lo aviso dentro del propio curso.
Fui responsable de producto allí, así que sería raro no contarlo: buena parte de lo que sé de esto lo aprendí viendo las APIs de sus clientes. Nombro herramientas suyas donde vienen a cuento, igual que nombro las de otros, y también digo dónde no llegan.
Si esperabas una demo de producto, te vas a llevar una decepción.
¿Es para gente de seguridad o para desarrolladores?
Para los dos, y ahí está media gracia del curso.
Quien viene de seguridad entiende por qué su WAF y sus reglas no tapan lo que creía, y por qué el inventario de APIs es el trabajo previo del que cuelga todo lo demás. Quien viene de backend entiende qué está exponiendo sin darse cuenta, empezando por lo que devuelve de más en cada respuesta.
Sirve igual si llevas arquitectura y lo que necesitas es decidir dónde poner el dinero.
¿Hace falta escribir código para seguirlo?
No hay ejercicios de programación. Se habla de código y se enseña, así que se sigue mucho mejor si has escrito una API alguna vez.
Si no has tocado una en tu vida y no sabes qué es un PUT, hay partes que se te van a quedar lejos.
Mi API no es REST, es GraphQL o gRPC. ¿Me vale?
A medias, y te digo dónde está el corte.
Todo lo que va de gobierno, inventario, versionado, deprecación y qué esperar de un WAF o de un análisis estático te sirve igual. Los ejemplos concretos son de REST sobre JSON, y ahí hay detalles que cambian de un protocolo a otro.
Si tienes las dos cosas conviviendo, que es lo normal, aprovechas el curso entero.
Ya tenemos OpenAPI. ¿Me sobra el último módulo?
Ese módulo va de cómo conseguir la definición cuando no la tienes, así que lo tuyo lo tienes ganado. Enhorabuena, porque es la parte que más se atraganta.
El resto del curso te sigue valiendo, y ese cimiento es justo lo que hace útil buena parte de lo que se cuenta en el módulo 2. Con la definición no tienes el trabajo hecho, pero sin ella no puedes ni empezarlo.
¿Y si luego no me sirve?
Arriba tienes con todo el detalle qué hay dentro y para quién está pensado. Está escrito para que te eches atrás si no te reconoces ahí.
Las condiciones de contratación dicen qué pasa después de comprar. Están en el pie y en el propio checkout.
Para quién esTrabajas en seguridad, en arquitectura o en backend, ya tienes APIs REST en producción y no acabas de entender por qué los controles que llevas años manteniendo no las cubren. No hace falta que sepas nada de seguridad de APIs.