Afficher l'aide pour la commande 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

# Ensemble d'outils pour les tests d'intrusion sur le protocole SIP #

Vous pouvez obtenir de l'aide sur l'utilisation de cet outil sur https://sippts.seguridadvoip.com ainsi que sur les pages wiki GitHub :

Sippts est un ensemble d'outils pour l'audit des serveurs et appareils VoIP utilisant le protocole SIP. Sippts est programmé en Python et se compose des commandes ou modules suivants :
  * _**scan**_ est un scanner multithread rapide pour les services SIP. Il peut vérifier plusieurs adresses IP et plages de ports, et fonctionne sur UDP, TCP et TLS. [Cliquez ici pour en savoir plus sur la commande scan](https://github.com/Pepelux/sippts/wiki/Command-scan)

  * _**exten**_ identifie les extensions sur un serveur SIP. Il indique également si l'extension nécessite une authentification. Il peut vérifier plusieurs adresses IP, et avec -f il lit les cibles depuis un fichier. [Cliquez ici pour en savoir plus sur la commande exten](https://github.com/Pepelux/sippts/wiki/Command-exten)

  * _**rcrack**_ est un cracker de mots de passe distant. Il peut tester les mots de passe de plusieurs utilisateurs sur plusieurs adresses IP, et avec -f il lit les cibles depuis un fichier. [Cliquez ici pour en savoir plus sur la commande rcrack](https://github.com/Pepelux/sippts/wiki/Command-rcrack)

  * _**invite**_ vérifie si un serveur nous permet de passer des appels sans authentification. Si le serveur SIP a une mauvaise configuration, il nous permettra de passer des appels vers des numéros externes. Il peut également transférer l'appel vers un second numéro externe. [Cliquez ici pour en savoir plus sur la commande invite](https://github.com/Pepelux/sippts/wiki/Command-invite)

  * _**leak**_ exploite la vulnérabilité SIP Digest Leak découverte par Sandro Gauci, qui affecte un grand nombre d'appareils matériels et logiciels. [Cliquez ici pour en savoir plus sur la commande leak](https://github.com/Pepelux/sippts/wiki/Command-leak)

  * _**flood**_ envoie des messages illimités à la cible. [Cliquez ici pour en savoir plus sur la commande flood](https://github.com/Pepelux/sippts/wiki/Command-flood)

  * _**send**_ envoie un message SIP personnalisé et analyse la réponse. [Cliquez ici pour en savoir plus sur la commande send](https://github.com/Pepelux/sippts/wiki/Command-send)

  * _**wssend**_ envoie un message SIP personnalisé via WebSockets et analyse la réponse. [Cliquez ici pour en savoir plus sur la commande wssend](https://github.com/Pepelux/sippts/wiki/Command-wssend)

  * _**enumerate**_ énumère les méthodes disponibles d'un service ou serveur SIP. [Cliquez ici pour en savoir plus sur la commande enumerate](https://github.com/Pepelux/sippts/wiki/Command-enumerate)

  * _**dump**_ extrait les authentifications SIP Digest d'un fichier PCAP. [Cliquez ici pour en savoir plus sur la commande dump](https://github.com/Pepelux/sippts/wiki/Command-dump)

  * _**dcrack**_ casse les authentifications digest du protocole SIP. [Cliquez ici pour en savoir plus sur la commande dcrack](https://github.com/Pepelux/sippts/wiki/Command-dcrack)

  * _**pcapdump**_ extrait les données SIP et RTP d'un fichier PCAP, et peut enregistrer les flux audio sous forme de fichiers WAV. [Cliquez ici pour en savoir plus sur la commande pcapdump](https://github.com/Pepelux/sippts/wiki/Command-pcapdump)

  * _**ping**_ envoie un ping SIP pour vérifier si un serveur ou un appareil est actif. [Cliquez ici pour en savoir plus sur la commande ping](https://github.com/Pepelux/sippts/wiki/Command-ping)

  * _**astami**_ scanne et audite l'Asterisk Manager Interface (AMI), et peut exécuter une commande sur ceux où les identifiants fonctionnent. [Cliquez ici pour en savoir plus sur la commande astami](https://github.com/Pepelux/sippts/wiki/Command-astami)

  * _**sniff**_ capture le trafic SIP en direct et affiche les messages, les appareils et les authentifications digest qu'il voit. [Cliquez ici pour en savoir plus sur la commande sniff](https://github.com/Pepelux/sippts/wiki/Command-sniff)

  * _**spoof**_ est un outil d'ARP spoofing, pour vous placer entre deux appareils et capturer leur trafic. [Cliquez ici pour en savoir plus sur la commande spoof](https://github.com/Pepelux/sippts/wiki/Command-spoof)

  * _**video**_ joue une démo animée des workflows habituels : scan vers exten vers rcrack, dump vers dcrack, leak vers dcrack, et spoof vers sniff.

  * _**rtpbleed**_ pour exploiter la vulnérabilité RTP Bleed en envoyant des données vers les ports RTP. [Cliquez ici pour en savoir plus sur la commande rtpbleed](https://github.com/Pepelux/sippts/wiki/Command-rtpbleed)

  * _**rtcpbleed**_ pour exploiter la vulnérabilité RTP bleed en envoyant des données vers les ports RTCP. [Cliquez ici pour en savoir plus sur la commande rtcpbleed](https://github.com/Pepelux/sippts/wiki/Command-rtcpbleed)

  * _**rtpbleedflood**_ pour exploiter la vulnérabilité RTP Bleed en inondant un port RTP avec un dialogue actif. [Cliquez ici pour en savoir plus sur la commande rtpbleedflood](https://github.com/Pepelux/sippts/wiki/Command-rtpbleedflood)

  * _**rtpbleedinject**_ pour exploiter la vulnérabilité RTP Bleed en injectant du trafic RTP. [Cliquez ici pour en savoir plus sur la commande rtpbleedinject](https://github.com/Pepelux/sippts/wiki/Command-rtpbleedinject)

## Certificats TLS ##

sippts parle TLS, et jusqu'à présent il jetait le certificat. Avec
`-tlsinfo` le module `scan` lit ce que le serveur présente :```
sippts scan -i 192.168.0.1 -r 5061 -p tls -tlsinfo

Chaque version revient comme `accepted`, `refused` ou `untested`. La dernière
signifie que *cet* OpenSSL ne peut pas proposer cette version, ce qui n'est pas
la même chose que le serveur l'ayant désactivée, et la différence compte quand
le résultat est intégré à un rapport.

Deux limites honnêtes, que l'outil affiche au lieu de les masquer :

  * **SSLv2 et SSLv3 ne peuvent pas être testés.** OpenSSL 3 est compilé sans
  eux, donc sippts ne peut pas les proposer. Ils sont signalés comme `untested`,
  jamais comme `disabled`.

  * Un certificat auto-signé sur un trunk SIP interne n'est pas une
  vulnérabilité en soi. Jugez-le en contexte.

Le tableau principal, le fichier de `-o` et le CSV de `-ocsv` ne changent pas. Le
JSON de `-oj` gagne `tls` et `tls_findings`.

## Détournement d'appel ##

`Replaces` (RFC 3891) pointe vers un appel déjà établi, par son Call-ID et
ses deux tags. `sippts dump` et `sippts sniff` sont ce qui vous donne ces trois
valeurs à partir d'une capture ; à partir de 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 première table conserve la forme qu'elle a toujours eue, et il en va de même pour le CSV de
`-ocsv`. Les nouvelles données sont uniquement ajoutées au JSON de `-oj`, sous
`capabilities`.

## Vulnérabilités connues ##

Avec `-cve`, le module `scan` compare ce qu'il identifie à une liste de
vulnérabilités connues qui voyage à l'intérieur du paquet
(`src/sippts/data/cve.csv`). Elle contient environ 1400 CVE de 54 fournisseurs, construite
à partir de la [NVD du NIST](https://nvd.nist.gov), et les plages de versions proviennent
des CPE de chaque CVE :```bash
sippts scan -i 192.168.0.0/24 -fp -cve

qui le télécharge depuis github avec le reste des modules.

### Sévérité ###

Chaque CVE porte son CVSS, coloré selon la sévérité : violet pour critique, rouge pour
élevée, jaune pour moyenne et cyan pour faible. Les plus graves sont listées en premier.

Le NVD n'a pas de CVSS v3 pour chaque CVE : environ un tiers de la liste est
antérieure à 2016 et ne dispose que de la v2, et pour Asterisk c'est la plupart d'entre elles. Lorsque
seule la v2 existe, elle est utilisée et **marquée avec `v2`**, car les deux échelles ne sont
pas équivalentes et la v2 n'a pas de niveau CRITICAL : CVE-2017-16563 est 6.0 MEDIUM en
v2 et 8.0 HIGH en v3.

Un sippts antérieur à 4.2.1 ne peut pas lire cette colonne. Mettez à jour avec `sippts -up`.

### Reconstruire la liste (mainteneurs) ###

`tools/cve_update.py` reconstruit `cve.csv` à partir du NVD. Ce n'est pas quelque chose que
l'utilisateur de sippts exécute : l'idée est de le régénérer, d'examiner le diff, de le commiter,
et de laisser tout le monde l'obtenir avec `sippts -up`. Cela garde la clé API et les
limites de débit du NVD en dehors du déroulement d'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 .