Comando strings de Linux con ejemplos prácticos

Introducción

En este laboratorio, aprenderá cómo utilizar el comando strings de Linux para extraer cadenas de caracteres imprimibles de archivos binarios, incluyendo archivos ejecutables, bibliotecas y otros datos binarios. Explorará el propósito y el uso del comando strings, aprenderá cómo extraer cadenas de archivos comprimidos y encriptados, y descubrirá ejemplos prácticos de cómo aplicar este comando en su trabajo diario. Este laboratorio brinda una comprensión integral del comando strings y sus aplicaciones, lo que le permitirá analizar y solucionar problemas de archivos binarios de manera efectiva en sistemas Linux.

Hoja de trucos de comandos de Linux

Skills Graph

Comprender el propósito y el uso básico del comando strings

El comando strings en Linux es una utilidad que extrae cadenas de texto legibles por humanos de archivos binarios. Los archivos binarios, como programas ejecutables y bibliotecas, contienen tanto código de máquina como datos de texto. Si bien el código de máquina no es legible por humanos, los datos de texto a menudo incluyen información valiosa como mensajes de error, configuraciones y documentación incrustada.

Comencemos asegurándonos de que estás en el directorio correcto para este laboratorio:

cd ~/project/strings_lab

Ahora, exploremos el uso básico del comando strings examinando el contenido de un archivo binario común: el comando ls:

strings /bin/ls | head -20

Este comando extrae las primeras 20 cadenas legibles del binario ls. Deberías ver una salida similar a esta:

/lib64/ld-linux-x86-64.so.2
libc.so.6
__stack_chk_fail
__cxa_finalize
setlocale
bindtextdomain
textdomain
__gmon_start__
abort
__errno_location
textdomain
dcgettext
dcngettext
strcmp
error
opendir
fdopendir
dirfd
closedir
readdir

Por defecto, el comando strings muestra cualquier secuencia de 4 o más caracteres imprimibles que termine con un salto de línea o un carácter nulo. Esto lo hace valioso para:

1. Encontrar texto incrustado en ejecutables
2. Descubrir rutas y configuraciones codificadas de forma fija
3. Análisis forense básico
4. Solución de problemas en archivos binarios

Intentemos un ejemplo más específico. Puedes usar el comando grep junto con strings para encontrar tipos particulares de información. Por ejemplo, para encontrar cualquier referencia a "error" en el comando ls:

strings /bin/ls | grep error

Tu salida podría incluir:

error
strerror
strerror_r
__file_fprintf::write_error
error in %s
error %d

El comando strings también ofrece varias opciones útiles para personalizar su comportamiento. Por ejemplo, puedes especificar la longitud mínima de las cadenas a mostrar:

strings -n 10 /bin/ls | head -10

Este comando muestra solo las cadenas que tienen al menos 10 caracteres de longitud. La salida podría ser así:

/lib64/ld-linux-x86-64.so.2
__stack_chk_fail
__cxa_finalize
bindtextdomain
__gmon_start__
__errno_location
_ITM_registerTMCloneTable
_ITM_deregisterTMCloneTable
__cxa_atexit
__cxa_finalize

Otra opción útil es -t, que muestra el desplazamiento (offset) de cada cadena dentro del archivo:

strings -t x /bin/ls | head -10

La salida incluye desplazamientos en formato hexadecimal:

    238 /lib64/ld-linux-x86-64.so.2
    4ca __stack_chk_fail
    4dd __cxa_finalize
    4ec setlocale
    4f7 bindtextdomain
    507 textdomain
    512 __gmon_start__
    522 abort
    528 __errno_location
    539 textdomain

Estos desplazamientos pueden ser útiles para un análisis más avanzado de archivos binarios.

Analizar diferentes tipos de archivos binarios con strings

En este paso, aprenderá cómo utilizar el comando strings para analizar diferentes tipos de archivos binarios, incluyendo bibliotecas del sistema y binarios de aplicaciones. Comprender cómo extraer texto de diversos archivos binarios puede ayudarlo a solucionar problemas, localizar información específica o incluso descubrir funcionalidades ocultas.

Primero, asegúrese de que todavía está en el directorio del laboratorio:

cd ~/project/strings_lab

Explorar bibliotecas del sistema

Las bibliotecas del sistema contienen código que se comparte entre múltiples programas. Examinemos una biblioteca del sistema común, libc.so.6, que es la biblioteca estándar C utilizada por la mayoría de los programas en Linux:

