grep, pipes y redirecciones: filtrando información en archivos

El Problema del Exceso de Información y los Flujos Estándar

Cuando ejecutas un comando en Linux, a menudo genera una gran cantidad de texto. Por ejemplo, al listar el contenido de un directorio grande o ver un archivo de log, la pantalla se llena de información. ¿Cómo encuentras la aguja en el pajar? Para resolver esto, primero debemos entender que cada comando opera con tres flujos de datos estándar.

• Entrada estándar (stdin): Por donde el comando recibe datos. Por defecto, es tu teclado.
• Salida estándar (stdout): Por donde el comando envía su resultado exitoso. Por defecto, es la pantalla de tu terminal.
• Error estándar (stderr): Por donde el comando envía los mensajes de error. Por defecto, también es la pantalla de tu terminal.

El siguiente diagrama ilustra este flujo. La entrada (teclado) va al comando 1, su salida se convierte en la entrada del comando 2, y finalmente la salida del comando 2 va al monitor (stdout), mientras que cualquier error también se muestra en el monitor (stderr).

Para obtener una explicación clara y visual de estos tres flujos, te recomiendo ver el siguiente video.

Redirecciones: Controlando la Salida (>, >>, 2>)

Saber que existen estos flujos no es útil a menos que podamos controlarlos. Aquí es donde entran las redirecciones. Nos permiten desviar la salida de un comando desde la pantalla hacia un archivo.

• > (Redirección de salida): Envía el stdout a un archivo. ¡Cuidado! Si el archivo ya existe, lo sobrescribirá.
  • Ejemplo: ls -l > lista_archivos.txt (guarda el listado de archivos en lista_archivos.txt).
• >> (Anexar a la salida): Envía el stdout a un archivo, pero en lugar de sobrescribirlo, añade el nuevo contenido al final.
  • Ejemplo: echo "Registro de actividad" >> log.txt (añade una nueva línea al archivo log.txt cada vez que se ejecuta).
• 2> (Redirección de error): Envía el stderr a un archivo. Esto es muy útil para separar los errores de la salida normal.
  • Ejemplo: find /etc -name "*.conf" 2> errores.log (busca archivos, pero guarda los errores de "permiso denegado" en errores.log).

Un truco muy común en pentesting es descartar los errores por completo para no saturar la pantalla. Esto se logra redirigiendo stderr a un lugar especial llamado /dev/null, que es como un agujero negro.

• Ejemplo: find / -name "id_rsa" 2>/dev/null (busca claves privadas en todo el sistema y descarta todos los errores de permisos).

El siguiente recurso en PDF explica estos conceptos de forma textual y concisa.

Para ver una demostración práctica de estas redirecciones, vuelve al video de Shawn Powers.

grep: Tu Herramienta de Búsqueda Esencial

Ahora que podemos guardar la salida, necesitamos una forma de filtrarla. grep es una de las herramientas más potentes y utilizadas en Linux para este propósito. Busca líneas que coincidan con un patrón específico en un texto. Como pentester, usarás grep constantemente para encontrar contraseñas, nombres de usuario, direcciones IP, o cualquier cadena de texto relevante en logs o archivos de configuración.

El uso básico es grep "patron" nombre_del_archivo.

El siguiente video, del canal HackerSploit, está orientado específicamente a hackers y te mostrará cómo usar grep de manera efectiva.

Pipes (|): Encadenando Comandos para Crear Superpoderes

Aquí es donde todo se une. El pipe o tubería (|) te permite tomar la salida estándar (stdout) de un comando y usarla directamente como la entrada estándar (stdin) del siguiente. Esto te permite crear cadenas de comandos increíblemente poderosas y complejas para procesar datos sobre la marcha, sin necesidad de guardarlos en archivos intermedios.

La verdadera magia ocurre cuando combinas herramientas. Por ejemplo, puedes usar cat para leer un archivo, grep para encontrar líneas de interés y otro grep para filtrar aún más.

