Comparte en:

AutoRecon es una herramienta de reconocimiento de red multiproceso que realiza una enumeración automática de servicios. Está destinada a ser una herramienta que ahorra tiempo para su uso en CTF (juegos diseñados para desafiar a novatos en seguridad informática) y otros entornos de pruebas de penetración (por ejemplo, OSCP). También puede ser útil en situaciones del mundo real.

La herramienta funciona realizando primero escaneos de puertos/escaneos de detección de servicios. A partir de esos resultados iniciales, la herramienta realiza más escaneos de enumeración de esos servicios, utilizando una serie de herramientas diferentes. Por ejemplo, si encuentra HTTP, iniciará nikto (así como muchos otros).

Todo en la herramienta es altamente configurable. La configuración predeterminada no realiza una explotación automatizada para mantener la herramienta en línea con las reglas del examen OSCP. Si deseas agregar herramientas de explotación automáticas a la configuración, lo haces bajo tu propio riesgo. El autor no es responsable de las acciones negativas que resulten del mal uso de esta herramienta.

Origen

AutoRecon ha sido inspirada en tres herramientas que el autor utilizó durante los laboratorios OSCP: Reconnoitre, ReconScan y bscan. Si bien las tres herramientas fueron útiles, ninguna de las tres tenía la funcionalidad deseada. AutoRecon combina las mejores características de las herramientas mencionadas, al mismo tiempo que implementa muchas características nuevas para ayudar a los pentesters con la enumeración de múltiples objetivos.

Características

  • Admite múltiples objetivos en forma de direcciones IP, rangos de IP (notación CIDR) y nombres de host resolubles.
  • Puede escanear objetivos simultáneamente, utilizando múltiples procesadores si están disponibles.
  • Perfiles de escaneo de puertos personalizables para flexibilidad en sus escaneos iniciales.
  • Comandos de enumeración de servicios personalizables y comandos de seguimiento manual sugeridos.
  • Una estructura de directorio intuitiva para la recopilación de resultados.
  • Registro completo de los comandos que se ejecutaron, junto con errores si fallan.
  • Coincidencia de patrones globales y por escaneo para que puedas resaltar/extraer información importante

Requisitos

  • Python 3
  • colorama
  • toml

Una vez que instalas Python 3, pip3 se puede utilizar para instalar los otros requisitos:

$ pip3 install -r requirements.txt

