# justCTF that's not crypto Write Up
## Details:Points: 500
Jeopardy style CTF
Category: Reversing
## Write up:
This challenge gave me a .pyc file so I knew that I would need to use uncompyle:
``` pythonuncompyle6 checker.pyc # uncompyle6 version 3.7.4# Python bytecode 3.6 (3379)# Decompiled from: Python 3.8.6 (default, Sep 25 2020, 09:36:53) # [GCC 10.2.0]# Embedded file name: checker.py# Compiled at: 2021-01-30 10:41:40# Size of source mod 2**32: 50109 bytesfrom random import randint
def make_correct_array(s):    from itertools import accumulate    s = map(ord, s)    s = accumulate(s)    return [x * 69684751861829721459380039 for x in s]
def validate(a, xs):
    def poly(a, x):        value = 0        for ai in a:            value *= x            value += ai
        return value
    if len(a) != len(xs) + 1:        return False    else:        for x in xs:            value = poly(a, x)            if value != 24196561:                return False
        return True
if __name__ == '__main__':    a = [...]    a = [ai * 4919 for ai in a]    flag_str = input('flag: ').strip()    flag = make_correct_array(flag_str)    if validate(a, flag):        print('Yes, this is the flag!')        print(flag_str)    else:        print('Incorrect, sorry. :(')# okay decompiling checker.pyc
```
The array (a) was massive so I shortened with ..., After seeing this I copied the python and put it in a file. 
I ran a few tests and found out that a had a length of 58. Looking into the validate function I saw that this meant that the flag would need to be 57 characters long.
I then decided that my best course of action would be to simply use the python code to semi-brute force the correct values:
``` pythonfrom random import randint
def make_correct_array(s):    from itertools import accumulate    s = map(ord, s)    s = accumulate(s)    return [x * 69684751861829721459380039 for x in s]
def validate(a, xs):
    def poly(a, x):        value = 0        for ai in a:            value *= x            value += ai
        return value
    for x in xs:        value = poly(a, x)        if value != 24196561:            return False
    return True
if __name__ == '__main__':    a = [...]    a = [ai * 4919 for ai in a]
    flag_str = "justCTF{"
    while len(flag_str) < 57:        i = 32        while i < 127:            print(flag_str + chr(i))            flag = make_correct_array(flag_str + chr(i))            if (validate(a, flag)):                print("correct:     " + chr(i))                flag_str += chr(i)            i += 1
    print(flag_str)```
I had done some testing so I knew that first part of the flag was justCTF{ which was the flag format. I then modified the validate function so that it no longer cared about the length of the input and instead only checked if it was correct. 
I then went through for the length of the flag and added each possible char to the end of the string and "hashed" the string using their equation. I then checked each combination until I got the correct character, at which point I went to the next one.
The program then spit out the following flag:
```justCTF{this_is_very_simple_flag_afer_so_big_polynomails}```