Commande Linux strings avec exemples pratiques

Introduction

Dans ce laboratoire, vous apprendrez à utiliser la commande Linux strings pour extraire des chaînes de caractères imprimables à partir de fichiers binaires, y compris les fichiers exécutables, les bibliothèques et autres données binaires. Vous explorerez le but et l'utilisation de la commande strings, apprendrez à extraire des chaînes de caractères à partir de fichiers compressés et chiffrés, et découvrirez des exemples pratiques d'application de cette commande dans votre travail quotidien. Ce laboratoire offre une compréhension complète de la commande strings et de ses applications, vous permettant d'analyser efficacement et de résoudre les problèmes liés aux fichiers binaires sur les systèmes Linux.

Feuille de triche sur les commandes Linux

Skills Graph

Comprendre le but et l'utilisation de base de la commande strings

La commande strings sous Linux est un utilitaire qui extrait des chaînes de texte lisibles par l'homme à partir de fichiers binaires. Les fichiers binaires, tels que les programmes exécutables et les bibliothèques, contiennent à la fois du code machine et des données textuelles. Bien que le code machine ne soit pas lisible par l'homme, les données textuelles incluent souvent des informations précieuses telles que des messages d'erreur, des paramètres de configuration et de la documentation intégrée.

Commençons par vous assurer que vous êtes dans le bon répertoire pour ce laboratoire :

cd ~/project/strings_lab

Maintenant, explorons l'utilisation de base de la commande strings en examinant le contenu d'un fichier binaire courant - la commande ls :

strings /bin/ls | head -20

Cette commande extrait les 20 premières chaînes lisibles du binaire ls. Vous devriez voir une sortie similaire à ceci :

/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

Par défaut, la commande strings affiche toute séquence de 4 caractères imprimables ou plus se terminant par un saut de ligne ou un caractère nul. Cela la rend précieuse pour :

1. Trouver du texte intégré dans les exécutables
2. Découvrir des chemins et des paramètres codés en dur
3. Effectuer une analyse forensique de base
4. Résoudre les problèmes liés aux fichiers binaires

Essayons un exemple plus spécifique. Vous pouvez utiliser la commande grep avec strings pour trouver des types d'informations particulières. Par exemple, pour trouver toutes les références à "error" dans la commande ls :

strings /bin/ls | grep error

Votre sortie pourrait inclure :

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

La commande strings propose également plusieurs options utiles pour personnaliser son comportement. Par exemple, vous pouvez spécifier la longueur minimale des chaînes à afficher :

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

Cette commande affiche uniquement les chaînes d'au moins 10 caractères. La sortie pourrait ressembler à ceci :

/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

Une autre option utile est -t, qui affiche le décalage (offset) de chaque chaîne dans le fichier :

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

La sortie inclut des décalages en hexadécimal :

    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

Ces décalages peuvent être utiles pour une analyse plus avancée des fichiers binaires.

Analyser différents types de fichiers binaires avec strings

Dans cette étape, vous apprendrez à utiliser la commande strings pour analyser différents types de fichiers binaires, y compris les bibliothèques système et les binaires d'applications. Comprendre comment extraire du texte à partir de divers fichiers binaires peut vous aider à résoudre des problèmes, à localiser des informations spécifiques ou même à découvrir des fonctionnalités cachées.

Tout d'abord, assurez-vous que vous êtes toujours dans le répertoire du laboratoire :

cd ~/project/strings_lab

Explorer les bibliothèques système

Les bibliothèques système contiennent du code qui est partagé entre plusieurs programmes. Examinons une bibliothèque système courante, libc.so.6, qui est la bibliothèque standard C utilisée par la plupart des programmes sous Linux :

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

Votre sortie pourrait ressembler à :

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$)

Comme vous pouvez le voir, le début de la bibliothèque inclut des informations de version, des mentions de copyright et d'autres textes lisibles par l'homme. Ces informations peuvent être précieuses lors de la résolution de problèmes de compatibilité ou de la vérification de la version d'une bibliothèque.

Trouver des informations spécifiques dans les binaires

Supposons que vous souhaitiez trouver toutes les variables d'environnement qui pourraient être utilisées par un programme. Vous pouvez rechercher des chaînes commençant par "$" dans un fichier binaire :

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

Cette commande pourrait afficher :

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

Cela vous montre toutes les variables d'environnement que le shell bash pourrait référencer.

