Comandos de Linux que todo hacker ético necesita (con ejemplos reales)

Las herramientas de hacking cambian cada año; la terminal de Linux, no. Casi todo lo que harás en un laboratorio (encontrar una contraseña olvidada en un fichero de configuración, entender por qué un binario te da root, comprobar si un puerto está abierto o decodificar una cadena rara) se resuelve con un puñado de comandos de Linux bien combinados. Esta guía los organiza por tarea, con ejemplos realistas y, sobre todo, con qué tienes que buscar en la salida, que es lo que de verdad marca la diferencia.

Si todavía no tienes un entorno montado, empieza por Kali Linux para principiantes, donde ya repasamos lo más básico (ls, cd, cat…). Aquí vamos un paso más allá. Todos los ejemplos están pensados para ejecutarse en tu propia máquina virtual o en plataformas de práctica autorizadas.

1. Moverse por el sistema y encontrar cosas

find: la navaja suiza de la búsqueda

find recorre el árbol de directorios y filtra por casi cualquier atributo. La estructura es siempre find <dónde> <condiciones> <acción>. Añade 2>/dev/null para ocultar los miles de «Permiso denegado» cuando buscas desde /.

# Ficheros con el bit SUID activado (clásico en escalada de privilegios)
find / -perm -4000 -type f 2>/dev/null

# Ficheros que pertenecen a un usuario concreto
find / -user www-data -type f 2>/dev/null

# Ficheros de más de 50 MB en /home
find /home -type f -size +50M

# Ficheros modificados después que otro fichero de referencia
find /var/www -type f -newer /var/www/html/index.php

# Modificados en los últimos 30 minutos
find /etc -type f -mmin -30 2>/dev/null

# Directorios en los que tu usuario puede escribir
find / -type d -writable 2>/dev/null

Qué buscar: en la lista de SUID, la mayoría serán binarios esperados (/usr/bin/passwd, /usr/bin/sudo, /usr/bin/mount). Lo interesante es lo que no encaja: un binario en /opt, un script propio o una herramienta como find, vim o python3 con SUID. Con -newer y -mmin detectas qué ha cambiado recientemente, algo útil tanto para atacar un laboratorio como para investigar un incidente en tu propio servidor.

Ojo con la sintaxis de -perm: -perm -4000 significa «tiene al menos ese bit», mientras que -perm 4000 (sin guion) exige permisos exactamente iguales, y casi nunca devuelve nada.

locate: búsqueda instantánea por nombre

sudo updatedb
locate id_rsa
locate -i backup | grep -E '\.(zip|tar|gz|sql)$'

locate no recorre el disco: consulta una base de datos que genera updatedb. Por eso es rapidísimo, pero no verá ficheros creados después de la última actualización. En Kali viene como plocate. Úsalo para preguntas rápidas («¿hay alguna clave SSH en el sistema?») y find cuando necesites filtros o datos frescos.

which, type y command -v: ¿qué se ejecuta realmente?

which python3
type ll
command -v nc

which te dice qué ruta del PATH se ejecutará; type además te avisa si es un alias, una función o un comando interno de la shell. Es importante cuando ves un comportamiento extraño: si ls resulta ser un alias o un script en un directorio que va antes en el PATH, no estás ejecutando lo que crees. Ese mismo detalle es la base de una técnica de escalada conocida como PATH hijacking.

2. Leer y filtrar texto

En Linux casi todo es texto: configuraciones, logs, listados de usuarios, salidas de herramientas. Saber filtrarlo es la habilidad que más tiempo te ahorra.

grep: buscar dentro de ficheros

# Recursivo (-r), sin distinguir mayúsculas (-i), con número de línea (-n)
grep -rni "password" /var/www/ 2>/dev/null

# Solo los nombres de fichero que contienen la cadena
grep -rli "DB_PASS" /var/www/

# Invertir la búsqueda: quitar comentarios y líneas vacías de un .conf
grep -vE '^\s*(#|$)' /etc/ssh/sshd_config

# Extraer solo las IPs de un log
grep -oE '([0-9]{1,3}\.){3}[0-9]{1,3}' access.log

Qué buscar: ficheros como wp-config.php, .env, config.php o settings.py con credenciales en claro. Y en un sshd_config limpio de comentarios, líneas como PermitRootLogin yes o PasswordAuthentication yes, que indican una configuración débil.

cut y awk: quedarte con las columnas que importan

# Usuario y shell de cada cuenta (campos 1 y 7, separados por ':')
cut -d: -f1,7 /etc/passwd

# Usuarios "humanos" (UID >= 1000) con su directorio personal
awk -F: '$3 >= 1000 {print $1, $6}' /etc/passwd

# Cuentas con una shell válida para iniciar sesión
grep -E 'sh$' /etc/passwd

