writeups/hah/asis2019.md

   1 # Retrospective
   2 Luckily I could spend two afternoons to work uninterruptedly on challenges during the Asis CTF. Even though I started with a bit of delay on saturday I quickly found a pwn challenge that was already available and still unsolved that looked interesting which I ultimately finished in the late afternoon. I didn't expect to get far on sunday due to less time but decided to take on a Reverse/Misc-challenge because the full python source code was available and it seemed easier to get into than some others, and I managed to finish it in time before the CTF ended as well. I had some cursory looks at other challenges as well but did not seriously attempt any of them.
   3 All in all the challenges I solved weren't extremely complicated and I spent more time on them than was probably necessary figuring some things out; especially "Cursed app" was simpler when I analyzed it after having finished it than it seemed like during working on it, but both were interesting nonetheless and were fun to figure out. I was slowed down by not being too familiar with all the relevant assembly instructions in "Cursed app", and wasted some time on both challenges by not analyzing them closely enough before taking them on, but it was a good learning experience.
   4
   5 # Challenges
   6 ## Cursed app (Reverse / 90pts / 60 solves)
   7 ```
   8 If we want to say 100, should we start at 1 and count until 100?
   9
  10 sha256(flag) = dd791346264fc02ddcd2466b9e8b2b2bba8057d61fbbc824d25c7957c127250d
  11 ```
  12
  13 The "cursed app" was a ELF binary that analyzed the contents of a file passed as an argument; depending on whether it contained the correct file or not it printed a message to let the user know.
  14 Looking at the binary in cutter revealed a lot of similar looking blocks that all ended in a conditional jump to the program section that printed the message indicating a wrong flag; the blocks iterated over an ever increasing variable that was probably the content read from the file, and in total 59 positions were handled suggesting that the flag was 59 characters long, of which the first 5 and the last one were known. Storing "ASIS{" in the file provided to the executable and stepping through indeed showed that the first five blocks in question passed successfully but the check in the sixth one jumped to the error message. Now knowing for sure that each code block analyzed a character by reading the byte value, doing calculations based on it and finally checking the results to decide whether to proceed or fail it was simply a matter of reversing the calculations to retrieve the correct characters one by one.
  15 The calculations had a similar structure but seemed to vary a bit so I transferred the to python one after another in order to iterate over all printable characters and find the ones for which the calculations worked out; only after having retrieved the flag and cleaning up the script did I realize that not only could most parts be copy-pasted with some values exchanged, but they actually all had the exact same structure if fed with the appropriate values. For example some blocks were missing instructions that were present in most others, but they could simply be performed by the same function by providing parameters that simply neutralized those instructions, such as multiplying values by 1 to simply prevent any changes taking place.
  16 The basic structure of the function was as follows:
  17
  18 - Read character byte value into EAX, multiply it by some value and then add to it.
  19 - Perform a CDQ instruction which sign-extends the value in EAX by copying the sign bit into every bit of the EDX register. Because we know that our bytes are all positive due to representing printable characters and only being multiplied by positive numbers this effectively serves as a way to zero out EDX.
  20 - An IDIV instruction is performed which divides EAX by the provided argument and stores the result in EAX and, more importantly, the remainder in EDX. Because EDX wasn't explicitely mentioned in the assembly code this was a bit tricky to figure out when just translating the obvious calculation steps into python because they obviously didn't match and no characters for which they worked out could be found.
  21 - The value of EDX is then copied to EAX and, multiplied by some value, into ESI.
  22 - EAX and EDX are multiplied by some values.
  23 - Values are added to EAX and ESI, this time not by ADD instructions but by way of LEAs.
  24 - Finally there's another EAX IDIV followed by a TEST on EDX and a JNE conditional jump; effectively at this point EAX has to be a multiple of the divisor, thus writing a remainder of 0 into EDX which is the only way to avoid a jump to the error message, instead continuing into the next block loading and analyzing the following character.
  25
  26 Most of the calculation steps were pretty straight forward, but some such as IDIV and CDQ had some side effects that weren't easily spotted in the disassembly and required some analysis. In some blocks certain instructions were changed, such as a multiplication being replace by a shift, which made them look more different than they actually were. The challenge description was probably a hint to that fact.
  27 Transcribing the calculations to python this way allowed for bruteforcing the character in each position, with some being obvious due to the flag format. The following script is a heavily cleaned up version that defines the basic structure that is common to each calculation and provides the appropriate values visible in the disassembly to construct a function for each position into which characters can be passed to check whether they pass the test (returning the remainder of the final division):
  28
  29 ```python
  30 #!/usr/bin/env python
  31
  32 import string
  33
  34 def calc(char, eax_m_1, eax_a_1, esi_m, edx_m_1, eax_m_2, eax_s_1, esi_s_1):
  35     ecx = 0x100
  36     eax = ord(char)
  37     eax *= eax_m_1
  38     eax += eax_a_1
  39     edx = eax % ecx
  40     eax = edx
  41     esi = edx * esi_m
  42     eax *= edx
  43     edx *= edx_m_1
  44     eax *= eax_m_2
  45     eax = eax + esi + eax_s_1
  46     esi = edx + esi_s_1
  47     edx = eax % esi
  48     return edx
  49
  50 calculations = [
  51     lambda char: 0 if c == "A" else 1,
  52     lambda char: 0 if c == "S" else 1,
  53     lambda char: 0 if c == "I" else 1,
  54     lambda char: 0 if c == "S" else 1,
  55     lambda char: 0 if c == "{" else 1,
  56     lambda char: calc(char, 91, 2, 0x2f7, 0x30e, 5, 0x4b, 0x55),
  57     lambda char: calc(char, 0x43, 0x76, 0xed, 0x106, 0x37d, 0x1f1, 0xdd),
  58     lambda char: calc(char, 0xe7, 0x74, 0x287, 0xf5, 0x213, 0x3e5, 0x184),
  59     lambda char: 0 if c == "_" else 1,
  60     lambda char: calc(char, 0xcb, 0x88, 0x95, 0x78, 0x336, 0x3bd, 0x230),
  61     lambda char: calc(char, 0x51, 0x96, 0x2b0, 0x144, 0x9d, 0x21a, 0x265),
  62     lambda char: calc(char, 0x29, 0x8d, 0x2db, 0x15, 0x56, 0xcb, 0x203),
  63     lambda char: calc(char, 0x73, 0x5f, 0x178, 0x116, 0x2df, 0x88, 0x262), # _
  64     lambda char: calc(char, 0xf3, 0xe4, 0xdd, 0xca, 0x31b, 0x37c, 0x33b),
  65     lambda char: calc(char, 0x4f, 0x51, 0x345, 0x234, 0x66, 0x366, 0xf9),
  66     lambda char: calc(char, 0x7b, 0x8e, 0x2b0, 5, 0x12e, 0x282, 0xd5),
  67     lambda char: calc(char, 0xa9, 0x59, 0x272, 0x96, 0xe, 0x2a8, 0x1c8), #_
  68     lambda char: calc(char, 0xad, 0xe6, 0x214, 0x19f, 0x33e, 0x12e, 0x1f1),
  69     lambda char: calc(char, 0xab, 0x9a, 0x72, 2**5, 0x10f, 0xe2, 0x292),
  70     lambda char: calc(char, 0x4b, 0xb8, 0x35a, 0x37d, 0x366, 0x39, 0x1a8),
  71     lambda char: calc(char, 0xf5, 0x5b, 0x2f3, 0x6a, 0x375, 0x9d, 0x3d7),
  72     lambda char: 0 if c == "_" else 1,
  73     lambda char: calc(char, 0x3d, 0x69, 0x3c0, 0x3e, 0x3cb, 0x214, 0x390),
  74     lambda char: calc(char, 0x9f, 0x2c, 0x1d8, 0x29, 0x215, 0x7a, 0x32),
  75     lambda char: calc(char, 0x77, 0xef, 0x21f, 0x38, 0xa7, 0x308, 0x290), #_
  76     lambda char: calc(char, 0xb3, 0x70, 0x3ce, 0x87, 0xf8, 0x19e, 0x52),
  77     lambda char: calc(char, 0x47, 0xae, 0x1cf, 0xa, 0x2f3, 0x115, 0x113),
  78     lambda char: calc(char, 0xbf, 0x90, 0x2a6, 0x37, 0xe3, 0x234, 0x27a),
  79     lambda char: calc(char, 0x51, 0x9b, 0x210, 0x173, 0x379, 0x330, 0x2ea),
  80     lambda char: calc(char, 0x57, 0xc8, 0x2e0, 0x2e6, 0x14d, 0x25, 0xd),
  81     lambda char: calc(char, 0xa7, 0xa0, 0xc8, 0x382, 0x27c, 0xd5, 0x265),
  82     lambda char: 0 if c == "_" else 1,
  83     lambda char: calc(char, 0x71, 0xd9, 0x34b, 0x14d, 0x8a, 0xfc, 0x244),
  84     lambda char: calc(char, 0xaf, 9, 0x164, 0x69, 0x1ae, 0x2cb, 0x1fc),
  85     lambda char: calc(char, 0xdb, 0xa6, 0x2ca, 2, 0xac, 0x32c, 0x124),
  86     lambda char: calc(char, 0xb3, 0x39, 0x3be, 0x1f1, 0x358, 0x2b9, 0x3be),
  87     lambda char: 0 if c == "_" else 1,
  88     lambda char: calc(char, 0x3d, 0xf0, 0x3b9, 0x78, 0x141, 0x1ec, 0x199),
  89     lambda char: calc(char, 0x29, 0x76, 0x10c, 0x4a, 0x7b, 0x3c4, 0x14e),
  90     lambda char: calc(char, 0x2d, 0x96, 0x210, 0xd, 0x264, 0x16c, 0x27d),
  91     lambda char: 0 if c == "_" else 1,
  92     lambda char: calc(char, 0x3f, 0xa0, 0x15a, 0xf0, 0x388, 0x34d, 0x3d),
  93     lambda char: calc(char, 0xd3, 0x72, 0x22a, 0x93, 0x22f, 0x299, 0x379),
  94     lambda char: calc(char, 0x79, 2, 0x3df, 0x82, 0x2cf, 0x32b, 0x195),
  95     lambda char: calc(char, 0x75, 0xe6, 0x134, 0x27, 0x21d, 0x12c, 0x29),
  96     lambda char: calc(char, 0x51, 0x52, 0x253, 0x23, 0x234, 0x229, 0x205),
  97     lambda char: 0 if c == "_" else 1,
  98     lambda char: calc(char, 0xed, 0xa5, 0x306, 0x24, 0x203, 0x14b, 0x28c),
  99     lambda char: calc(char, 0x81, 0x7f, 0x1a4, 0xb, 0x362, 0x14, 0x15a),
 100     lambda char: calc(char, 0x19, 0xeb, 0x67, 0x211, 0xb8, 0x140, 0x17e),
 101     lambda char: calc(char, 0x9b, 0x3a, 0x33c, 0x46, 0x357, 0xa0, 0x10e),
 102     lambda char: calc(char, 0x55, 0xf0, 0x234, 0xa, 0x3b7, 0xd5, 0x207),
 103     lambda char: calc(char, 0x49, 0x3d, 0x79, 0x7, 0x282, 0x362, 0x142),
 104     lambda char: calc(char, 0x81, 0x56, 0x326, 0x17, 0x3d, 0x181, 0x14f),
 105     lambda char: calc(char, 0x9b, 0xb1, 0xc4, 0x65, 0x18f, 0x24, 0xda),
 106     lambda char: calc(char, 0x99, 0x7e, 0x116, 0x3c, 0x360, 0x2aa, 0x142),
 107     lambda char: calc(char, 0xe3, 0xf5, 0x152, 0x51, 0x123, 0x1f8, 0x2bc),
 108     lambda char: calc(char, 0xc3, 0x16, 0x3ca, 0x148, 0x300, 0x13, 0x1e1)
 109 ]
 110
 111 possible_chars = string.printable
 112
 113 for i in range(len(calculations)):
 114     for c in possible_chars:
 115         if calculations[i](c) == 0:
 116             print("Found character for index {}: {}".format(i, c))
 117 ```
 118
 119 ## Yet funny (Misc/Reverse / 154pts / 29 solves)
 120 ```
 121 Sometimes you come up with something incredibly stupid yet funny.
 122 Don`t ignore it!
 123
 124 nc 76.74.177.238 7777
 125 ```
 126
 127 This challenge was a python script running on a remote server that consisted of two parts: A proof of work as well as the possibility to modifiy C++-code in a limited way that then was compiled and executed on the server; only if it exited with status 0 the flag was read and printed.
 128
 129 ### Proof of work
 130 The proof of work generated a random string of a random length between 10 and 40, hashed it with one randomly selected function out of five and printed the final 6 characters; the task was to find and enter the correct random string.
 131 This was easily solvable by parsing the provided information and bruteforcing strings of the appropriate lengths and hash functions. The actual work that had to be proven wasn't massive bcause the strings mainly consisted of zeroes and only a couple of relevant characters at the end; this was pretty straight forward and mainly a speedbump.
 132
 133 ### Randomized C++-program
 134 After clearing the proof of work the second part of the program could be accessed: Here a simple C++-function was filled with four randomly generated integers and could be displayed. To get to the flag two of thos values had to be replaced by user input, and only if they then matched a simple formula the information would be displayed.
 135
 136 ```c++
 137 #include <stdio.h>
 138 int main(){
 139     int c = 0, d = 0;
 140     c = first_number, d = second_number;
 141     int a = first_random, b = second_random;
 142     if((a*c + b*d) == 1)
 143         return 0;
 144     return -1;
 145 }
 146 ```
 147
 148 ```first_random` and ```second_random``` were immutable random numbers while ```first_number``` and ```second_number``` would be replaced by user input. However this user input was filtered: Besides making sure that only printable characters were present, there was an additional function that was executed on each input:
 149
 150 ```python
 151 def aux(inp):
 152     pm = set(inp)
 153     try:
 154         vux = inp.replace(list(pm)[0] * 2, chr(0)).replace(list(pm)[1] * 2, chr(1))
 155         if set(vux) == set([chr(0), chr(1)]) and len(inp) <1<<10:
 156             return True and len(inp) > 4
 157     except:
 158         pass
 159     return False
 160 ```
 161
 162 This had me stumbling around for a bit: At first I thought the first two characters of each input had to be 0 and 1, but at some point I realized that the conversions to and from sets indeed had a point: They reduced the input to the unique values present, and by replacing the first two and then comparing the sets this effectively ensured that only two different characters were present; the multiplication of course didn't alter those characters but ensured that only pairs would be replaced, further limiting the input to strings of at least 4 characters, consisting only of pairs of two unique characters.
 163 Having cleared that hurdle it was time to think about possible inputs. The first obvious idea was to insert two slashes to comment out parts of the code to alter the variables and thus the calculations, but there was no way to get legal C++-code this way and get the compilation pass. However the compiler errors were helpfully printed out and pointed out a peculiarity in the way the user input was used to subsitute program parts that was present in the available python code:
 164
 165 ```python
 166     tmp_code = code
 167     tmp_code = str(tmp_code).replace("first_random", str(first_rand))
 168     tmp_code = str(tmp_code).replace("second_random", str(second_rand))
 169     tmp_code = str(tmp_code).replace("first_number", str(first_var) + "c+" + str(first_number))
 170     tmp_code = str(tmp_code).replace("second_number", str(second_var) + "d+" + str(second_number))
 171 ```
 172
 173 Instead of replacing the placeholder text in the source code the script actually inserted the user input followed by the variable name and another addition, resulting in a line like:
 174
 175 ```c++
 176 c = <USER_INPUT>c+<first_number>, d = <USER_INPUT>d+<second_number>;
 177 ```
 178
 179 Considering the input could only consist of pairs of the same character there was no way to end the statement early by inserting a semicolon or commenting parts of it out, but there are pairs of characters that could immediately preceed variables and result in legal code: Pre-increments and pre-decrements.
 180 While I at first only tested with up to six characters because thats what I had used to analyze the ```aux```-function I at some point realized that it also explicitely checked the input length and not only limited it to being at least 6 characters but also added an upper bound of 1024. Because two different characters were required to be present, resulting in an increment and a decrement that cancelled each other out, this left 509 operations that could be performed on either variable which opened up a huge range of values that could possibly be used in the program.
 181 With this information it was again down to bruteforcing the values by iterating over them until a combination was found that satisfied the formula, then generating and submitting the appropriate string.
 182
 183 The following steps combine both tasks and exploit the remote server fully automatted retrieving the flag:
 184
 185 ```python
 186 #!/usr/bin/env python
 187
 188 from pwn import *
 189 import string
 190 from parse import *
 191 from hashlib import *
 192 from itertools import chain, product
 193
 194 prompt1_template = "Please submit a printable string X, such that {}(X)[-6:] = {} and len(X) = {}"
 195 vars_cd_template = "           c = {}, d = {};"
 196 vars_ab_template = "           int a = {}, b = {};"
 197 HASH = {"md5": md5, "sha1": sha1, "sha224": sha224, "sha256": sha256, "sha384": sha384, "sha512": sha512}
 198
 199 def pow(algo, hash, len):
 200     candidates = product(string.printable, repeat=int(len))
 201     for candidate in candidates:
 202         if HASH[algo](''.join(candidate)).hexdigest()[-6:] == hash:
 203             return ''.join(candidate)
 204
 205 def find_solution_strings(a, b, c, d):
 206     solution_string = "++--"
 207     for c_diff in range(-509, 509):
 208         for d_diff in range(-509, 509):
 209             if a*(c + c_diff) + b*(d + d_diff) == 1:
 210                 print("Solution found!")
 211                 solution_string_c = abs(c_diff)*"--" if c_diff < 0 else c_diff*"++"
 212                 solution_string_d = abs(d_diff)*"--" if d_diff < 0 else d_diff*"++"
 213                 return solution_string + solution_string_c, solution_string + solution_string_d
 214
 215 def exploit():
 216     r = remote("76.74.177.238", "7777")
 217
 218     print("##### Step 1: Proof of work #####")
 219     prompt1_request = r.recvline()
 220     prompt1_data = parse(prompt1_template, prompt1_request)
 221     print("Attempting PoW: {}(X) = {}, len(X) = {}".format(prompt1_data[0], prompt1_data[1], prompt1_data[2]))
 222     correct_X = pow(prompt1_data[0], prompt1_data[1], prompt1_data[2])
 223     print("Found PoW: {}".format(correct_X))
 224     r.sendline(correct_X)
 225
 226     print("##### Step 2: Find equation solution #####")
 227     r.recvline_endswith("[Q]uit!")
 228     r.sendline("g")
 229     r.recvline_endswith("d = 0;")
 230     vars_cd_line = r.recvline()
 231     vars_ab_line = r.recvline()
 232     vars_cd_data = parse(vars_cd_template, vars_cd_line)
 233     vars_ab_data = parse(vars_ab_template, vars_ab_line)
 234     a = int(vars_ab_data[0])
 235     b = int(vars_ab_data[1])
 236     c = int(vars_cd_data[0])
 237     d = int(vars_cd_data[1])
 238     print("Challenge: a = {}, b = {}, c = {}, d = {}".format(a, b, c, d))
 239     solution_c, solution_d = find_solution_strings(a, b, c, d)
 240     r.recvline_endswith("[Q]uit!")
 241     r.sendline("t")
 242     r.recvline_endswith("first variable:")
 243     r.sendline(solution_c)
 244     r.recvline_endswith("second variable:")
 245     r.sendline(solution_d)
 246     flag_line = r.recvline()
 247     r.close()
 248     print(flag_line)
 249
 250 if __name__ == "__main__":
 251     exploit()
 252 ```