Adding hacklu and ekoparty writeups

Author: Pharisaeus

2015-10-20 hacklu/README.md

@@ -0,0 +1,28 @@
+# Writeup Hack.lu CTF 2015
+
+Uczestniczyliśmy (msm, Rev, Shalom, other019, nazywam i pp) w Hack.lu CTF, i znowu spróbujemy opisać zadania z którymi walczyliśmy (a przynajmniej te, które pokonaliśmy).
+
+Ogólne wrażenia:
+- CTF w środku tygodnia = bardzo słaby pomysł bo wszyscy w pracy albo w szkole więc na CTFa zostaje tylko kilka godzin...
+
+Opisy zadań po kolei.
+
+# Spis treści / Table of contents:
+* Module Loader 100+10 
+* PHP Golf 75+70
+* Stackstuff 150+80
+* Bashful 200+40
+* Creative Cheating 150+60
+* Checkcheckcheck 150+80
+* Perl Golf 75+50
+* Teacher's Pinboard 352+100
+* Secret Library 200+70 
+* Grading Board 300+80
+* [GuessTheNumber (ppc 150+80)](ppc150_guess_the_number)
+* GuessTheNumber 150+80
+* Salt 200+90
+* Dr. Bob 150+80
+
+# Zakończenie
+
+Zachęcamy do komentarzy/pytań/czegokolwiek.

2015-10-20 hacklu/ppc150_guess_the_number/README.md

