# False Flags

`falseFlags` ist eine einsteigerfreundliche Reverse-Engineering-Challenge. Wir erhalten eine Binärdatei, die mehrere "falsche" Flaggen enthält, und unser Ziel ist es, die richtige zu identifizieren.

## 1. Erste Analyse

Wir beginnen mit der Untersuchung des Dateityps und der grundlegenden Eigenschaften.

```bash
$ file false_flags
false_flags: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, BuildID[sha1]=..., for GNU/Linux 3.2.0, stripped
```

Es ist eine Standard-64-Bit-ELF-ausführbare Datei. Versuchen wir, sie auszuführen. Die Challenge ist auch remote verfügbar unter `<SERVER_IP>:1301`.

```bash
$ nc <SERVER_IP> 1301
=== The Vault of Falsehoods ===
There are many keys, but only one opens the door.
Enter the password: test
[-] Wrong! That was merely a decoy.
```

Da die Beschreibung "versteckte Passwörter in der Binärdatei" erwähnt, ist der `strings`-Befehl ein guter erster Schritt, um zu sehen, was drin ist.

```bash
$ strings false_flags | grep flag
{flag:This_Is_Definitely_Not_It}
{flag:Try_Harder_To_Find_The_Key}
{flag:Strings_Are_Misleading_You}
...
{flag:Reverse_Engineering_Is_Cool}
...
```

Wir sehen eine lange Liste potenzieller Flaggen. Wir könnten sie eine nach der anderen ausprobieren, aber das ist mühsam (und "Brute-Force" ist nicht der elegante Weg!). Wir müssen herausfinden, mit *welchem* spezifischen String das Programm unsere Eingabe vergleicht.

## 2. Statische Analyse

Wir können die Binärdatei mit `objdump` analysieren, um uns den Assembler-Code anzusehen. Da die Binärdatei "stripped" ist, sehen wir keine Funktionsnamen wie `main`. Wir können jedoch den Einsprungpunkt finden.

```bash
$ readelf -h false_flags | grep "Entry point"
  Entry point address:               0x4019f0
```

Der Einsprungpunkt ist bei `0x4019f0`. Wenn wir an dieser Adresse disassemblieren, sehen wir den Startcode (`_start`), der `__libc_start_main` aufruft. Das erste Argument für `__libc_start_main` ist die Adresse von `main`.

```bash
$ objdump -d -M intel --start-address=0x4019f0 --stop-address=0x401a20 false_flags

00000000004019f0 <.text+0x830>:
  ...
  401a08:       48 c7 c7 52 1b 40 00    mov    rdi,0x401b52  <-- Adresse von main
  401a0f:       67 e8 5b 15 00 00       addr32 call 0x402f70 <-- Aufruf von __libc_start_main
  ...
```

Also befindet sich `main` bei `0x401b52`. Disassemblieren wir sie.

```bash
$ objdump -d -M intel --start-address=0x401b52 --stop-address=0x401c50 false_flags
```

In der Ausgabe sehen wir früh in der Funktion einen Aufruf:

```assembly
  401ba0:       e8 70 ff ff ff          call   0x401b15
  401ba5:       89 85 6c ff ff ff       mov    DWORD PTR [rbp-0x94],eax
```

Der Rückgabewert (in `eax`) wird in `[rbp-0x94]` gespeichert. Diese Variable wird später verwendet, um auf ein Array zuzugreifen. Schauen wir uns an, was `0x401b15` tut.

```bash
$ objdump -d -M intel --start-address=0x401b15 --stop-address=0x401b52 false_flags

0000000000401b15 <.text+0x955>:
  ...
  401b4b:       b8 0c 00 00 00          mov    eax,0xc
  401b50:       5d                      pop    rbp
  401b51:       c3                      ret
```

Trotz einiger Schleifenlogik davor gibt die Funktion letztendlich `0xc` (dezimal 12) zurück. Dieser Index wird verwendet, um die richtige Flagge aus dem Array von Strings auszuwählen, die wir früher gesehen haben.

## 3. Die Lösung

Jetzt müssen wir einfach den String am Index 12 (beginnend bei 0) in der Liste finden, die wir früher gefunden haben.

0. {flag:This_Is_Definitely_Not_It}
1. {flag:Try_Harder_To_Find_The_Key}
2. {flag:Strings_Are_Misleading_You}
...
10. {flag:Do_Not_Trust_Simple_Strings}
11. {flag:Index_Twelve_Is_Not_Real_11}
12. {flag:Reverse_Engineering_Is_Cool}

Der String bei Index 12 ist:
`{flag:Reverse_Engineering_Is_Cool}`

Überprüfen wir dies, indem wir uns mit dem Remote-Server verbinden:

```bash
$ nc <SERVER_IP> 1301
=== The Vault of Falsehoods ===
There are many keys, but only one opens the door.
Enter the password: {flag:Reverse_Engineering_Is_Cool}

[+] Correct! Access Granted.
[*] The flag is indeed: {flag:Reverse_Engineering_Is_Cool}
```

## Fazit

Diese Challenge zeigt, dass `strings` zwar interessante Daten offenbaren kann, das Verständnis der *Logik* (Kontrollfluss) des Programms jedoch oft notwendig ist, um nützliche Daten von Täuschungen zu unterscheiden.