Mostra l'aiuto per il comando scan:```
sippts scan -h
usage: sippts scan [-i IP|HOST] [-f FILE] [-r REMOTE_PORT] [-p PROTOCOL]
                   [-proxy IP:PORT] [-m METHOD] [-d DOMAIN]
                   [-cd CONTACT_DOMAIN] [-fn FROM_NAME] [-fu FROM_USER]
                   [-fd FROM_DOMAIN] [-tn TO_NAME] [-tu TO_USER]
                   [-td TO_DOMAIN] [-ua USER_AGENT] [-ppi PPI] [-pai PAI] [-v]
                   [-vv] [-nocolor] [-o FILE] [-oi FILE] [-ot FILE] [-oj FILE]
                   [-ocsv FILE] [-cve] [-th THREADS] [-t TIMEOUT] [-ping]
                   [-fp] [-random] [-local-ip IP] [-h]


  ___ ___ ___ ___ _____ ___                    
 / __|_ _| _ \ _ \_   _/ __|  ___ __ __ _ _ _  
 \__ \| ||  _/  _/ | | \__ \ (_-</ _/ _` | ' \ 
 |___/___|_| |_|   |_| |___/ /__/\__\__,_|_||_|
            
  Module scan is a fast SIP scanner using multithread that can check several IPs and port ranges. It works with UDP, TCP and TLS protocols.

Target:
  -i IP|HOST            Host/IP address/network (ex: mysipserver.com | 192.168.0.10 | 192.168.0.0/24)
  -f FILE               File with several IPs or network ranges
  -r REMOTE_PORT        Ports to scan. Ex: 5060 | 5070,5080 | 5060-5080 | 5060,5062,5070-5080 | ALL for 1-65535 (default: 5060)
  -p, --protocol PROTOCOL
                        Protocol: udp|tcp|tls|all (default: udp)
  -proxy IP:PORT        Use an outbound proxy (ex: 192.168.1.1 or 192.168.1.1:5070)

Headers:
  -m METHOD             SIP method: options, invite, register (default: options)
  -d, --domain DOMAIN   SIP Domain or IP address. Ex: my.sipserver.com (default: target IP address)
  -cd CONTACT_DOMAIN    Domain or IP address for Contact header. Ex: 10.0.1.2
  -fn FROM_NAME         From Name. Ex: Bob
  -fu FROM_USER         From User (default: 100)
  -fd FROM_DOMAIN       From Domain. Ex: 10.0.0.1
  -tn TO_NAME           To Name. Ex: Alice
  -tu TO_USER           To User (default: 100)
  -td TO_DOMAIN         To Domain. Ex: 10.0.0.1
  -ua USER_AGENT        User-Agent header (default: pplsip)
  -ppi PPI              P-Preferred-Identity
  -pai PAI              P-Asserted-Identity

Log:
  -v                    Increase verbosity
  -vv                   Increase more verbosity
  -nocolor              Show result without colors
  -o FILE               Save data into a log file
  -oi FILE              Save IPs into a log file
  -ot FILE              Save found hosts as ip:port/proto, ready for -f of exten, rcrack and leak
  -oj FILE              Save results into a JSON file
  -ocsv FILE            Save results into a CSV file
  -cve                  Show possible CVEs

Other options:
  -th THREADS           Number of threads (default: 200)
  -t, --timeout TIMEOUT
                        Sockets timeout (default: 5)
  -ping                 Ping host before scan
  -fp                   Try to fingerprinting
  -random               Randomize target hosts
  -local-ip IP          Set local IP address (by default try to get it)
  -h, --help            Show this help

Usage examples:
  Searching for SIP services and devices with default ports (5060/udp) on the local network
     sippts scan -i 192.168.0.0/24
  Extend the port range from 5060 to 5080 and look for UDP, TCP and TLS services
     sippts scan -i 192.168.0.0/24 -r 5060-5080 -p all
  Load several target IP addresses from a file
     sippts scan -f targets.txt
  Random scanning for non-sequential scanning of IP ranges
     sippts scan -f targets.txt -random
  Disguise the tool behind another User-Agent
     sippts scan -i 192.168.0.0/24 -ua Grandstream
  Scan all ports and protocols of an address range using 500 threads (slow)
     sippts scan -f targets.txt -r all -p all -th 500 -ua Grandstream
  Typical scanning for large ranges
     sippts scan -f targets.txt -r 5060-5080 -p all -th 500 -ua Grandstream -v -fp -o output.txt
  Save the hosts found as ip:port/proto, to chain with exten, rcrack or leak
     sippts scan -i 192.168.0.0/24 -r 5060-5080 -p all -ot targets.txt
     sippts exten -f targets.txt -e 100-200 -oe extens.txt
     sippts rcrack -f targets.txt -ef extens.txt -w wordlist.txt
  Save the results as JSON or CSV, to process them with another tool
     sippts scan -i 192.168.0.0/24 -oj result.json -ocsv result.csv

# Set di strumenti per il penetration test sul protocollo SIP #

Puoi ottenere assistenza su come utilizzare questo strumento su https://sippts.seguridadvoip.com e anche sulle pagine wiki di Github:

Sippts è un set di strumenti per l'auditing di server e dispositivi VoIP che utilizzano il protocollo SIP. Sippts è programmato in Python ed è composto dai seguenti comandi o moduli:
  * _**scan**_ è un veloce scanner multithread per servizi SIP. Può controllare diversi indirizzi IP e intervalli di porte, e funziona su UDP, TCP e TLS. [Clicca qui per leggere di più sul comando scan](https://github.com/Pepelux/sippts/wiki/Command-scan)

  * _**exten**_ identifica le estensioni su un server SIP. Indica anche se l'estensione richiede autenticazione. Può controllare diversi indirizzi IP, e con -f legge i target da un file. [Clicca qui per leggere di più sul comando exten](https://github.com/Pepelux/sippts/wiki/Command-exten)

  * _**rcrack**_ è un cracker di password remoto. Può testare password per diversi utenti su diversi indirizzi IP, e con -f legge i target da un file. [Clicca qui per leggere di più sul comando rcrack](https://github.com/Pepelux/sippts/wiki/Command-rcrack)

  * _**invite**_ verifica se un server ci consente di effettuare chiamate senza autenticazione. Se il server SIP ha una cattiva configurazione, ci permetterà di effettuare chiamate verso numeri esterni. Può anche trasferire la chiamata a un secondo numero esterno. [Clicca qui per leggere di più sul comando invite](https://github.com/Pepelux/sippts/wiki/Command-invite)

  * _**leak**_ sfrutta la vulnerabilità SIP Digest Leak scoperta da Sandro Gauci, che colpisce un gran numero di dispositivi hardware e software. [Clicca qui per leggere di più sul comando leak](https://github.com/Pepelux/sippts/wiki/Command-leak)

  * _**flood**_ invia messaggi illimitati al target. [Clicca qui per leggere di più sul comando flood](https://github.com/Pepelux/sippts/wiki/Command-flood)

  * _**send**_ invia un messaggio SIP personalizzato e analizza la risposta. [Clicca qui per leggere di più sul comando send](https://github.com/Pepelux/sippts/wiki/Command-send)

  * _**wssend**_ invia un messaggio SIP personalizzato tramite WebSockets e analizza la risposta. [Clicca qui per leggere di più sul comando wssend](https://github.com/Pepelux/sippts/wiki/Command-wssend)

  * _**enumerate**_ enumera i metodi disponibili di un servizio o server SIP. [Clicca qui per leggere di più sul comando enumerate](https://github.com/Pepelux/sippts/wiki/Command-enumerate)

  * _**dump**_ estrae le autenticazioni SIP Digest da un file PCAP. [Clicca qui per leggere di più sul comando dump](https://github.com/Pepelux/sippts/wiki/Command-dump)

  * _**dcrack**_ cracca le autenticazioni digest del protocollo SIP. [Clicca qui per leggere di più sul comando dcrack](https://github.com/Pepelux/sippts/wiki/Command-dcrack)

  * _**pcapdump**_ estrae i dati SIP e RTP da un file PCAP, e può salvare i flussi audio come file WAV. [Clicca qui per leggere di più sul comando pcapdump](https://github.com/Pepelux/sippts/wiki/Command-pcapdump)

  * _**ping**_ invia un ping SIP per verificare se un server o dispositivo è attivo. [Clicca qui per leggere di più sul comando ping](https://github.com/Pepelux/sippts/wiki/Command-ping)

  * _**astami**_ scansiona e verifica l'Asterisk Manager Interface (AMI), e può eseguire un comando su quelli in cui le credenziali funzionano. [Clicca qui per leggere di più sul comando astami](https://github.com/Pepelux/sippts/wiki/Command-astami)

  * _**sniff**_ cattura il traffico SIP in tempo reale e mostra i messaggi, i dispositivi e le autenticazioni digest che rileva. [Clicca qui per leggere di più sul comando sniff](https://github.com/Pepelux/sippts/wiki/Command-sniff)

  * _**spoof**_ è uno strumento di ARP spoofing, per posizionarti tra due dispositivi e catturare il loro traffico. [Clicca qui per leggere di più sul comando spoof](https://github.com/Pepelux/sippts/wiki/Command-spoof)

  * _**video**_ riproduce una demo animata dei flussi di lavoro abituali: scan to exten to rcrack, dump to dcrack, leak to dcrack, e spoof to sniff.

  * _**rtpbleed**_ per sfruttare la vulnerabilità RTP Bleed inviando dati alle porte RTP. [Clicca qui per leggere di più sul comando rtpbleed](https://github.com/Pepelux/sippts/wiki/Command-rtpbleed)

  * _**rtcpbleed**_ per sfruttare la vulnerabilità RTP bleed inviando dati alle porte RTCP. [Clicca qui per leggere di più sul comando rtcpbleed](https://github.com/Pepelux/sippts/wiki/Command-rtcpbleed)

  * _**rtpbleedflood**_ per sfruttare la vulnerabilità RTP Bleed inondando una porta RTP con un dialogo attivo. [Clicca qui per leggere di più sul comando rtpbleedflood](https://github.com/Pepelux/sippts/wiki/Command-rtpbleedflood)

  * _**rtpbleedinject**_ per sfruttare la vulnerabilità RTP Bleed iniettando traffico RTP. [Clicca qui per leggere di più sul comando rtpbleedinject](https://github.com/Pepelux/sippts/wiki/Command-rtpbleedinject)

## Certificati TLS ##

sippts parla TLS, e fino ad ora scartava il certificato. Con
`-tlsinfo` il modulo `scan` legge ciò che il server presenta:```
sippts scan -i 192.168.0.1 -r 5061 -p tls -tlsinfo

Ogni versione viene restituita come `accepted`, `refused` o `untested`. L'ultima
significa che *questo* OpenSSL non può offrire quella versione, il che non è la
stessa cosa del server che la ha disattivata, e la differenza conta quando il risultato
finisce in un report.

Due limiti onesti, che lo strumento stampa invece di nascondere:

  * **SSLv2 e SSLv3 non possono essere testati.** OpenSSL 3 è compilato senza di essi, quindi
  sippts non può offrirli. Vengono segnalati come `untested`, mai come
  `disabled`.

  * Un certificato self signed su un trunk SIP interno non è di per sé un finding.
  Va giudicato nel contesto.

La tabella principale, il file di `-o` e il CSV di `-ocsv` non cambiano. Il
JSON di `-oj` guadagna `tls` e `tls_findings`.

## Call hijacking ##

`Replaces` (RFC 3891) punta a una chiamata già attiva, tramite il suo Call-ID e
i suoi due tag. `sippts dump` e `sippts sniff` sono ciò che ti fornisce quei tre
valori da una cattura; da lì:```
sippts send -i 192.168.0.1 -m REFER -refer-to 200 -replaces "CALLID;to-tag=X;from-tag=Y"
sippts send -i 192.168.0.1 -m INVITE -replaces "CALLID;to-tag=X;from-tag=Y"

La prima tabella mantiene la forma che ha sempre avuto, e così anche il CSV di
`-ocsv`. I nuovi dati vengono aggiunti solo al JSON di `-oj`, sotto
`capabilities`.

## Vulnerabilità note ##

Con `-cve`, il modulo `scan` confronta ciò che identifica con un elenco di
vulnerabilità note che viaggia all'interno del pacchetto
(`src/sippts/data/cve.csv`). Contiene circa 1400 CVE di 54 vendor, costruito
a partire dall'[NVD di NIST](https://nvd.nist.gov), e gli intervalli di versione provengono
dai CPE di ciascuna CVE:```bash
sippts scan -i 192.168.0.0/24 -fp -cve

che lo scarica da github insieme al resto dei moduli.

### Severità ###

Ogni CVE porta il suo CVSS, colorato in base alla severità: viola per critico, rosso per
alto, giallo per medio e ciano per basso. I peggiori sono elencati per primi.

L'NVD non ha CVSS v3 per ogni CVE: circa un terzo della lista è
precedente al 2016 e ha solo la v2, e per Asterisk è la maggior parte di essi. Quando
esiste solo la v2 viene utilizzata e **contrassegnata con `v2`**, perché le due scale non sono
equivalenti e la v2 non ha un livello CRITICAL: CVE-2017-16563 è 6.0 MEDIUM in
v2 e 8.0 HIGH in v3.

Un sippts precedente alla 4.2.1 non può leggere questa colonna. Aggiorna con `sippts -up`.

### Ricostruire la lista (manutentori) ###

`tools/cve_update.py` ricostruisce `cve.csv` dall'NVD. Non è qualcosa che
l'utente di sippts esegue: l'idea è di rigenerarlo, guardare il diff, committarlo,
e lasciare che tutti gli altri lo ottengano con `sippts -up`. Questo tiene la chiave API e i
limiti di velocità dell'NVD fuori dal mezzo di un audit.```bash
./tools/cve_update.py --dry-run          # what would change, writing nothing
./tools/cve_update.py                    # rebuild it
./tools/cve_update.py --vendor yealink   # only one vendor
NVD_API_KEY=xxxx ./tools/cve_update.py   # ten times faster

```bash
cd sippts

pip3 install .