Cómo Grep Correntemente para el texto en scripts bash

grep es una utilidad versátil de Linux, que puede tardar unos años en dominar bien. Incluso los ingenieros experimentados de Linux pueden cometer el error de suponer que un archivo de texto de entrada determinado tendrá un determinado formato. grep También se puede usar, directamente en combinación con si Búsquedas basadas para escanear la presencia de una cadena dentro de un archivo de texto dado. Descubra cómo Grep Correctamente para el texto independiente de los conjuntos de caracteres, cómo usar el -Q opción para enviar mensajes de texto para la presencia de cadena y más!

En este tutorial aprenderás:

• Cómo hacer las búsquedas de texto independientes de ajuste de caracteres correctas con GREP
• Cómo usar declaraciones GREP avanzadas de los scripts o los comandos de la línea oneladora terminal
• Cómo probar la presencia de cadena usando el -Q Opción para GREP
• Ejemplos que destacan el uso de GREP para estos casos de uso

Requisitos y convenciones de software utilizados

Ejemplo 1: Búsquedas de texto de ajuste de caracteres correctas con GREP

¿Qué sucede cuando greh a través de un archivo que está basado en texto/caracteres, pero contiene caracteres especiales fuera del rango normal?? Esto puede suceder potencialmente cuando el archivo contiene conjuntos de caracteres complejos o parece contener contenido como binario como. Para comprender esto mejor, primero debemos comprender qué son los datos binarios.

La mayoría (pero no todas) las computadoras usan en su nivel más básico solo dos estados: 0 y 1. Quizás sobre simplificado, ¿puede pensar en esto como un interruptor: 0 no es voltio, no hay energía y 1 es "algún nivel de voltaje" o encendido. Las computadoras modernas pueden procesar millones de estos 0 y 1 en una fracción de segundo. Este es el estado 0/1 se llama 'bit' y es un sistema numérico base-2 (al igual que nuestro sistema decimal 0-9 es un sistema numérico base-10). Hay otras formas de representar datos basados ​​en bit/binarios como Octal (8-base: 0-7) y hexadecimal (16-base: 0-F).

Volviendo a 'binario' (bin, dual), puede comenzar a ver cómo se usa comúnmente para describir cualquier tipo de datos que los humanos no puedan reconocer fácilmente, pero que pueden ser entendidos por las computadoras basadas. Quizás no sea la mejor analogía, ya que binario generalmente se refiere a dos estados (verdadero/falso), mientras que en común Jerga 'Binary Data' ha llegado a serios que no se interpretan fácilmente.

Por ejemplo, un archivo de código fuente compilado con un compilador contiene datos binarios sobre todo ilegible por humanos. Por ejemplo, un archivo de código fuente compilado con un compilador contiene datos binarios sobre todo ilegible por el ojo humano. Otro ejemplo podría ser un archivo cifrado o un archivo de configuración escrito en un formato de propiedad.

¿Cómo se ve cuando intenta ver datos binarios??

Por lo general, al ver los datos binarios para ejecutables, verá algunos datos binarios reales (todos los caracteres de aspecto impar: su computadora muestra datos binarios en las capacidades de formato de salida limitadas que admite su terminal), así como algunos resultados basados ​​en texto. En el caso de LS Como se ve aquí, parecen ser nombres de funciones dentro del LS código.

Para ver los datos binarios correctamente, realmente necesita un visor de archivos binarios. Dichos espectadores simplemente formatan datos en su formato nativo, junto con una columna lateral basada en texto. Esto evita las limitaciones de la salida textual y le permite ver el código de la computadora para lo que realmente es: 0 y 1, aunque a menudo formateado en formato hexadecimal (0-F o 0-F como se muestra a continuación).

Echemos un vistazo a dos conjuntos de 4 líneas del código binario de LS Para ver cómo se ve esto:

$ hexdump -c /bin /ls | cabeza -n4; eco '… '; hexdump -c /bin /ls | cola -n131 | Cabeza -n4 00000000 7F 45 4C 46 02 01 01 00 00 00 00 00 00 00 00 00 |.Elfo ... | 00000010 03 00 3E 00 01 00 00 00 D0 67 00 00 00 00 00 00 | ...> ... g ... | 00000020 40 00 00 00 00 00 00 00 C0 23 02 00 00 00 00 00 |@... #… | 00000030 00 00 00 00 40 00 38 00 0D 00 40 00 1E 00 1D 00 | ... @.8… @… |… 00022300 75 2e 76 65 72 73 69 6f 6e 00 2e 67 6e 75 2e 76 |.Versión ... GNU.V | 00022310 65 72 73 69 6F 6E 5F 72 00 2E 72 65 6C 61 2E 64 | ersion_r… RelA.D | 00022320 79 6e 00 2e 72 65 6c 61 2e 70 6c 74 00 2e 69 6e | yn… rela.plt ... en | 00022330 69 74 00 2e 70 6c 74 2e 67 6f 74 00 2e 70 6c 74 | it… plt.tengo ... plt | 