@@ -0,0 +1,151 @@
+## GuessTheNumber (ppc, 150+80p)
+
+	The teacher of your programming class gave you a tiny little task: just write a guess-my-number script that beats his script. He also gave you some hard facts:
+	he uses some LCG with standard glibc LCG parameters
+	the LCG is seeded with server time using number format YmdHMS (python strftime syntax)
+	numbers are from 0 up to (including) 99
+	numbers should be sent as ascii string
+	You can find the service on school.fluxfingers.net:1523
+
+### PL
+[ENG](#eng-version)
+
+Pierwsze podejście do zadania polegało na implementacji opisanego w zadaniu LCG i próbie dopasowania wyników do zgadywanki z serwera. Jednak bardzo szybko uznaliśmy, że możliwości jest bardzo dużo i nie ma sensu ich analizować skoro da się to zadanie wykonać dużo prościej.
+Do zgadnięcia mamy zaledwie 100 liczb pod rząd a rozdzielczość zegara na serwerze to 1s. W związku z tym uznaliśmy, że prościej i szybciej będzie po prostu oszukiwać w tej grze :)
+
+Wiemy że liczby generowane są przez LCG co oznacza, że dla danego seeda liczby do zgadnięcia są zawsze takie same. W szczególności jeśli dwóch użytkowników połączy się w tej samej sekundzie to wszystkie 100 liczb do zgadnięcia dla nich będzie takie samo. Dodatkowo serwer zwraca nam liczbę której oczekiwał jeśli się pomylimy.
+
+Nasze rozwiązanie jest dość proste:
+
+* Uruchamiamy 101 wątków, które w tej samej sekundzie łączą się z docelowym serwerem.
+* Synchronizujemy wątki tak, żeby wszystkie zgadywały jedną turę w tej samej chwili a następnie czekały aż wszystkie skończą.
+* W każdej turze wszystkie wątki oprócz jednego czekają na liczbę do wysłania.
+* W każdej iteracji jeden wątek "poświęca się" wysyłając -1 jako odpowiedź, a następnie odbiera od serwera poprawną odpowiedź i informuje o niej pozostałe wątki.
+* W efekcie co turę "tracimy" jeden wątek, ale wszystkie pozostałe przechodzą do następnej tury podając poprawną odpowiedź.
+
+Każdy wątek realizuje poniższy kod:
+
+```python
+max = 101
+threads = Queue()
+correct_values = Queue()
+init_barier = threading.Barrier(max)
+init_barier_seeds = threading.Barrier(max)
+bar = [threading.Barrier(max - i) for i in range(max)]
+seeds = set()
+
+
+def worker(index):
+    threads.get()
+    init_barier.wait()
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.connect(("school.fluxfingers.net", 1523))
+    initial_data = str(s.recv(4096))
+    seeds.add(parse_seed(initial_data))
+    init_barier_seeds.wait()
+    if len(seeds) != 1:  # make sure we all start with the same seed, otherwise quit
+        threads.task_done()
+        return
+    for i in range(max):
+        bar[i].wait() #wait on the barrier for all other threads
+        if i == index:  # suicide thread
+            value = -1
+        else:
+            value = correct_values.get()
+        s.send(bytes(str(value) + "\n", "ASCII"))
+        data = str(s.recv(4096))
+        print("thread " + str(index) + " iteration " + str(i) + " " + data)
+        if "wrong" in data.lower():
+            correct = re.compile("'(\d+)'").findall(data)[0]
+            for j in range(max - i - 1):  # tell everyone what is the right number
+                correct_values.put(correct)
+            break
+    threads.task_done()
+```
+
+Kompletny skrypt dostępny [tutaj](guess.py)
+
+Uruchamiamy skrypt i dostajemy:
+```
+thread 98 iteration 97 b'Correct! Guess the next one!\n'
+thread 99 iteration 97 b'Correct! Guess the next one!\n'
+thread 100 iteration 97 b'Correct! Guess the next one!\n'
+thread 98 iteration 98 b"Wrong! You lost the game. The right answer would have been '38'. Quitting."
+thread 99 iteration 98 b'Correct! Guess the next one!\n'
+thread 100 iteration 98 b'Correct! Guess the next one!\n'
+thread 99 iteration 99 b"Wrong! You lost the game. The right answer would have been '37'. Quitting."
+thread 100 iteration 99 b"Congrats! You won the game! Here's your present:\nflag{don't_use_LCGs_for_any_guessing_competition}"
+```
+
+`flag{don't_use_LCGs_for_any_guessing_competition}`
+
+### ENG version
+
+Initial attempt for this task was to implement described LCG and trying to match the output for the results on the server. But we instantly decided that there are too many possibilities and there is no point in wasting time for analysis when we can do it much easier.
+We need to guess only 100 numbers in a row and the clock resolution on the server is just 1s. So we decided that it will be better and faster just to cheat the game :)
+
+We know that the numbers are generated with LCG which means that for given seed the numbers are always the same. In particular, if two users connect at the same time the 100 numbers to guess will be identical. On top of that the server returns the expected number if we make a mistake.
+
+Our solution was quite simple:
+
+* Run 101 threads, which will connect to the server at the same time.
+* Synchronize the threads so that they all execute a single turn and the wait for the rest.
+* In each turn all threads but one are waiting for the number to send.
+* In each turn one thread "sacrifices himself" sending -1 as answer, and the collects the correct number form server response and informs rest of the threads about it.
+* As a result in each turn we "lose" one thread but all the others pass to the next round.
+
+Eaach thread executes:
+
+```python
+max = 101
+threads = Queue()
+correct_values = Queue()
+init_barier = threading.Barrier(max)
+init_barier_seeds = threading.Barrier(max)
+bar = [threading.Barrier(max - i) for i in range(max)]
+seeds = set()
+
+
+def worker(index):
+    threads.get()
+    init_barier.wait()
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.connect(("school.fluxfingers.net", 1523))
+    initial_data = str(s.recv(4096))
+    seeds.add(parse_seed(initial_data))
+    init_barier_seeds.wait()
+    if len(seeds) != 1:  # make sure we all start with the same seed, otherwise quit
+        threads.task_done()
+        return
+    for i in range(max):
+        bar[i].wait() #wait on the barrier for all other threads
+        if i == index:  # suicide thread
+            value = -1
+        else:
+            value = correct_values.get()
+        s.send(bytes(str(value) + "\n", "ASCII"))
+        data = str(s.recv(4096))
+        print("thread " + str(index) + " iteration " + str(i) + " " + data)
+        if "wrong" in data.lower():
+            correct = re.compile("'(\d+)'").findall(data)[0]
+            for j in range(max - i - 1):  # tell everyone what is the right number
+                correct_values.put(correct)
+            break
+    threads.task_done()
+```
+
+Complete script is [here](guess.py).
+
+We run the script and we get:
+```
+thread 98 iteration 97 b'Correct! Guess the next one!\n'
+thread 99 iteration 97 b'Correct! Guess the next one!\n'
+thread 100 iteration 97 b'Correct! Guess the next one!\n'
+thread 98 iteration 98 b"Wrong! You lost the game. The right answer would have been '38'. Quitting."
+thread 99 iteration 98 b'Correct! Guess the next one!\n'
+thread 100 iteration 98 b'Correct! Guess the next one!\n'
+thread 99 iteration 99 b"Wrong! You lost the game. The right answer would have been '37'. Quitting."
+thread 100 iteration 99 b"Congrats! You won the game! Here's your present:\nflag{don't_use_LCGs_for_any_guessing_competition}"
+```
+
+`flag{don't_use_LCGs_for_any_guessing_competition}`

