Erkunden Sie Binärdateien mit diesem voll funktionsfähigen Linux-Tool

In 10 Möglichkeiten zur Analyse von Binärdateien unter Linux , habe ich erklärt, wie man die umfangreichen nativen Tools von Linux verwendet, um Binärdateien zu analysieren. Wenn Sie Ihre Binärdatei jedoch weiter untersuchen möchten, benötigen Sie ein Tool, das speziell für die Binäranalyse entwickelt wurde. Wenn Sie neu in der Binäranalyse sind und hauptsächlich mit Skriptsprachen gearbeitet haben, 9 wesentliche GNU-Binutils-Tools hilft Ihnen beim Einstieg in den Kompilierungsprozess und was eine Binärdatei ausmacht.

Warum brauche ich ein weiteres Tool?

Weitere Linux-Ressourcen

• Spickzettel für Linux-Befehle
• Spickzettel für fortgeschrittene Linux-Befehle
• Kostenloser Online-Kurs:RHEL Technical Overview
• Spickzettel für Linux-Netzwerke
• SELinux-Spickzettel
• Spickzettel für allgemeine Linux-Befehle
• Was sind Linux-Container?
• Unsere neuesten Linux-Artikel

Es ist natürlich zu fragen, warum Sie noch ein weiteres Tool benötigen, wenn vorhandene Linux-native Tools ähnliche Dinge tun. Nun, aus den gleichen Gründen verwenden Sie Ihr Handy als Wecker, um Notizen zu machen, als Kamera, um Musik zu hören, im Internet zu surfen und gelegentlich Anrufe zu tätigen und entgegenzunehmen. Zuvor wurden diese Funktionen von separaten Geräten und Tools übernommen – wie eine physische Kamera zum Aufnehmen von Bildern, ein kleiner Notizblock zum Aufzeichnen von Notizen, ein Wecker am Bett zum Aufwachen und so weiter. Es ist bequem, ein Gerät für mehrere (aber verwandte) Dinge zu haben für den Benutzer. Außerdem ist das Killer-Feature Interoperabilität zwischen den einzelnen Funktionen.

Auch wenn viele Linux-Tools einen bestimmten Zweck haben, ist es sehr hilfreich, ähnliche (und bessere) Funktionen in einem einzigen Tool zu haben. Aus diesem Grund denke ich, dass Radare2 Ihr Werkzeug der Wahl sein sollte, wenn Sie mit Binärdateien arbeiten müssen.

Radare2 (auch bekannt als r2) ist laut seinem GitHub-Profil ein „Unix-ähnliches Reverse-Engineering-Framework und ein Befehlszeilen-Toolset“. Die "2" in seinem Namen kommt daher, dass diese Version von Grund auf neu geschrieben wurde, um sie modularer zu machen.

Warum Radare2?

Es gibt unzählige (nicht-native) Linux-Tools, die für die Binäranalyse verwendet werden, also warum sollten Sie sich für Radare2 entscheiden? Meine Gründe sind einfach.

Erstens ist es ein Open-Source-Projekt mit einer aktiven und gesunden Community. Wenn Sie nach raffinierten, neuen Funktionen oder der Verfügbarkeit von Fehlerbehebungen suchen, ist dies sehr wichtig.

Zweitens kann Radare2 auf der Befehlszeile verwendet werden und verfügt über eine umfangreiche grafische Benutzeroberflächenumgebung (GUI) namens Cutter für diejenigen, die mit GUIs vertrauter sind. Als langjähriger Linux-User füttere ich mich wohler über die Shell. Während es eine leichte Lernkurve gibt, sich mit den Befehlen von Radare2 vertraut zu machen, würde ich es mit dem Erlernen von Vim vergleichen. Sie lernen zuerst grundlegende Dinge, und sobald Sie sie beherrschen, gehen Sie zu fortgeschritteneren Dingen über. In kürzester Zeit wird es zur zweiten Natur.

Drittens bietet Radare2 über Plugins eine gute Unterstützung für externe Tools. Beispielsweise ist das kürzlich als Open-Source veröffentlichte Ghidra-Binäranalyse- und Umkehrtool für seine Decompiler-Funktion beliebt, die ein entscheidendes Element der Umkehrsoftware ist. Sie können den Ghidra-Decompiler direkt von der Radare2-Konsole installieren und verwenden, was erstaunlich ist und Ihnen das Beste aus beiden Welten bietet.

Erste Schritte mit Radare2

