Búsqueda de texto con grep en Linux

Introducción

En esta práctica de laboratorio, aprenderás a buscar texto de manera efectiva dentro de los archivos de un sistema Linux utilizando el potente comando grep. Comenzarás realizando búsquedas básicas de cadenas específicas tanto en archivos individuales como en múltiples archivos, comprendiendo cómo grep muestra las líneas coincidentes e identifica el archivo de origen cuando se busca en varias ubicaciones.

Partiendo de esta base, explorarás funciones más avanzadas para refinar tus búsquedas. Aprenderás a mostrar los números de línea para tener contexto, a utilizar anclajes como ^ y $ para coincidir con patrones al principio o al final de una línea, y a aprovechar las capacidades de las expresiones regulares tanto básicas como extendidas para realizar coincidencias de patrones complejas y flexibles.

Realizar una búsqueda básica en archivos con grep

En este paso, aprenderás el uso fundamental del comando grep para realizar búsquedas básicas dentro de archivos. El comando grep (Global Regular Expression Print) es una potente utilidad de línea de comandos que se utiliza para buscar una cadena o patrón específico en uno o más archivos y mostrar las líneas que lo contienen.

La sintaxis básica de grep es: grep PATTERN [FILE...]

Comencemos con una tarea sencilla: buscar información sobre nuestro usuario actual, labex, en el archivo de la base de datos de usuarios del sistema. Esta información se almacena en el archivo /etc/passwd.

Ejecuta el siguiente comando en tu terminal para encontrar cualquier línea que contenga la cadena labex en el archivo /etc/passwd:

grep labex /etc/passwd

Deberías ver una línea de salida del archivo que contiene tu nombre de usuario, labex.

labex:x:5000:5000::/home/labex:/usr/bin/zsh

El comando grep también puede buscar en varios archivos simultáneamente. Ahora buscaremos la cadena labex en tres archivos de configuración importantes del sistema: /etc/passwd, /etc/shadow (que almacena información segura de las cuentas de usuario) y /etc/group (que define los grupos de usuarios).

Dado que el archivo /etc/shadow contiene información sensible, necesitas privilegios de administrador para leerlo. Puedes usar el comando sudo para ejecutar grep con estos privilegios. El usuario labex está configurado con acceso sudo sin contraseña.

Ejecuta el siguiente comando para buscar labex en los tres archivos:

sudo grep labex /etc/passwd /etc/shadow /etc/group

Observa que al buscar en varios archivos, grep antepone a cada línea coincidente el nombre del archivo donde se encontró la coincidencia.

/etc/passwd:labex:x:5000:5000::/home/labex:/usr/bin/zsh
/etc/shadow:labex:$y$j9T$L6UYJUCu2XytrdFToEOw.1$yp2xAOVTbIPmbABMnS/xDsyce7xayU80JgIs3lrqw4B:20265:0:99999:7:::
/etc/group:sudo:x:27:labex
/etc/group:ssl-cert:x:121:labex
/etc/group:labex:x:5000:
/etc/group:public:x:5002:labex

Esto te muestra todas las líneas de estos tres archivos que están relacionadas con el usuario labex.

Mostrar números de línea con la opción -n

En este paso, aprenderás a mejorar la salida de grep mostrando los números de línea donde se encuentran las coincidencias. Esto es particularmente útil cuando necesitas localizar un patrón dentro de un archivo grande para editarlo o analizarlo más a fondo. La opción -n le indica a grep que anteponga a cada línea de salida su número de línea correspondiente del archivo de entrada.

Basémonos en el comando del paso anterior. Buscaste el usuario labex en tres archivos del sistema. Ahora, realizarás la misma búsqueda pero también mostrarás los números de línea para cada coincidencia.

Añade la opción -n al comando que ejecutaste en el paso anterior. Recuerda usar sudo, ya que sigues accediendo al archivo restringido /etc/shadow.

Ejecuta el siguiente comando en tu terminal:

sudo grep -n labex /etc/passwd /etc/shadow /etc/group

Verás una salida similar a la anterior, pero ahora cada línea va precedida por el nombre del archivo y el número de línea donde se produjo la coincidencia, separados por dos puntos.

/etc/passwd:32:labex:x:5000:5000::/home/labex:/usr/bin/zsh
/etc/shadow:32:labex:$y$j9T$L6UYJUCu2XytrdFToEOw.1$yp2xAOVTbIPmbABMnS/xDsyce7xayU80JgIs3lrqw4B:20265:0:99999:7:::
/etc/group:21:sudo:x:27:labex
/etc/group:60:ssl-cert:x:121:labex
/etc/group:61:labex:x:5000:
/etc/group:62:public:x:5002:labex