cut es perfecto para separadores fijos; awk cuando necesitas condiciones o columnas separadas por espacios variables. Las cuentas con /usr/sbin/nologin o /bin/false son de servicio; las que terminan en bash o zsh son las que pueden iniciar sesión, y por tanto tus objetivos en un laboratorio.

sort | uniq -c: contar y encontrar patrones

# Las 10 IPs que más peticiones hacen a tu servidor web
awk '{print $1}' /var/log/apache2/access.log | sort | uniq -c | sort -nr | head

Esta cadena es un clásico: uniq solo agrupa líneas consecutivas, por eso hay que ordenar antes con sort. El segundo sort -nr ordena numéricamente de mayor a menor. Una sola IP con miles de peticiones suele ser un escáner o un ataque de fuerza bruta.

head, tail -f y wc

head -n 20 wordlist.txt         # primeras 20 líneas
tail -n 50 /var/log/auth.log    # últimas 50
tail -f /var/log/apache2/access.log   # seguir el fichero en tiempo real
wc -l /usr/share/wordlists/rockyou.txt   # número de líneas

tail -f es ideal para ver en directo qué ocurre en tu servidor de pruebas mientras lanzas una herramienta desde otra terminal. Si no encuentras /var/log/auth.log (en Kali y Debian recientes los logs del sistema suelen ir solo al journal de systemd), el equivalente es journalctl -f. Y wc -l te dice cuántas contraseñas tiene un diccionario antes de lanzar un ataque que podría tardar horas.

3. Permisos y usuarios

Leer permisos y cambiarlos con chmod y chown

ls -l script.sh
-rwxr-x--- 1 kali developers 812 nov  3 10:15 script.sh

Los nueve caracteres tras el tipo de fichero son tres bloques: propietario (rwx), grupo (r-x) y otros (---). En notación numérica, r=4, w=2, x=1, así que este fichero es 750.

chmod 600 ~/.ssh/id_rsa       # solo el propietario lee y escribe
chmod u+x exploit.sh          # añadir ejecución al propietario
chmod o-r informe.txt         # quitar lectura a "otros"
sudo chown kali:kali notas.txt   # cambiar propietario y grupo

SSH se niega a usar una clave privada con permisos demasiado abiertos, así que chmod 600 es algo que harás a menudo. Al revés, un fichero sensible legible por todos (-rw-r--r-- en un backup con contraseñas) es justo el tipo de fallo que buscas en una auditoría.

SUID explicado sin rodeos

Normalmente un programa se ejecuta con los permisos de quien lo lanza. Con el bit SUID activado, se ejecuta con los permisos del propietario del fichero. Lo verás como una s en lugar de la x del propietario:

ls -l /usr/bin/passwd
-rwsr-xr-x 1 root root 68248 mar 23  2025 /usr/bin/passwd

passwd necesita SUID para que un usuario normal pueda modificar su propia contraseña en /etc/shadow, que es de root. El problema aparece cuando un binario con SUID de root permite hacer más de lo previsto, por ejemplo lanzar una shell o leer ficheros arbitrarios. Para saber si un binario concreto es abusable, el proyecto GTFOBins documenta cientos de casos. Herramientas como PEASS-ng (LinPEAS) automatizan esta revisión, pero entender el concepto te permite interpretar sus resultados en lugar de copiarlos.

id y sudo -l: quién eres y qué puedes hacer

id
uid=1000(kali) gid=1000(kali) groups=1000(kali),27(sudo),998(docker)

sudo -l
User kali may run the following commands on lab:
    (root) NOPASSWD: /usr/bin/vim

Qué buscar: en id, grupos privilegiados como sudo, wheel, docker, lxd, adm (puede leer logs) o disk. Pertenecer a docker equivale en la práctica a ser root. En sudo -l, cualquier línea NOPASSWD y cualquier programa que permita escapar a una shell (editores, intérpretes, paginadores como less) merece una mirada atenta.

/etc/passwd frente a /etc/shadow

	/etc/passwd	/etc/shadow
Quién puede leerlo	Todos los usuarios	Solo root (y el grupo shadow)
Contenido	Usuario, UID, GID, directorio personal, shell	Hash de la contraseña y caducidad
Ejemplo	kali:x:1000:1000:,,,:/home/kali:/usr/bin/zsh	kali:$y$j9T$...:20390:0:99999:7:::

La x del segundo campo de /etc/passwd indica que el hash está en /etc/shadow. El prefijo del hash dice el algoritmo: $6$ es SHA-512 y $y$ es yescrypt, el predeterminado en Debian y Kali actuales. Dos hallazgos graves en un laboratorio: que /etc/shadow sea legible por tu usuario, o que /etc/passwd sea escribible (podrías añadir un usuario con UID 0). Compruébalo con ls -l /etc/passwd /etc/shadow.

4. Procesos y servicios

ps aux: qué se está ejecutando