Um Radare2 zu installieren, klonen Sie einfach das Repo und führen Sie user.sh aus Skript. Möglicherweise müssen Sie einige vorausgesetzte Pakete installieren, wenn sie sich nicht bereits auf Ihrem System befinden. Führen Sie nach Abschluss der Installation r2 -v aus Befehl, um zu sehen, ob Radare2 richtig installiert wurde:

$ git clone https://github.com/radareorg/radare2.git
$ cd radare2
$ sys/user.sh

# version
 
$ r2 -v
radare2 4.6.0-git 25266 @ linux-x86-64 git.4.4.0-930-g48047b317
commit:48047b3171e6ed0480a71a04c3693a0650d03543 build:2020-11-17.__ :03
$ 

Holen Sie sich eine Beispiel-Testbinärdatei

Nachdem r2 installiert ist, benötigen Sie eine Beispielbinärdatei, um es auszuprobieren. Sie können jede Systembinärdatei (ls , bash , und so weiter), aber um die Dinge für dieses Tutorial einfach zu halten, kompilieren Sie das folgende C-Programm:

$ cat adder.c 
#include 

int adder(int num) {
        return num + 1;
}

int main() {
        int res, num1 =100;
        res =adder(num1);
        printf("Zahl ist jetzt  :%d\n", res);
        return 0;
}
$ 
$ 
$ gcc adder.c -o adder
$ 
$ file adder
adder:ELF 64-Bit LSB ausführbar, x86-64, Version 1 (SYSV), dynamisch verknüpft, Interpreter /lib64/ld-linux-x86-64.so.2, für GNU/Linux 3.2.0, BuildID [sha1]=9d4366f7160e1ffb46b14466e8e0d70f10de2240, nicht gestrippt
$ 
$ ./adder 
Nummer ist jetzt  :101
$ 

Lade die Binärdatei

Um die Binärdatei zu analysieren, müssen Sie sie in Radare2 laden. Laden Sie es, indem Sie die Datei als Befehlszeilenargument für r2 bereitstellen Befehl. Sie landen in einer separaten Radare2-Konsole, die sich von Ihrer Shell unterscheidet. Um die Konsole zu verlassen, können Sie Quit eingeben oder Beenden oder drücken Sie Strg +D :

$ r2 ./adder
 -- Lerne Pfannkuchen wie ein Radar!
[0x004004b0]> beende
$ 

Binärdatei analysieren

Bevor Sie die Binärdatei erkunden können, müssen Sie r2 bitten, sie für Sie zu analysieren. Sie können dies tun, indem Sie aaa ausführen Befehl in der r2-Konsole;

$ r2 ./adder
 - Entschuldigung, bei radare2 ist ein interner Fehler aufgetreten.
[0x004004b0]> 
[0x004004b0]> 
[0x004004b0]> aaa
[x] Analysiere alle Flags beginnend mit sym. und entry0 (aa)
[x] Funktionsaufrufe analysieren (aac)
[x] len Bytes von Anweisungen auf Referenzen analysieren (aar)
[x] Vtables prüfen
[ x] Type-Matching-Analyse für alle Funktionen (aaft)
[x] Norreturn-Informationen weitergeben
[x] Verwenden Sie -AA oder aaaa, um zusätzliche experimentelle Analysen durchzuführen.
[0x004004b0]> 

Das bedeutet, dass Sie jedes Mal, wenn Sie eine Binärdatei zur Analyse auswählen, einen zusätzlichen Befehl für aaa eingeben müssen nach dem Laden der Binärdatei. Sie können dies umgehen, indem Sie r2 mit -A aufrufen gefolgt vom binären Namen; dies weist r2 an, die Binärdatei automatisch für Sie zu analysieren:

$ r2 -A ./adder
[x] Analysiere alle Flags beginnend mit sym. und entry0 (aa)
[x] Funktionsaufrufe analysieren (aac)
[x] len Bytes von Anweisungen auf Referenzen analysieren (aar)
[x] Vtables prüfen
[ x] Type-Matching-Analyse für alle Funktionen (aaft)
[x] Noreturn-Informationen weitergeben
[x] Verwenden Sie -AA oder aaaa, um zusätzliche experimentelle Analysen durchzuführen.
 -- Bereits auf dem neuesten Stand- Datum.
[0x004004b0]> 

Besorgen Sie sich einige grundlegende Informationen über die Binärdatei

Bevor Sie mit der Analyse einer Binärdatei beginnen, benötigen Sie einen Ausgangspunkt. In vielen Fällen kann dies das Dateiformat der Binärdatei (ELF, PE usw.), die Architektur sein, für die die Binärdatei erstellt wurde (x86, AMD, ARM usw.) und ob die Binärdatei 32 Bit oder 64 Bit ist . R2s praktischer iI Befehl kann die erforderlichen Informationen bereitstellen:

