El último tiempo he probado bastante las fallas de tipo HTTP Request Smuggling (HRS), y estos son los apuntes que me ayudaron a realizar una explotación manual (sin las herramientas publicadas en Github que listo más abajo).
Otros nombres para HTTP Request Smuggling
- HTTP Hijacking (no confundir con robo de sesión)
- HTTP Desync Attack (¿HDA?)
¿Qué ocurre realmente en un HTTP Request Smuggling?
Lo que se busca es “robar un request” o incluir un request adicional mediante otro válido, a través de la desincronización del HTTP pipelining provocada por la generación de crafted requests y la explotación de bugs.
Por consecuencia, el objetivo de un ataque HTTP Request Smuggling es obtener como resultado un “double-response”, en vez de un único response, y otros posibles e inesperados comportamientos de la infraestructura tecnológica, como por ejemplo, ejecutar solicitudes HTTP a recursos web de una red privada, un backend, reenvío de requests mediante un proxy…
En otras situaciones, no necesariamente se recibe un double-response, sino que un único response con el smuggled request.
Sobre la generación de crafted requests
- Es requerido el uso del Protocolo HTTP/1.1
- Downgrade del protocolo HTTP/2 al protocolo HTTP/1.1
- Conexiones persistentes (requisito no excluyente)
- Duplicación de la cabecera Content-Length (requisito no excluyente)
- Uso de espacios entre los 2 puntos (:) de la cabecera y su valor
- El stream de tipo chunked transfer encoding (uso de la cabecera Transfer-Encoding)
Métodos o verbos HTTP para explotación
En PortSwigger promocionan los HTTP Request Smuggling a punta de métodos POST como si fueran hamburguesas del McDonald’s.
Sin embargo, es posible explotar también un HTTP Desyng Attack, con métodos GET, HEAD, TRACE y todo método HTTP que provoque la desincronización del HTTP pipelining (previa validación, por supuesto).
A continuación, 2 ejemplos que encontré en una plataforma de bug bounty:
Ejemplo N°1. HTTP Request Smuggling con método GET realizando solicitud de un archivo *.svg para robar el request y ejecutar una segunda solicitud HTTP usando el método HEAD, mediante downgrade del protocolo HTTP/2 al protocolo HTTP/1.1:
Ejemplo N°2. HTTP Request Smuggling con método HEAD realizando solicitud de un archivo *.js para robar el request y ejecutar una segunda solicitud HTTP usando el método GET, mediante downgrade del protocolo HTTP/2 al protocolo HTTP/1.1:
Downgrade de HTTP/2 a HTTP/1.1
En el caso de Burp Suite, es posible lograr esto con Inspector, el gadget de Repeater:
- https://portswigger.net/burp/documentation/desktop/functions/message-editor/inspector
- https://portswigger.net/burp/documentation/desktop/functions/message-editor/getting-started-inspector
Por otro lado, en el caso de que se requiera ejecutar un ataque HTTP Request Smuggling con Intruder, se debe deshabilitar el forzado del protocolo HTTP/2 siguiendo esta referencia:
Para scripting, basta con especificar el protocolo HTTP/1.1 y ya es posible evadir el uso de protocolo HTTP/2. Yo lo probé con el módulo requests de Python3.x y funciona genial.
Datos importantes a considerar
- HTTP tiene 4 versiones hasta ahora: (1) HTTP/0.9 (deprecado), (2) HTTP/1.0, (3) HTTP/1.1, y (4) HTTP/2; y una quinta versión en proyecto de desarrollo: HTTP/3
- Se supone que en la versión HTTP/1.0 no se permiten las conexiones persistentes
- Se supone que para la versión HTTP/1.1, todos los requests son considerados como conexiones persistentes
- En la vida real, he visto la utilización del valor “keep-alive” para la cabecera “Connection” en ambas versiones del protocolo HTTP (1.0 y 1.1).
- El protocolo HTTP/2 sólo permite solicitudes mediante TLS/SSL
Guías básicas de explotación
- https://www.cgisecurity.com/lib/HTTP-Request-Smuggling.pdf
- https://portswigger.net/research/http-desync-attacks-request-smuggling-reborn
- https://www.youtube.com/watch?v=_A04msdplXs
- https://portswigger.net/web-security/request-smuggling
- https://portswigger.net/web-security/request-smuggling/exploiting
- https://www.youtube.com/watch?v=zP4b3pw94s0
PoC CVE-2020-11724
Tools para identificación y explotación de HTTP Request Smuggling
Las herramientas que listo acá, no las he usado, por lo tanto no sé como funcionan ni tampoco si alguna es más efectiva que otra; las encontré buscando en Github, así https://github.com/search?q=smuggler o https://github.com/search?q=smuggling:
- https://github.com/defparam/smuggler
- https://github.com/epsylon/Smuggler
- https://github.com/kowainik/smuggler
- https://github.com/Lactea98/smuggler.py
- https://github.com/gwen001/pentest-tools/blob/master/smuggler.py
- https://github.com/PortSwigger/http-request-smuggler
Tool para ataques HTTP Request Smuggling basados en la versión del protocolo HTTP/2 y la explotación de la cabecera Upgrade:
Para una posible PoC con HTTP/2
Una base interesante pero simple para tratar de implementar HTTP/2 como prueba de concepto, estudiar cómo funciona, empezar a buscar ataques que se puedan realizar por medio de este protocolo, e implementarlo con Python:
- https://stackoverflow.com/questions/38878880/serving-python-flask-rest-api-over-http2
- https://medium.com/python-pandemonium/how-to-serve-http-2-using-python-5e5bbd1e7ff1
- https://github.com/jdaroesti/flask-http2-push
- https://hyper.readthedocs.io/en/latest/
- Requisito: HTTP/2 necesita cabeceras de compresión HPACK, y soporte para ALPN del sistema operativo
Posibilidades e impactos de un ataque HTTP Request Smuggling
A decir verdad, las posibilidades y el impacto son bastante impredescibles, porque todas las infraestructuras son diferentes. Sin embargo, a modo de ejemplo, dejo acá un enlace sobre el cual es posible entender la complejidad de estos ataques y sus posibles impactos para conseguir, entre otras cosas: Bypass de 403, Bypass de Autenticación, Explotación de Cabeceras Hop-by-hop, Cross-site Scripting (XSS), Server Side Request Forgery (SSRF), robo de cookies y sesiones, Cache Poisoning, etc: