Bash scripting

Qué es un script de bash

Un script es simplemente un archivo de texto con una secuencia de comandos que el shell ejecuta uno detrás de otro, como si los escribieras a mano en la terminal. La ventaja frente a teclear comandos sueltos es evidente: lo escribes una vez y lo reutilizas siempre que quieras, sin errores de repetición.

Bash no es el único shell (existen zsh, ksh, csh…), pero es el que viene por defecto en la inmensa mayoría de distribuciones Linux y en macOS, así que es el estándar de facto para scripting de sistema.

Tu primer script

Todo script de bash empieza con una línea especial llamada shebang, que le dice al sistema qué intérprete debe usar para ejecutar el resto del archivo:

#!/bin/bash

# Este es mi primer script. Simplemente saluda.
echo "Hola, mundo"

Guarda el archivo, por ejemplo, como saludo.sh. Aunque la extensión .sh no es obligatoria para que el script funcione, es la convención que indica a cualquiera que lea el directorio que ese archivo es un script de shell.

Dar permisos de ejecución

Por defecto, un archivo recién creado no es ejecutable, ni siquiera para su propietario:

ls -l saludo.sh
# -rw-r--r-- 1 ansango ansango 52 jul 11 10:00 saludo.sh

Le falta el permiso x (ejecución). Se lo damos con chmod:

chmod +x saludo.sh
# o, de forma más explícita:
chmod 755 saludo.sh

Ejecutar el script

./saludo.sh

Variables y entrada de usuario

Una variable es simplemente un espacio de memoria con un nombre al que puedes asignar y recuperar un valor. Para leer un valor introducido por el usuario se usa el comando read, que lo captura de la entrada estándar y lo guarda en la variable indicada.

#!/bin/bash

echo "¿Cómo te llamas?"
read nombre

echo "¿En qué directorio trabajas normalmente?"
read directorio

echo "Hola $nombre, hoy vamos a trabajar en $directorio"

Parámetros posicionales: pasar argumentos al script

Antes de meternos con el escáner, conviene distinguir las dos formas de dar datos a un script: pedirlos de forma interactiva con read (como en el ejemplo anterior) o pasarlos como argumentos en la propia línea de invocación, al estilo de cualquier comando de Linux (grep -i patron archivo).

Dentro del script, esos argumentos están disponibles como parámetros posicionales:

#!/bin/bash

echo "El script se llama: $0"
echo "Se han pasado $# argumentos"
echo "El primero es: $1"
echo "Todos juntos: $@"

Un script práctico: escáner de puertos con bash puro

Bash tiene un truco poco conocido pero muy útil para un administrador o para depurar conectividad: el pseudo-dispositivo /dev/tcp/<host>/<puerto>. Al intentar abrir ese “archivo” en redirección, bash intenta abrir una conexión TCP real contra ese host y puerto, sin depender de herramientas externas como nc o nmap.

Vamos a construir un escáner simple que recorra un rango de puertos de un host usando un bucle for y decida con un condicional si cada puerto está abierto o cerrado:

#!/bin/bash

# Escáner de puertos TCP usando solo bash, sin herramientas externas.
# Uso: ./escaner.sh <host> <puerto_inicial> <puerto_final>

host="$1"
puerto_inicio="$2"
puerto_fin="$3"

echo "Escaneando $host del puerto $puerto_inicio al $puerto_fin..."

for puerto in $(seq "$puerto_inicio" "$puerto_fin"); do
    # Intentamos abrir una conexión TCP con timeout de 1 segundo.
    if timeout 1 bash -c "echo > /dev/tcp/$host/$puerto" 2>/dev/null; then
        echo "Puerto $puerto: ABIERTO"
    fi
done

echo "Escaneo completado."

Desglosemos las dos piezas nuevas:

• El bucle for puerto in $(seq inicio fin); do ... done itera la variable puerto sobre cada número generado por seq, ejecutando el bloque una vez por cada valor. Es el patrón estándar para repetir una acción sobre un rango o una lista.
• El condicional if ... ; then ... fi evalúa el código de salida del comando que le sigue: si bash -c "echo > /dev/tcp/$host/$puerto" consigue abrir la conexión, el código de salida es 0 (éxito) y el if se cumple. Si el puerto está cerrado o filtrado, el intento falla y el if no entra en el bloque.

