Hilfe für den Befehl scan anzeigen:```
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 von Tools für Penetrationstests über das SIP-Protokoll #

Hilfe zur Verwendung dieses Tools findest du unter https://sippts.seguridadvoip.com sowie auf den Github-Wiki-Seiten:

Sippts ist ein Set von Tools zum Auditieren von VoIP-Servern und -Geräten, die das SIP-Protokoll verwenden. Sippts ist in Python programmiert und besteht aus den folgenden Befehlen bzw. Modulen:
  * _**scan**_ ist ein schneller multithreaded Scanner für SIP-Dienste. Er kann mehrere IP-Adressen und Portbereiche prüfen und arbeitet über UDP, TCP und TLS. [Klicke hier, um mehr über den scan-Befehl zu lesen](https://github.com/Pepelux/sippts/wiki/Command-scan)

  * _**exten**_ identifiziert Extensions auf einem SIP-Server. Er teilt dir außerdem mit, ob die Extension eine Authentifizierung erfordert. Er kann mehrere IP-Adressen prüfen, und mit -f liest er die Ziele aus einer Datei. [Klicke hier, um mehr über den exten-Befehl zu lesen](https://github.com/Pepelux/sippts/wiki/Command-exten)

  * _**rcrack**_ ist ein Remote-Passwort-Cracker. Er kann Passwörter für mehrere Benutzer auf mehreren IP-Adressen testen, und mit -f liest er die Ziele aus einer Datei. [Klicke hier, um mehr über den rcrack-Befehl zu lesen](https://github.com/Pepelux/sippts/wiki/Command-rcrack)

  * _**invite**_ prüft, ob ein Server es uns erlaubt, Anrufe ohne Authentifizierung zu tätigen. Wenn der SIP-Server eine schlechte Konfiguration hat, erlaubt er uns, Anrufe an externe Nummern zu tätigen. Er kann den Anruf auch an eine zweite externe Nummer weiterleiten. [Klicke hier, um mehr über den invite-Befehl zu lesen](https://github.com/Pepelux/sippts/wiki/Command-invite)

  * _**leak**_ nutzt die von Sandro Gauci entdeckte SIP-Digest-Leak-Schwachstelle aus, die eine große Anzahl von Hardware- und Softwaregeräten betrifft. [Klicke hier, um mehr über den leak-Befehl zu lesen](https://github.com/Pepelux/sippts/wiki/Command-leak)

  * _**flood**_ sendet unbegrenzt viele Nachrichten an das Ziel. [Klicke hier, um mehr über den flood-Befehl zu lesen](https://github.com/Pepelux/sippts/wiki/Command-flood)

  * _**send**_ sendet eine angepasste SIP-Nachricht und analysiert die Antwort. [Klicke hier, um mehr über den send-Befehl zu lesen](https://github.com/Pepelux/sippts/wiki/Command-send)

  * _**wssend**_ sendet eine angepasste SIP-Nachricht über WebSockets und analysiert die Antwort. [Klicke hier, um mehr über den wssend-Befehl zu lesen](https://github.com/Pepelux/sippts/wiki/Command-wssend)

  * _**enumerate**_ zählt die verfügbaren Methoden eines SIP-Dienstes oder -Servers auf. [Klicke hier, um mehr über den enumerate-Befehl zu lesen](https://github.com/Pepelux/sippts/wiki/Command-enumerate)

  * _**dump**_ extrahiert SIP-Digest-Authentifizierungen aus einer PCAP-Datei. [Klicke hier, um mehr über den dump-Befehl zu lesen](https://github.com/Pepelux/sippts/wiki/Command-dump)

  * _**dcrack**_ knackt die Digest-Authentifizierungen des SIP-Protokolls. [Klicke hier, um mehr über den dcrack-Befehl zu lesen](https://github.com/Pepelux/sippts/wiki/Command-dcrack)

  * _**pcapdump**_ extrahiert SIP- und RTP-Daten aus einer PCAP-Datei und kann die Audiostreams als WAV-Dateien speichern. [Klicke hier, um mehr über den pcapdump-Befehl zu lesen](https://github.com/Pepelux/sippts/wiki/Command-pcapdump)

  * _**ping**_ sendet einen SIP-Ping, um zu prüfen, ob ein Server oder Gerät erreichbar ist. [Klicke hier, um mehr über den ping-Befehl zu lesen](https://github.com/Pepelux/sippts/wiki/Command-ping)

  * _**astami**_ scannt und auditiert das Asterisk Manager Interface (AMI) und kann auf denjenigen, bei denen die Anmeldedaten funktionieren, einen Befehl ausführen. [Klicke hier, um mehr über den astami-Befehl zu lesen](https://github.com/Pepelux/sippts/wiki/Command-astami)

  * _**sniff**_ erfasst SIP-Verkehr live und zeigt die Nachrichten, die Geräte und die Digest-Authentifizierungen, die er sieht. [Klicke hier, um mehr über den sniff-Befehl zu lesen](https://github.com/Pepelux/sippts/wiki/Command-sniff)

  * _**spoof**_ ist ein ARP-Spoofing-Tool, um sich zwischen zwei Geräte zu platzieren und deren Verkehr abzufangen. [Klicke hier, um mehr über den spoof-Befehl zu lesen](https://github.com/Pepelux/sippts/wiki/Command-spoof)

  * _**video**_ spielt eine animierte Demo der üblichen Workflows ab: scan zu exten zu rcrack, dump zu dcrack, leak zu dcrack und spoof zu sniff.

  * _**rtpbleed**_ zum Ausnutzen der RTP-Bleed-Schwachstelle durch Senden von Daten an RTP-Ports. [Klicke hier, um mehr über den rtpbleed-Befehl zu lesen](https://github.com/Pepelux/sippts/wiki/Command-rtpbleed)

  * _**rtcpbleed**_ zum Ausnutzen der RTP-Bleed-Schwachstelle durch Senden von Daten an RTCP-Ports. [Klicke hier, um mehr über den rtcpbleed-Befehl zu lesen](https://github.com/Pepelux/sippts/wiki/Command-rtcpbleed)

  * _**rtpbleedflood**_ zum Ausnutzen der RTP-Bleed-Schwachstelle durch Fluten eines RTP-Ports mit einem aktiven Dialog. [Klicke hier, um mehr über den rtpbleedflood-Befehl zu lesen](https://github.com/Pepelux/sippts/wiki/Command-rtpbleedflood)

  * _**rtpbleedinject**_ zum Ausnutzen der RTP-Bleed-Schwachstelle durch Injizieren von RTP-Verkehr. [Klicke hier, um mehr über den rtpbleedinject-Befehl zu lesen](https://github.com/Pepelux/sippts/wiki/Command-rtpbleedinject)

## TLS-Zertifikate ##

sippts spricht TLS und hat bisher das Zertifikat verworfen. Mit
`-tlsinfo` liest das `scan`-Modul aus, was der Server präsentiert:```
sippts scan -i 192.168.0.1 -r 5061 -p tls -tlsinfo