Observa los números como 32, 32, 21, 60, 61 y 62 en la salida. Estos son los números de línea. Por ejemplo, la cadena labex se encontró en la línea 32 de /etc/passwd y en la línea 32 de /etc/shadow. Esta sencilla opción convierte a grep en una herramienta aún más eficaz para navegar y comprender el contenido de los archivos.

Coincidir con la posición de la línea con los anclajes ^ y $

En este paso, avanzarás en tus habilidades con grep aprendiendo a usar anclajes. Los anclajes son caracteres especiales en las expresiones regulares que no coinciden con caracteres, sino con posiciones dentro de una línea. Esto te permite crear patrones de búsqueda más específicos y potentes. Los dos anclajes más comunes son:

• ^ (circunflejo): Coincide con el principio de una línea.
• $ (signo de dólar): Coincide con el final de una línea.

Veamos cómo funcionan utilizando el archivo /etc/passwd.

Primero, considera una búsqueda simple de la cadena root en /etc/passwd:

grep root /etc/passwd

Es posible que obtengas varias líneas en la salida, ya que otras entradas podrían contener la cadena "root".

root:x:0:0:root:/root:/bin/bash
operator:x:11:0:operator:/root:/sbin/nologin

Ahora, refinemos esto. En el archivo /etc/passwd, el primer campo de cada registro es el nombre de usuario. Para encontrar el registro de usuario específicamente para el usuario root, puedes anclar tu búsqueda al principio de la línea usando ^.

Ejecuta el siguiente comando. El patrón ^root le indica a grep que solo coincida con las líneas que comienzan con root.

grep ^root /etc/passwd

Esta vez, la salida es mucho más específica, mostrando solo la línea para el usuario root.

root:x:0:0:root:/root:/bin/bash

A continuación, utilicemos el anclaje de fin de línea, $. El último campo de un registro de /etc/passwd especifica la shell de inicio de sesión predeterminada del usuario. Podemos usar esto para encontrar todos los usuarios que tienen /bin/bash como su shell predeterminada.

El patrón bash$ coincidirá con cualquier línea que termine con la cadena bash.

grep bash$ /etc/passwd

Este comando mostrará todas las entradas de usuario donde /bin/bash es la shell asignada.

root:x:0:0:root:/root:/bin/bash

(Nota: Tu salida puede variar si otros usuarios en el sistema también usan bash como su shell predeterminada).

Al usar los anclajes ^ y $, puedes reducir significativamente los resultados de tu búsqueda para encontrar exactamente lo que estás buscando.

Coincidencia de patrones con expresiones regulares básicas

En este paso, explorarás cómo usar Expresiones Regulares Básicas (BRE) con grep para crear patrones de búsqueda más flexibles. En BRE, ciertos caracteres, llamados metacaracteres, tienen significados especiales que van más allá de su valor literal. Esto te permite coincidir con patrones, no solo con cadenas fijas.

Exploraremos dos metacaracteres fundamentales: * (asterisco) y . (punto).

Primero, examinemos el asterisco (*). Este metacarácter coincide con el carácter que le precede inmediatamente cero o más veces. Para ver esto en acción, ejecuta el siguiente comando. Encerraremos el patrón entre comillas simples ('roo*') para asegurar que la shell lo trate como un patrón literal y no intente expandir el * como un comodín de archivo.

grep 'roo*' /etc/passwd

La salida probablemente mostrará varias líneas:

root:x:0:0:root:/root:/bin/bash
proxy:x:13:13:proxy:/bin:/usr/sbin/nologin
systemd-timesync:x:104:110:systemd Time Synchronization,,,:/run/systemd:/usr/sbin/nologin
rtkit:x:108:113:RealtimeKit,,,:/proc:/usr/sbin/nologin
operator:x:11:0:operator:/root:/sbin/nologin

Analicemos este resultado. El patrón 'roo*' busca líneas que contengan ro seguido de cero o más letras o.

• La línea root coincide porque contiene roo (ro seguido de una o).
• La línea proxy coincide porque contiene ro (ro seguido de cero o) en "proxy".
• La línea systemd-timesync coincide porque contiene ro en "Synchronization".
• La línea rtkit coincide porque contiene ro en "proc".
• La línea operator coincide porque contiene ro tanto en "operator" como en "/root".

Ahora, veamos el metacarácter punto (.). El punto coincide con cualquier carácter individual. Ejecuta el siguiente comando para ver cómo difiere su comportamiento:

