
Conjunto de herramientas para auditar sistemas VoIP basados en SIP
<center><img src="https://assets.kitploit.com/production/public/readmes/43212/6eee71d2f1e4d138db0d22382ca5a1f07e559d06c8ba6257179156199bdb8d47/88ff772aec8502903eb55970a1f2c4a9f02b189a5a2d10516482a8a9c32f5763-display-v1.webp" alt="logo" width="300"></center>
# ¿Qué es Sippts? #
Sippts es un conjunto de herramientas para auditar servidores y dispositivos VoIP que utilizan el protocolo SIP. Sippts está programado en Python y nos permite comprobar la seguridad de un servidor VoIP mediante el protocolo SIP.
# ¿Es gratuito? #
Sí. Puedes usarlo, modificarlo y distribuirlo libremente. Si lo modificas, incluye una referencia a este sitio.
# ¿Se puede usar sippts con fines ilegales? #
El propósito de esta herramienta es auditar tus propios sistemas o realizar pruebas de penetración en sistemas para los que hayas recibido autorización expresa. No soy responsable del uso indebido de esta herramienta.
# Uso #
Mostrar la ayuda:
```
sippts -h
usage: sippts [-h] [-up] {video,astami,scan,exten,rcrack,send,enumerate,leak,ping,invite,dump,dcrack,flood,sniff,spoof,pcapdump,rtpbleed,rtcpbleed,rtpbleedflood,rtpbleedinject} ...
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣀⣀⣀⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣄⣀⣀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣤⠤⠶⠒⠛⠉⠉⠉⠉⠀⠀⢀⣀⣀⣀⣤⣤⣤⣤⣤⣤⣤⣤⣬⣍⣙⣳⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣤⠴⠒⠋⠉⠀⠀⠀⢀⣀⣠⡤⠴⠖⠚⠛⠉⠉⠉⠀⣠⡶⠖⠲⣄⠀⠀⠀⠀⠀⠀⠀⠈⠉⢷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⡤⠖⠋⠁⠀⠀⠀⣀⣤⠴⠖⣛⣉⣁⠀⠀⠀⠀⠀⠀⠀⣀⣀⣠⡇⢹⡄⠀⠸⡆⠀⠀⠀⠀⠀⠀⠀⠀⠈⢿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⣀⡤⠞⠋⠀⠀⠀⢀⣠⠴⠚⠋⠁⠀⠀⡿⡏⠀⠈⣧⣤⠴⠖⠚⠛⠉⠉⠳⢄⡀⠀⣧⠀⠀⢷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⢠⡞⠧⣄⠀⢀⣠⠴⠚⠉⠀⠀⠀⠀⠀⢀⣴⠇⢹⠀⠀⢸⡆⠀⠀⠀⠀⠀⠀⠀⠀⠉⣲⣿⣀⣠⣼⣦⣤⣀⣀⣀⡀⠀⢀⣀⣠⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⢀⡿⠀⠀⠈⣿⠉⠀⠀⠀⠀⠀⠀⠙⢄⣰⠏⠀⠀⠘⡇⠀⠀⣇⢀⣀⡤⠤⠖⠒⠛⠉⠉⠉⣁⣀⠀⠀⠀⠉⠙⠛⢿⣿⡛⠛⠛⢻⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⣸⣧⣄⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⢈⣿⡄⠀⠀⠀⣷⠴⠚⠋⠉⠀⠀⢀⣠⣴⡖⠛⠉⠿⢻⣿⣉⡉⠙⠓⢲⠦⢤⣈⠙⢶⣶⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⢠⣏⠙⢦⣹⣼⠀⠀⠀⠀⠀⠀⢀⣴⣾⠟⠁⢀⡏⢀⡞⠀⠀⠀⠀⠀⣰⣯⡟⡀⠀⣼⡏⢘⡢⢠⣷⣾⡿⠿⠿⣷⣤⣞⠀⠙⢦⡀⠀⠙⢿⣷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⣰⡟⠿⡍⢷⢀⡇⠀⠀⠀⠀⠀⠀⠀⣠⣾⠏⣧⠀⢀⡞⠁⠀⠀⠀⠀⢠⡴⠋⠛⠻⣧⣤⡶⢿⡹⡟⠛⢯⣉⣿⢾⣧⣄⡈⠙⠲⢝⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⢠⣏⠙⢦⣹⣼⠀⠀⠀⠀⠀⠀⢀⣴⣾⠟⠁⢀⡏⢀⡞⠀⠀⠀⠀⠀⣰⣯⡟⡀⠀⣼⡏⢘⡢⢠⣷⣾⡿⠿⠿⣷⣤⣞⠀⠙⢦⡀⠀⠙⢿⣷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ SIPPTS version 4.1.2 (updated)
⣿⣍⡓⣄⣿⣧⣤⣤⣤⣶⣶⠿⠟⠋⠀⠀⣠⣎⣠⠎⠘⢄⠀⠀⠀⢀⡏⠛⠙⠋⢸⠋⠧⠤⠗⣾⢻⠁⠀⠀⠀⠀⠈⠻⡳⡀⠀⠙⢦⠀⣠⡹⡟⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀ CVE version 0.1 (updated)
⣷⣤⣙⢾⣿⣭⡉⠉⠉⠁⠀⠀⣀⣠⠴⠚⠉⠉⠀⠀⠀⠈⠳⡀⠀⠘⣧⣤⢀⠀⢸⡶⣏⠙⣦⠹⡜⢦⡀⠀⠀⠀⠀⢀⡇⣿⣶⣶⣾⣿⣥⡇⠹⡌⠻⣄⠀⠀⠀⠀⠀⠀⠀⠀ https://github.com/Pepelux/sippts
⣿⠤⢬⣿⣇⠈⢹⡟⠛⠛⠛⠉⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢆⠀⢻⡹⡎⠃⠀⠳⡄⣽⠛⠦⠉⠲⣍⣓⣒⢒⣒⣉⡴⠋⣟⠙⢲⣿⠘⠃⠀⣷⠀⠙⢧⡀⠀⠀⠀⠀⠀⠀by Pepelux - https://twitter.com/pepeluxx
⣿⠶⠒⠺⣿⡀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢣⡀⠳⡄⢀⡀⠀⠙⠮⣗⠚⢠⡖⠲⣌⣉⡭⣍⡡⣞⠓⣾⠉⣽⠃⢠⡄⣼⣿⠀⠀⠈⠳⡄⠀⠀⠀⠀⠀
⠸⡟⠉⣉⣻⣧⣼⠿⣦⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⣄⠙⢮⡿⢿⡃⠀⠈⠑⠶⢽⣒⣃⣘⣲⣤⣗⣈⣹⠵⠛⠁⠀⠀⡴⣻⠃⠀⠀⠀⠀⠹⣆⠀⠀⠀⠀
⠀⠹⣯⣁⣠⠼⠿⣿⡲⠿⠷⣤⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢦⠀⠙⠳⣄⡀⠀⣄⣶⣄⠀⠉⠉⠉⣉⡉⠉⠀⠀⠘⣶⣴⣦⠞⠁⠀⠀⠀⠀⠀⠀⠘⣧⠀⠀⠀
⠀⠀⠘⣧⡤⠖⢋⣩⠿⣶⣤⣈⣙⣷⣤⣀⣠⣤⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢳⡀⠀⠀⠉⠓⠶⢽⣼⣆⡀⠀⠀⢿⣿⣶⣀⣀⡬⠷⠚⠁⣀⣀⣀⠀⢰⣿⠿⡇⠀⠘⣧⠀⠀
⠀⠀⠀⠀⠙⠾⣏⣤⠞⢁⡞⠉⣿⠋⣹⠉⢹⠀⣿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠹⡄⠀⠀⠀⠀⠀⠀⠉⠉⠉⠉⠉⠉⠉⠉⠀⣤⣤⣄⠀⣿⠙⢻⠆⠀⠓⢒⣁⡤⠴⠺⡆⠀
⠀⠀⠀⠀⠀⠀⠀⠙⠒⠻⠤⣴⣇⣀⣿⣀⣾⡤⠿⢷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣆⠀⠀⠀⠀⠀⣀⣀⡀⠀⢸⠿⢷⡄⠀⣿⣀⡿⠀⢈⣉⡭⠴⠒⠋⠉⠀⠀⠀⠀⢻⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠻⣦⣀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢆⠀⠀⠀⠰⣟⠛⡇⠀⠘⠧⠞⢁⣀⡤⠴⠒⠋⠉⠀⠀⠀⠀⠀⠀⠀⠀⣀⣠⣼⠃
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠳⣦⣀⠀⠀⠀⠀⠀⠀⠈⢧⠀⠀⠀⠉⢋⣁⡤⠴⠚⠋⠉⠀⠀⠀⠀⠀⠀⠀⢀⣀⣠⣴⠶⠚⠛⠉⢉⣽⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠙⠷⣤⡀⠀⠀⠀⠀⠘⡆⠴⠒⠋⠉⠀⠀ ⢀⣀⣤⠴⠖⠛⠉⠉⠉⠉⠙⠛⠋⠉⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢛⠷⠦⠀⠀⠀⣿⠀⠀ ⠀⠀⠀⢠⠴⡖⠛⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠙⠷⣤⡀⠀⠘⡆⠴⠒⠋⠉⣤⠴⠖⠛⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢛⢠⠴⡖⠛⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-= SIPPTS is a set of tools for auditing VoIP systems based on the SIP protocol =-
Commands:
{video,astami,scan,exten,rcrack,send,enumerate,leak,ping,invite,dump,dcrack,flood,sniff,spoof,pcapdump,rtpbleed,rtcpbleed,rtpbleedflood,rtpbleedinject}
video Animated help
astami Asterisk AMI pentest
scan Fast SIP scanner
exten Search SIP extensions of a PBX
rcrack Remote password cracker
send Send a customized message
enumerate Enumerate methods of a SIP server
leak Exploit SIP Digest Leak vulnerability
ping SIP ping
invite Try to make calls through a PBX
dump Dump SIP digest authentications from a PCAP file
dcrack SIP digest authentication cracking
flood Flood a SIP server
sniff SIP network sniffing
spoof ARP Spoofing tool
pcapdump Extract data from a PCAP file
rtpbleed Detect RTPBleed vulnerability (send RTP streams)
rtcpbleed Detect RTPBleed vulnerability (send RTCP streams)
rtpbleedflood Exploit RTPBleed vulnerability (flood RTP)
rtpbleedinject Exploit RTPBleed vulnerability (inject WAV file)
Options:
-h, --help show this help message and exit
-up Update scripts
Command help:
sippts <command> -h
```
Mostrar ayuda para el 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, TLS, WS and WSS 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|ws|wss|all, or a list like udp,tls,wss (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
```
Actualizar scripts:
```
sippts -up
```
# Conjunto de herramientas para pruebas de penetración sobre el protocolo SIP #
Puedes obtener ayuda sobre cómo usar esta herramienta en https://sippts.seguridadvoip.com y también en las páginas wiki de Github:
Sippts es un conjunto de herramientas para auditar servidores y dispositivos VoIP que utilizan el protocolo SIP. Sippts está programado en Python y consta de los siguientes comandos o módulos:
* _**scan**_ es un escáner multihilo rápido para servicios SIP. Puede comprobar varias direcciones IP y rangos de puertos, y funciona sobre UDP, TCP, TLS y WebSockets (WS y WSS). [Haz clic aquí para leer más sobre el comando scan](https://github.com/Pepelux/sippts/wiki/Command-scan)
* _**exten**_ identifica extensiones en un servidor SIP. También te indica si la extensión requiere autenticación. Puede comprobar varias direcciones IP y, con -f, lee los objetivos desde un archivo. [Haz clic aquí para leer más sobre el comando exten](https://github.com/Pepelux/sippts/wiki/Command-exten)
* _**rcrack**_ es un crackeador de contraseñas remoto. Puede probar contraseñas para varios usuarios en varias direcciones IP y, con -f, lee los objetivos desde un archivo. [Haz clic aquí para leer más sobre el comando rcrack](https://github.com/Pepelux/sippts/wiki/Command-rcrack)
* _**invite**_ comprueba si un servidor nos permite realizar llamadas sin autenticación. Si el servidor SIP tiene una mala configuración, nos permitirá realizar llamadas a números externos. También puede transferir la llamada a un segundo número externo. [Haz clic aquí para leer más sobre el comando invite](https://github.com/Pepelux/sippts/wiki/Command-invite)
* _**leak**_ explota la vulnerabilidad SIP Digest Leak descubierta por Sandro Gauci, que afecta a un gran número de dispositivos de hardware y software. [Haz clic aquí para leer más sobre el comando leak](https://github.com/Pepelux/sippts/wiki/Command-leak)
* _**flood**_ envía mensajes ilimitados al objetivo. [Haz clic aquí para leer más sobre el comando flood](https://github.com/Pepelux/sippts/wiki/Command-flood)
* _**send**_ envía un mensaje SIP personalizado sobre UDP, TCP, TLS o WebSockets (WS y WSS) y analiza la respuesta. [Haz clic aquí para leer más sobre el comando send](https://github.com/Pepelux/sippts/wiki/Command-send)
* _**enumerate**_ enumera los métodos disponibles de un servicio o servidor SIP, sobre UDP, TCP, TLS o WebSockets (WS y WSS). [Haz clic aquí para leer más sobre el comando enumerate](https://github.com/Pepelux/sippts/wiki/Command-enumerate)
* _**dump**_ extrae las autenticaciones SIP Digest de un archivo PCAP. [Haz clic aquí para leer más sobre el comando dump](https://github.com/Pepelux/sippts/wiki/Command-dump)
* _**dcrack**_ crackea las autenticaciones digest del protocolo SIP. [Haz clic aquí para leer más sobre el comando dcrack](https://github.com/Pepelux/sippts/wiki/Command-dcrack)
* _**pcapdump**_ extrae datos SIP y RTP de un archivo PCAP, y puede guardar los flujos de audio como archivos WAV. [Haz clic aquí para leer más sobre el comando pcapdump](https://github.com/Pepelux/sippts/wiki/Command-pcapdump)
* _**ping**_ envía un ping SIP para comprobar si un servidor o dispositivo está activo. [Haz clic aquí para leer más sobre el comando ping](https://github.com/Pepelux/sippts/wiki/Command-ping)
* _**astami**_ escanea y audita la Asterisk Manager Interface (AMI), y puede ejecutar un comando en aquellas donde las credenciales funcionan. [Haz clic aquí para leer más sobre el comando astami](https://github.com/Pepelux/sippts/wiki/Command-astami)
* _**sniff**_ captura tráfico SIP en vivo y muestra los mensajes, los dispositivos y las autenticaciones digest que ve. [Haz clic aquí para leer más sobre el comando sniff](https://github.com/Pepelux/sippts/wiki/Command-sniff)
* _**spoof**_ es una herramienta de ARP spoofing, para situarte entre dos dispositivos y capturar su tráfico. [Haz clic aquí para leer más sobre el comando spoof](https://github.com/Pepelux/sippts/wiki/Command-spoof)
* _**video**_ reproduce una demostración animada de los flujos de trabajo habituales: scan a exten a rcrack, dump a dcrack, leak a dcrack, y spoof a sniff.
* _**rtpbleed**_ para explotar la vulnerabilidad RTP Bleed enviando datos a los puertos RTP. [Haz clic aquí para leer más sobre el comando rtpbleed](https://github.com/Pepelux/sippts/wiki/Command-rtpbleed)
* _**rtcpbleed**_ para explotar la vulnerabilidad RTP bleed enviando datos a los puertos RTCP. [Haz clic aquí para leer más sobre el comando rtcpbleed](https://github.com/Pepelux/sippts/wiki/Command-rtcpbleed)
* _**rtpbleedflood**_ para explotar la vulnerabilidad RTP Bleed inundando un puerto RTP con un diálogo activo. [Haz clic aquí para leer más sobre el comando rtpbleedflood](https://github.com/Pepelux/sippts/wiki/Command-rtpbleedflood)
* _**rtpbleedinject**_ para explotar la vulnerabilidad RTP Bleed inyectando tráfico RTP. [Haz clic aquí para leer más sobre el comando rtpbleedinject](https://github.com/Pepelux/sippts/wiki/Command-rtpbleedinject)
## Certificados TLS ##
sippts habla TLS y, hasta ahora, descartaba el certificado. Con
`-tlsinfo` el módulo `scan` lee lo que presenta el servidor:
```
sippts scan -i 192.168.0.1 -r 5061 -p tls -tlsinfo
```
No cuesta ninguna conexión adicional, porque el handshake ocurre de todos modos. Tras la tabla habitual vienen dos tablas: lo que dice el certificado (versión de TLS, cifrado, clave, caducidad y, con `-v`, también sujeto, emisor, SAN y SHA-256), y lo que merece la pena reportar sobre él — caducado, autofirmado, clave de menos de 2048 bits, firma SHA-1 o MD5, un nombre que no coincide, una versión de TLS antigua o un cifrado débil.
El que más importa en VoIP es `CERT_DEFAULT_VENDOR`: el certificado de fábrica de una PBX o de un teléfono, cuya clave privada se distribuye dentro de la imagen del firmware. Cualquiera que descargue esa imagen puede situarse en medio del SIP-TLS.
Con `-tlsversions` también prueba TLS 1.0, 1.1, 1.2 y 1.3 uno a uno, lo que cuesta un handshake por versión y se hace una vez por host y puerto:
```
sippts scan -i 192.168.0.1 -r 5061 -p tls -tlsversions
```
Cada versión se devuelve como `accepted`, `refused` o `untested`. La última
significa que *este* OpenSSL no puede ofrecer esa versión, lo cual no es lo mismo que
el servidor la tenga desactivada, y la diferencia importa cuando el resultado va
a un informe.
Dos límites honestos, que la herramienta imprime en lugar de ocultar:
* **SSLv2 y SSLv3 no se pueden probar.** OpenSSL 3 está compilado sin ellos, por lo que
sippts no puede ofrecerlos. Se reportan como `untested`, nunca como
`disabled`.
* Un certificado autofirmado en un troncal SIP interno no es un hallazgo por
sí mismo. Júzgalo en contexto.
La tabla principal, el archivo de `-o` y el CSV de `-ocsv` no cambian. El
JSON de `-oj` gana `tls` y `tls_findings`.
## Secuestro de llamadas ##
`Replaces` (RFC 3891) apunta a una llamada que ya está establecida, mediante su Call-ID y
sus dos tags. `sippts dump` y `sippts sniff` son lo que te proporciona esos tres
valores a partir de una captura; a partir de ahí:
```
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"
```
En un REFER es una transferencia atendida, y en un INVITE toma el control de la llamada. `sippts invite` también acepta `-replaces`, para añadirlo al REFER que `-t` ya envía, de modo que la transferencia ocurre dentro de una llamada que acaba de establecer.
## Lo que un servidor dice que soporta ##
`enumerate` prueba los 14 métodos SIP uno por uno y los distingue por la respuesta, pero un servidor también declara lo que acepta en las cabeceras `Allow`, `Supported` y `Allow-Events`. Esas también se leen y se imprimen en una segunda tabla, que además señala las dos contradicciones que merece la pena revisar: un método anunciado en `Allow` que luego responde `405`, y un método que responde correctamente sin estar anunciado en absoluto. `Allow-Events` es la que indica si se puede suscribir a `dialog`, `message-summary` o `presence`, que es adonde va después `send -m subscribe`.
```
sippts enumerate -i 192.168.0.1
```
La primera tabla conserva la forma que siempre tuvo, y también el CSV de
`-ocsv`. Los nuevos datos solo se añaden al JSON de `-oj`, bajo
`capabilities`.
## Vulnerabilidades conocidas ##
Con `-cve`, el módulo `scan` compara lo que identifica contra una lista de
vulnerabilidades conocidas que viaja dentro del paquete
(`src/sippts/data/cve.csv`). Contiene alrededor de 1400 CVE de 54 proveedores, construida
a partir del [NVD de NIST](https://nvd.nist.gov), y los rangos de versiones provienen de
los CPE de cada CVE:
```bash
sippts scan -i 192.168.0.0/24 -fp -cve
```
Los resultados cuya versión realmente cae dentro del rango afectado se listan primero.
El resto se muestra detrás de ellos como meramente posibles, porque en un escáner un CVE
que existe y no se reporta es peor que uno reportado en exceso. Una fila
sin rango significa que todas las versiones de ese dispositivo están afectadas.
Dos límites que conviene conocer. La detección se apoya en el `User-Agent`, por lo que un servidor
que lo oculta no puede comprobarse contra nada. Y algunos productos están versionados con letras (la A, B y C de Asterisk Business Edition, o
`beta_5`), que ninguna comparación numérica puede ordenar: esos se emparejan solo por texto, y siempre aparecen como posibles en lugar de confirmados.
Para actualizar la lista:
```bash
sippts -up
```
que lo descarga desde github junto con el resto de los módulos.
### Severidad ###
Cada CVE lleva su CVSS, coloreado según la severidad: púrpura para crítica, rojo
para alta, amarillo para media y cian para baja. Las más graves se listan primero.
El NVD no tiene CVSS v3 para todas las CVE: aproximadamente un tercio de la lista es
anterior a 2016 y solo tiene v2, y para Asterisk es la mayoría. Cuando
solo existe v2 se usa y **se marca con `v2`**, porque las dos escalas no son
equivalentes y v2 no tiene nivel CRITICAL: CVE-2017-16563 es 6.0 MEDIUM en
v2 y 8.0 HIGH en v3.
Un sippts anterior a 4.2.1 no puede leer esta columna. Actualiza con `sippts -up`.
### Reconstruir la lista (mantenedores) ###
`tools/cve_update.py` reconstruye `cve.csv` desde el NVD. No es algo que el
usuario de sippts ejecute: la idea es regenerarlo, revisar el diff, hacer commit,
y que todos los demás lo obtengan con `sippts -up`. Eso mantiene la clave de API y los
límites de tasa del NVD fuera del desarrollo de una auditoría.
```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
```
Sin una clave de API, el NVD permite 5 solicitudes cada 30 segundos y una ejecución completa
tarda alrededor de quince minutos. Son gratuitas en
[nvd.nist.gov](https://nvd.nist.gov/developers/request-an-api-key).
Dos listas al principio del script controlan qué se busca. `VENDORS` contiene
los proveedores, y cada uno puede ser el proveedor completo, una lista de productos o
filtrado por etiqueta. `TAGS_VOIP` contiene las etiquetas (`voip`, `sip`, `ip_phone`, `ata`,
`pbx`, `ip_office`, `mivoice`...). El filtro es importante para los proveedores que también
fabrican routers y firewalls: pedirle al NVD el paquete completo de Zyxel devuelve 3223
filas de equipos WiFi y DSL que sippts nunca va a ver a través de SIP.
## Sistemas operativos ##
Sippts ha sido probado en:
* Linux
* MacOS
## Requisitos ##
* Python 3
* Las dependencias listadas en requirements.txt, instaladas automáticamente por pip
* Para sniff, dump y pcapdump: tshark (parte de Wireshark)
* Para extraer audio con pcapdump: sox y ffmpeg
## Instalación ##
Instalación mediante git:
```bash
git clone https://github.com/Pepelux/sippts.git
```
```bash
cd sippts
```
```bash
pip3 install .
```Descubre las herramientas más usadas por nuestra comunidad.
Sin datos de popularidad aún.