strings /lib/x86_64-linux-gnu/libc.so.6 | head -20

Su salida podría ser similar a:

GNU C Library (Ubuntu GLIBC 2.35-0ubuntu3.4) stable release version 2.35.
Copyright (C) 2022 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.
There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE.
Compiled by GNU CC version 11.4.0.
libc ABIs: UNIQUE IFUNC ABSOLUTE
For bug reporting instructions, please see:
<https://bugs.launchpad.net/ubuntu/+source/glibc/+bugs>.
/build/glibc-bBNzrH/glibc-2.35/elf/../sysdeps/x86_64/startup.c
7e
m3
.n
zN
?$
?G
G0
5')
5$)

Como puede ver, el comienzo de la biblioteca incluye información de versión, avisos de copyright y otro texto legible por humanos. Esta información puede ser valiosa al solucionar problemas de compatibilidad o comprobar la versión de una biblioteca.

Encontrar información específica en binarios

Digamos que desea encontrar todas las variables de entorno que podría utilizar un programa. Puede buscar cadenas que comiencen con "$" en un archivo binario:

strings /bin/bash | grep '^\$' | head -10

Este comando podría mostrar la siguiente salida:

$HOME
$PATH
$SHELL
$TERM
$USER
$HOSTNAME
$PWD
$MAIL
$LANG
$LC_ALL

Esto le muestra todas las variables de entorno que la shell bash podría hacer referencia.

Analizar información de versión

También puede utilizar el comando strings para encontrar información de versión en archivos binarios:

strings /bin/bash | grep -i version

La salida podría incluir:

GNU bash, version %s (%s)
version
VERSION
version_string
dist_version
show_shell_version
BASH_VERSION
GNU bash, version %s-(%s)
@(#)version.c
version.c

Esto puede ser especialmente útil cuando necesita comprobar rápidamente la versión de un programa sin ejecutarlo.

Crear un archivo binario simple para análisis

Creemos un archivo binario simple que contenga tanto datos binarios como cadenas de texto:

## Create a file with some text and binary data
echo "This is a visible string in our test file." > testfile.bin
echo "Another string that should be extractable." >> testfile.bin
## Add some binary data
dd if=/dev/urandom bs=100 count=1 >> testfile.bin 2> /dev/null
## Add one more text string
echo "Final string after some binary data." >> testfile.bin

Ahora, utilice el comando strings para extraer el texto de este archivo binario:

strings testfile.bin

Su salida debería incluir las tres cadenas de texto:

This is a visible string in our test file.
Another string that should be extractable.
Final string after some binary data.

Esto demuestra cómo strings puede filtrar eficazmente los datos binarios y mostrar solo el texto legible por humanos, incluso cuando está mezclado con datos no textuales.

Trabajar con archivos comprimidos y encriptados

En este paso, aprenderá cómo utilizar el comando strings con archivos comprimidos y encriptados. Dado que estos archivos a menudo contienen datos binarios, el comando strings puede ser útil para extraer texto legible sin descomprimirlos o desencriptarlos por completo.

Asegúrese de estar en el directorio del laboratorio:

cd ~/project/strings_lab

Analizar archivos comprimidos

Creemos un archivo de texto y comprimámoslo utilizando diferentes métodos para ver cómo strings maneja el contenido comprimido:

Utilizar compresión gzip

Primero, creemos un archivo de texto simple con múltiples líneas:

cat > sample_text.txt << EOF
This is a sample text file.
It contains multiple lines of text.
We will compress it in different ways.
Then we'll use the strings command to see what we can extract.
The strings command is useful for examining binary files.
EOF

Ahora, comprimamos este archivo utilizando gzip:

gzip -c sample_text.txt > sample_text.gz

La opción -c le indica a gzip que escriba en la salida estándar en lugar de reemplazar el archivo original. Ahora, utilicemos strings para ver qué podemos extraer:

strings sample_text.gz

Puede ver una salida como esta:

sample_text.txt
This is a sample text file.
It contains multiple lines of text.
We will compress it in different ways.
Then we'll use the strings command to see what we can extract.
The strings command is useful for examining binary files.

Note que strings puede extraer el contenido de texto original aunque el archivo esté comprimido. Esto se debe a que gzip no encripta los datos; solo los comprime, lo que aún deja intactos muchos segmentos de texto legibles.

Utilizar diferentes formatos de compresión

Intentemos otro método de compresión, bzip2:

bzip2 -c sample_text.txt > sample_text.bz2

Ahora, examine este archivo con strings:

strings sample_text.bz2

La salida puede ser menos legible que con gzip:

BZh91AY&SY
s1r
U*T)