[0x004004b0]> iI
arch     x86
baddr    0x400000
binsz    14724
bintype  elf
bits     64
canary   false
class    ELF64 
Compiler GCC:(GNU) 8.3.1 20190507 (Red Hat 8.3.1-4)
crypto   false
endian   little
havecode true
intrp    /lib64/ld -linux-x86-64.so.2
laddr    0x0
lang     c
linenum  true
lsyms    true
machine  AMD x86-64 architecture
maxopsz  16 
minopsz  1
nx       true
os       linux
pcalign  0
pic      false
relocs   true
relro    partial
rpath    NONE
sanitiz  false
static   false
stripped false
subsys   linux
va       true

[0x004004b0]> 
[0x004004b0]> 
Importe und Exporte
 

 Sobald Sie wissen, mit welcher Art von Datei Sie es zu tun haben, möchten Sie oft wissen, welche Art von Standardbibliotheksfunktionen die Binärdatei verwendet, oder die potenziellen Funktionalitäten des Programms kennenlernen. Im Beispiel-C-Programm in diesem Tutorial ist die einzige Bibliotheksfunktion printf um eine Nachricht auszudrucken. Sie können dies sehen, indem Sie ii ausführen Befehl, der alle Importe der Binärdatei anzeigt:
 
[0x004004b0]> ii
[Imports]
nth vaddr      bind   type   lib name
――――――――――――――――――――― ------------------ /> 1 0x00000000 schwachem nutype _Itm_deregistertmClonetable 
 2 0x004004A0 Global Func Printf 
 3 0x00000000 Global Func __LIBC_START_MAIN 
 4 0x00000000 schwach NOTYPE     __gmon_start__
5   0x00000000 WEAK   NOTYPE     _ITM_registerTMCloneTable
 

 Die Binärdatei kann auch ihre eigenen Symbole, Funktionen oder Daten haben. Diese Funktionen werden normalerweise unter Exports angezeigt . Die Test-Binärdatei hat zwei Funktionen – main und adder – die exportiert werden. Der Rest der Funktionen wird während der Kompilierungsphase hinzugefügt, wenn die Binärdatei erstellt wird. Der Loader benötigt diese, um die Binärdatei zu laden (machen Sie sich vorerst nicht allzu viele Gedanken darüber):
 
[0x004004b0]> 
[0x004004b0]> iE
[Exporte]

nth paddr       vaddr      bind   type   size lib name
――――――― ――――――――――――――――――――――――――――――――――――/> 82 0x00000650 0x00400650 Global Func 5 __LIBC_CSU_FINI 
 85 ----------- 0x00601024 Global Notype 0 _EDATA 
 86 0x00000658 0x00400658 Global Func 0 _FINI 
 89 0x00001020 0x00601020 Global Notype 0 __Data_start 
 90 0x00000596 0x00400596 Global Func 15 Addierer 
 92 0x00000670 0x00400670 Global obj 0 __dso_Handle 
 93 0x00000668 0x00400668 Globaler obj 4 _io_stdin_sused 
 94 0x000005E0 0x004005E0 Global Func 101 __libc_csu_init 
 95 - --------- 0x00601028 Global Notype 0 _end 
 96 0x000004E0 0x004004E0 Global Func 5 _dl_relocate_static_pie 
 97 0x000004B0 0x004004B0 Global Func 47 _START 
 98 ----------- - 0x00601024 GLOBAL NOTYPE 0        __bss_start
99   0x00000 5A5 0x004005A5 Global Func 55 MAIN 
 100 ---------- 0x00601028 Global obj 0 __tmc_end__ 
 102 0x00000468 0x00400468 Global Func 0 _init 
 
 [0x004004B0]> 
 
Hash-Informationen
 

 Woher wissen Sie, ob zwei Binärdateien ähnlich sind? Sie können eine Binärdatei nicht genau öffnen und den darin enthaltenen Quellcode anzeigen. In den meisten Fällen wird der Hash einer Binärdatei – md5sum, sha1, sha256 – verwendet, um sie eindeutig zu identifizieren. Sie können den binären Hash mithilfe von it finden Befehl:
 
 [0x004004b0]> es 
 md5 7e6732f2b11dec4a0c7612852cede670 
 SHA1 d5fa848c4b53021f6570dd9b18d115595a2290ae 
 sha256 13dd5a492219dac1443a816ef5f91db8d149e8edbf26f24539c220861769e1c2 
 [0x004004b0]> 
 