Varios comandos utilizados en AutoRecon hacen referencia al proyecto SecLists, en el directorio /usr/share/seclists/. Puedes descargar manualmente el proyecto SecLists a este directorio (https://github.com/danielmiessler/SecLists), o si estás utilizando Kali Linux (muy recomendable ) puedes ejecutar lo siguiente:

$ sudo apt install seclists

AutoRecon seguirá ejecutándose si no instalax SecLists, aunque varios comandos pueden fallar y algunos comandos manuales pueden no ejecutarse tampoco.

Además, los siguientes comandos pueden necesitar ser instalados, dependiendo de tu sistema operativo:

curl
enum4linux
gobuster
nbtscan
nikto
nmap
onesixtyone
oscanner
smbclient
smbmap
smtp-user-enum
snmpwalk
sslscan
svwar
tnscmd10g
whatweb
wkhtmltoimage

Uso

AutoRecon utiliza la funcionalidad específica de Python 3 y no es compatible con Python 2.

usage: autorecon.py [-h] [-ct <number>] [-cs <number>] [--profile PROFILE]
                    [-o OUTPUT] [--nmap NMAP | --nmap-append NMAP_APPEND] [-v]
                    [--disable-sanity-checks]
                    targets [targets ...]

Network reconnaissance tool to port scan and automatically enumerate services
found on multiple targets.

positional arguments:
  targets               IP addresses (e.g. 10.0.0.1), CIDR notation (e.g.
                        10.0.0.1/24), or resolvable hostnames (e.g. foo.bar)
                        to scan.

optional arguments:
  -h, --help            show this help message and exit
  -ct <number>, --concurrent-targets <number>
                        The maximum number of target hosts to scan
                        concurrently. Default: 5
  -cs <number>, --concurrent-scans <number>
                        The maximum n   umber of scans to perform per target
                        host. Default: 10
  --profile PROFILE     The port scanning profile to use (defined in port-
                        scan-profiles.toml). Default: default
  -o OUTPUT, --output OUTPUT
                        The output directory for results. Default: results
  --nmap NMAP           Override the {nmap_extra} variable in scans. Default:
                        -vv --reason -Pn
  --nmap-append NMAP_APPEND
                        Append to the default {nmap_extra} variable in scans.
  -v, --verbose         Enable verbose output. Repeat for more verbosity.
  --disable-sanity-checks
                        Disable sanity checks that would otherwise prevent the
                        scans from running.

Ejemplos

Escaneo de un solo objetivo:

python3 autorecon.py 127.0.0.1
[*] Scanning target 127.0.0.1
[*] Running service detection nmap-full-tcp on 127.0.0.1
[*] Running service detection nmap-top-20-udp on 127.0.0.1
[*] Running service detection nmap-quick on 127.0.0.1
[*] Service detection nmap-quick on 127.0.0.1 finished successfully
[*] [127.0.0.1] ssh found on tcp/22
[*] [127.0.0.1] http found on tcp/80
[*] [127.0.0.1] rpcbind found on tcp/111
[*] [127.0.0.1] postgresql found on tcp/5432
[*] Running task tcp/22/nmap-ssh on 127.0.0.1
[*] Running task tcp/80/nmap-http on 127.0.0.1
[*] Running task tcp/80/curl-index on 127.0.0.1
[*] Running task tcp/80/curl-robots on 127.0.0.1
[*] Running task tcp/80/whatweb on 127.0.0.1
[*] Running task tcp/80/nikto on 127.0.0.1
[*] Running task tcp/111/nmap-nfs on 127.0.0.1
[*] Task tcp/80/curl-index on 127.0.0.1 finished successfully
[*] Task tcp/80/curl-robots on 127.0.0.1 finished successfully
[*]    Task tcp/22/nmap-ssh on 127.0.0.1 finished successfully
[*] Task tcp/80/whatweb on 127.0.0.1 finished successfully
[*] Task tcp/111/nmap-nfs on 127.0.0.1 finished successfully
[*] Task tcp/80/nmap-http on 127.0.0.1 finished successfully
[*] Task tcp/80/nikto on 127.0.0.1 finished successfully
[*] Service detection nmap-top-20-udp on 127.0.0.1 finished successfully
[*] Service detection nmap-full-tcp on 127.0.0.1 finished successfully
[*] [127.0.0.1] http found on tcp/5984
[*] [127.0.0.1] rtsp found on tcp/5985
[*] Running task tcp/5984/nmap-http on 127.0.0.1
[*] Running task tcp/5984/curl-index on 127.0.0.1
[*] Running task tcp/5984/curl-robots on 127.0.0.1
[*] Running task tcp/5984/whatweb on 127.0.0.1
[*] Running task tcp/5984/nikto on 127.0.0.1
[*] Task tcp/5984/curl-index on 127.0.0.1 finished successfully
[*] Task tcp/5984/curl-robots on 127.0.0.1 finished successfully
[*] Task tcp/5984/whatweb on 127.0.0.1 finish   ed successfully
[*] Task tcp/5984/nikto on 127.0.0.1 finished successfully
[*] Task tcp/5984/nmap-http on 127.0.0.1 finished successfully
[*] Finished scanning target 127.0.0.1

 El perfil de escaneo de puertos predeterminado primero realiza un escaneo completo de puertos TCP, un escaneo de 20 puertos UDP principales y un escaneo de los primeros 1000 puertos TCP.

Puedes preguntar por qué AutoRecon escanea los primeros 1000 puertos TCP al mismo tiempo que un escaneo completo de puertos TCP (que también escanea esos puertos). La razón es simple: la mayoría de los puertos abiertos generalmente estarán entre los primeros 1000, y queremos comenzar a enumerar los servicios rápidamente, en lugar de esperar a que Nmap escanee cada puerto.

Como puedes ver, todos los escaneos de enumeración de servicios realmente finalizan antes de que se complete el escaneo completo de puertos TCP. Si bien existe una ligera duplicación de esfuerzos, vale la pena al devolver los resultados de enumeración reales al pentester más rápido.

Ten en cuenta que la salida de la línea de comando real se coloreará si tu terminal lo admite.

Escaneo de múltiples objetivos

python3 autorecon.py 192.168.1.100 192.168.1.1/30 localhost
[*] Scanning target 192.168.1.100
[*] Scanning target 192.168.1.1
[*] Scanning target 192.168.1.2
[*] Scanning target localhost
[*] Running service detection nmap-quick on 192.168.1.100
[*] Running service detection nmap-quick on localhost
[*] Running service detection nmap-top-20-udp on 192.168.1.100
[*] Running service detection nmap-quick on 192.168.1.1
[*] Running service detection nmap-quick on 192.168.1.2
[*] Running service detection nmap-top-20-udp on 192.168.1.1
[*] Running service detection nmap-full-tcp on 192.168.1.100
[*] Running service detection nmap-top-20-udp on localhost
[*] Running service detection nmap-top-20-udp on 192.168.1.2
[*] Running service detection nmap-full-tcp on localhost
[*] Running service detection nmap-full-tcp on 192.168.1.1
[*] Running service detection nmap-full-tcp on 192.168.1.2

AutoRecon admite múltiples objetivos por escaneo y ampliará los rangos de IP proporcionados en la notación CIDR. De forma predeterminada, solo se escanearán 5 objetivos a la vez, con 10 escaneos por objetivo.

Escaneo de múltiples objetivos con opciones avanzadas

python3 autorecon.py -ct 2 -cs 2 -vv -o outputdir 192.168.1.100 192.168.1.1/30 localhost
[*] Scanning target 192.168.1.100
[*] Scanning target 192.168.1.1
[*] Running service detection nmap-quick on 192.168.1.100 with nmap -vv --reason -Pn -sV -sC --version-all -oN "/root/outputdir/192.168.1.100/scans/_quick_tcp_nmap.txt" -oX "/root/outputdir/192.168.1.100/scans/_quick_tcp_nmap.xml" 192.168.1.100
[*] Running service detection nmap-quick on 192.168.1.1 with nmap -vv --reason -Pn -sV -sC --version-all -oN "/root/outputdir/192.168.1.1/scans/_quick_tcp_nmap.txt" -oX "/root/outputdir/192.168.1.1/scans/_quick_tcp_nmap.xml" 192.168.1.1
[*] Running service detection nmap-top-20-udp on 192.168.1.100 with nmap -vv --reason -Pn -sU -A --top-ports=20 --version-all -oN "/root/outputdir/192.168.1.100/scans/_top_20_udp_nmap.txt" -oX "/root/outputdir/192.168.1.100/scans/_top_20_udp_nmap.xml" 192.168.1.100
[*] Running service detection nmap-top-20-udp on 192.168.1.1    with nmap -vv --reason -Pn -sU -A --top-ports=20 --version-all -oN "/root/outputdir/192.168.1.1/scans/_top_20_udp_nmap.txt" -oX "/root/outputdir/192.168.1.1/scans/_top_20_udp_nmap.xml" 192.168.1.1
[-] [192.168.1.1 nmap-quick] Starting Nmap 7.70 ( https://nmap.org ) at 2019-03-01 17:25 EST
[-] [192.168.1.100 nmap-quick] Starting Nmap 7.70 ( https://nmap.org ) at 2019-03-01 17:25 EST
[-] [192.168.1.100 nmap-top-20-udp] Starting Nmap 7.70 ( https://nmap.org ) at 2019-03-01 17:25 EST
[-] [192.168.1.1 nmap-top-20-udp] Starting Nmap 7.70 ( https://nmap.org ) at 2019-03-01 17:25 EST
[-] [192.168.1.1 nmap-quick] NSE: Loaded 148 scripts for scanning.
[-] [192.168.1.1 nmap-quick] NSE: Script Pre-scanning.
[-] [192.168.1.1 nmap-quick] NSE: Starting runlevel 1 (of 2) scan.
[-] [192.168.1.1 nmap-quick] Initiating NSE at 17:25
[-] [192.168.1.1 nmap-quick] Completed NSE at 17:25, 0.00s elapsed
[-] [192.168.1.1 nmap-quick] NSE: Starting runlevel 2 (of 2) sca   n.
[-] [192.168.1.1 nmap-quick] Initiating NSE at 17:25
[-] [192.168.1.1 nmap-quick] Completed NSE at 17:25, 0.00s elapsed
[-] [192.168.1.1 nmap-quick] Initiating ARP Ping Scan at 17:25
[-] [192.168.1.100 nmap-quick] NSE: Loaded 148 scripts for scanning.
[-] [192.168.1.100 nmap-quick] NSE: Script Pre-scanning.
[-] [192.168.1.100 nmap-quick] NSE: Starting runlevel 1 (of 2) scan.
[-] [192.168.1.100 nmap-quick] Initiating NSE at 17:25
[-] [192.168.1.100 nmap-quick] Completed NSE at 17:25, 0.00s elapsed
[-] [192.168.1.100 nmap-quick] NSE: Starting runlevel 2 (of 2) scan.
[-] [192.168.1.100 nmap-quick] Initiating NSE at 17:25
[-] [192.168.1.100 nmap-quick] Completed NSE at 17:25, 0.00s elapsed
[-] [192.168.1.100 nmap-quick] Initiating ARP Ping Scan at 17:25

En este ejemplo, la opción -ct limita el número de objetivos concurrentes a 2, y la opción –cs limita el número de escaneos concurrentes por objetivo a 2. La opción -vv hace que la salida sea muy detallada, mostrando la salida de cada escaneo ejecutado. La opción -o establece un directorio de salida personalizado para guardar los resultados del análisis.

Opciones

AutoRecon admite tres niveles de opciones:

  • (ninguna) Salida mínima. AutoRecon anunciará cuándo comienzan y finalizan los escaneos objetivo, así como qué servicios se identificaron.
  • (-v) Salida detallada. AutoRecon especificará adicionalmente los comandos exactos que se están ejecutando, así como resaltará los patrones que coincidan en la salida del comando.
  • (-vv) Salida muy detallada. AutoRecon mostrará todo. Literalmente, cada línea de todos los comandos que se están ejecutando actualmente. Al escanear múltiples objetivos simultáneamente, esto puede conducir a una cantidad ridícula de resultados. No se recomienda usar -vv a menos que sea absolutamente necesario ver la salida en vivo de los comandos.

Resultados

Por defecto, los resultados se almacenarán en el directorio ./results. Se crea un nuevo subdirectorio para cada objetivo. La estructura de este subdirectorio es:

.
├── exploit/
├── loot/
├── report/
│   ├── local.txt
│   ├── notes.txt
│   ├── proof.txt
│   └── screenshots/
└── scans/
    ├── _commands.log
    ├── _manual_commands.txt
    └── xml/

El directorio exploit está destinado a contener cualquier código de exploit que descargues/escribas para el objetivo.
La carpeta loot está destinado a contener cualquier botín (por ejemplo, hashes, archivos interesantes) que encuentre en el objetivo.

El directorio report contiene algunos archivos y directorios generados automáticamente que son útiles para informar:

  • local.txt se puede usar para almacenar el indicador local.txt que se encuentra en los objetivos.
  • notes.txt debe contener una plantilla básica donde puedas escribir notas para cada servicio descubierto.
  • proof.txt se puede usar para almacenar el indicador proof.txt que se encuentra en los objetivos.
  • El directorio screenshots está destinado a contener las capturas de pantalla que utilizan para documentar la explotación del objetivo.

Directorio Scans

El directorio de scans es donde irán todos los resultados de los escaneos realizados por AutoRecon. Esto incluye escaneos de puertos/escaneos de detección de servicios, así como cualquier escaneo de enumeración de servicios. También contiene otros dos archivos:

  • _commands.log contiene una lista de todos los comandos que AutoRecon ejecutó contra el objetivo. Esto es útil si uno de los comandos falla y deseas ejecutarlo nuevamente con modificaciones.
  • _manual_commands.txt contiene todos los comandos que se consideran “demasiado peligrosos” para ejecutarse automáticamente, ya sea porque son demasiado intrusivos, requieren modificaciones basadas en análisis humanos o simplemente funcionan mejor cuando hay un ser humano que los controla.

Si un análisis produce un error, también aparecerá un archivo llamado _errors.log en el directorio scans con algunos detalles para alertar al usuario.

Si la salida coincide con un patrón definido, un archivo llamado _patterns.log también aparecerá en el directorio scans con detalles sobre la salida coincidente.

El directorio scans/xml almacena cualquier salida XML (por ejemplo, de escaneos Nmap) por separado de las salidas principales de escaneo, de modo que el directorio scans en sí no se desordene demasiado.

Perfiles de escaneo de puertos

El archivo port-scan-profiles.toml es donde puedes definir los escaneos de puertos iniciales/comandos de detección de servicio. El archivo de configuración usa el formato TOML, que se explica aquí: https://github.com/toml-lang/toml

Aquí hay un perfil de ejemplo llamado “quick“:

[quick]

    [quick.nmap-quick]

        [quick.nmap-quick.service-detection]
        command = 'nmap {nmap_extra} -sV --version-all -oN "{scandir}/_quick_tcp_nmap.txt" -oX "{scandir}/xml/_quick_tcp_nmap.xml" {address}'
        pattern = '^(?P<port>\d+)\/(?P<protocol>(tcp|udp))(.*)open(\s*)(?P<service>[\w\-\/]+)(\s*)(.*)$'

    [quick.nmap-top-20-udp]

        [quick.nmap-top-20-udp.service-detection]
        command = 'nmap {nmap_extra} -sU -A --top-ports=20 --version-all -oN "{scandir}/_top_20_udp_nmap.txt" -oX "{scandir}/xml/_top_20_udp_nmap.xml" {address}'
        pattern = '^(?P<port>\d+)\/(?P<protocol>(tcp|udp))(.*)open(\s*)(?P<service>[\w\-\/]+)(\s*)(.*)$'

Ten en cuenta que la sangría es opcional, se usa aquí únicamente por estética. El perfil “quick” define un escaneo llamado “nmap-quick”. Este escaneo tiene un comando de detección de servicio que usa nmap para escanear los primeros 1000 puertos TCP.

El comando usa dos referencias: {scandir} es la ubicación del directorio de escaneos para el objetivo, y {address} es la dirección del objetivo.

Se define un patrón regex que coincide con tres grupos con nombre (puerto, protocolo y servicio) en la salida. Cada comando de detección de servicio debe tener un patrón correspondiente que coincida con los tres grupos. AutoRecon intentará hacer algunas comprobaciones y se negará a escanear si falta alguno de estos grupos.

También se define una exploración casi idéntica llamada “nmap-top-20-udp”. Esto escanea los 20 principales puertos UDP.

Aquí hay un ejemplo más complicado:

[udp]

    [udp.udp-top-20]

        [udp.udp-top-20.port-scan]
        command = 'unicornscan -mU -p 631,161,137,123,138,1434,445,135,67,53,139,500,68,520,1900,4500,514,49152,162,69 {address} 2>&1 | tee "{scandir}/_top_20_udp_unicornscan.txt"'
        pattern = '^UDP open\s*[\w-]+\[\s*(?P<port>\d+)\].*$'

        [udp.udp-top-20.service-detection]
        command = 'nmap {nmap_extra} -sU -A -p {ports} --version-all -oN "{scandir}/_top_20_udp_nmap.txt" -oX "{scandir}/xml/_top_20_udp_nmap.xml" {address}'
        pattern = '^(?P<port>\d+)\/(?P<protocol>(udp))(.*)open(\s*)(?P<service>[\w\-\/]+)(\s*)(.*)$'

En este ejemplo, un perfil llamado “udp” define un escaneo llamado “udp-top-20”. Este escaneo tiene dos comandos, uno es un escaneo de puertos y el otro es una detección de servicio.

Ejecución

Cuando se define un comando de escaneo de puertos, siempre se ejecutará primero. El patrón correspondiente debe coincidir con un grupo de nombre “puerto” que extrae el número de puerto de la salida.

La detección de servicio se ejecutará después de que el comando port-scan haya finalizado y use una nueva referencia: {ports}. Esta referencia es una cadena separada por comas de todos los puertos extraídos por el comando port-scan.

Ten en cuenta que los mismos tres grupos con nombre (puerto, protocolo y servicio) se definen en el patrón de detección de servicio.

Tanto los comandos de escaneo de puertos como los de detección de servicio utilizan las referencias {scandir} y {address}.

Ten en cuenta que, si se define un comando de escaneo de puertos sin un comando de detección de servicio correspondiente, AutoRecon se negará a escanear.

Este ejemplo más complicado solo es realmente útil si deseas utilizar la velocidad de unicornscan junto con las capacidades de detección de servicio de nmap. Si estás satisfecho con el uso de Nmap para el escaneo de puertos y la detección de servicios, no necesitas usar esta configuración.

Escaneos de servicio

El archivo service-scans.toml es donde puedes definir escaneos de enumeración de servicios y otros comandos manuales asociados con ciertos servicios.
Aquí hay un ejemplo de una configuración simple:

[ftp]

service-names = [
    '^ftp',
    '^ftp\-data'
]

    [[ftp.scan]]
    name = 'nmap-ftp'
    command = 'nmap {nmap_extra} -sV -p {port} --script="(ftp* or ssl*) and not (brute or broadcast or dos or external or fuzzer)" -oN "{scandir}/{protocol}_{port}_ftp_nmap.txt" -oX "{scandir}/xml/{protocol}_{port}_ftp_nmap.xml" {address}'

        [[ftp.scan.pattern]]
        description = 'Anonymous FTP Enabled!'
        pattern = 'Anonymous FTP login allowed'

    [[ftp.manual]]
    description = 'Bruteforce logins:'
    commands = [
        'hydra -L "{username_wordlist}" -P "{password_wordlist}" -e nsr -s {port} -o "{scandir}/{protocol}_{port}_ftp_hydra.txt" ftp://{address}',
        'medusa -U "{username_wordlist}" -P "{password_wordlist}" -e ns -n {port} -O "{scandir}/{protocol}_{port}_ftp_medusa.txt" -M ftp -h {address}'
    ]

Cabe mencionar que la sangría es opcional, se usa aquí únicamente por estética. El servicio “ftp” se define aquí. La matriz de nombres de servicio contiene cadenas de expresiones regulares que deben coincidir con el nombre del servicio de los escaneos de detección de servicio.

Regex se utiliza para ser lo más flexible posible. La matriz de nombres de servicio funciona en una lista blanca; siempre que una de las cadenas de expresiones regulares coincida, el servicio se escaneará.

También se puede definir una matriz opcional ignore-service-names, si deseas incluir en la lista negra ciertas cadenas de expresiones regulares para que no coincidan.

La sección ftp.scan define un solo escaneo, llamado nmap-ftp. Este escaneo define un comando que ejecuta nmap con varios scripts relacionados con ftp. Aquí se usan varias referencias:

Referencias

  • {nmap_extra} de forma predeterminada se establece en “-vv –reason -Pn”, pero esto se puede anular o agregar usando las opciones de línea de comando –nmap o –nmap-append respectivamente. Si el protocolo es UDP, también se agregará “-sU”.
  • {port} es el puerto en el que se ejecuta el servicio.
  • {scandir} es la ubicación del directorio de escaneos para el objetivo.
  • {protocol} es el protocolo que se está utilizando (tcp o udp).
  • {Address} es la dirección del objetivo.

Se define un patrón para el escaneo nmap-ftp, que coincide con el patrón simple “Anonymous FTP login allowed”. En el caso de que este patrón coincida con la salida del comando nmap-ftp, la descripción del patrón (“Anonymous FTP Enabled!”) Se guardará en el archivo _patterns.log en el directorio de scans. Se puede usar una referencia especial {match} en la descripción para hacer referencia a toda la coincidencia, o al primer grupo de captura.

La sección ftp.manual define un grupo de comandos manuales. Este grupo contiene una descripción para el usuario y una matriz de comandos, que contiene los comandos que puede ejecutar un usuario.

Aquí se definen dos nuevas referencias: {username_wordlist} y {password_wordlist}, que se configuran en la parte superior del archivo service-scans.toml, y por defecto a una lista de palabras de nombre de usuario y contraseña proporcionadas por SecLists.

[smb]

service-names = [
    '^smb',
    '^microsoft\-ds',
    '^netbios'
]

    [[smb.scan]]
    name = 'nmap-smb'
    command = 'nmap {nmap_extra} -sV -p {port} --script="(nbstat or smb* or ssl*) and not (brute or broadcast or dos or external or fuzzer)" --script-args="unsafe=1" -oN "{scandir}/{protocol}_{port}_smb_nmap.txt" -oX "{scandir}/xml/{protocol}_{port}_smb_nmap.xml" {address}'

    [[smb.scan]]
    name = 'enum4linux'
    command = 'enum4linux -a -M -l -d {address} 2>&1 | tee "{scandir}/enum4linux.txt"'
    run_once = true
    ports.tcp = [139, 389, 445]
    ports.udp = [137]

    [[smb.scan]]
    name = 'nbtscan'
    command = 'nbtscan -rvh {address} 2>&1 | tee "{scandir}/nbtscan.txt"'
    run_once = true
    ports.udp = [137]

    [[smb.scan]]
    name = 'smbclient'
    command = 'smbclient -L\\ -N -I {address} 2>&1 | tee "{scan   dir}/smbclient.txt"'
    run_once = true
    ports.tcp = [139, 445]

    [[smb.scan]]
    name = 'smbmap-share-permissions'
    command = 'smbmap -H {address} -P {port} 2>&1 | tee -a "{scandir}/smbmap-share-permissions.txt"; smbmap -u null -p "" -H {address} -P {port} 2>&1 | tee -a "{scandir}/smbmap-share-permissions.txt"'

    [[smb.scan]]
    name = 'smbmap-list-contents'
    command = 'smbmap -H {address} -P {port} -R 2>&1 | tee -a "{scandir}/smbmap-list-contents.txt"; smbmap -u null -p "" -H {address} -P {port} -R 2>&1 | tee -a "{scandir}/smbmap-list-contents.txt"'

    [[smb.scan]]
    name = 'smbmap-execute-command'
    command = 'smbmap -H {address} -P {port} -x "ipconfig /all" 2>&1 | tee -a "{scandir}/smbmap-execute-command.txt"; smbmap -u null -p "" -H {address} -P {port} -x "ipconfig /all" 2>&1 | tee -a "{scandir}/smbmap-execute-command.txt"'

    [[smb.manual]]
       description = 'Nmap scans for SMB vulnerabilities that could potentially cause a DoS if scanned (according to Nmap). Be careful:'
    commands = [
        'nmap {nmap_extra} -sV -p {port} --script="smb-vuln-ms06-025" --script-args="unsafe=1" -oN "{scandir}/{protocol}_{port}_smb_ms06-025.txt" -oX "{scandir}/xml/{protocol}_{port}_smb_ms06-025.xml" {address}',
        'nmap {nmap_extra} -sV -p {port} --script="smb-vuln-ms07-029" --script-args="unsafe=1" -oN "{scandir}/{protocol}_{port}_smb_ms07-029.txt" -oX "{scandir}/xml/{protocol}_{port}_smb_ms07-029.xml" {address}',
        'nmap {nmap_extra} -sV -p {port} --script="smb-vuln-ms08-067" --script-args="unsafe=1" -oN "{scandir}/{protocol}_{port}_smb_ms08-067.txt" -oX "{scandir}/xml/{protocol}_{port}_smb_ms08-067.xml" {address}'
    ]

Aquí hay una configuración más complicada:

Configuraciones

La principal diferencia aquí es que varios escaneos tienen algunas configuraciones nuevas:

  • La matriz ports.tcp define una lista blanca de puertos TCP con los que se puede ejecutar el comando. Si el servicio se detecta en un puerto que no está en la lista blanca, el comando no se ejecutará contra él.
  • La matriz ports.udp define una lista blanca de puertos UDP con los que se puede ejecutar el comando. Funciona de la misma manera que la matriz ports.tcp.

¿Por qué existen estas configuraciones? Bueno, algunos comandos solo se ejecutarán en puertos específicos y no se les puede pedir que se ejecuten en ningún otro puerto. enum4linux, por ejemplo, solo se ejecutará en los puertos TCP 139, 389 y 445, y en el puerto UDP 137.

De hecho, enum4linux siempre probará estos puertos cuando se ejecute. Entonces, si el servicio SMB se encuentra en los puertos TCP 139 y 445, AutoRecon puede intentar ejecutar enum4linux dos veces sin ningún motivo. Por eso existe la tercera configuración:

  • Si run_once se establece en true, el comando solo se ejecutará una vez para ese objetivo, incluso si el servicio SMB se encuentra en varios puertos.




0 Comments

Deja un comentario