2015-10-20 hacklu/ppc150_guess_the_number/guess.py

@@ -0,0 +1,60 @@
+from queue import Queue
+import socket
+import threading
+import re
+
+
+def parse_seed(data):
+    pattern = re.compile(".*(\d{2})\\.(\d{2})\\.(\d{4}).*(\d{2}):(\d{2}):(\d{2})", re.MULTILINE | re.DOTALL)
+    seed = pattern.findall(data)[0]
+    return int(str.format("{2}{1}{0}{3}{4}{5}", *seed))
+
+
+max = 101
+threads = Queue()
+correct_values = Queue()
+init_barier = threading.Barrier(max)
+init_barier_seeds = threading.Barrier(max)
+bar = [threading.Barrier(max - i) for i in range(max)]
+seeds = set()
+
+
+def worker(index):
+    threads.get()
+    init_barier.wait()
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.connect(("school.fluxfingers.net", 1523))
+    initial_data = str(s.recv(4096))
+    seeds.add(parse_seed(initial_data))
+    init_barier_seeds.wait()
+    if len(seeds) != 1:  # make sure we all start with the same seed, otherwise quit
+        threads.task_done()
+        return
+    for i in range(max):
+        bar[i].wait() #wait on the barrier for all other threads
+        if i == index:  # suicide thread
+            value = -1
+        else:
+            value = correct_values.get()
+        s.send(bytes(str(value) + "\n", "ASCII"))
+        data = str(s.recv(4096))
+        print("thread " + str(index) + " iteration " + str(i) + " " + data)
+        if "wrong" in data.lower():
+            correct = re.compile("'(\d+)'").findall(data)[0]
+            for j in range(max - i - 1):  # tell everyone what is the right number
+                correct_values.put(correct)
+            break
+    threads.task_done()
+
+
+def conn():
+    for i in range(max):
+        thread = threading.Thread(target=worker, args=[i])
+        thread.daemon = True
+        thread.start()
+    for i in range(max):
+        threads.put(i)
+    threads.join()
+
+
+conn()

2015-10-22-ekoparty/README.md

@@ -0,0 +1,27 @@
+# Writeup Ekoparty CTF 2015
+
+Uczestniczyliśmy (msm, Rev, Shalom, other019, nazywam i pp) w Ekoparty CTF, i znowu spróbujemy opisać zadania z którymi walczyliśmy (a przynajmniej te, które pokonaliśmy).
+
+Ogólne wrażenia:
+
+Opisy zadań po kolei.
+
+# Spis treści/Table of contents:
+
+* Slogans (trivia 50)
+* Banner (trivia 70)
+* Mr Anderson (trivia 80)
+* SSL Attack (trivia 90)
+* Pass Check (web 50)
+* Crazy JSON (web 200)
+* Rand DOOM (web 300)
+* SCYTCRYPTO (crypto 50)
+* [XOR Crypter (crypto 200)](crpto_200_xorcrypter)
+* Patch me (reverse 50)
+* Malware (reverse 200)
+* Olive (misc 50)
+
+
+# Zakończenie
+
+Zachęcamy do komentarzy/pytań/czegokolwiek.

2015-10-22-ekoparty/crpto_200_xorcrypter/README.md

