# Escaneo

## Detectar hosts activos y puertos

### Nombres de servicios y números de puertos

* [https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml](https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml)

### Tools

{% tabs %}
{% tab title="TCP SYN Crafting" %}
```bash
hping3 -S 192.168.1.1 -p 80 -c 4
hping3 -S 192.168.1.1 -p445 -c 4
hping3 -S --scan 1-1000 192.168.1.1
hping3 -S --scan '1-1000,!900' 192.168.1.1
hping3 -S --scan 80,443 192.168.1.1
hping3 -S --scan known 192.168.1.1
hping3 -S --scan all 192.168.1.1
```

* Respuesta `flag=RA` Reset/ACK indica que el servicio no está corriendo
* Respuesta `flag=SA` SYN/ACK indica que el servicio está activo
* `--scan` especifica que puertos se van a escanear. Se pueden indicar usando una `,`, un `-`, la palabra `all` (para indicar todos los puertos), usando la palabra `known` (para indicar los puertos más conocidos), o utilizando el signo `!` para no escanear dicho puerto
{% endtab %}

{% tab title="NMAP" %}
* [https://nmap.org/book/man-port-scanning-techniques.html](https://nmap.org/book/man-port-scanning-techniques.html)

> Los scripts de NMAP se encuentra en la siguiente ruta: `/usr/share/nmap/scripts`

```bash
nmap -sS -p 135 192.168.1.1
nmap -sS -d -p 135 192.168.1.1
nmap -sS -n -Pn -p 135 192.168.1.1
nmap -sT -p 135 192.168.1.1
nmap -sU -p 137,161 192.168.1.1
nmap -sN -p 135 192.168.1.1
nmap -sX --top-ports 200 192.168.1.1
nmap -sF --top-ports 200 192.168.1.1
nmap --scanflags URG 192.168.1.1
nmap -sA 192.168.1.2 -p445
nmap --script-updatedb
nmap --script-help "smb*" and discovery
nmap --script-help whois-domain
nmap --script whois-domain w0lff4ng.org -sn
nmap --script smb-os-discovery -p 445 192.168.1.1
nmap --script smb-enum-shares -p 445 192.168.1.1
nmap --script auth 192.168.1.1
nmap --script default 192.168.1.1
```

* `-sS` escaneo TCP SYN
* `-d` aumenta el nivel de debugging
* `-n` no realiza resolución DNS
* `-Pn` deshabilitar el descubrimiento de hosts
* `-p` indicar los puertos a escanear. Para indicar todos los puertos se escribe `-p-`
* `-sT` escaneo TCP Connect (no es tan confiable como un escaneo usando raw packets)
* `-sU` escaneo UDP
* `-v` verbose
* `-sN` escaneo Null (sin flags habilitadas)
* `-sX` escaneo Xmas (envía un segmento con los siguientes flags: `FIN`, `PSH` y `URG`)
* `--top-ports` se indican cuantos puertos se requieren escanear
* `--scanflags` escaneo Custom TCP. Se pueden indicar los flags que queremos habilitar en el escaneo
* `-sA` escaneo TCP ACK. Valida si el puerto se encuentra filtrado o no
* `--script-help "smb*" and discovery` muestra información sobre lo relacionado con smb y la categoría discovery
* `--script-help whois-domain` muestra información sobre el script `whois-domain`
* `--script whois-domain w0lff4ng.org` se realiza un whois al dominio `w0lff4ng.org`
* `--script smb-os-discovery` validar el OS usando el script `smb-os-discovery`. Para este caso, se debe tener el puerto 445 abierto
* `--script smb-enum-shares` valida los shares de un target. Se debe tener el puerto 445 abierto
* `--script auth` ejecuta los scripts en la categoría auth
* `--script default` ejecuta los scripts en la categoría default
{% endtab %}

{% tab title="Otras herramientas" %}
* [Angry IP Scanner](https://angryip.org/)
* [masscan](https://github.com/robertdavidgraham/masscan)
{% endtab %}
{% endtabs %}

## Idle Scan

* [https://tools.ietf.org/html/rfc791  ](https://tools.ietf.org/html/rfc791https://nmap.org/idlescan-es.htmlhttps://www.variablenotfound.com/2007/02/escaneo-con-idle-scan.htmlhttps://nmap.org/book/idlescan.html)
* [https://nmap.org/idlescan-es.html  ](https://tools.ietf.org/html/rfc791https://nmap.org/idlescan-es.htmlhttps://www.variablenotfound.com/2007/02/escaneo-con-idle-scan.htmlhttps://nmap.org/book/idlescan.html)
* [https://www.variablenotfound.com/2007/02/escaneo-con-idle-scan.html  ](https://tools.ietf.org/html/rfc791https://nmap.org/idlescan-es.htmlhttps://www.variablenotfound.com/2007/02/escaneo-con-idle-scan.htmlhttps://nmap.org/book/idlescan.html)
* [https://nmap.org/book/idlescan.html](https://tools.ietf.org/html/rfc791https://nmap.org/idlescan-es.htmlhttps://www.variablenotfound.com/2007/02/escaneo-con-idle-scan.htmlhttps://nmap.org/book/idlescan.html)

{% tabs %}
{% tab title="Idle Scan con NMAP" %}
- Detectar un buen zombie. Si el `IP ID Sequence Generation` incrementa, es un buen zombie:

```bash
nmap -O -v -n 192.168.1.1
```

* Validar si es un buen candidato para zombie:

```bash
nmap --script ipidseq 192.168.1.1 -p 135
```

* Ejecución del idle scan:

```bash
nmap -Pn -sI 192.168.1.1:135 192.168.1.2 -p- -v
```

> La primera IP es el zombie.

* Otras formas:

```bash
nmap -Pn -sI 192.168.1.1:135 192.168.1.2 -p- -v --packet-trace
nmap -S 192.168.1.1 192.168.1.2 -p23 -Pn -n -e tun0 --disable-arp-ping
```

* `-O` detectar OS
* `-v` verbose
* `-n` no realiza resolución DNS
* `-Pn` no realiza descubrimiento de hosts
* `-sI` idle scan
* `-p` indicamos los puertos a escanear. Para indicar todos los puertos, se escribe `-p-`
* `--packet-trace` muestra todos los paquetes enviados y recibidos
* `-S` especificamos la dirección IP de origen spoofeada
* `-e` indicar la interfaz donde se originarán los paquetes
* `--disable-arp-ping` deshabilita el ARP/ND, y envía solo mensajes ICMP
* `--script ipidseq` ejecuta el script NSE `ipidseq`
{% endtab %}

{% tab title="Idle Scan con Hping" %}
* Escaneo número 1:

```bash
hping3 -S -r -p 135 192.168.1.1
```

* Escaneo número 2:

```bash
hping3 -a 192.168.1.1 -S -p 23 192.168.1.2
```

> Es necesario tener ambos escaneres corriendo, debido que, al ejecutar el segundo, si en el primero el `id` pasa a tener un `+2`, significa que el puerto del segundo escaneo se encuentra `open`.

* `-S` escaneo TCP SYN
* `-r` validamos si el `IP ID Sequence Generation` incrementa. Si el valor `id` posee un `+1`, significa que puede usarse como zombie
* `-p` indicamos el puerto de destino
* `-a` especificamos la IP del zombie que vamos a usar
{% endtab %}
{% endtabs %}

## Detección de OS

{% tabs %}
{% tab title="Banner Grabbing" %}
* Ncat:

```bash
ncat 192.168.1.1 22
```

* Netcat:

```bash
nc 192.168.1.1 22
```

* Telnet:

```bash
telnet 192.168.1.1 22
```
{% endtab %}

{% tab title="Detección de versión del servicio" %}
```bash
nmap -sV -p22,23,53,110,445 192.168.1.1
```

* `-sV` en base a los puertos abiertos, se intenta determinar la versión del servicio
* `-p` indicamos los puertos a escanear. Para indicar todos los puertos se escribe `-p`
{% endtab %}

{% tab title="OS Fingerprinting" %}
```bash
nmap -O -n 192.168.1.1
nmap -A -n 192.168.1.1
```

* `-O` realiza una identificación de OS activa
* `-n` no realiza resolución DNS
* `-A` habilita la detección de OS, versiones, script `scanning` y `traceroute`
{% endtab %}
{% endtabs %}

## Evasión de Firewall e IDS

{% tabs %}
{% tab title="Evasión usando NMAP" %}
```bash
nmap -sS -f 192.168.1.1
nmap -sS -f -f 192.168.1.1
nmap -sS -D 192.168.1.2,192.168.1.3,ME,192.168.1.4 192.168.1.1
nmap -sS -D RND:10 192.168.1.1 -p80 -Pn -n
nmap -sS -T1 192.168.1.1 -p22,23,135,443,445 --max-retries 1
nmap -sS -g 53 192.168.1.1
nmap -sS --data length 10 -p 21 192.168.1.1
nmap --spoof-mac apple 192.168.1.1 -p80 -Pn --disable-arp-ping -n
```

* `-sS` escaneo TCP SYN
* `-f` fragmentar paquetes. No funciona con los siguientes tipos de escanear: `-sT` y `-sV`. Esto divide en 8 bytes después del IP header. Si se le agrega otro `-f`, lo divide en 16 bytes
* `-D` Decoys. Se deben indicar direcciones (se recomienda que estas direcciones se encuentren activas para que no sea fácil de determinar cuál es la IP del atacante). `ME` indica nuestra posición en el escaneo. En caso de no indicarlo, NMAP nos pone en una posición random
* `-T` indica el tiempo que tomará de cada cuanto tiempo esperará entre el envío de cada paquete
* `-p` indicamos los puertos a escanear. Para indicar todos los puertos se escribe `-p`
* `--max-retries` indica la cantidad de reintentos en caso de no tener respuesta
* `-g` indica el puerto de origen. Puede usarse la opción `--source-port`
* `-n` no realiza resolución DNS
* `-Pn` no realizar descubrimiento de hosts
* `RND` genera decoys random, dependiendo de la cantidad indicada
* `--data-length` envía random data. La cantidad de bytes depende de la indicada
* `--spoof-mac` utiliza una mac de origen spoofeada, la cual, se le puede indicar el vendor a utilizar. Si el valor es `0`, utiliza una mac random. También se puede indicar una, escribiendola en el siguiente formato:`XX:XX:XX:XX:XX:XX`
* `--disable-arp-ping` deshabilita el ARP/ND, y envía solo mensajes ICMP
{% endtab %}

{% tab title="Evasión usando Hping" %}
```bash
hping3 -S -f -p 80 192.168.1.1 -c 1
hping3 --rand-source -S -p 80 192.168.1.1 -c 1
hping3 -a 192.168.1.1 -S -p 23 192.168.1.2
hping3 -S -s 53 --scan known 192.168.1.1
hping3 -S -p 21 --data 24 192.168.1.1
```

* `-S` escaneo TCP SYN
* `-p` indica el puerto de destino
* `-f` fragmenta los paquetes
* `-c` cantidad de paquetes a enviar
* `--rand-source` envía paquetes de origenes random
* `-a` indicamos la IP de origen que vamos a usar
* `-s` indica el puerto de origen
* `--scan` indica que puertos se van a escanear
* `--data` envía random data. La cantidad de bytes depende de la indicada
{% endtab %}
{% endtabs %}