Analyser les informations de version

Vous pouvez également utiliser la commande strings pour trouver des informations de version dans les fichiers binaires :

strings /bin/bash | grep -i version

La sortie pourrait inclure :

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

Cela peut être particulièrement utile lorsque vous avez besoin de vérifier rapidement la version d'un programme sans le lancer.

Créer un simple fichier binaire pour l'analyse

Créons un simple fichier binaire qui contient à la fois des données binaires et des chaînes de texte :

## 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

Maintenant, utilisez la commande strings pour extraire le texte de ce fichier binaire :

strings testfile.bin

Votre sortie devrait inclure les trois chaînes de texte :

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

Cela démontre comment strings peut efficacement filtrer les données binaires et n'afficher que le texte lisible par l'homme, même lorsqu'il est mélangé avec des données non textuelles.

Travailler avec des fichiers compressés et chiffrés

Dans cette étape, vous apprendrez à utiliser la commande strings avec des fichiers compressés et chiffrés. Étant donné que ces fichiers contiennent souvent des données binaires, la commande strings peut être utile pour extraire du texte lisible sans les décompresser ou les déchiffrer entièrement.

Assurez-vous d'être dans le répertoire du laboratoire :

cd ~/project/strings_lab

Analyser des fichiers compressés

Créons un fichier texte et compressons-le en utilisant différentes méthodes pour voir comment strings gère le contenu compressé :

Utilisation de la compression gzip

Tout d'abord, créons un simple fichier texte avec plusieurs lignes :

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

Maintenant, compressons ce fichier en utilisant gzip :

gzip -c sample_text.txt > sample_text.gz

L'option -c indique à gzip d'écrire sur la sortie standard au lieu de remplacer le fichier original. Maintenant, utilisons strings pour voir ce que nous pouvons extraire :

strings sample_text.gz

Vous pourriez voir une sortie comme :

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.

Notez que strings peut extraire le contenu texte original même si le fichier est compressé. Cela est dû au fait que gzip ne chiffre pas les données ; il les compresse simplement, laissant ainsi de nombreux segments de texte lisibles intacts.

Utilisation de différents formats de compression

Essayons une autre méthode de compression, bzip2 :

bzip2 -c sample_text.txt > sample_text.bz2

Maintenant, examinons ce fichier avec strings :

strings sample_text.bz2

La sortie pourrait être moins lisible qu'avec gzip :

BZh91AY&SY
s1r
U*T)

Cela est dû au fait que différents algorithmes de compression produisent différents motifs binaires, et certains laissent moins de segments de texte lisibles que d'autres.

Travailler avec des fichiers chiffrés

Le chiffrement est conçu pour rendre le contenu illisible sans la clé appropriée. Créons un fichier chiffré et voyons ce que strings peut extraire :

## 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

Maintenant, utilisons strings pour examiner le fichier chiffré :

strings secret.enc

Vous pourriez voir une sortie comme :

Salted__

Comme prévu, vous ne pouvez pas voir le message original car il a été correctement chiffré. Le seul texte lisible est l'en-tête "Salted__" que OpenSSL ajoute au début des fichiers chiffrés pour indiquer qu'un sel a été utilisé dans le processus de chiffrement.

Application pratique : Examiner des fichiers journaux compressés

Les administrateurs système compressent souvent les fichiers journaux pour économiser de l'espace. Simulons un fichier journal et examinons-le après compression :

## 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

Maintenant, utilisons strings avec quelques options supplémentaires pour examiner le fichier journal compressé :

strings -n 20 system.log.gz

L'option -n 20 indique à strings de n'afficher que les séquences de 20 caractères imprimables ou plus. Votre sortie pourrait inclure :