¿Cómo todo esto (además de aprender más sobre cómo funcionan las computadoras)? grep uso? Volvamos a nuestra pregunta original: ¿Qué sucede cuando se greh a través de un archivo que está basado en texto/caracteres, pero contiene caracteres especiales fuera del rango normal??

Ahora podemos volver a redactar esto con razón a 'lo que sucede cuando se greh a través de un archivo binario'? Su primera reacción puede ser: ¿Por qué querría buscar a través de un archivo binario??. En parte, la respuesta se muestra en lo anterior LS ejemplo ya; A menudo, los archivos binarios todavía contienen cadenas basadas en texto.

Y hay una razón mucho más importante y principal; grep Por defecto, asumirá muchos archivos que contienen datos binarios tan pronto como tengan caracteres especiales en ellos, y tal vez cuando contienen ciertas secuencias de escape binarias, a pesar de que el archivo en sí mismo puede estar basado en datos. Lo que es peor es que, por defecto, GREP fallará y abortará escaneando estos archivos tan pronto como se encuentren dichos datos:

$ head -n2 test_data.SQL Crear tabla T1 (ID int); Insertar en valores T1 (1); $ GREP 'insertar' test_data.SQL | cola -n2 insertar en valores T1 (1000); Archivo binario test_data.partidos de SQL 

Como dos ejemplos destacados de la experiencia personal con el trabajo de la base de datos, cuando escanea los registros de errores del servidor de la base de datos, que pueden contener fácilmente caracteres especiales como los mensajes de error, la base de datos, la base de datos y los nombres de campo pueden llegar al registro de errores y dichos mensajes son regularmente En conjuntos de caracteres específicos de la región.

Otro ejemplo es la prueba SQL obtenida de las suites de prueba de la base de datos (que se muestra en el ejemplo anterior). Dichos datos a menudo contienen caracteres especiales para probar y estresar el servidor de muchas maneras. Lo mismo se aplicaría a la mayoría de los datos de pruebas de sitio web y otros conjuntos de datos de pruebas de dominio. Como GREP falla de forma predeterminada con dichos datos, es importante asegurarse de agregar una opción a GREP para cubrir esto.

La opción es --archivos binarios = texto. Podemos ver cómo nuestro GREP ahora funciona correctamente:

$ GREP 'insertar' test_data.SQL | WC -L 7671 $ Grep 'Insert' test_data.SQL | Tail -n1 Archivo binario test_data.SQL coincide con $ Grep--Binary-Files = Text 'Insert' test_data.SQL | WC -L 690427 

Que diferencia! Puedes imaginar cuántos automatizados grep Los scripts de todo el mundo no están escaneando todos los datos que deberían escanear. Lo que es peor, y agrava significativamente el problema es que grep falla 100% en silencio cuando esto sucede, el código de error será 0 (éxito) en ambos casos:

$ grep -q 'insertar' test_data.sql; Echo $? 0 $ Grep - -Binary -Files = Text -q 'Insert' test_data.sql; Echo $? 0 

Agradeciéndolo aún más, el mensaje de error se muestra en stdout salida, y no stderr Como uno podría esperar. Podemos verificar esto redirigiendo stderr al dispositivo nulo /dev/nulo, Solo mostrando stdout producción. La salida permanece:

$ GREP 'insertar' test_data.SQL 2>/dev/null | Tail -n1 Archivo binario test_data.partidos de SQL 

Esto también significa que si redirigiera sus resultados de GREP a otro archivo (> algún archivo.TXT Después del comando GREP), que el 'archivo binario ... coincidentes' ahora sería parte de ese archivo, además de perder todas las entradas vistas después de que ocurriera dicho problema.

Otro problema es el aspecto de seguridad: tomemos una organización que haya escrito el registro de acceso de acceso a los informes por correo electrónico a los sistemas de Sysadmins siempre que un agente deshonesto (como un hacker) intente y acceda a recursos no autorizados. Si dicho hacker puede insertar algunos datos binarios en el registro de acceso antes de su intento de acceso, y el GREP no está protegido por --archivos binarios = texto, No se enviarán tales correos electrónicos.