Esto se debe a que diferentes algoritmos de compresión producen diferentes patrones binarios, y algunos dejan menos segmentos de texto legibles que otros.

Trabajar con archivos encriptados

La encriptación está diseñada para hacer que el contenido sea ilegible sin la clave adecuada. Creemos un archivo encriptado y veamos qué puede extraer strings:

## Create a file with a secret message
echo "This is a top secret message that should be encrypted." > secret.txt

## Encrypt the file using OpenSSL
openssl enc -aes-256-cbc -salt -in secret.txt -out secret.enc -k "password123" -pbkdf2

Ahora, utilicemos strings para examinar el archivo encriptado:

strings secret.enc

Puede ver una salida como esta:

Salted__

Como se esperaba, no puede ver el mensaje original porque ha sido encriptado correctamente. El único texto legible es el encabezado "Salted__" que OpenSSL agrega al comienzo de los archivos encriptados para indicar que se utilizó una sal en el proceso de encriptación.

Aplicación práctica: Examinar archivos de registro comprimidos

Los administradores de sistemas a menudo comprimen los archivos de registro para ahorrar espacio. Simulemos un archivo de registro y examinémoslo después de la compresión:

## Create a simulated log file
cat > system.log << EOF
[2023-10-25 08:00:01] INFO: System startup completed
[2023-10-25 08:05:22] WARNING: High memory usage detected
[2023-10-25 08:10:15] ERROR: Failed to connect to database
[2023-10-25 08:15:30] INFO: Database connection restored
[2023-10-25 08:20:45] WARNING: CPU temperature above threshold
EOF

## Compress the log file
gzip -c system.log > system.log.gz

Ahora, utilicemos strings con algunas opciones adicionales para examinar el archivo de registro comprimido:

strings -n 20 system.log.gz

La opción -n 20 le indica a strings que solo muestre secuencias de 20 o más caracteres imprimibles. Su salida puede incluir:

[2023-10-25 08:00:01] INFO: System startup completed
[2023-10-25 08:05:22] WARNING: High memory usage detected
[2023-10-25 08:10:15] ERROR: Failed to connect to database
[2023-10-25 08:15:30] INFO: Database connection restored
[2023-10-25 08:20:45] WARNING: CPU temperature above threshold

Esto demuestra cómo los administradores de sistemas pueden verificar rápidamente el contenido de archivos de registro comprimidos sin tener que descomprimirlos primero, lo que puede ser especialmente útil cuando se trata de archivos de registro grandes.

Uso avanzado y aplicaciones prácticas del comando strings

En este último paso, explorará algunos patrones de uso avanzado y aplicaciones prácticas del comando strings. Estas técnicas pueden ser especialmente útiles para la administración de sistemas, el desarrollo de software y la forense digital.

Asegúrese de que todavía está en el directorio del laboratorio:

cd ~/project/strings_lab

Combinar strings con otros comandos

El verdadero poder del comando strings se hace evidente cuando se lo combina con otros comandos de Linux. Exploremos algunas combinaciones útiles:

Buscar credenciales codificadas de forma rígida (hardcoded)

Los auditores de seguridad a menudo utilizan strings para buscar credenciales codificadas de forma rígida en archivos binarios:

## Create a sample program with "credentials"
cat > credentials_example.c << EOF
#include <stdio.h>

int main() {
    char* username = "admin";
    char* password = "supersecret123";
    
    printf("Connecting with credentials...\n");
    return 0;
}
EOF

## Compile the program
gcc credentials_example.c -o credentials_example

Ahora, busquemos posibles contraseñas:

strings credentials_example | grep -i 'password\|secret\|admin\|user\|login'

Esto podría mostrar la siguiente salida:

admin
supersecret123
password

Esto demuestra cómo los auditores de seguridad podrían identificar posibles credenciales codificadas de forma rígida en aplicaciones.

Analizar tipos de archivos

El comando strings puede ayudar a identificar el tipo de un archivo cuando la extensión falta o es engañosa:

## Create a PNG file without the correct extension
cp /usr/share/icons/Adwaita/16x16/places/folder.png mystery_file

Ahora, utilicemos strings para buscar pistas sobre el tipo de archivo:

strings mystery_file | grep -i 'png\|jpeg\|gif\|image'

Puede ver una salida como esta:

PNG
IHDR
pHYs
iDOT

