Hackover CTF 2015 – easy-shell

This writeup describes the solution for the easy-shell challenge in Hackover CTF 2015 held by Chaos Computer Club Hamburg.

Hackover CTF 2015 - easy-shell - Task description

Lets first check what the binary does when executing.

ruport@zentaur:~/hackover2015$ ./easy_shell

        .-"; ! ;"-.
      .'!  : | :  !`.
     /\  ! : ! : !  /\
    /\ |  ! :|: !  | /\
   (  \ \ ; :!: ; / /  )
  ( `. \ | !:|:! | / .' )
  (`. \ \ \!:|:!/ / / .')
   \ `.`.\ |!|! |/,'.' /
    `._`.\\\!!!// .'_.'
       `.`.\\|//.'.'
        |`._`n'_.'| 
        "----^----">>

nom nom, shell> rup0rt

Some nice ascii art and data reading without output. Because this is a pwn challenge lets send much data in GDB and check the result.

nom nom, shell> AAAAAAAAAAA [300 * "A"]

Program received signal SIGSEGV, Segmentation fault.
0x41414141 in ?? ()

Wow, we already got EIP control – that will literally be an easy-shell :-). Lets check where to direct the EIP into a controlled code segment.
Continue reading

Hackover CTF 2015 – easy-math

This writeup describes the solution for the easy-math challenge in Hackover CTF 2015 held by Chaos Computer Club Hamburg.

The task describes some basic arithmetics to warm up:

Hackover CTF 2015 - easy-math - task description

This file was published: easy-math.tar.gz. It is a 32bit ELF executable. Running the file shows this output:

ruport@zentaur:~/hackover2015$ ./easy_math
Warmup: sh0w m3 h0w 1337 y0u 4r3> rup0rt

It reads some data and does stuff with it. I gonna try GDB to have a detailed look in the operations.
So lets set a breakpoint after the read() functions and single step (si).

(gdb) b *0x0804855d
Breakpoint 1 at 0x804855d
(gdb) display /i $eip
(gdb) run
Starting program: /home/ruport/hackover2015/easy_math 
Warmup: sh0w m3 h0w 1337 y0u 4r3> AAAABBBBCCCC

(gdb) CC
Undefined command: "CC". Try "help".
1: x/i $eip
=> 0x804855d <main+153>:	add    esp,0x10

We already recognize that the binary only takes 10 bytes of input because, 2 bytes of our input (CC) is already passed back to GDB. Then the program does some compares. One of them is very interesting because it checks our input data:
Continue reading

Hack.Lu CTF 2013 – FluxArchiv (1)

Hack.lU 2013 CTF - FluxArchiv (Part 1) - Task Description

Die Challenge “FluxArchiv (Part 1)” befasst sich mit einer Archivierungssoftware. Damit können Archive erstellt und mit Passwörtern versehen werden. Außerdem erhalten wir die Information, dass ein Archiv mit einem sechsstelligen Passwort versehen wurde, dass nur Großbuchstaben und Zahlen beinhaltet. Zusätzlich zur Beschreibung erhalten wir diese Dateien.

Dabei handelt es sich um ein 64bit Linux-Binary (die Archivierungssoftware) und ein damit verschlüsseltes Archiv. Die Software führen wir direkt einmal aus.

ruport@lambda:~$ ./archiv 

################################################################################

FluxArchiv - solved security since 2007!
Written by sqall - leading expert in social-kernel-web-reverse-engineering.

################################################################################

Unknown or invalid command.

Usage: ./archiv <command> <archiv> <password> <file>
commands:
-l <archiv> <password> - lists all files in the archiv.
-a <archiv> <password> <file> - adds a file to the archiv (when archiv does not exist create a new archiv).
-x <archiv> <password> <filename> - extracts the given filename from the archiv.
-d <archiv> <password> <filename> - delete the given filename from the archiv.

Es können mehrere Operationen durchgeführt werden. Wir probieren testweise das Anzeigen der beinhalteten Dateien des Archives.

rup0rt@lambda:~$ ./archiv -l FluxArchiv.arc rup0rt

################################################################################

FluxArchiv - solved security since 2007!
Written by sqall - leading expert in social-kernel-web-reverse-engineering.

################################################################################

Given password is not correct.

Continue reading

Hack.Lu CTF 2013 – RoboAuth

Hack.Lu 2013 CTF - RoboAuth - Task Description

Die “RoboAuth”-Challenge erzählt von einem Authentisierungssystem und übergibt uns ein Binary, das wir analysieren sollen um zwei Passwörter als Flagge zu erhalten. In guter Manier starten wir das fremde Programm natürlich erstmal als Administrator 😉

Hack.Lu 2013 CTF - RoboAuth - First run

Wir werden zur Eingabe des ersten Passwortes aufgefordert. Jeder fehlerhafte Versuch führt direkt zum Abbruch der Programmausführung. Nutzen wir also den Immunity Debugger um das Programm zu untersuchen.

Dazu starten wir das Programm im Debugger und Pausieren sobald die Passwort abfrage erscheint. Nun geben wir das Passwort ein lassen das Binary so lange weiter arbeiten (continue until return) bis wir in das Code Segment des Programmes zurück kehren. Im Ergebnis landen wir direkt an der Position, wo das Passwort auf Korrektheit überprüft wird:

Hack.Lu 2013 CTF - RoboAuth - First compare for password
Continue reading

NcN 2013 CTF Quals – Level 3

To access “Level 3” of the NcN CTF we first need to download the file (level.elf) the server offers. Running the program for the first time shows the following output:

NcN 2013 Quals - level 3 - program first run

The binary waits for user input. After pressing one key, it denies access with the message “I DON’T THINK SO”. Maybe we need to press another key to that one I pressed before. I tried all keys and finally got this result when pressing “SPACE”.