@@ -0,0 +1,52 @@
+## XOR Crypter (crypto 200p)
+
+	Description: The state of art on encryption, can you defeat it?
+	CjBPewYGc2gdD3RpMRNfdDcQX3UGGmhpBxZhYhFlfQA= 
+
+### PL
+[ENG](#eng-version)
+
+Cały kod szyfrujący jest [tutaj](shiftcrypt.py).
+Szyfrowanie jest bardzo proste, aż dziwne że zadanie było za 200 punktów. Szyfrowanie polega na podzieleniu wejściowego tekstu na 4 bajtowe kawałki (po dodaniu paddingu jeśli to konieczne, aby rozmiar wejścia był wielokrotnością 4 bajtów), rzutowanie ich na inta a następnie wykonywana jest operacja `X xor X >>16`. Jeśli oznaczymy kolejnymi literami bajty tego inta uzyskujemy: 
+
+`ABCD ^ ABCD >> 16 = ABCD ^ 00AB = (A^0)(B^0)(C^A)(D^B) = AB(C^A)(D^B)`
+
+Jak widać dwa pierwsze bajty są zachowywane bez zmian a dwa pozostałe bajty są xorowane z tymi dwoma niezmienionymi. Wiemy także że xor jest operacją odwracalną i `(A^B)^B = A` możemy więc odwrócić szyfrowanie dwóch ostatnich bajtów xorując je jeszcze raz z pierwszym oraz drugim bajtem (pamiętając przy tym o kolejności bajtów)
+
+```python
+data = "CjBPewYGc2gdD3RpMRNfdDcQX3UGGmhpBxZhYhFlfQA="
+decoded = base64.b64decode(data)
+blocks = struct.unpack("I" * (len(decoded) / 4), decoded)
+output = ''
+for block in blocks:
+	bytes = map(ord, struct.pack("I", block))
+	result = [bytes[0] ^ bytes[2], bytes[1] ^ bytes[3],  bytes[2], bytes[3]]
+	output += "".join(map(chr, result))
+print(output)
+```
+
+W wyniku czego uzyskujemy flagę: `EKO{unshifting_the_unshiftable}`
+
+### ENG version
+
+
+Cipher code is [here](shiftcrypt.py).
+The cipher is actually very simple, it was very strange that the task was worth 200 point. The cipher splits the input text in 4 byte blocks (after adding padding if necessary so that the input is a multiply of 4 bytes), casting each block to integer and the performing `X xor X >>16`. If we mark each byte of the single block with consecutive alphabet letters we get:
+
+`ABCD ^ ABCD >> 16 = ABCD ^ 00AB = (A^0)(B^0)(C^A)(D^B) = AB(C^A)(D^B)`
+
+As can be notices, first two bytes are unchanged and last two are xored with those two unchanged. We also know that xor is reversible and `(A^B)^B = A` so we can revert the cipher of the last two bytes by xoring them again with first and second byte (keeping in mind the byte order).
+
+```python
+data = "CjBPewYGc2gdD3RpMRNfdDcQX3UGGmhpBxZhYhFlfQA="
+decoded = base64.b64decode(data)
+blocks = struct.unpack("I" * (len(decoded) / 4), decoded)
+output = ''
+for block in blocks:
+	bytes = map(ord, struct.pack("I", block))
+	result = [bytes[0] ^ bytes[2], bytes[1] ^ bytes[3],  bytes[2], bytes[3]]
+	output += "".join(map(chr, result))
+print(output)
+```
+
+As a result we get: `EKO{unshifting_the_unshiftable}`

2015-10-22-ekoparty/crpto_200_xorcrypter/shiftcrypt.py

@@ -0,0 +1,23 @@
+import struct
+import sys
+import base64
+
+if len(sys.argv) != 2:
+    print "Usage: %s data" % sys.argv[0]
+    exit(0)
+
+data = sys.argv[1]
+padding = 4 - len(data) % 4
+if padding != 0:
+    data = data + "\x00" * padding
+
+result = []
+blocks = struct.unpack("I" * (len(data) / 4), data)
+for block in blocks:
+    result += [block ^ block >> 16]
+
+output = ''
+for block in result:
+    output += struct.pack("I", block)
+
+print base64.b64encode(output)

README.md

@@ -1,5 +1,7 @@
 # CTF writeups from P4 Team
 
+* [2015.10.18 **Ekoparty CTF 2015** (28th place / 356 teams)](2015-10-22-ekoparty)
+* [2015.10.18 **Hack.lu CTF 2015** (17th place / 248 teams)](2015-10-20 hacklu)
 * [2015.10.18 **Hitcon CTF 2015** (22th place / 382 teams)](2015-10-18-hitcon)
 * [2015.10.10 **ASIS CTF Finals 2015** (17th place / 197 teams)](2015-10-10-asisfin)
 * [2015.10.02 **Defcamp CTF Qualification 2015** (17th place / 378 teams)](2015-10-02-dctf)