La presencia de cadenas relacionadas con PNG sugiere que este archivo podría ser una imagen PNG, a pesar de carecer de la extensión adecuada.

Usar strings con desplazamientos de archivo

La opción -t le permite ver el desplazamiento de cada cadena dentro del archivo, lo que puede ser valioso para un análisis más detallado:

## Create a sample binary file
cat > offset_example.bin << EOF
This is at the beginning of the file.
EOF

## Add some binary data
dd if=/dev/urandom bs=100 count=1 >> offset_example.bin 2> /dev/null

## Add another string
echo "This is in the middle of the file." >> offset_example.bin

## Add more binary data
dd if=/dev/urandom bs=100 count=1 >> offset_example.bin 2> /dev/null

## Add a final string
echo "This is at the end of the file." >> offset_example.bin

Ahora, utilicemos strings con la opción -t para ver los desplazamientos:

strings -t d offset_example.bin

La opción -t d muestra los desplazamientos en decimal. Su salida podría ser similar a:

         0 This is at the beginning of the file.
       137 This is in the middle of the file.
       273 This is at the end of the file.

Esta información puede ser útil para localizar la posición exacta de las cadenas dentro de archivos binarios, lo que es esencial para tareas como la parcheo binario o el análisis detallado de archivos.

Estudio de caso: Analizar tráfico de red

Los paquetes de red a menudo contienen tanto datos binarios como texto legible. Simulemos un paquete de red capturado y analicémoslo:

## Create a simulated network packet with HTTP data
cat > http_packet.bin << EOF
GET /index.html HTTP/1.1
Host: www.example.com
User-Agent: Mozilla/5.0
Accept: text/html,application/xhtml+xml
EOF

## Add some binary header and footer to simulate packet framing
dd if=/dev/urandom bs=20 count=1 > packet_header.bin 2> /dev/null
dd if=/dev/urandom bs=20 count=1 > packet_footer.bin 2> /dev/null

## Combine them into a complete "packet"
cat packet_header.bin http_packet.bin packet_footer.bin > captured_packet.bin

Ahora, analicemos este "paquete capturado" con strings:

strings captured_packet.bin

Su salida debería incluir la solicitud HTTP:

GET /index.html HTTP/1.1
Host: www.example.com
User-Agent: Mozilla/5.0
Accept: text/html,application/xhtml+xml

Esto demuestra cómo los analistas de red pueden extraer rápidamente información útil del tráfico de red capturado, incluso cuando está mezclado con datos de protocolo binarios.

Resumen del uso avanzado

Las técnicas que ha aprendido en este paso demuestran la versatilidad del comando strings para aplicaciones avanzadas:

1. Combinar strings con grep para buscar patrones específicos
2. Utilizar strings para identificar tipos de archivos
3. Trabajar con desplazamientos de archivo para un análisis binario preciso
4. Extraer datos legibles de contenido binario como paquetes de red

Estas técnicas son valiosas para administradores de sistemas, profesionales de seguridad y desarrolladores de software que necesitan analizar datos binarios sin herramientas especializadas.

Resumen

En este laboratorio, exploró el comando strings de Linux y aprendió cómo usarlo para extraer texto legible de archivos binarios. Los puntos clave cubiertos en este laboratorio incluyen:

1. El propósito del comando strings es extraer secuencias de caracteres legibles por humanos de archivos binarios, lo cual es útil para examinar ejecutables, bibliotecas y otros archivos no de texto.

2. Uso básico del comando strings, incluyendo opciones como -n para especificar la longitud mínima de la cadena y -t para mostrar los desplazamientos de archivo.

3. Aplicación del comando strings para analizar diferentes tipos de archivos binarios, incluyendo bibliotecas del sistema y ejecutables de aplicaciones.

4. Técnicas para trabajar con archivos comprimidos y encriptados, demostrando cómo strings puede extraer información de archivos comprimidos, mientras que los archivos encriptados generalmente revelan poca información.

5. Patrones de uso avanzado, incluyendo la combinación de strings con otros comandos como grep para un análisis específico, la identificación de tipos de archivos y el examen del tráfico de red.

Las habilidades que ha aprendido en este laboratorio son valiosas para la administración de sistemas, el desarrollo de software, la auditoría de seguridad y la forense digital. El comando strings ofrece una forma simple pero poderosa de echar un vistazo dentro de archivos binarios sin herramientas especializadas, lo que lo convierte en una utilidad esencial en el conjunto de herramientas del administrador de Linux.

Hoja de trucos de comandos de Linux