Funktionen
 

 Code ist in Funktionen gruppiert; Um aufzulisten, welche Funktionen in einer Binärdatei vorhanden sind, führen Sie afl aus Befehl. Die folgende Liste zeigt die Haupt- und Addiererfunktionen. Normalerweise Funktionen, die mit sym.imp beginnen werden aus der Standardbibliothek (in diesem Fall glibc) importiert:
 
 [0x004004B0]> AFL 
 0x004004B0 1 46 Eintrag0 
 0x004004F0 4 41 -> 34 sym.deregister_tm_clones 
 0x00400520 4 57 -> 51 sym.register_tm_clone 
 0x00400560 3 33 -> 32 sym .__ do_global_dtors_aux 
 0x00400590 1 6 Eintrag.Init0 
 0x00400650 1 5 sym .__ libc_csu_fini 
 0x00400658 1 13 sym._fini 
 0x00400596 1 15 sym.Adder 
 0x0040055E0 4 101 loc..annobin_elf_init.c 
 0x004004E0 1 5 loc..annobin_static_reloc.c 
 0x004005A5 1 55 main 
 0x004004A0 1 6 sym.imp.printf 
 0x00400468 3 27 sym. _init
[0x004004b0]> 
 
Querverweise
 

 In C ist die Hauptfunktion dort, wo ein Programm seine Ausführung beginnt. Idealerweise werden andere Funktionen von main aufgerufen, und beim Beenden eines Programms gibt die main-Funktion einen Beendigungsstatus an das Betriebssystem zurück. Dies ist im Quellcode ersichtlich; Was ist jedoch mit einer Binärdatei? Wie können Sie feststellen, wo die Addiererfunktion aufgerufen wird?
 

 Sie können das axt verwenden Befehl gefolgt vom Funktionsnamen, um zu sehen, wo die Addiererfunktion aufgerufen wird; Wie Sie unten sehen können, wird es von der Hauptfunktion aufgerufen. Dies wird als Querverweis bezeichnet. Aber was ruft die Hauptfunktion selbst auf? Die axt main Die folgende Funktion zeigt, dass sie von entry0 aufgerufen wird (Ich lasse das Lernen über entry0 als Übung für den Leser):
 
[0x004004b0]> axt sym.adder
main 0x4005b9 [CALL] call sym.adder
[0x004004b0]> 
[0x004004b0]> axt main
entry0 0x4004d1 [DATA ] mov rdi, main
[0x004004b0]> 
 
Orte suchen
 

 Beim Arbeiten mit Textdateien bewegen Sie sich häufig innerhalb einer Datei, indem Sie auf eine Zeilennummer gefolgt von einer Zeilen- oder Spaltennummer verweisen; In einer Binärdatei verwenden Sie Adressen. Dies sind Hexadezimalzahlen beginnend mit 0x gefolgt von einer Adresse. Um herauszufinden, wo Sie sich in einer Binärdatei befinden, führen Sie s aus Befehl. Um an einen anderen Ort zu wechseln, verwenden Sie die s Befehl gefolgt von der Adresse.
 

 Funktionsnamen sind wie Labels, die intern durch Adressen repräsentiert werden. Wenn sich der Funktionsname in der Binärdatei befindet (nicht entfernt), können Sie die s verwenden Befehl gefolgt vom Funktionsnamen, um zu einer bestimmten Funktionsadresse zu springen. Wenn Sie zum Anfang der Binärdatei springen möchten, geben Sie auf ähnliche Weise s 0 ein :
 
[0x004004b0]> s
0x4004b0
[0x004004b0]> 
[0x004004b0]> s main
[0x004005a5]> 
[0x004005a5]> s
0x4005a5
[0x004005a5]> 
[0x004005a5]> s sym.adder
[0x00400596]> 
[0x00400596]> s
0x400596
[ 0x00400596]> 
[0x00400596]> s 0
[0x00000000]> 
[0x00000000]> s
0x0
[0x00000000]> 
 
Hexadezimalansicht
 

 Oft macht die rohe Binärdatei keinen Sinn. Es kann hilfreich sein, die Binärdatei im Hexadezimalmodus neben ihrer äquivalenten ASCII-Darstellung anzuzeigen:
 
