Linux strings-Befehl mit praktischen Beispielen

LinuxLinuxBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab lernen Sie, wie Sie den Linux-Befehl strings verwenden können, um druckbare Zeichenketten aus Binärdateien zu extrahieren, einschließlich ausführbaren Dateien, Bibliotheken und anderen Binärdaten. Sie werden den Zweck und die Verwendung des strings-Befehls untersuchen, erfahren, wie man Zeichenketten aus komprimierten und verschlüsselten Dateien extrahiert, und praktische Beispiele entdecken, wie Sie diesen Befehl in Ihrem täglichen Arbeitsalltag anwenden können. Dieses Lab vermittelt ein umfassendes Verständnis des strings-Befehls und seiner Anwendungen und befähigt Sie, Binärdateien auf Linux-Systemen effektiv zu analysieren und Probleme zu beheben.

Linux Commands Cheat Sheet

Verständnis des Zwecks und der Grundlegenden Verwendung des strings-Befehls

Der strings-Befehl in Linux ist ein Hilfsprogramm, das menschenlesbare Textzeichenketten aus Binärdateien extrahiert. Binärdateien, wie z. B. ausführbare Programme und Bibliotheken, enthalten sowohl Maschinencode als auch Textdaten. Während der Maschinencode nicht menschenlesbar ist, enthält die Textdaten oft wertvolle Informationen wie Fehlermeldungen, Konfigurationseinstellungen und eingebettete Dokumentation.

Beginnen wir damit, sicherzustellen, dass Sie sich im richtigen Verzeichnis für dieses Lab befinden:

cd ~/project/strings_lab

Jetzt lassen Sie uns die grundlegende Verwendung des strings-Befehls erkunden, indem wir den Inhalt einer gängigen Binärdatei - dem ls-Befehl - untersuchen:

strings /bin/ls | head -20

Dieser Befehl extrahiert die ersten 20 lesbaren Zeichenketten aus der ls-Binärdatei. Sie sollten eine Ausgabe ähnlich der folgenden sehen:

/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

Standardmäßig zeigt der strings-Befehl jede Sequenz von 4 oder mehr druckbaren Zeichen an, die mit einem Zeilenumbruch oder einem Nullzeichen enden. Dies macht es wertvoll für:

  1. Das Finden von eingebettetem Text in ausführbaren Dateien
  2. Das Entdecken von hartcodierten Pfaden und Einstellungen
  3. Die grundlegende forensische Analyse
  4. Die Fehlersuche bei Binärdateien

Versuchen wir ein spezifischeres Beispiel. Sie können den grep-Befehl zusammen mit strings verwenden, um bestimmte Arten von Informationen zu finden. Beispielsweise können Sie alle Verweise auf "error" im ls-Befehl finden:

strings /bin/ls | grep error

Ihre Ausgabe könnte Folgendes enthalten:

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

Der strings-Befehl bietet auch mehrere nützliche Optionen, um sein Verhalten anzupassen. Beispielsweise können Sie die Mindestlänge der anzuzeigenden Zeichenketten angeben:

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

Dieser Befehl zeigt nur Zeichenketten an, die mindestens 10 Zeichen lang sind. Die Ausgabe könnte so aussehen:

/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

Eine andere nützliche Option ist -t, die den Offset jeder Zeichenkette innerhalb der Datei anzeigt:

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

Die Ausgabe enthält hexadezimale Offsets:

    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

Diese Offsets können für eine fortgeschrittenere Analyse von Binärdateien nützlich sein.

Analyse verschiedener Typen von Binärdateien mit strings

In diesem Schritt lernen Sie, wie Sie den strings-Befehl verwenden können, um verschiedene Typen von Binärdateien zu analysieren, einschließlich Systembibliotheken und Anwendungsbinärdateien. Das Verständnis, wie man Text aus verschiedenen Binärdateien extrahiert, kann Ihnen helfen, Probleme zu beheben, spezifische Informationen zu finden oder sogar versteckte Funktionen zu entdecken.