cat /var/log/auth.log | grep "Failed password" | grep "from 192.168.1.10"

Esta cadena de comandos:

1. Lee el log de autenticación.
2. Filtra solo las líneas sobre contraseñas fallidas.
3. De esas líneas, filtra solo las que provienen de la IP 192.168.1.10.

El siguiente recurso de Unihackers destaca por qué esta habilidad es tan crítica en ciberseguridad y muestra un ejemplo muy potente.

Para ver una demostración de cómo funcionan los pipes, puedes volver al video de HackerSploit, que también cubre este tema.

✏️ Ejercicio Práctico

Es hora de poner a prueba tus nuevas habilidades. Abre tu terminal y simula un escenario de reconocimiento básico.

1. Simular un archivo de configuración:
   Imagina que has encontrado un archivo de configuración de una aplicación. Vamos a crearlo.

   echo "user=admin" > config.txt
   echo "password=Password123!" >> config.txt
   echo "DB_HOST=10.0.2.5" >> config.txt
   echo "# Esta línea es un comentario" >> config.txt
   

2. Buscar información sensible:
   Usa grep para encontrar la contraseña en el archivo. Prueba primero con una búsqueda sensible a mayúsculas y luego insensible.

   grep "password" config.txt
   grep -i "password" config.txt 
   

   Verás que la segunda opción encuentra la línea porque -i ignora que "Password" empieza con mayúscula.

3. Filtrar el historial de comandos:
   El historial de comandos puede contener información valiosa. Vamos a buscar comandos ssh que podrías haber ejecutado.

   history | grep "ssh"
   

   Esto te mostrará todas las veces que has usado el comando ssh en tu sesión.

4. Guardar los resultados:
   Ahora, guarda el resultado de tu búsqueda de ssh en un archivo llamado hallazgos.txt.

   history | grep "ssh" > hallazgos.txt
   

   Verifica el contenido con cat hallazgos.txt.

5. Filtrar ruido y anexar:
   Los procesos en ejecución también son una fuente de información. El comando ps aux lista todos los procesos. Es una salida enorme. Úsalo para encontrar procesos relacionados con tu terminal (p. ej., bash) pero excluyendo el propio comando grep. Luego, añade el resultado a tu archivo de hallazgos.

   ps aux | grep "bash" | grep -v "grep" >> hallazgos.txt
   

   • ps aux: Lista todos los procesos.
   • | grep "bash": Filtra las líneas que contienen "bash".
   • | grep -v "grep": Excluye la línea del propio proceso grep (un truco muy común).
   • >> hallazgos.txt: Añade esta nueva información a tu archivo sin borrar lo anterior.

Revisa tu archivo hallazgos.txt para ver los resultados combinados. ¡Has realizado un pequeño ciclo de recolección de información!

Conclusión

¡Felicidades! Has adquirido un conjunto de habilidades que forman la columna vertebral del trabajo en la línea de comandos de Linux. Ser capaz de buscar, filtrar y redirigir información de manera eficiente te ahorrará incontables horas y te permitirá descubrir detalles ocultos que otros pasarían por alto.

Puntos clave:

• Linux utiliza tres flujos: stdin, stdout y stderr.
• Las redirecciones (>, >>, 2>) te dan control sobre dónde va la salida y los errores.
• grep es tu herramienta principal para buscar texto y patrones en archivos o salidas de comandos.
• Los pipes (|) son el pegamento que te permite construir cadenas de comandos complejas, procesando datos en múltiples pasos.

En la próxima lección, "Utilizar comandos de red (ip, netstat, ss) para inspeccionar configuración y conexiones", empezarás a aplicar estas habilidades de línea de comandos al dominio de las redes. Verás cómo puedes usar pipes y grep para filtrar la salida de comandos de red y obtener rápidamente la información que necesitas durante una fase de reconocimiento.