grep 'ro.' /etc/passwd

Esta vez, la salida muestra varias coincidencias:

root:x:0:0:root:/root:/bin/bash
proxy:x:13:13:proxy:/bin:/usr/sbin/nologin
systemd-timesync:x:104:110:systemd Time Synchronization,,,:/run/systemd:/usr/sbin/nologin
rtkit:x:108:113:RealtimeKit,,,:/proc:/usr/sbin/nologin
operator:x:11:0:operator:/root:/sbin/nologin

El patrón 'ro.' busca líneas que contengan ro seguido de exactamente un carácter de cualquier tipo.

• La línea root coincide porque ro va seguido de o en "root".
• La línea proxy coincide porque ro va seguido de x en "proxy".
• La línea systemd-timesync coincide porque ro va seguido de n en "Synchronization".
• La línea rtkit coincide porque ro va seguido de c en "proc".
• La línea operator coincide porque ro va seguido de otro carácter en "operator" y "/root".

Al comparar las salidas, puedes ver claramente el poder de las expresiones regulares. Tanto el patrón 'roo*' como 'ro.' coinciden con múltiples líneas, demostrando cómo diferentes metacaracteres te permiten ajustar tus búsquedas de diferentes maneras.

Usar expresiones regulares extendidas para búsquedas complejas

En este paso, aprenderás a usar Expresiones Regulares Extendidas (ERE) para realizar búsquedas aún más complejas y potentes. ERE ofrece un conjunto de metacaracteres más rico que las Expresiones Regulares Básicas (BRE). Para habilitar ERE, puedes usar el comando grep -E o su alias tradicional, egrep. El uso de grep -E es el enfoque más moderno y recomendado.

Primero, exploremos los cuantificadores. En ERE, puedes especificar el número exacto de veces que debe aparecer un carácter utilizando llaves {}. Por ejemplo, para encontrar cualquier línea que tenga exactamente dos letras 'o' minúsculas juntas, puedes usar el patrón o{2}.

Ejecuta el siguiente comando. Encerramos el patrón entre comillas simples para evitar que la shell malinterprete los caracteres especiales.

grep -E 'o{2}' /etc/passwd

La salida mostrará varias líneas que contienen "oo":

root:x:0:0:root:/root:/bin/bash
lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
news:x:9:9:news:/var/spool/news:/usr/sbin/nologin
uucp:x:10:10:uucp:/var/spool/uucp:/usr/sbin/nologin
operator:x:11:0:operator:/root:/sbin/nologin

Este comando funciona porque el patrón o{2} coincide específicamente con dos caracteres 'o' consecutivos, que se encuentran en "root", "spool" y otras entradas.

A continuación, veamos la alternancia. Esta potente función de ERE te permite buscar uno de varios patrones posibles utilizando el símbolo de tubería |, que actúa como un operador 'O' (OR).

Por ejemplo, si quisieras encontrar un registro de usuario para root o Root (en caso de que no estuvieras seguro de las mayúsculas), podrías usar el siguiente comando:

grep -E 'root|Root' /etc/passwd

Este comando busca cualquier línea que contenga la cadena root o la cadena Root. La salida muestra:

root:x:0:0:root:/root:/bin/bash
operator:x:11:0:operator:/root:/sbin/nologin

Tanto la línea del usuario root como la línea operator coinciden porque ambas contienen la cadena "root" en minúsculas.

Las expresiones regulares extendidas, habilitadas con grep -E, proporcionan una sintaxis más expresiva y potente para elaborar patrones de búsqueda complejos, lo que convierte a grep en una herramienta indispensable para el procesamiento de texto.

Resumen

En esta práctica de laboratorio, aprendiste a utilizar el comando grep para realizar búsquedas de texto fundamentales en Linux. Comenzaste ejecutando búsquedas básicas de una cadena específica dentro de un solo archivo y luego extendiste esto para buscar en múltiples archivos, observando cómo grep antepone a las líneas coincidentes sus nombres de archivo correspondientes. También aprendiste a usar la opción -n para mostrar el número de línea de cada coincidencia, lo cual es útil para localizar patrones dentro de los archivos.

Además, exploraste capacidades de coincidencia de patrones más avanzadas mediante el uso de anclajes para encontrar texto al principio (^) o al final ($) de una línea. La práctica progresó hasta cubrir el uso de expresiones regulares tanto básicas como extendidas, lo que te permitió construir patrones de búsqueda más complejos y potentes para encontrar información específica dentro de los archivos.