adding writeups for mindblown, dtune, isolv and pwn

Author: Pharisaeus

2016-06-04-backdoor-ctf/crypto_mindblown/README.md

@@ -3,4 +3,96 @@
 ###ENG
 [PL](#pl-version)
 
+We are given authentication logic running on the server:
+
+```
+var express = require('express');
+var app = express();
+var port = process.env.PORT || 9898;
+var crypto = require('crypto');
+var bodyParser = require('body-parser')
+var salt = 'somestring';
+var iteration = /// some number here;
+var keylength = // some number here;
+
+app.post('/login', function (req, res) {
+	var username = req.body.username;
+	var password = req.body.password;
+	if (username !== 'chintu') {
+		res.send('Username is wrong');
+		return;
+	}
+	if (crypto.pbkdf2Sync(password, salt, iteration, keylength).toString() === hashOfPassword) {
+		if (password === 'complexPasswordWhichContainsManyCharactersWithRandomSuffixeghjrjg') {
+			// some logic here and return something
+		} else {
+			// return flag here
+		}
+	} else {
+		res.send('Password is wrong');
+	}
+});
+```
+
+It seems straightforward: we need to login as user `chintu` and our password hash has to match the hash value for `complexPasswordWhichContainsManyCharactersWithRandomSuffixeghjrjg` while at the same time it has to be a different string.
+
+Initially we thought it will require time-consuming hash collision generation, almost impossible since we don't know the number of iterations and keylen.
+
+However, we found this: https://mathiasbynens.be/notes/pbkdf2-hmac which describes vulnerability of `pbkdf2Sync` function in case password is longer than the size of hash function used. 
+In our case the default `sha1` hash is used and we notice that the user password is longer than 64 bytes.
+This means that `pbkdf2Sync` will actually use `sha1(password)` instead of actual passsword value, and therefore we can use `sha1(password)` as `password` itself -> `sha1('complexPasswordWhichContainsManyCharactersWithRandomSuffixeghjrjg') = e6~n22k81<[p"k5hhV6*`
+
+We therefore login using
+`username: chintu`
+`password: e6~n22k81<[p"k5hhV6*`
+
+And we get the flag.
+
 ###PL version
+
+Dostajemy kod autentykacji działającej na serwerze:
+
+```
+var express = require('express');
+var app = express();
+var port = process.env.PORT || 9898;
+var crypto = require('crypto');
+var bodyParser = require('body-parser')
+var salt = 'somestring';
+var iteration = /// some number here;
+var keylength = // some number here;
+
+app.post('/login', function (req, res) {
+	var username = req.body.username;
+	var password = req.body.password;
+	if (username !== 'chintu') {
+		res.send('Username is wrong');
+		return;
+	}
+	if (crypto.pbkdf2Sync(password, salt, iteration, keylength).toString() === hashOfPassword) {
+		if (password === 'complexPasswordWhichContainsManyCharactersWithRandomSuffixeghjrjg') {
+			// some logic here and return something
+		} else {
+			// return flag here
+		}
+	} else {
+		res.send('Password is wrong');
+	}
+});
+```
+
+Zadanie wydaje się dość proste koncepcyjnie: mamy zalogować się jako użytkownik `chintu` a hash podanego hasła musi zgodzić się z hashem dla hasła `complexPasswordWhichContainsManyCharactersWithRandomSuffixeghjrjg`, jednocześnie będąc innym stringiem.
+
+Początkowo myśleliśmy, że będzie wymagało to czasochłonnego liczenia kolizji hashy, praktycznie niemożliwego przy braku znajomości liczby iteracji oraz długości klucza.
+
+Niemniej jednak znaleźliśmy artykuł: https://mathiasbynens.be/notes/pbkdf2-hmac opisujący podatność funkcji `pbkdf2Sync` w sytuacji gdy podane hasło jest dłuższe niż rozmiar hasha używanej funkcji.
+
+W naszym przypadku używana jest domyślna funkcja `sha1` i widzimy że hasło ma wiecej niż 64 bajty.
+To oznacza, że `pbkdf2Sync` w praktyce użyje wartości `sha1(password)` zamiast wartości hasła a co za tym idzie możemy z powodzeniem użyć wartości `sha1(password)` jako `password` -> `sha1('complexPasswordWhichContainsManyCharactersWithRandomSuffixeghjrjg') = e6~n22k81<[p"k5hhV6*`
+
+
+Dzięki temu logujemy się za pomocą:
+`username: chintu`
+`password: e6~n22k81<[p"k5hhV6*`
+
+I dostajemy flagę.

2016-06-04-backdoor-ctf/misc_dtune/Dtune.wav

@@ -3,4 +3,22 @@
 ###ENG
 [PL](#pl-version)
 
+We get an [audio file](Dtune.wav) with recording of someone typing a password.
+We recognized the sounds as phone dial tones, and therefore we used an Audacity plugin to recognize which buttons were pressed:
+`8 44 33 0 333 555 2 4 0 444 7777 0 7777 44 2 2 5 6 0 666 333 0 33 7 222 3 44 99 44 6 222 2 77 9`
+
+Initially we mistakingly merged the multiplied button presses and we thought we need to use T9 to recognize words.
+Only later we figured that it was plain old keyboard typing, which translated to:
+
+`the flag is sha256 of EPCDHXHMCAQW`
+
 ###PL version
+
+Dostaliśmy [plik audio](Dtune.wav) z nagraniem wpisywania hasła.
+Rozpoznalismy dźwięki jako dźwięki wybierania tonowego na klawiaturze telefonicznej i wykorzystaliśmy plugin do Audacity, aby rozpoznać które klawisze wybrano:
+`8 44 33 0 333 555 2 4 0 444 7777 0 7777 44 2 2 5 6 0 666 333 0 33 7 222 3 44 99 44 6 222 2 77 9`
+
+Początkowo błędne skleiliśmy te same klawisze i próbowaliśmy dopasować słowa za pomocą T9.
+Dopiero później zorientowaliśmy się, że klawisze są wybierane w zwykły sposób i wpisany tekst tłumaczy się do:
+
+`the flag is sha256 of EPCDHXHMCAQW `

2016-06-04-backdoor-ctf/misc_dtune/README.md

@@ -3,4 +3,138 @@
 ###ENG
 [PL](#pl-version)
 
+The task was pretty obvious: the server provides us with a regular expression and we need to supply a string which can be matched by this regex.
+Since we're lazy we checked if someone has not done this already, and of course they did: https://bitbucket.org/leapfrogdevelopment/rstr/
+
+So we simply write a short parser for the communication with server, and use `xeger` to get answers.
+We had to modify the xeger code a bit because it was generating `\n` in place of whitespace placeholders and the server was not handling this well, so we forced the library to use `\t` always for `\s`.
+There was also some issue with non-alphanumeric characters so we also forced those to a single chosen character.
+Rest was just the communication with the server:
+
+```python
+import rstr
+import socket
+import re
+from time import sleep
+
+def recvuntil(s, pattern, tryouts):
+    data = ""
+    for i in range(tryouts):
+        sleep(1)
+        data += s.recv(9999)
+        if pattern in data:
+            return data
+    return data
+
+
+def main():
+    url = "hack.bckdr.in"
+    port = 7070
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.connect((url, port))
+    while True:
+        task = recvuntil(s, "Pass your solution:", 10)
+        print(task)
+        to_solve = re.findall("Your regex:\s+(.*)\s+Pass your solution", task)
+        if len(to_solve) == 0:
+            print(task)
+        else:
+            print("to solve = '%s'" % to_solve[0])
+            solution = rstr.xeger(to_solve[0])
+            print("solution  = %s" % solution)
+            s.sendall(solution + "\n")
+
+
+main()
+```
+
+Which gave:
+
+```
+Passed regex! Way to go.
+################################
+#######     ROUND 47        #####
+################################
+
+
+Your regex:
+ab*
+
+
+Pass your solution:
+
+to solve = 'ab*'
+solution  = ab
+Passed regex! Way to go.
+Congratulations, you can now say ISOLVE
+flag{...}
+```
+
 ###PL version
+
+Zadanie było dość oczywiste koncepcyjnie: serwer podaje nam wyrażenie regularne a my mamy zwrócić ciąg znaków, który będzie przez to wyrażenie przyjęty.
+Jako, że jesteśmy leniwi z natury, sprawdziliśmy czy ktoś już czegoś podobnego nie napisał i oczywiście ktoś taki się znalazł: https://bitbucket.org/leapfrogdevelopment/rstr/
+
+W związku z tym napisalismy krótki parser do komunikacji z serwerem i użylismy `xegera` do uzyskiwania odpowiedzi.
+Musieliśmy lekko zmodyfikować kod biblioteki ponieważ generowała znaki `\n` jako białe znaki, a serwer sobie z tym nie radził zbyt dobrze, w związku z tym wymusiliśmy używanie `\t` zawsze dla `\s`.
+Były też jakieś problemy ze znakami nie-alfanumerycznymi i te także sprowadziliśmy do jednego wybranego znaku.
+Reszta to już tylko komunikacja z serwerem:
+
+```python
+import rstr
+import socket
+import re
+from time import sleep
+
+def recvuntil(s, pattern, tryouts):
+    data = ""
+    for i in range(tryouts):
+        sleep(1)
+        data += s.recv(9999)
+        if pattern in data:
+            return data
+    return data
+
+
+def main():
+    url = "hack.bckdr.in"
+    port = 7070
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.connect((url, port))
+    while True:
+        task = recvuntil(s, "Pass your solution:", 10)
+        print(task)
+        to_solve = re.findall("Your regex:\s+(.*)\s+Pass your solution", task)
+        if len(to_solve) == 0:
+            print(task)
+        else:
+            print("to solve = '%s'" % to_solve[0])
+            solution = rstr.xeger(to_solve[0])
+            print("solution  = %s" % solution)
+            s.sendall(solution + "\n")
+
+
+main()
+```
+
+Co dało:
+
+```
+Passed regex! Way to go.
+################################
+#######     ROUND 47        #####
+################################
+
+
+Your regex:
+ab*
+
+
+Pass your solution:
+
+to solve = 'ab*'
+solution  = ab
+Passed regex! Way to go.
+Congratulations, you can now say ISOLVE
+flag{...}
+```

2016-06-04-backdoor-ctf/ppc_isolve/README.md

@@ -3,4 +3,32 @@
 ###ENG
 [PL](#pl-version)
 
+We get netcat connection parameters to work with.
+After connecting to the server we get a custom command-line prompt, but typing some random things cause the connection to close.
+Some fuzzing lead us to typing `1+()` which crashes with a nice python exception that we can't add int to a tuple.
+This means that our input has to be evaluated by python interpreter.
+We use this to run:
+
+```python
+__import__("pty").spawn("/bin/sh")
+```
+
+To get a real shell on the target machine.
+After that we tried the standard aproach with `find flag` but it gave us nothing.
+Fortunately we came back to task description which stated that the admin is `environmentalist` and so we typed `set` to see evn variables and there was a variable named `_F_L_AG` containing the flag itself.
+
 ###PL version
+
+Dostajemy parametry do połączenia się przez netcata.
+Po połączeniu serwer wyświetla znak zachęty jak w shellu, ale próby wpisywania losowych rzeczy powodują zerwanie połączenia.
+Trochę fuzzowanai pozwala zauważyć że wpisanie `1+()` wysypuje shella z ładnym pythonowym wyjątkiem ze nie można dodać inta do krotki.
+To oznacza, że nasz input jest ewaluowany przez interpreter pythona.
+W związku z tym uruchamiamy:
+
+```python
+__import__("pty").spawn("/bin/sh")
+```
+
+Aby dostać prawdziwego shella na docelowej maszynie.
+Po tym próbowaliśmy trochę standardowych operacji jak `find flag` ale niczego nie znaleźliśmy.
+Na szczęście wróciliśmy do opisu zadania, w którym było napisane że admin to `environmentalist` w zwiazku z tym wpisaliśmy komendę `set` żeby zobaczyć wszystkie zmienne środowiskowe i faktycznie jedną z nich była `_F_L_AG` zawierająca flagę.