Stellen Sie zunächst sicher, dass Sie sich noch im Lab-Verzeichnis befinden:

cd ~/project/strings_lab

Untersuchung von Systembibliotheken

Systembibliotheken enthalten Code, der von mehreren Programmen gemeinsam genutzt wird. Lassen Sie uns eine gängige Systembibliothek untersuchen, libc.so.6, die die C-Standardbibliothek ist, die von den meisten Programmen unter Linux verwendet wird:

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

Ihre Ausgabe könnte ähnlich aussehen wie:

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

Wie Sie sehen können, enthält der Anfang der Bibliothek Versionsinformationen, Copyright-Hinweise und anderen menschenlesbaren Text. Diese Informationen können bei der Behebung von Kompatibilitätsproblemen oder beim Überprüfen der Version einer Bibliothek wertvoll sein.

Finden spezifischer Informationen in Binärdateien

Angenommen, Sie möchten alle Umgebungsvariablen finden, die von einem Programm verwendet werden könnten. Sie können in einer Binärdatei nach Zeichenketten suchen, die mit "$" beginnen:

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

Dieser Befehl könnte die folgende Ausgabe liefern:

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

Dies zeigt Ihnen alle Umgebungsvariablen, auf die die bash-Shell möglicherweise verweist.

Analyse von Versionsinformationen

Sie können auch den strings-Befehl verwenden, um Versionsinformationen in Binärdateien zu finden:

strings /bin/bash | grep -i version

Die Ausgabe könnte Folgendes enthalten:

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

Dies kann besonders nützlich sein, wenn Sie schnell die Version eines Programms überprüfen müssen, ohne es auszuführen.

Erstellen einer einfachen Binärdatei zur Analyse

Lassen Sie uns eine einfache Binärdatei erstellen, die sowohl Binärdaten als auch Textzeichenketten enthält:

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

Jetzt verwenden Sie den strings-Befehl, um den Text aus dieser Binärdatei zu extrahieren:

strings testfile.bin

Ihre Ausgabe sollte alle drei Textzeichenketten enthalten:

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

Dies zeigt, wie strings effektiv Binärdaten herausfiltern und nur den menschenlesbaren Text anzeigen kann, auch wenn er mit Nicht-Text-Daten vermischt ist.

Arbeiten mit komprimierten und verschlüsselten Dateien

In diesem Schritt lernen Sie, wie Sie den strings-Befehl mit komprimierten und verschlüsselten Dateien verwenden können. Da diese Dateien oft Binärdaten enthalten, kann der strings-Befehl nützlich sein, um lesbaren Text zu extrahieren, ohne sie vollständig zu dekomprimieren oder zu entschlüsseln.

Stellen Sie sicher, dass Sie sich im Lab-Verzeichnis befinden:

cd ~/project/strings_lab

Analyse von komprimierten Dateien

Lassen Sie uns eine Textdatei erstellen und sie mit verschiedenen Methoden komprimieren, um zu sehen, wie strings komprimierten Inhalt verarbeitet:

Verwendung der gzip-Komprimierung

Zunächst erstellen wir eine einfache Textdatei mit mehreren Zeilen:

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

Jetzt komprimieren wir diese Datei mit gzip:

gzip -c sample_text.txt > sample_text.gz

Die Option -c teilt gzip mit, an die Standardausgabe zu schreiben, anstatt die Originaldatei zu ersetzen. Jetzt verwenden wir strings, um zu sehen, was wir extrahieren können:

strings sample_text.gz

Sie könnten eine Ausgabe wie die folgende sehen:

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.

Beachten Sie, dass strings den ursprünglichen Textinhalt extrahieren kann, obwohl die Datei komprimiert ist. Dies liegt daran, dass gzip die Daten nicht verschlüsselt; es komprimiert sie nur, wodurch viele lesbare Textsegmente intakt bleiben.

Verwendung unterschiedlicher Komprimierungsformate

Versuchen wir eine andere Komprimierungsmethode, bzip2:

bzip2 -c sample_text.txt > sample_text.bz2