[0x004004b0]> s main
[0x004005a5]> 
[0x004005a5]> px
- offset -   0 1  2 3  4 5  6 7  8 9  A B  C D  E F  0123456789ABCDEF
0x004005a5  5548 89e5 4883 ec10 c745 fc64 0000 008b  UH..H....E.d....
0x004005b5  45fc 89c7 e8d8 ffff ff89 45f8 8b45 f889  E.........E..E. ... [email protected]
0x004005e5  5749 89d7 4156 4989 f641 5541 89fd 4154  WI..AVI..AUA..AT
0x004005f5  4c8d 2504 0820 0055 488d 2d04 0820 0055 488d 2d04 0820 0,05,3 % .UH.-.. .S
0x00400605  4c29 e548 83ec 08e8 57fe ffff 48c1 fd03  L).H....W...H...
0x00400615  741f 31db 0f1f 8000 0000 004c 89fa 4c89 t.1........L..L.
0x00400625  f644 89ef 41ff 14dc 4883 c301 4839 dd75 .D..A...H...H9.u
0x00400635  ea48 83c4 085b 5d41 5c41 5d41 5e41 5fc3  .H...[]A\A]A^A_.
0x00400645  9066 2e0f 1f84 0000 0000 00f3 0f1e fac3  .f............. .
0x00400655  0000 00f3 0f1e fa48 83ec 0848 83c4 08c3  .......H...H....
0x00400665  0000 0001 0002 0000 0000 0000 0000 0000  ................ 
0x00400675  0000 004e 756d 6265 7220 6e6f 7720 6973  ...Nummer ist jetzt
0x00400685  2020 3a20 2564 0a00 0000 0001 1b03 3b44    :%d........; 0000 0007 0000 0000 feff ff88 0000 0020  ................. 
[0x004005a5]> 
 
Demontage
 

 Wenn Sie mit kompilierten Binärdateien arbeiten, können Sie keinen Quellcode anzeigen. Der Compiler übersetzt den Quellcode in Anweisungen in Maschinensprache, die die CPU verstehen und ausführen kann; das Ergebnis ist die Binärdatei oder ausführbare Datei. Sie können jedoch Montageanweisungen (Mnemonik) anzeigen, um zu verstehen, was das Programm tut. Wenn Sie beispielsweise sehen möchten, was die main-Funktion macht, können Sie die Adresse der main-Funktion mit s main suchen und führen Sie dann das pdf aus Befehl, um die Demontageanweisungen anzuzeigen.
 

 Um die Assembleranweisungen zu verstehen, müssen Sie das Architekturhandbuch (in diesem Fall x86) und seine binäre Anwendungsschnittstelle (sein ABI oder Aufrufkonventionen) lesen und ein grundlegendes Verständnis dafür haben, wie der Stack funktioniert:
 
[0x004004b0]> s main
[0x004005a5]> 
[0x004005a5]> s
0x4005a5
[0x004005a5]> 
[0x004005a5]> pdf
           ; DATA XREF from entry0 @ 0x4004d1
┌ 55:int main (int argc, char **argv, char **envp);
│          ; var int64_t var_8h @ rbp-0x8
│          ; VAR INT64_T VAR_4H @ RBP-0x4 
 │ 0x004005A5 55 Push RBP 
 │ 0x004005A6 4889E5 MOV RBP, RSP 
 │ 0x004005A9 4883EC10 SUB RSP, 0x10 
 │ 0x004005AD C745FC640000. mov dword [var_4h], 0x64    ; 'd'; 100 
 │ 0x004005B4 8B45FC MOV EAX, DWORD [VAR_4H] 
 │ 0x004005B7 89c7 MOV EDI, EAX 
 │ 0x004005b9 E8D8FFFFFF-Anruf sym.Adder 
 │ 0x004005BE 8945F8 MOV DWORD [VAR_8H], EAX 
 │ 0x004005c1 8B45F8 MOV EAX, DWORD [VAR_8H] 
 │ 0x004005c4 89c6 MOV ESI, EAX 
 │ 0x004005c6 BF78064000 MOV EDI, STR.Number_now_is __:__ d; 0x400678; "Nummer ist jetzt  :%d\n"; const char *format
│           0x004005cb      b800000000     mov eax, 0
│           0x004005d0       e8cbfeffff     call sym.imp.printf        ; int printf (const char * format) 
 │ 0x004005D5 B800000000 MOV EAX, 0 
 │ 0x004005DA C9 verlassen 
 └ 0x004005DB C3 RET 
 [0x004005A5]> 
 

 Hier ist die Disassemblierung für die Addiererfunktion:
 
[0x004005a5]> s sym.adder
[0x00400596]> 
[0x00400596]> s
0x400596
[0x00400596]> 
[0x00400596]> pdf 
           ; CALL XREF from main @ 0x4005b9