Ejecutado así:

chmod +x escaner.sh
./escaner.sh 192.168.1.1 20 25
# Escaneando 192.168.1.1 del puerto 20 al 25...
# Puerto 22: ABIERTO
# Escaneo completado.

Variante combinando bash con nmap

El truco de /dev/tcp es elegante porque no depende de nada externo, pero en la práctica casi ningún script de reconocimiento real reinventa el escaneo TCP: se apoya en nmap y bash se limita a orquestar la entrada, la salida y el filtrado. Es el patrón que usa el propio libro para construir un escáner de MySQL (puerto 3306, la base de datos que casi todo atacante quiere encontrar):

#!/bin/bash

if [[ $# -lt 3 ]]; then
    echo "Uso: $0 <ip_inicial> <ultimo_octeto_final> <puerto>"
    exit 1
fi

primera_ip="$1"
ultimo_octeto="$2"
puerto="$3"

# -oG genera una salida "grep-able", pensada para procesarse línea a línea
nmap -sT "$primera_ip-$ultimo_octeto" -p "$puerto" >/dev/null -oG escaneo.tmp

# Nos quedamos solo con las líneas que contienen la palabra "open"
grep open escaneo.tmp > escaneo_abiertos.tmp
cat escaneo_abiertos.tmp
rm -f escaneo.tmp escaneo_abiertos.tmp

Más control de flujo

El bucle for y el condicional if del escáner cubren el caso más habitual, pero bash ofrece más estructuras que conviene conocer para no forzar todo a base de for.

while y until

while repite un bloque mientras una condición sea cierta; until hace justo lo contrario, repite mientras sea falsa:

#!/bin/bash

# Reintenta una conexión hasta 5 veces, esperando 2 segundos entre intento e intento
intentos=0
until timeout 1 bash -c "echo > /dev/tcp/$1/$2" 2>/dev/null || [[ $intentos -ge 5 ]]; do
    echo "Intento $((intentos+1)) fallido, reintentando..."
    intentos=$((intentos+1))
    sleep 2
done

case, la alternativa legible a una cadena de if/elif

Cuando hay que comparar una misma variable contra varios valores posibles, case es más claro que encadenar if/elif/else:

#!/bin/bash

read -p "¿Qué acción quieres? (start/stop/status): " accion

case "$accion" in
    start)
        echo "Arrancando servicio..."
        ;;
    stop)
        echo "Deteniendo servicio..."
        ;;
    status)
        echo "Consultando estado..."
        ;;
    *)
        echo "Opción no reconocida: $accion"
        exit 1
        ;;
esac

break, continue y trap

break corta un bucle inmediatamente; continue salta a la siguiente iteración sin ejecutar el resto del cuerpo del bucle en la iteración actual. Son útiles para descartar casos concretos dentro de un for, por ejemplo saltarse un puerto ya conocido:

for puerto in $(seq 1 100); do
    [[ "$puerto" == "22" ]] && continue   # nos saltamos el 22, ya sabemos que está abierto
    # resto del escaneo...
done

trap, por su parte, intercepta una señal del sistema (por ejemplo, Ctrl+C, que envía SIGINT) para ejecutar una acción de limpieza antes de salir, en lugar de dejar el script a medias:

#!/bin/bash

trap 'echo "Escaneo interrumpido por el usuario. Saliendo limpio."; exit 1' SIGINT

for puerto in $(seq 1 65535); do
    # escaneo largo que el usuario podría querer cancelar...
    :
done

Comandos built-in habituales de bash

Además de los programas externos (ls, grep, etc.), bash trae sus propios comandos internos, que no dependen de ningún binario en disco:

Próximos pasos

• Compresión y archivado: empaqueta y comprime los archivos que generan tus scripts con tar, gzip, bzip2 y dd.