Jede Version wird als `accepted`, `refused` oder `untested` zurückgegeben. Letzteres
bedeutet, dass *dieses* OpenSSL diese Version nicht anbieten kann, was nicht
dasselbe ist wie ein Server, bei dem sie abgeschaltet wurde, und der Unterschied
ist wichtig, wenn das Ergebnis in einen Bericht einfließt.

Zwei ehrliche Grenzen, die das Tool ausgibt, anstatt sie zu verbergen:

  * **SSLv2 und SSLv3 können nicht getestet werden.** OpenSSL 3 wird ohne sie
    gebaut, daher kann sippts sie nicht anbieten. Sie werden als `untested`
    gemeldet, niemals als `disabled`.

  * Ein selbstsigniertes Zertifikat auf einem internen SIP-Trunk ist für sich
    genommen kein Befund. Beurteile es im Kontext.

Die Haupttabelle, die Datei von `-o` und die CSV von `-ocsv` ändern sich nicht. Das
JSON von `-oj` erhält `tls` und `tls_findings`.

## Call hijacking ##

`Replaces` (RFC 3891) verweist auf einen Anruf, der bereits aktiv ist, über seine Call-ID und
seine beiden Tags. `sippts dump` und `sippts sniff` sind das, was dir diese drei
Werte aus einem Capture liefert; von dort aus:```
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"

Die erste Tabelle behält ihre bisherige Form, ebenso wie die CSV von
`-ocsv`. Die neuen Daten werden nur dem JSON von `-oj` hinzugefügt, unter
`capabilities`.

## Bekannte Schwachstellen ##

Mit `-cve` vergleicht das `scan`-Modul seine Fingerabdrücke mit einer Liste
bekannter Schwachstellen, die im Paket mitgeliefert wird
(`src/sippts/data/cve.csv`). Sie enthält etwa 1400 CVEs von 54 Herstellern, erstellt
aus dem [NVD von NIST](https://nvd.nist.gov), und die Versionsbereiche stammen
aus den CPEs der jeweiligen CVE:```bash
sippts scan -i 192.168.0.0/24 -fp -cve

welches es von github zusammen mit den restlichen Modulen herunterlädt.

### Schweregrad ###

Jede CVE trägt ihren CVSS, eingefärbt nach Schweregrad: violett für kritisch, rot für
hoch, gelb für mittel und cyan für niedrig. Die schwerwiegendsten werden zuerst aufgelistet.

Das NVD hat nicht für jede CVE CVSS v3: etwa ein Drittel der Liste ist
älter als 2016 und hat nur v2, und bei Asterisk trifft das auf die meisten zu. Wenn
nur v2 existiert, wird es verwendet und **mit `v2` markiert**, weil die beiden Skalen
nicht äquivalent sind und v2 keine CRITICAL-Stufe hat: CVE-2017-16563 ist 6.0 MEDIUM in
v2 und 8.0 HIGH in v3.

Ein sippts älter als 4.2.1 kann diese Spalte nicht lesen. Aktualisieren mit `sippts -up`.

### Die Liste neu erstellen (Maintainer) ###

`tools/cve_update.py` erstellt `cve.csv` aus dem NVD neu. Das ist nichts, was der
Benutzer von sippts ausführt: die Idee ist, sie neu zu generieren, sich das Diff anzusehen, es zu committen
und alle anderen es mit `sippts -up` abrufen zu lassen. Das hält den API-Schlüssel und die
Rate Limits des NVD aus der Mitte eines Audits heraus.```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 .