ps aux | grep -i mysql
ps aux --sort=-%mem | head    # los que más memoria consumen
ps -ef --forest               # árbol de procesos padre-hijo

Qué buscar: la primera columna indica el usuario. Un proceso de root que ejecuta un script en un directorio donde tú puedes escribir es una vía de escalada. También verás a veces credenciales pasadas como argumentos (mysql -u root -pSecreto), visibles para cualquier usuario que liste procesos.

ss -tulpn: qué está escuchando

sudo ss -tulpn
Netid State  Local Address:Port  Process
tcp   LISTEN 0.0.0.0:22          users:(("sshd",pid=812,fd=3))
tcp   LISTEN 127.0.0.1:3306      users:(("mariadbd",pid=950,fd=21))

Las opciones significan: tCP, uDP, solo puertos a la escucha (listening), proceso asociado y números en vez de nombres. La columna clave es la dirección local: 0.0.0.0 o [::] significa accesible desde la red; 127.0.0.1 significa solo local. Un servicio interno que un escaneo externo no veía (como esa base de datos) aparece aquí, y es habitual en máquinas de laboratorio. Sin sudo no verás el proceso de los servicios de otros usuarios.

systemctl y kill

sudo systemctl status ssh
sudo systemctl start apache2
sudo systemctl enable ssh          # arrancar al iniciar el sistema
systemctl list-units --type=service --state=running

kill 4321          # pide terminar (SIGTERM, señal 15)
kill -9 4321       # fuerza el cierre (SIGKILL), último recurso
pkill -f "python3 -m http.server"

En Kali los servicios de red vienen desactivados por defecto, así que systemctl start es lo que usarás para levantar un servidor web o SSH de pruebas. Usa siempre kill sin opciones primero: deja al proceso cerrar ficheros y limpiar; -9 no le da esa oportunidad.

5. Red

ip y ping: tu punto de partida

ip a           # interfaces y direcciones
ip r           # tabla de rutas y puerta de enlace
ping -c 3 10.10.10.5

Cuando te conectas por VPN a una plataforma de práctica, aparece una interfaz tun0: esa IP es la que debes usar cuando una máquina tenga que conectarse de vuelta a ti. Que ping no responda no significa que el equipo esté apagado; muchos sistemas (Windows por defecto) bloquean ICMP.

curl y wget: hablar HTTP desde la terminal

curl -I http://10.10.10.5            # solo cabeceras
curl -s http://10.10.10.5/robots.txt
curl -v -X POST -d "user=admin&pass=test" http://10.10.10.5/login
wget -q http://10.10.14.2:8000/linpeas.sh -O /tmp/linpeas.sh

Qué buscar: en las cabeceras, Server y X-Powered-By revelan software y versiones; Set-Cookie sin HttpOnly o Secure es un fallo de configuración. Con -v ves la conversación completa, redirecciones incluidas. Para pasar ficheros entre tus máquinas de laboratorio, un python3 -m http.server 8000 en el origen y un wget o curl -O en el destino es lo más rápido.

dig: preguntar al DNS

dig example.com +short
dig example.com MX +short
dig -x 8.8.8.8 +short                  # resolución inversa
dig axfr @nsztm1.digi.ninja zonetransfer.me

El último ejemplo intenta una transferencia de zona contra zonetransfer.me, un dominio creado precisamente para practicarla legalmente. Si un servidor DNS mal configurado la permite, te entrega todos los subdominios de golpe.

nc: comprobar puertos a mano

nc -zv 10.10.10.5 22 80 443     # ¿están abiertos?
nc -zv -w 2 10.10.10.5 20-25    # rango, con 2 s de espera
nc -nv 10.10.10.5 21            # conectar y leer el banner

-z comprueba sin enviar datos, -v muestra el resultado y -n evita resolver DNS. Para un escaneo serio usarás Nmap, pero nc es perfecto para confirmar un puerto concreto o leer el banner de un servicio (FTP, SMTP y SSH suelen anunciar su versión al conectar).

6. Archivos comprimidos y codificaciones

tar -czvf web-backup.tar.gz /var/www/html   # crear .tar.gz
tar -tzf web-backup.tar.gz                  # listar sin extraer
tar -xzvf web-backup.tar.gz -C /tmp/revisar # extraer en otra carpeta

Recuerda las letras: crear, extraer, listar, z para gzip, v detallado, f fichero (siempre la última antes del nombre). Lista antes de extraer un archivo que no conoces.

echo -n 'admin:admin123' | base64      # YWRtaW46YWRtaW4xMjM=
echo 'YWRtaW46YWRtaW4xMjM=' | base64 -d
xxd misterio.bin | head
file misterio.bin
sha256sum kali-linux.iso
sha256sum -c SHA256SUMS