Incluso si el script se desarrolla lo suficientemente bien como para verificar el grep Código de salida, todavía nadie notará un error de script, ya que Grep regresa 0, o en otras palabras: éxito. Éxito no es aunque 🙂

Hay dos soluciones fáciles; agregar --archivos binarios = texto a todos tus grep declaraciones, y es posible que desee considerar escanear la salida GREP (o el contenido de un archivo de salida redirigido) para la expresión regular '^Archivo binario.*partidos'. Para obtener más información sobre expresiones regulares, consulte Bash Regexps para principiantes con ejemplos y Bash Regex avanzado con ejemplos. Sin embargo, se preferiría hacer ambos o solo el primero, ya que la segunda opción no es a prueba de futuro; El texto 'Archivo binario ... de coincidencias' puede cambiar.

Finalmente, tenga en cuenta que cuando un archivo de texto se corrompe (falla en el disco, falla de la red, etc.), su contenido puede terminar siendo un texto parcial y parcial. Esta es otra razón más para proteger siempre su grep declaraciones con el --archivos binarios = texto opción.

Tl; dr: Usar --archivos binarios = texto por todo tu grep declaraciones, incluso si actualmente funcionan bien. Nunca se sabe cuándo los datos binarios pueden presionar su archivo.

Ejemplo 2: Pruebe la presencia de una cadena dada dentro de un archivo de texto

Nosotros podemos usar grep -q en combinación con un si Declaración para probar la presencia de una cadena dada dentro de un archivo de texto:

$ if grep - -binary -files = text -qi "insertar" test_data.sql; Entonces Echo "encontrado!"; de lo contrario, no se encuentra!"; Fi encontrado! 

Desglosemos un poco esto al verificar primero si los datos realmente existe:

$ Grep - -Binary -Files = Text -i "Insertar" test_data.SQL | cabeza -n1 insertar en valores T1 (1); 

Aquí dejamos caer el Q Opción (tranquila) para obtener salida y ver que la cadena 'insertar', tomada de manera insensible a los casos (especificando el -i opción para grep existe en el archivo como 'insertar ...'.

Tenga en cuenta que el Q La opción no es específicamente un pruebas opción. Es más bien un modificador de salida que indica grep estar 'callado', yo.mi. no para emitir nada. Entonces, ¿cómo es el si Declaración saber si hay presencia de una cadena dada dentro de un archivo de texto? Esto se hace a través del grep Código de salida:

$ Grep - -Binary -Files = Text -i "Insertar" test_data.SQL 2> & 1>/dev/null; Echo $? 0 $ Grep - -Binary -Files = Text -i "Esto realmente no existe" Test_data.SQL 2> & 1>/dev/null; Echo $? 1 

Aquí hicimos una redirección manual de todos stderr y sdtout salir /dev/nulo redirigiendo stderr (2>) a stdout (Y 1) y redirigir todo stdout Salida al dispositivo NULL (>/dev/nulo). Esto es básicamente equivalente al -Q (tranquila) opción para grep.

Luego verificamos el código de salida y establecimos que cuando se encuentra la cadena, 0 (éxito) se devuelve, mientras que 1 (falla) se devuelve cuando no se encuentra la cadena. si puede usar estos dos códigos de salida para ejecutar el entonces o el demás cláusulas especificadas.

En resumen, podemos usar Si grep -q Para probar la presencia de una determinada cadena dentro de un archivo de texto. La sintaxis completamente correcta, como se ve anteriormente en este artículo, es if grep - -binary -fililes = text -qi "search_term" your_file.sql para búsquedas insensibles a los casos, y if grep - -binary -fililes = text -q "search_term" your_file.sql Para búsquedas sensibles a los casos.

Conclusión

En este artículo, vimos las muchas razones por las que es importante usar --archivos binarios = texto en casi todas las búsquedas de GREP. También exploramos usando grep -q en combinación con si declaraciones para probar la presencia de una cadena dada dentro de un archivo de texto. Disfrutar usando grep, y déjanos un comentario con tu mayor grep descubrimientos!

Tutoriales de Linux relacionados:

• Cosas para instalar en Ubuntu 20.04
• Manejo de la entrada del usuario en scripts bash
• Mastering Bash Script Loops
• Cómo encontrar una cadena o texto en un archivo en Linux
• Use WPSCan para escanear WordPress para vulnerabilidades en Kali
• Mint 20: Mejor que Ubuntu y Microsoft Windows?
• Cómo recuperar información de hardware con DMIDECODE en Linux
• Bucles anidados en guiones Bash
• Una introducción a la automatización, herramientas y técnicas de Linux
• Cosas que hacer después de instalar Ubuntu 20.04 fossa focal Linux