writeups/icecrax/asis2019.md

   1 # ASIS 2019
   2 ## web: protected-area (unsolved)
   3 A web page is given which printed the content of a file from a directory to the html of the page.
   4
   5 First I looked up the source file of the webpage. It was importing the following JS script:
   6 ``` javascript
   7     var file_check = function(file){
   8         $.ajax({
   9             url: '/check_perm/readable/',
  10             data: {'file': file}
  11         }).done(function(data){
  12             if (data == "True") {
  13                 file_read(file)
  14             }else{
  15                 console.log('fail')
  16             }
  17         })
  18     }
  19
  20     var file_read = function(file){
  21         $.ajax({
  22             url: '/read_file/',
  23             data: {'file': file}
  24         }).done(function(data){
  25             update_page(data)
  26         })
  27         return
  28     }
  29
  30     var update_page = function(text){
  31         $("#t").append(text)
  32     }
  33
  34     $(document).ready(function() {
  35         console.log("ready!");
  36         file_check('public.txt');
  37     });
  38 ```
  39 The first command `file_check` executed like this `http://66.172.33.148:8008/check_perm/readable/?file=public.txt` gives either `True` or `0`, depending if the file exists. If the file is not found it prints in the console `fail`. If it exists its being passed to the command `file_read`.
  40
  41 The second command `file_read` executed like this `http://66.172.33.148:8008/read_file/?file=public.txt` opens the file. It then passes itas an argument to `update_page`. If the file is not found `security` or `500` is being printed.
  42
  43 The trird command `update_page` takes the passed text and appends to the DOM.
  44
  45 I tried path triversal by encoding the ../ in UTF-8, by replacing ../ with ..././ or ..;/, but it seems the dots and slash are still being replace, bacause `http://66.172.33.148:8008/read_file/?file=../../../public.txt` is being interpreted the same as `http://66.172.33.148:8008/read_file/?file=public.txt`
  46
  47 There was also `private.txt` file in the same directory as `public.txt` with the content `lol haha`.
  48
  49 I tried to mess up with the console:
  50 `update_page("<script>alert()</script>")` executes the script and the pop up shows, hints towards an XSS attack.
  51
  52 I tried looking for a way to list the directory via javascript
  53 ``` javascript
  54 const testFolder = './public.txt';
  55 const fs = require('fs');
  56
  57 fs.readdir(testFolder, (err, files) => {
  58   files.forEach(file => {
  59     console.log(file);
  60   });
  61 });
  62 ```
  63
  64 ## web: cursed-app (unsolved)
  65
  66 An `cursed_app.elf` file is given.
  67 The description of the challenge stated `If we want to say 100, should we start at 1 and count until 100?` and `sha256(flag) = dd791346264fc02ddcd2466b9e8b2b2bba8057d61fbbc824d25c7957c127250d` was given.
  68
  69 First I tried to brute force the hash using variuos websites. No luck there.
  70 Hexdumping the file reveals some readable strings: `hexdump -C cursed_app.elf`.
  71 After that I found a more useful command `strings`, which filters only the readable strings.
  72 Intressting segment was
  73 ```
  74 []A\A]A^A_
  75 please locate license file, run ./app license_key
  76 Congratz! You got the correct flag!!
  77 Bummer! You got the wrong flag!!
  78 ;*3$"
  79 ```
  80 So I tried executing file. If it's being run without arguments the first message is printed: `please locate license file, run ./app license_key`, if a file is specified it prited `Bummer! You got the wrong flag!!`.
  81
  82 So clearly the program was reading the flag file and computing and comparing the string.
  83
  84 I tried `strace` and `ltrace` to understand better what functions and libraries are being called.
  85
  86 Using `objdump -d cursed_app.elf` showed me that there was no main function.
  87
  88 I then installed `Hopper`, which is a reverse engineering tool that lets me disassemble, decompile and debug the applications. With it I tried to undestand the execution pattern and to find out how and when `Congratz!` is being printed. I figured out that after opening the flag/key file 59 characters are being read and most likely compared (although no cmp function was found). Those 59 chars could be brute forced and encrypted with `sha256` and then compared with the given solution in the description. A brute force of 59 chars seems impossible.
  89
  90 ## web: Golden_Delicios (unsolved)
  91
  92  A `.sage` file is given, containing the following python scrypt. And at the bottom of it, there were the results of the print function commented.
  93
  94  ``` python
  95  #!/usr/local/bin/sage
  96
  97 from sage.all import *
  98 from secret import *
  99
 100 print '(A_1, B_1) =', (A_1, B_1)
 101 print '(A_2, B_2) =', (A_2, B_2)
 102
 103 E_1 = EllipticCurve(Zmod(n_1), [A_1, B_1])
 104 E_2 = EllipticCurve(Zmod(n_2), [A_2, B_2])
 105
 106 d_1 = int(flag[:len(flag)/2].encode('hex'), 16)
 107 d_2 = int(flag[len(flag)/2:].encode('hex'), 16)
 108
 109 assert d_1 < n_1 and d_2 < n_2 and n_1 * n_2 % 2 == 1
 110
 111 print 'P_1 =', P_1
 112 print 'P_2 =', P_2
 113
 114 Q_1 = d_1 * P_1
 115 Q_2 = d_2 * P_2
 116
 117 print 'Q_1 =', Q_1
 118 print 'Q_2 =', Q_2
 119  ```
 120
 121 The EllipticCurve function was interesting. After googling it I found out that there exists a very popular algorithm in cryptography for encrypting public keys.
 122 The formula for an elliptic curve is as follows: `y^2=x^3+ax+b` and the parameters corresponded to those used in the script, so I guessed I was on the right track.
 123 After that I spent time reading wikipedia articles and watching youtube youtibe videos explaining it. But after some time trying to understand it, I gave up... I decided to concetrate more on the other challenges.
 124
 125 ## web: Bit_game (unsolved)
 126 The following script was given, together with a text file containing the resulting H and enc variables:
 127 ```python
 128 import random
 129 from Crypto.Util.number import *
 130 #from flag import flag
 131
 132 def gen_rand(nbit, l):
 133     R = []
 134     while True:
 135         r = random.randint(0, nbit-1)
 136         if r not in R:
 137             R.append(r)
 138             if len(R) == l:
 139                 break
 140     R.sort()
 141     rbit = '1'
 142     for i in range(l-1):
 143         rbit += (R[i+1] - R[i] - 1) * '0' + '1'
 144     rbit += (nbit - R[-1] - 1) * '0'
 145     return int(rbit, 2)
 146
 147 def genkey(p, l):
 148     n = len(bin(p)[2:])
 149     f, skey = gen_rand(n, l), gen_rand(n, l)
 150     pkey = f * inverse(skey, p) % p
 151     return (p, pkey), skey
 152
 153 def encrypt(msg, pkey):
 154     p, g = pkey
 155     msg, enc, n = bytes_to_long(msg), [], len(bin(p)[2:])
 156     print(n)
 157     for b in bin(msg)[2:]:
 158         s, t = gen_rand(n, l), gen_rand(n, l)
 159         c = (s * g + t) % p
 160         if b == '0':
 161             enc.append((c, t))
 162         else:
 163             enc.append((p-c, t))
 164     return enc
 165
 166 p = 862718293348820473429344482784628181556388621521298319395315527974911
 167 l = 5
 168
 169 pkey, skey = genkey(p, l)
 170 enc = encrypt(flag, pkey)
 171 H = pkey[1] ** 2 % p
 172 print('H =', H)
 173 print('enc =', enc)
 174 ```
 175 I think I was on the right track on this one. Sadly this challenge was released on the last day and I didn't get the opportunity to spent more time on it. The CTF was over and the challenge was left unsolved...
 176 Nevertheless that is what I managed to put together:
 177
 178 ``` python
 179 #enc = [...]
 180 flag = ''
 181 l = 5
 182 p = 862718293348820473429344482784628181556388621521298319395315527974911
 183 r = 738852413361336333302472130287418462898049591392380573449381971565615
 184 for i in range(len(enc)):
 185     c = enc[i][0]
 186     print("c: ",c)
 187     t = enc[i][1]
 188     print("t: ",t)
 189     deca = ((-c-t) * r) % p
 190     print("deca: ",deca)
 191     b = bin(deca)[2:].count('1')
 192     print("b: ", b)
 193     if b == l:
 194         flag += '0'
 195         continue
 196     deca = ((c-t) * r) % p
 197     print("deca: ",deca)
 198     a = bin(deca)[2:].count('1')
 199     print("a: ",a)
 200     if a == l:
 201         flag += '1'
 202         continue
 203 print(hex(int(flag,2))[2:-1].decode('hex'))
 204 ```