Jetzt untersuchen wir diese Datei mit strings:

strings sample_text.bz2

Die Ausgabe ist möglicherweise weniger lesbar als bei gzip:

BZh91AY&SY
s1r
U*T)

Dies liegt daran, dass verschiedene Komprimierungsalgorithmen unterschiedliche Binärmuster erzeugen und einige weniger lesbare Textsegmente hinterlassen als andere.

Arbeiten mit verschlüsselten Dateien

Verschlüsselung ist so konzipiert, dass der Inhalt ohne den richtigen Schlüssel nicht lesbar ist. Lassen Sie uns eine verschlüsselte Datei erstellen und sehen, was strings extrahieren kann:

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

Jetzt verwenden wir strings, um die verschlüsselte Datei zu untersuchen:

strings secret.enc

Sie könnten eine Ausgabe wie die folgende sehen:

Salted__

Wie erwartet können Sie die ursprüngliche Nachricht nicht sehen, da sie ordnungsgemäß verschlüsselt wurde. Der einzige lesbare Text ist der "Salted__"-Header, den OpenSSL an den Anfang von verschlüsselten Dateien hinzufügt, um anzuzeigen, dass ein Salt bei der Verschlüsselung verwendet wurde.

Praktische Anwendung: Untersuchung von komprimierten Protokolldateien

Systemadministratoren komprimieren oft Protokolldateien, um Speicherplatz zu sparen. Lassen Sie uns eine Protokolldatei simulieren und sie nach der Komprimierung untersuchen:

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

Jetzt verwenden wir strings mit einigen zusätzlichen Optionen, um die komprimierte Protokolldatei zu untersuchen:

strings -n 20 system.log.gz

Die Option -n 20 teilt strings mit, nur Sequenzen von 20 oder mehr druckbaren Zeichen anzuzeigen. Ihre Ausgabe könnte Folgendes enthalten:

[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

Dies zeigt, wie Systemadministratoren schnell den Inhalt von komprimierten Protokolldateien überprüfen können, ohne sie zunächst dekomprimieren zu müssen, was besonders nützlich sein kann, wenn es um große Protokollarchive geht.

Fortgeschrittene Nutzung und praktische Anwendungen des strings-Befehls

In diesem letzten Schritt werden Sie einige fortgeschrittene Nutzungsmuster und praktische Anwendungen des strings-Befehls erkunden. Diese Techniken können besonders nützlich für Systemadministration, Softwareentwicklung und digitale Forensik sein.

Stellen Sie sicher, dass Sie sich noch im Lab-Verzeichnis befinden:

cd ~/project/strings_lab

Kombinieren von strings mit anderen Befehlen

Die wahre Stärke des strings-Befehls wird ersichtlich, wenn Sie ihn mit anderen Linux-Befehlen kombinieren. Lassen Sie uns einige nützliche Kombinationen erkunden:

Suchen nach potenziell hartkodierten Anmeldeinformationen

Sicherheitsprüfer verwenden oft strings, um nach hartkodierten Anmeldeinformationen in Binärdateien zu suchen:

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

Jetzt suchen wir nach potenziellen Passwörtern:

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

Dies könnte die folgende Ausgabe liefern:

admin
supersecret123
password

Dies zeigt, wie Sicherheitsprüfer potenziell hartkodierte Anmeldeinformationen in Anwendungen identifizieren können.

Analysieren von Dateitypen

Der strings-Befehl kann helfen, den Typ einer Datei zu identifizieren, wenn die Dateierweiterung fehlt oder irreführend ist:

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

Jetzt verwenden wir strings, um nach Hinweisen auf den Dateityp zu suchen:

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

Sie könnten eine Ausgabe wie die folgende sehen:

PNG
IHDR
pHYs
iDOT

Das Vorhandensein von PNG-bezogenen Zeichenketten deutet darauf hin, dass diese Datei möglicherweise ein PNG-Bild ist, obwohl die richtige Dateierweiterung fehlt.

Verwenden von strings mit Dateioffsets

Die Option -t ermöglicht es Ihnen, den Offset jeder Zeichenkette innerhalb der Datei anzuzeigen, was für eine detailliertere Analyse wertvoll sein kann:

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

Jetzt verwenden wir strings mit der Option -t, um die Offsets anzuzeigen:

strings -t d offset_example.bin

Die Option -t d zeigt dezimale Offsets an. Ihre Ausgabe könnte wie folgt aussehen:

         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.

Diese Informationen können nützlich sein, um die genaue Position von Zeichenketten innerhalb von Binärdateien zu finden, was für Aufgaben wie das Patchen von Binärdateien oder die detaillierte Dateianalyse unerlässlich ist.

Fallstudie: Analysieren von Netzwerkverkehr

Netzwerkpakete enthalten oft sowohl Binärdaten als auch lesbaren Text. Lassen Sie uns ein aufgezeichnetes Netzwerkpaket simulieren und analysieren:

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

Jetzt analysieren wir dieses "aufgezeichnete Paket" mit strings:

strings captured_packet.bin

Ihre Ausgabe sollte die HTTP-Anfrage enthalten:

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

Dies zeigt, wie Netzwerkanalysten schnell nützliche Informationen aus aufgezeichnetem Netzwerkverkehr extrahieren können, auch wenn er mit Binärprotokolldaten vermischt ist.

Zusammenfassung der fortgeschrittenen Nutzung

Die Techniken, die Sie in diesem Schritt gelernt haben, zeigen die Vielseitigkeit des strings-Befehls für fortgeschrittene Anwendungen:

  1. Kombinieren von strings mit grep, um nach bestimmten Mustern zu suchen
  2. Verwenden von strings, um Dateitypen zu identifizieren
  3. Arbeiten mit Dateioffsets für eine präzise Binäranalyse
  4. Extrahieren von lesbaren Daten aus gemischten Binärinhalten wie Netzwerkpaketen

Diese Techniken sind wertvoll für Systemadministratoren, Sicherheitsexperten und Softwareentwickler, die Binärdaten ohne spezialisierte Tools analysieren müssen.

Zusammenfassung

In diesem Lab haben Sie den Linux-Befehl strings erkundet und gelernt, wie Sie ihn verwenden können, um lesbaren Text aus Binärdateien zu extrahieren. Die wichtigsten Punkte, die in diesem Lab behandelt wurden, umfassen:

  1. Der Zweck des strings-Befehls besteht darin, menschenlesbare Zeichenfolgen aus Binärdateien zu extrahieren. Dies ist nützlich für die Untersuchung von ausführbaren Dateien, Bibliotheken und anderen Nicht-Textdateien.

  2. Die grundlegende Nutzung des strings-Befehls, einschließlich Optionen wie -n, um die Mindestlänge der Zeichenfolge anzugeben, und -t, um Dateioffsets anzuzeigen.

  3. Die Anwendung des strings-Befehls zur Analyse verschiedener Arten von Binärdateien, einschließlich Systembibliotheken und Anwendungsausführbaren Dateien.

  4. Techniken für die Arbeit mit komprimierten und verschlüsselten Dateien, die zeigen, wie strings Informationen aus komprimierten Dateien extrahieren kann, während verschlüsselte Dateien in der Regel nur minimale Informationen preisgeben.

  5. Fortgeschrittene Nutzungsmuster, einschließlich der Kombination von strings mit anderen Befehlen wie grep für gezielte Analysen, die Identifizierung von Dateitypen und die Untersuchung von Netzwerkverkehr.

Die Fähigkeiten, die Sie in diesem Lab erworben haben, sind wertvoll für die Systemadministration, die Softwareentwicklung, die Sicherheitsüberprüfung und die digitale Forensik. Der strings-Befehl bietet eine einfache, aber leistungsstarke Möglichkeit, in Binärdateien zu schauen, ohne spezialisierte Tools. Daher ist er ein unverzichtbares Hilfsmittel im Werkzeugkasten des Linux-Administrators.

Linux Commands Cheat Sheet