┌ 15:sym.adder (int64_t arg1);
│          ; var int64_t var_4h @ rbp-0x4
│          ; Arg Int64_T ARG1 @ RDI 
 │ 0x00400596 55 Push RBP 
 │ 0x00400597 4889E5 MOV RBP, RSP 
 │ 0x0040059A 897DFC MOV DWORD [VAR_4H], EDI; Arg1 
 │ 0x0040059D 8B45FC MOV EAX, DWORD [VAR_4H] 
 │ 0x004005A0 83c001 Hinzufügen EAX, 1 
 │ 0x004005A3 5D POP RBP 
 └ 0x004005A4 C3 RET 
 [0x004005596]>
 
Strings
 

 Zu sehen, welche Zeichenfolgen in der Binärdatei vorhanden sind, kann ein Ausgangspunkt für die Binäranalyse sein. Zeichenfolgen sind in einer Binärdatei fest codiert und liefern oft wichtige Hinweise, um Ihren Fokus auf die Analyse bestimmter Bereiche zu verlagern. Führen Sie iz aus Befehl innerhalb der Binärdatei, um alle Zeichenfolgen aufzulisten. Die Test-Binärdatei hat nur eine Zeichenfolge, die in der Binärdatei fest codiert ist:
 
[0x004004b0]> iz
[Strings]
nth paddr      vaddr      len size section type  string
――――――――――――――――――― ------------------------------------------------------ /> 0 0x00000678 0x00400678 20 21.Rodata ascii nummer jetzt ist  :%d\n

[0x004004b0]> 
 
Querverweis-Strings
 

 Wie bei Funktionen können Sie Strings mit Querverweisen versehen, um zu sehen, woher sie gedruckt werden, und um den Code um sie herum zu verstehen:
 
[0x004004b0]> ps @ 0x400678
Nummer ist jetzt  :%d

[0x004004b0]> 
[0x004004b0]> axt 0x400678
main 0x4005c6 [DATA ] mov edi, str.Number_now_is__:__d
[0x004004b0]> 
 
Visueller Modus
 

 Wenn Ihr Code mit mehreren aufgerufenen Funktionen kompliziert ist, kann man sich leicht verirren. Es kann hilfreich sein, eine grafische oder visuelle Ansicht darüber zu haben, welche Funktionen aufgerufen werden, welche Pfade basierend auf bestimmten Bedingungen genommen werden usw. Sie können den visuellen Modus von r2 erkunden, indem Sie VV verwenden Befehl nach dem Wechsel zu einer Funktion von Interesse. Zum Beispiel für die Addiererfunktion:
 
[0x004004b0]> s sym.adder
[0x00400596]> 
[0x00400596]> VV
 

  
 
Debugger
 

 Bisher haben Sie statische Analysen durchgeführt – Sie sehen sich nur Dinge in der Binärdatei an, ohne sie auszuführen. Manchmal müssen Sie die Binärdatei ausführen und zur Laufzeit verschiedene Informationen im Speicher analysieren. Mit dem internen Debugger von r2 können Sie eine Binärdatei ausführen, Haltepunkte setzen, Variablenwerte analysieren oder Registerinhalte ausgeben.
 

 Starten Sie den Debugger mit dem -d Flag und fügen Sie das -A hinzu Flag, um eine Analyse durchzuführen, während die Binärdateien geladen werden. Sie können Breakpoints an verschiedenen Stellen, wie Funktionen oder Speicheradressen, setzen, indem Sie die db <function-name> verwenden Befehl. Um vorhandene Haltepunkte anzuzeigen, verwenden Sie dbi Befehl. Sobald Sie Ihre Haltepunkte gesetzt haben, starten Sie die Ausführung der Binärdatei mit dc Befehl. Sie können den Stack mit dbt anzeigen Befehl, der Funktionsaufrufe anzeigt. Schließlich können Sie den Inhalt der Register mit drr ausgeben Befehl:
 
$ r2 -d -A ./adder
Prozess mit PID 17453 gestartet...
=17453 17453 anhängen
bin.baddr 0x00400000
Using 0x400000
 asm.bits 64
[x] Analysiere alle Flags beginnend mit sym. und entry0 (aa)
[x] Funktionsaufrufe analysieren (aac)
[x] len Bytes von Anweisungen auf Referenzen analysieren (aar)
[x] Vtables prüfen
[ x] Type-Matching-Analyse für alle Funktionen (aaft)
[x] Noreturn-Informationen weitergeben
[x] Verwenden Sie -AA oder aaaa, um zusätzliche experimentelle Analysen durchzuführen.
 -- git checkout hamster