NcN 2013 Quals - Level 3 - First character found

It displays an additional star to indicate that our first character (SPACE) was right. Pressing SPACE again leads to program failure again. What we need to do is just gaining the full passphrase. This can be achieved by brute forcing it – the same way we found the first character – or by analyzing the binary code.

A first look into the assembler code of the binary shows some obfuscation inside. So I decided that brute forcing the key will be much faster. The following PERL Script does the job for us:

#!/usr/bin/perl -w

$found = $ARGV[0];

for ($i = 0x20; $i<=0x7f; $i++) {
  $try = $found . chr($i);
  print "TRYING: $try ($i)\n";

  open(CRACK, "| ./level.elf");
  print CRACK $try;
  close(CRACK);
}

At first it takes one argument that contains the beginning of the string, we already verified. Afterwards the script just tries to append all human-readable characters to the string and passes it to the binary. The result is printed on the screen.
Continue reading

EBCTF Teaser 2013 – BIN100

EBCTF Teaser 2013 - BIN100 - task description

Die BIN100 Challenge (“Dice Game”) verlangt von uns, das “Würfelspiel” zu schlagen und so die Flagge zu erhalten. Bei dem Würfelspiel handelt es sich um diese EXE-Datei, die wir auch direkt ausführen.

EBCTF Teaser 2013 - BIN100 - dice game

Wir sehen, dass das Programm Würfel simuliert, die per Zufall geworfen werden. Beim ersten Wurf war es mir hier noch aus eigener Kraft möglich, die Bedingung, eine Drei zu würfeln zu erfüllen ;-). Beim zweiten Wurf jedoch war der Zufall nicht mehr auf unserer Seite.

Es sieht also nach danach aus, das Programm binär manipulieren zu müssen, weshalb wir es in den Immunity Debugger laden. Wir starten das Programm, lassen es bis zur Eingabeaufforderung laufen und übernehmen dann mit dem Debugger. Dabei stößt man schnell auf folgenden Programmteil:

EBCTF Teaser 2013 - BIN100 - rand function assembler
Continue reading

plaidCTF 2013 – hypercomputer 1

plaidCTF 2013 - Hypercomputer 1 - Task description

Diese Challenge (hypercomputer 1) erinnert nicht nur vom Namen her an die Supercomputer-Challenge aus dem vorjährigen plaidCTF 2012. Auch die Aufgabenstellung selbst weist bereits auf diese Challenge hin und vermerkt, dass es diesmal einfacher sein soll. Neben der Beschreiben erhalten wir die IP-Adresse eines SSH-Servers von dem wir uns dieses Binary kopieren.

Eine erste Untersuchung zeigt uns…

root@linux64:~/Plaid2013# file hypercomputer 
hypercomputer: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.24, BuildID[sha1]=0x0b7c8d904831417f536c59b59fdecfc738136536, stripped

…, dass es sich um ein 64bit Linux-Binary handelt, das beim normalen, testweisen Ausführen diese Ausgabe liefert:

root@linux64:~/Plaid2013# ./hypercomputer 
...Welcome to Hypercomputer!...
...This could take a very long time...

Es ist jedoch nicht so, dass dieser Text sofort erscheint – vielmehr dauert es mehrere Sekunden, was darauf schließen lässt, wie lange die gesamte Berechnung und Ausgabe der Flagge dauern könnte. Im letzten Jahr musste der Assembler-Code per Hand untersucht und optimiert werden, also sehen wir uns auch diesmal das Programm im Debugger an.

root@linux64:~/Plaid2013# gdb ./hypercomputer 
GNU gdb (GDB) 7.4.1-debian
Reading symbols from /root/Plaid2013/hypercomputer...(no debugging symbols found)...done.
(gdb) run
Starting program: /root/Plaid2013/hypercomputer 
...Welcome to Hypercomputer!...
...This could take a very long time...
^C
Program received signal SIGINT, Interrupt.
0x00007ffff787cbc0 in nanosleep () from /lib/x86_64-linux-gnu/libc.so.6

Durch die Unterbrechung der Programmausführung mit CTRL+C sehen wir, dass die Ausführung in der Funktion nanosleep(), die eine bestimmte Zeit abwartet, angehalten wurde. Dies erinnert schon an das Vorjahr, in dem der Programmablauf ebenfalls durch solche Funktionen künstlich verzögert wurde.
Continue reading

plaidCTF 2013 – three eyed fish

plaidCTF 2013 - three eyed fish - task description

Diese Challenge (three eyed fish) verrät zunächst nicht viel über das eigentliche Ziel. Nur eine Binärdatei wird zum Download bereit gestellt und der legendäre “Ban Hammer” als Belohnung für dieses Quest versprochen 😉

rup0rt@linux64:~/Plaid2013# file three_eyed_fish
three_eyed_fish: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.18, stripped

Eine erste Untersuchung ergibt, dass es sich um ein 64bit Linux-Binary handelt. Um das normale Verhalten des Programmes zu testen, starten wir die Datei direkt.

rup0rt@linux64:~/Plaid2013# ./three_eyed_fish

Eine Ausgabe erzeugt das Programm nach dem Starten nicht. Beendet wird es jedoch auch nicht sofort – es muss also eine andere Funktion geben. Nach weiterer Betrachtung stellt man fest, dass immer nach dem Starten die Umschalt-LED des Keyboards aufleuchtet und zu blinken beginnt.

Die LED blinkt jedoch nicht einheitlich oder nach einem festen Muster. Alles was erkennbar ist, dass regelmäßig größere Pausen zwischen den Sequenzen liegen. Es könnte sich demnach um eine Art Morse-Code handeln, wobei die Pausen die Trennung zwischen den einzelnen Buchstaben darstellt.
Continue reading