Usa echo -n al codificar: sin él se cuela un salto de línea y el resultado cambia. Una cadena con letras, números, +, / y uno o dos = al final suele ser Base64 (por ejemplo, en una cabecera Authorization: Basic). Recuerda que Base64 es una codificación, no un cifrado: cualquiera lo revierte. xxd muestra el volcado hexadecimal, donde los primeros bytes («números mágicos») delatan el tipo real del fichero: 89 50 4e 47 es PNG, 50 4b 03 04 es ZIP, aunque la extensión diga otra cosa; file hace esa comprobación por ti. Y los hashes sirven para verificar que una descarga no ha sido alterada.

7. Productividad en la shell

Tuberías y redirecciones

comando > salida.txt        # sobrescribe
comando >> salida.txt       # añade al final
comando 2> errores.txt      # solo errores (stderr)
comando > todo.txt 2>&1     # salida y errores al mismo fichero
comando 2>&1 | tee log.txt  # verlo en pantalla y guardarlo a la vez

El orden importa: en > todo.txt 2>&1 primero rediriges la salida al fichero y después «los errores van donde vaya la salida». Al revés no funciona igual. tee es tu mejor amigo para documentar: todo lo que guardes ahora te servirá para el informe o el writeup.

Historial

history | grep nmap   # ¿cómo lancé aquel escaneo?
!!                    # repetir el último comando
sudo !!               # repetirlo con sudo
Ctrl+R                # búsqueda inversa interactiva

En un laboratorio, el historial de otros usuarios (~/.bash_history, ~/.zsh_history) a veces contiene contraseñas tecleadas por error. Revisa también el tuyo antes de compartir capturas.

tmux: varias terminales en una

tmux new -s lab        # nueva sesión llamada "lab"
Ctrl+b %               # paneles lado a lado
Ctrl+b "               # paneles arriba y abajo
Ctrl+b flechas         # moverse entre paneles
Ctrl+b c / Ctrl+b n    # nueva ventana / siguiente
Ctrl+b d               # desconectarse (la sesión sigue viva)
tmux attach -t lab     # volver a ella

Lo típico: un panel con la VPN, otro con un escaneo largo y otro para trabajar. Y si se cae tu conexión SSH a una máquina remota, la sesión de tmux sigue ejecutándose.

Alias

alias ll='ls -lah'
alias myip="ip -4 addr show tun0 | grep -oP '(?<=inet )[0-9.]+'"
echo "alias ll='ls -lah'" >> ~/.zshrc   # hacerlo permanente

Kali usa Zsh, así que los alias permanentes van en ~/.zshrc (en Bash, ~/.bashrc). Recarga con source ~/.zshrc.

Chuleta: comandos de Linux para hacking ético

Tarea	Comando	Qué buscar
Binarios SUID	find / -perm -4000 -type f 2>/dev/null	Binarios fuera de lo normal
Cambios recientes	find /etc -mmin -30	Configuraciones tocadas hace poco
Buscar credenciales	grep -rni "password" /var/www	Contraseñas en claro
Usuarios con shell	grep -E 'sh$' /etc/passwd	Cuentas que pueden iniciar sesión
Contar ocurrencias	sort | uniq -c | sort -nr	Valores que se repiten mucho
Identidad	id	Grupos sudo, docker, lxd, adm
Privilegios sudo	sudo -l	NOPASSWD y programas con escape a shell
Procesos	ps aux	Procesos de root y argumentos con credenciales
Puertos locales	sudo ss -tulpn	Servicios solo en 127.0.0.1
Cabeceras web	curl -I URL	Server, X-Powered-By, cookies
DNS	dig dominio +short	IPs, MX, transferencias de zona
Puerto concreto	nc -zv IP PUERTO	«succeeded» / «open» y banners
Decodificar	base64 -d	Texto legible oculto
Tipo real de fichero	file / xxd | head	Números mágicos
Guardar evidencias	cmd 2>&1 | tee log.txt	Todo, para el informe

Cómo practicar estos comandos

Leer una lista de comandos no basta; hay que usarlos con un objetivo. La mejor forma de empezar es OverTheWire: su wargame Bandit obliga a usar find, grep, sort | uniq, base64, xxd, tar y nc exactamente como en esta guía. Si te atascas, tienes nuestras soluciones de Bandit explicadas nivel a nivel (intenta cada nivel antes de mirarlas). Después, monta una máquina vulnerable en tu red local y repite la sección de permisos y procesos desde dentro: es exactamente la revisión que hace LinPEAS, pero entendiendo cada paso.

Practica siempre en tu propia máquina, en laboratorios locales o en plataformas que lo autoricen expresamente. Ejecutar estas búsquedas en sistemas ajenos sin permiso puede ser delito.

Si prefieres una ruta guiada en español, con ejercicios prácticos que construyen sobre estos comandos, echa un vistazo a la Academia de Hackers en Acción.