[0x7f77b0a28030]> 
[0x7f77b0a28030]> db main
[0x7f77b0a28030]> 
[0x7f77b0a28030]> db sym.adder
[0x7f77b0a28030]> 
[0x7f770.a.a ]> dbi
0 0x004005a5 E:1 T:0
1 0x00400596 E:1 T:0
[0x7f77b0a28030]> 
[0x7f77b0a28030]> afl | grep main
0x004005a5    1 55           main
[0x7f77b0a28030]> 
[0x7f77b0a28030]> afl | grep sym.adder
0x00400596    1 15           sym.adder
[0x7f77b0a28030]> 
[0x7f77b0a28030]> dc
Haltepunkt erreicht bei:0x4005a5
[0x004005a5]> 
 [0x004005A5]> DBT 
 0 0x4005A5 SP:0x0 0 [Haupt] Hauptsym.Adder + 15 
 1 0x7F77B0687873 SP:0x7Fe35FF6858 0 [??] Abschnitt..GNU.BUILD.ATTRIBUTS-1345820597 
2  0x7f77b0a36e0a     sp:0x7ffe35ff68e8      144  [??]  map.usr_lib64_ld_2.28.so.r_x+65034 
[0x004005a5]> dc
Haltepunkt erreicht bei:0x400596
[05x90][05x90]> DBT 
 0 0x400596 SP:0x0 0 [sym.Adder] RIP Entry.Init0 + 6 
 1 0x4005BE SP:0x7ffe35FF6838 0 [Haupt] Haupt + 25 
 2 0x7F77B0687873 SP:0x7Fe35FF6858 32 [ ??]  section..gnu.build.attributes-1345820597 
3  0x7f77b0a36e0a     sp:0x7ffe35ff68e8      144  [??]  map.usr_lib64_ld_2.28.so.r_x+65034 
[0x0040055] 
6]> [0x00400596]> 
[0x00400596]> dr
rax =0x00000064
rb x =0x00000000
rcx =0x7f77b0a21738
rdx =0x7ffe35ff6948
r8 =0x7f77b0a22da0
r9 =0x7f77b0a22da0
r10 =0x0000000f
r10 =0x0000000f
r10 =0x0000000f =0x004004b0
r13 =0x7ffe35ff6930
r14 =0x00000000
r15 =0x00000000
rsi =0x7ffe35ff6938
rdi =0x00000064 =0x7ffe35ff6.
rsp =0x7ffe35ff6 0x7ffe35ff6850
rip =0x00400596
rflags =0x00000202
orax =0xffffffffffffffff
[0x00400596]> 
 
Decompiler
 

 Die Fähigkeit, die Assemblierung zu verstehen, ist eine Voraussetzung für die binäre Analyse. Die Assemblersprache ist immer an die Architektur gebunden, auf der die Binärdatei aufgebaut ist und auf der sie ausgeführt werden soll. Es gibt niemals eine 1:1-Zuordnung zwischen einer Zeile Quellcode und Assemblercode. Oft erzeugt eine einzelne Zeile des C-Quellcodes mehrere Assemblerzeilen. Daher ist es nicht optimal, Assemblercode Zeile für Zeile zu lesen.
 

 Hier kommen Decompiler ins Spiel. Sie versuchen, den möglichen Quellcode anhand der Assembleranleitung zu rekonstruieren. Dies ist NIEMALS genau derselbe wie der Quellcode, der zum Erstellen der Binärdatei verwendet wurde; es ist eine genaue Darstellung der Quelle basierend auf der Montage. Berücksichtigen Sie auch, dass Compiler-Optimierungen, die unterschiedlichen Assembler-Code generieren, um die Dinge zu beschleunigen, die Größe einer Binärdatei zu reduzieren usw., die Arbeit des Decompilers erschweren. Außerdem verschleiern Malware-Autoren häufig absichtlich Code, um einen Malware-Analysten abzuschrecken.
 

 Radare2 bietet Decompiler über Plugins. Sie können jeden Decompiler installieren, der von Radare2 unterstützt wird. Zeigen Sie aktuelle Plugins mit dem r2pm -l an Befehl. Installieren Sie ein Beispiel r2dec Decompiler mit dem r2pm install Befehl:
 
$ r2pm  -l
$ 
$ r2pm installiere r2dec
Klonen in 'r2dec'...
remote:Objekte aufzählen:100, fertig.
remote :Objekte zählen:100 % (100/100), fertig.
remote:Objekte komprimieren:100 % (97/97), fertig.
remote:Gesamt 100 (Delta 18), wiederverwendet 27 (Delta 1), pack-reused 0
Empfangsobjekte:100% (100/100), 1,01 MiB | 1,31 MiB/s, fertig.
Auflösung von Deltas:100% (18/18), fertig.
Installation erledigt für r2dec
gmake:Verzeichnis '/root/.local/share/radare2 /r2pm/git/r2dec/p'
[CC] duktape/duktape.o
[CC] duktape/duk_console.o
[CC] core_pdd.o
[CC] core_pdd.so
gmake:Verzeichnis '/root/.local/share/radare2/r2pm/git/r2dec/p' verlassen
$ 
$ r2pm  -l
r2dec
$ 
 