[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

Cela démontre comment les administrateurs système peuvent rapidement vérifier le contenu des fichiers journaux compressés sans avoir à les décompresser d'abord, ce qui peut être particulièrement utile lorsqu'ils traitent d'archive de journaux volumineuses.

Utilisation avancée et applications pratiques de la commande strings

Dans cette étape finale, vous allez explorer certains modèles d'utilisation avancés et des applications pratiques de la commande strings. Ces techniques peuvent être particulièrement utiles pour l'administration système, le développement logiciel et la forensic numérique.

Assurez-vous d'être toujours dans le répertoire du laboratoire :

cd ~/project/strings_lab

Combiner strings avec d'autres commandes

Le véritable pouvoir de la commande strings devient évident lorsque vous la combinez avec d'autres commandes Linux. Explorons quelques combinaisons utiles :

Rechercher des identifiants potentiellement codés en dur

Les auditeurs de sécurité utilisent souvent strings pour rechercher des identifiants codés en dur dans les fichiers binaires :

## 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

Maintenant, recherchons des mots de passe potentiels :

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

Cela pourrait afficher :

admin
supersecret123
password

Cela montre comment les auditeurs de sécurité pourraient identifier des identifiants potentiellement codés en dur dans les applications.

Analyser les types de fichiers

La commande strings peut aider à identifier le type d'un fichier lorsque l'extension est manquante ou trompeuse :

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

Maintenant, utilisons strings pour rechercher des indices sur le type de fichier :

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

Vous pourriez voir une sortie comme :

PNG
IHDR
pHYs
iDOT

La présence de chaînes liées à PNG suggère que ce fichier pourrait être une image PNG, malgré l'absence de l'extension appropriée.

Utiliser strings avec des décalages de fichier

L'option -t vous permet de voir le décalage de chaque chaîne dans le fichier, ce qui peut être précieux pour une analyse plus détaillée :

## 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

Maintenant, utilisons strings avec l'option -t pour voir les décalages :

strings -t d offset_example.bin

L'option -t d affiche les décalages en décimal. Votre sortie pourrait ressembler à :

         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.

Ces informations peuvent être utiles pour localiser la position exacte des chaînes dans les fichiers binaires, ce qui est essentiel pour des tâches telles que la modification binaire ou l'analyse détaillée de fichiers.

Étude de cas : Analyser le trafic réseau

Les paquets réseau contiennent souvent à la fois des données binaires et du texte lisible. Simulons un paquet réseau capturé et analysons-le :

## 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

Maintenant, analysons ce "paquet capturé" avec strings :

strings captured_packet.bin

Votre sortie devrait inclure la requête HTTP :

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

Cela montre comment les analystes réseau peuvent rapidement extraire des informations utiles à partir du trafic réseau capturé, même lorsqu'il est mélangé avec des données de protocole binaires.

Résumé des utilisations

Les techniques que vous avez apprises dans cette étape démontrent la polyvalence de la commande strings pour des applications avancées :

1. Combiner strings avec grep pour rechercher des motifs
2. Utiliser strings pour identifier les types de fichiers
3. Travailler avec des décalages de fichier pour l'analyse binaire
4. Extraire des données lisibles à partir de contenu binaire comme les paquets réseau

Ces techniques sont précieuses pour les administrateurs système, les professionnels de la sécurité et les développeurs logiciels qui ont besoin d'analyser des données binaires sans outils spécialisés.

Résumé

Dans ce laboratoire, vous avez exploré la commande Linux strings et appris à l'utiliser pour extraire du texte lisible à partir de fichiers binaires. Les points clés abordés dans ce laboratoire sont les suivants :

1. Le but de la commande strings est d'extraire des séquences de caractères lisibles par l'homme à partir de fichiers binaires, ce qui est utile pour examiner les exécutables, les bibliothèques et autres fichiers non textuels.

2. L'utilisation de base de la commande strings, y compris des options telles que -n pour spécifier la longueur minimale d'une chaîne et -t pour afficher les décalages dans le fichier.

3. L'application de la commande strings pour analyser différents types de fichiers binaires, y compris les bibliothèques système et les exécutables d'applications.

4. Les techniques pour travailler avec des fichiers compressés et chiffrés, montrant comment strings peut extraire des informations à partir de fichiers compressés tandis que les fichiers chiffrés révèlent généralement peu d'informations.

5. Les modèles d'utilisation avancés, y compris la combinaison de strings avec d'autres commandes telles que grep pour une analyse ciblée, l'identification des types de fichiers et l'examen du trafic réseau.

Les compétences que vous avez acquises dans ce laboratoire sont précieuses pour l'administration système, le développement logiciel, l'audit de sécurité et la forensic numérique. La commande strings offre un moyen simple mais puissant de jeter un coup d'œil à l'intérieur des fichiers binaires sans outils spécialisés, ce qui en fait un outil essentiel dans la boîte à outils de l'administrateur Linux.

[ Feuille de triche sur les commandes Linux