> For the complete documentation index, see [llms.txt](https://w0lf-f4ng.gitbook.io/cheat-sheet/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://w0lf-f4ng.gitbook.io/cheat-sheet/escaneo.md).

# 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>

### 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>

> 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/rfc791&#xD;&#xA;https://nmap.org/idlescan-es.html&#xD;&#xA;https://www.variablenotfound.com/2007/02/escaneo-con-idle-scan.html&#xD;&#xA;https://nmap.org/book/idlescan.html>)
* [https://nmap.org/idlescan-es.html  ](<https://tools.ietf.org/html/rfc791&#xD;&#xA;https://nmap.org/idlescan-es.html&#xD;&#xA;https://www.variablenotfound.com/2007/02/escaneo-con-idle-scan.html&#xD;&#xA;https://nmap.org/book/idlescan.html>)
* [https://www.variablenotfound.com/2007/02/escaneo-con-idle-scan.html  ](<https://tools.ietf.org/html/rfc791&#xD;&#xA;https://nmap.org/idlescan-es.html&#xD;&#xA;https://www.variablenotfound.com/2007/02/escaneo-con-idle-scan.html&#xD;&#xA;https://nmap.org/book/idlescan.html>)
* [https://nmap.org/book/idlescan.html](<https://tools.ietf.org/html/rfc791&#xD;&#xA;https://nmap.org/idlescan-es.html&#xD;&#xA;https://www.variablenotfound.com/2007/02/escaneo-con-idle-scan.html&#xD;&#xA;https://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 %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://w0lf-f4ng.gitbook.io/cheat-sheet/escaneo.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