Decompiler-Ansicht
 

 Um eine Binärdatei zu dekompilieren, laden Sie die Binärdatei in r2 und analysieren Sie sie automatisch. Wechseln Sie mithilfe von s sym.adder zur gewünschten Funktion – in diesem Beispiel adder Befehl, dann verwenden Sie den pdda Befehl, um die Assembly und den dekompilierten Quellcode nebeneinander anzuzeigen. Das Lesen dieses dekompilierten Quellcodes ist oft einfacher als das Lesen von Assembler Zeile für Zeile:
 
$ r2 -A ./adder
[x] Analysiere alle Flags beginnend mit sym. und entry0 (aa)
[x] Funktionsaufrufe analysieren (aac)
[x] len Bytes von Anweisungen auf Referenzen analysieren (aar)
[x] Vtables prüfen
[ x] Type-Matching-Analyse für alle Funktionen (aaft)
[x] Noreturn-Informationen weitergeben
[x] Verwenden Sie -AA oder aaaa, um zusätzliche experimentelle Analysen durchzuführen.
 -- Was möchten Sie tun? heute debuggen?
[0x004004b0]> 
[0x004004b0]> s sym.adder
[0x00400596]> 
[0x00400596]> s
0x400596
[ 0x00400596]> 
[0x00400596]> pdda
   ; Versammlung                               | /* r2dec-Pseudocodeausgabe */
                                             | /* ./adder @ 0x400596 */
                                             | #include 
                                             | 
   ; (fcn) sym.adder ()                     | int32_t Addierer (int64_t arg1) {
                                             | int64_t var_4h;
                                               | rdi =arg1;
    0x00400596 Push-rbp                      | 
    0x00400597 mov rbp, rsp                  | 
    0x0040059a mov dword [rbp - 4], edi      | *((rbp - 4)) =edi;
    0x0040059d mov eax, dword [rbp - 4]      | eax =*((rbp - 4));
    0x004005a0 add eax, 1                    | eax++;
    0x004005a3 pop rbp                       | 
    0x004005a4 ret                           | return eax;
                                             | }
[0x00400596]> 
 
Einstellungen konfigurieren
 

 Wenn Sie mit Radare2 vertrauter werden, werden Sie seine Konfiguration ändern wollen, um es an Ihre Arbeitsweise anzupassen. Sie können die Standardkonfigurationen von r2 mit e anzeigen Befehl. Um eine bestimmte Konfiguration festzulegen, fügen Sie config = value hinzu nach dem e Befehl:
 
[0x004005a5]> und | wc -l
593
[0x004005a5]> e | grep syntax
asm.syntax =intel
[0x004005a5]> 
[0x004005a5]> und asm.syntax =att
[0x004005a5]> 
[0x004005a5]> z | grep-Syntax
asm.syntax =att
[0x004005a5]> 
 

 Um die Konfigurationsänderungen dauerhaft zu machen, platzieren Sie sie in einer Startdatei mit dem Namen .radare2rc die r2 beim Start liest. Diese Datei befindet sich normalerweise in Ihrem Home-Verzeichnis; Wenn nicht, können Sie eine erstellen. Einige Beispielkonfigurationsoptionen umfassen:
 
$ cat ~/.radare2rc 
und asm.syntax =att
und scr.utf8 =true
eco solarized
und cmd.stack =true
e stack.size =256
$
 
Erkunden Sie mehr
 

 Sie haben genug Radare2-Funktionen gesehen, um sich im Tool zurechtzufinden. Da Radare2 der Unix-Philosophie folgt, verwendet es, obwohl Sie verschiedene Dinge von seiner Konsole aus erledigen können, einen separaten Satz von Binärdateien darunter, um seine Aufgaben zu erledigen.
 

 Erkunden Sie die unten aufgeführten eigenständigen Binärdateien, um zu sehen, wie sie funktionieren. Zum Beispiel die binären Informationen, die in der Konsole mit dem iI angezeigt werden Der Befehl kann auch mit rabin2 <binary> gefunden werden Befehl:
 
$ cd bin/
$ 
$ ls
Präfix  r2agent    r2pm  rabin2   radiff2  ragg2    rarun2   rasm2
r2      r2-indent  r2r   radare2  rafind2  rahash2  rasign2  rax2
$ 
 

 Was haltet ihr von Radare2? Teilen Sie Ihr Feedback in den Kommentaren.