July 22nd 2021

# ImaginaryCTF Round 12 Writeups

A short month this time around

## Sanity Check Round 12

You copy and paste the flag:

ictf{Round_12_Sanity_Check}

## smth here

We get :4E7L6oD*049p==b?8b=D07EHN and due to the fact that there are only printable characters (and also because it was a day 2 challenge) I guessed it was just a ROT47, which was in fact correct, so doing a rot47 again gives us the flag:

ictf{e@sY_chAll3ng3ls_ftw}

## Slow Internet

We get the site router, and a hint that it is a default "default business router"

We visit the webpage and see a loginpage, so a quick google for Business Wireless Gateway default admin yields us the default credentials for cusadmin here.

So we try both passwords and with CantTouchThis we get the flag ictf{w3b_and_0s1nt???_gr3at_c0mb0!}

## Quintessentially Quick Quiche

We get the site quiche and when we visit it tells us to use http/3. My first solution was with a python script which was way too complicated, you can just reload the page in firefox (Because after the initial load a header is set that firefox should use HTTP/3 for it).

So we get the flag ictf{who_knew_http_over_udp_could_be_so_quic(k)}

## Caesar Tart

We see that there's a function caesar which applies a key to a character, we also see that the key is 5 to 10 characters long and we just loop over that. This encryption is called vigenere and there exist online solvers for it. I used dcode and told it to find something containing the word ICTF. It then pretty quickly found a solution, but I had to copy the recovered key to another website to get the full plaintext:

HEY IF YOURE READING THIS MESSAGE I SUPPOSE THIS MEANS YOUVE SUCCESSFULLY DECRYPTED IT EH NEAT TODAY I WANNA TALK ABOUT APPLE TARTS DID YOU KNOW APPLE TARTS WERE MADE OUT OF APPLES BONKERS RIGHT I HEARD PEOPLE EVEN PUT SUGAR INTO IT SUGAR THIS ISR EALLY CRAZY ANYWAY EVEN THOUGH THERE ARE APPLES IN APPLE TARTS THEY ARE STILL DELICIOUS ENOUGH THIS MADE MEH UNGRY I WANNA EAT ONE NOW THINK ABOUT THES MELL THAT WAFTS THROUGH THE AIR INTO YOUR NOSE IMAGINE THE DELIGHTFUL GOLDEN COLORATION OF THE TART IM SERIOUSLY RUNNING OUT OF THINGS TO TELL IN HERE SO I GUESS WITHOUT FURTHER ADO HERES YOUR FLAG ICTFMORELIKEVIGENERETART


thus we get ictf{MORELIKEVIGENERETART}

## Glitchy Video

We get a .wav file together with a pretty explicit hint to look at it, so I opened the file in audacity and switch to the spectrogram view. There is the a string, which looks like rot encoded text, so I just try all rotations on the string nhyk{34xd_4zi10_xy3l4s0lw4umd} and with a rotation of 21, I get the flag:

ictf{34sy_4ud10_st3g4n0gr4phy}

## Web Flagchecker

We get the site flagchecker. There we get the sourcecode. The first line which catches the eye is actually just there to print the code, but that's fairly quickly discovered once we decoded \x3cpre\x3e\x3ccode\x3e%s\x3c/code\x3e\x3c/pre\x3e to be <pre><code>%s</code></pre>. So we look at the other function and see that we format the string which is then passed into the render_template_string function, which means we can make the query be something which will be interpreted by that function. But first we need to pass all the previous conditions, so our query must start with "ictf" and end with "}", also we need to have the exact same length as the flag, so we first try a few lengths (I just did a quick 3 lines script to get the check page with a few "a"s) to find the correct length. Then we put in the stuff to make the other check happy and finally we put a "}}{{flag}} somewhere in there to include the flag variable, so our final payload looks like this: /check?flag=ictf{"}}aaaa{{flag}} and this gives us the flag (After the inital Falseaaaa:

ictf{@llth3br@ck3t5}

## overflowwwwwwwww

We get a binary and a libc, we open the binary and see that main just reads a string and then compares a value with a constant (But that value is initialized to another variable and we never write to it, so binja actually optimized that code out), anyway, there is a heap bufferoverflow because the variable is also on the heap. So all we need to do is to overflow enough memory with the correct bytes and that value will be set. I am rather lazy, so I did not calculate any offsets, but just ran python -c "print('\x37\x13\x37\x13\x00\x00\x00\x00'*32+'cat flag.txt')" | ./overflowwwwwwwww with different values (instead of 32) until it worked. Then I switched to remote and hurray, we get the flag

ictf{aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa_h34p_c4n_b3_0v3rfl0w3d_t00}

## how r u

We see python 2 and input (But not raw_input), we know we can just input code, which then will be eval'd. So we have one line to do anything. So we just launch a shell by doing __import__("os").system("sh") and get our shell and flag.

ictf{n3v3r_3v3r_3v3r_3v3r_u53_1npu7_1n_pyth0n2}

## Arabica

We need to reverse engineer a java class. JD-GUI didn't support the java version, so I ended up using this online decompiler. After decompilation, we see that there are three phases. Other people realized you could skip the first two by just copying the code of phase 3, I however solved all the phases. Also I needed to install a java16 jvm and had to rename the file from Coffe.class to Arabica.class (Else it would complain that the classname and filename didn't match)

Phase 1: you enter a string and it needs to match ascii codes which are hardcoded, so just convert the ascii codes to text and you get hotcupofcoffee

Phase 2: We read an int and that int divided by the last int we gave it (or one in the first iteration) needs to be equal to the current iteration, so we just have to multiply the last input by the iteration number (which results in the factorials) So we just need to enter 1 2 6 24 120

Phase 3: We need this to return not zero, so we need to input a number which is not -1 and which when doubled and added 1 gives -1, so we first convert -1 into it's hex form, 0xFFFFFFFF then subtract one and shift one to the right to get 0x7FFFFFFF convert that back into decimal to get 2147483647 and use that to finally get our flag:

flag{i_4ctU411y_l1k3_T34_m0R3!}

We get a file of email transcript. The first email tells us that in each email following it, there is a password generated in python like this: b64encode(getrandbits(32).to_bytes(4, 'big') + getrandbits(32).to_bytes(4, 'big')).decode() also we need to generate the next 10 getrandbits(32) to get the flag. Luckily there's already pre-made solutions for that (Like randcrack) which takes 624 32-bit integers and then is able to predict following values. So I simply parsed the file, extracted all the passwords, fed them into randrcrack and got the flag:

from randcrack import *
from base64 import b64decode

with open("out.txt") as f:
d=[b64decode(x.strip()) for x in f.read().split("\n")[3:] if x.strip() != ""]

rc = RandCrack()
for x in d:
try:
rc.submit(int.from_bytes(x[:4], 'big'))
except ValueError:
rc.predict_getrandbits(32)
try:
rc.submit(int.from_bytes(x[4:], 'big'))
except ValueError:
rc.predict_getrandbits(32)
print(hex(rc.predict_getrandbits(32*11)))


where out.txt was simply contained the passwords in correct order (Sorted them, just to make sure) Then I needed to swap the endianess and reverse the string, to get the flag:

ictf{Pr3d1ct_M3rs3nn3_By_S3tt1ng_St4t3}

## ICICLE Jail

We get a new interpreter and a new spec and we need to read a file, but we can't use "read" and certain other strings in the icicle code (Which needs to be one single line long). Luckily there's also a new "exec" instruction. And by sheer coincidence, that will convert an int to a string if it's given an int as parameter. So we just use

readf r0, "flag.txt"
pr r0


convert the character to hex, then convert that into decimal to get exec 47059791966767526693337926357987238923915048615978680990013992970

and by inputting that on the remote we get:

ictf{3x3cut!v3_3x3cu+0r_3x3cut3s_3x3c}

## Too Old

We see that we generate a random number between 10^7 and 10^8, which means that we have 24 to 27 bits, which is totally bruteforcable, so that's what I did:

from multiprocessing import Pool
def brute(a):
for key in range(a&(~0xFF)|(0xe6^ord('i')), a+10**8//16,256):
ok=key
f = bytes.fromhex("e649fd7458fb36acb341346324635da87427d8d25f5c8b7665b921052727bf730f1c0273d00c23217873")
out = b""
for c in f:
out += bytes([c ^ (key&0xff)])
key = int("{:016d}".format(key**2)[4:12])
if b"ictf" in out:
print(ok)
print(out)
with Pool(16) as p:
p.map(brute, [10**8//16*i+10**7 for i in range(16)])


the script runs for about 2 second on my machine and gives me the flag. The intended solution is a bit smarter than this and also looks at the second character before fully decrypting, but meh, good enough.

ictf{f0r_l00p5_r1ght_th3r3_4nd_3v3ryWh3r3}

## smells Like Stereo Bits

So we get the hint of stereo bits and LSB in the title. To view the distorted image, I used this. (Just googled magic eye solver, because I can't see those damn things). After doing that we get G1R12B0, which I first thought was a password until I remembered the hint that LSB is involved, so I opened up stegsolve and opened the file, went to extract data and set the bit plane order to GRB, and check the indicated bits, bit 1 for G, bit 1 and 2 for R and bit 0 for B.

I then saw that there was a JFIF in the output, so I exported it as a .jpg and looking at that gave us the flag:

ictf{90s_st3r30grams_r_k3wl}

## ovvvvvvvvvverflow

We open the binary, see it's a bufferoverflow and enter a lot of a's, then it tells us that the command aaaaaaaaa was not found, so we play a bit around until we see that after 10 characters we overwrite the command that is run. So we enter aaaaaaaaaash to get a shell and read the flag file.

ictf{aAAaAAaaaAAAaaAAAaaAaaAaAAaaAAaAaAaaAAaaaAaAAAAAaAAaAAaAAAaAAAaash}

## Regular Reversing

I can't say too much about this challenge, except that it's just tedious work and going through the "hints" again and again (I called each look ahead a hint and went through each one until I found something I could do; Solving it on paper was easier than on the computer)

There may or may not have been a lot of guessing involved towards the end (When I had the end of the string but didn't have the kn0w yet)

ictf{C4N'7_kn0w_2_much_4b0u+_R3Gul4r_3xpr3ss10n5}

Again we are given passwords generated like in part 1, but this time we're missing pieces of it and need to get some part in the middle. The intended solution actually uses math to compute everything, I just asked z3 to solve it for me:

from base64 import b64decode
from z3 import *
from pwn import u32

d = [x.strip() for x in f.readlines() if x.strip() != ""]
lastnum = -1
nextpw = False
pws={}
minnum = -1
maxnum = -1
for l in d:
if "Subject: " in l:
lastnum = int(l.split("#")[-1])
if lastnum < minnum or minnum == -1:
minnum = lastnum
maxnum = max(maxnum, lastnum)
elif "We have assigned you" in l:
nextpw = True
elif nextpw:
nextpw = False
pws[lastnum] = b64decode(l)

### randrack inspired, but modified

MT = [BitVec(f"vec_{i}", 32) for i in range(624)] # initial state unknown
MTO = [x for x in MT]
index = 625 # initial state is to do regen

def regen():
global MT
global index

N, M = 624, 397
A = 0x9908b0df
LO, HI = 0x7FFFFFFF, 0x80000000

for kk in range(0, N-M):
y = (MT[kk] & HI) | (MT[kk+1] & LO)
MT[kk] = MT[kk+M] ^ LShR(y,1) ^ ((y&1)*A)
for kk in range(N-M-1, N-1):
y = (MT[kk] & HI) | (MT[kk+1] & LO)
MT[kk] = MT[kk+(M-N)] ^ LShR(y,1) ^ ((y&1)*A)
y = (MT[N-1]&HI)|(MT[0]&LO)
MT[N-1] = MT[M-1] ^ LShR(y,1) ^ ((y&1)*A)
index = 0

def extract():
global index
if index >= 624:
regen()
r = MT[index]
r = r ^ LShR(r, 11)
r = r ^ ((r << 7) & 0x9d2c5680)
r = r ^ ((r << 15) & 0xefc60000)
r = r ^ LShR(r, 18)
index += 1
return r&0xFFFFFFFF

def regen_int():
global MT
global index

N, M = 624, 397
A = 0x9908b0df
LO, HI = 0x7FFFFFFF, 0x80000000

for kk in range(0, N-M):
y = (MT[kk] & HI) | (MT[kk+1] & LO)
MT[kk] = MT[kk+M] ^ (y>>1) ^ ((y&1)*A)
for kk in range(N-M-1, N-1):
y = (MT[kk] & HI) | (MT[kk+1] & LO)
MT[kk] = MT[kk+(M-N)] ^ (y>>1) ^ ((y&1)*A)
y = (MT[N-1]&HI)|(MT[0]&LO)
MT[N-1] = MT[M-1] ^ (y>>1) ^ ((y&1)*A)
index = 0

def extract_int():
global index
r = MT[index]
r = r ^ (r >> 11)
r = r ^ ((r << 7) & 0x9d2c5680)
r = r ^ ((r << 15) & 0xefc60000)
r = r ^ (r >> 18)
index += 1
return r&0xFFFFFFFF

### Now solve it

solver = Solver()

start = minnum-(minnum%312)
for i in range(start, maxnum+1):
x1 = extract()
x2 = extract()

expected = pws.get(i, None)
if expected != None:

if solver.check() == sat:
model = solver.model()
MT = [model[x].as_long() if model[x] != None else 0 for x in MTO]
solver.add(Or([MT[i] != MTO[i] for i in range(624)]))
regen_int() # initial one
regen_int() # the second one to get to the second state
index = 0
for i in range(2*9):
extract_int()
print(b"".join([bytes.fromhex(hex(extract_int())[2:].rjust(8,'0')) for i in range(9)]))
else:
print("Nay")


This runs for about two minutes, but then finds the correct flag:

{St4t3_i+397_is_7rivi4lly_c0mpu73d}

## Reversing Some Algorithms

Thanks to implementing a powermod function a few times, I recognized the method f immediatly to just be the python pow method, but recursive. Then in the main function we convert the flag into a number by just doing the same as converting to hex and then reading the number. Then we choose ten integers and they need to be equal to themselves when raised to flag*y, so we know that flag and y need to be modular inverse modulo phi(n), which is trivially computed to be 96933099098818028735695816363963142716310037576504750007863794238150071327948258222722982318041571631903896405924017042636201556382459909420519737582821842523796669050908979263786208808450207855351074945914505034111693323560346396010640647631560540364278925789581677681912012172605890035796657063975789700396 Then we can compute pow(y,-1,phi(n)) and get the flagnum. We just need to convert that to hex and then to characters again.

ictf{the_abuse_of_the_initials_of_rivest_shamir_and_adelman_is_criminal}

## Puzzle

We get a unity game and need to somehow get the flag. We can either open the Csharp assembly file in a program like ILSpy and export the code, patch the code and build the dll in Visual studio to stop the pillars from rising. Alternatively we can extract the objects using something like AssetStudio and then we get a folder for each cube with a letter, with the letter in the folder. Unluckily using that method the letter y was duplicated (Because the cube exists twice but you can only see one of course)

ICTF{ARE_YOU_WINNING_SON_GGGGG}

## ICICLE Golf

We had to implement some algorithms in ICICLE

my cat program (very quickly done and not optimized at all) looks like this:

loop:
strint r1, r0
sub r1, r1, 1702390132
jz r1, exit
pr r0
mov r1, 10
intstr r1, r1
pr r1
j loop
exit:


My gcd looks like this

readint r0
loop:
jz r1, exit

mov r3, r1
mod r1, r0, r1
mov r0, r3
j loop
exit:
pr r0


And for the sort, I implemented a bubble sort in around 20 lines, sadly I don't have the code for that anymore. The code for the new insertion code will be pasted when the month is over :P

Converting those to base64 and inserting them online results in

ictf{wh@ts_c00l3r_th@n_b3!ng_c00l?_ICICLE!}

Again we are given passwords, but this time we need to go back in time to get the flag. Luckily my z3 script was almost good to go, I had to fix a few things (Only related to the password reading and then the flag printing actually)

from base64 import b64decode
from z3 import *

d = [x.strip() for x in f.readlines() if x.strip() != ""]
lastnum = -1
nextpw = False
pws={}
minnum = -1
maxnum = -1
for l in d:
if "Subject: " in l:
lastnum = int(l.split("#")[-1]) // 2
if lastnum < minnum or minnum == -1:
minnum = lastnum
maxnum = max(maxnum, lastnum)
elif "We have assigned you" in l:
nextpw = True
elif nextpw:
nextpw = False
pws[lastnum] = b64decode(l)

#print(pws)

### randrack inspired, but modified

MT = [BitVec(f"vec_{i}", 32) for i in range(624)] # initial state unknown
MTO = [x for x in MT]
index = 625 # initial state is to do regen

def regen():
global MT
global index

N, M = 624, 397
A = 0x9908b0df
LO, HI = 0x7FFFFFFF, 0x80000000

for kk in range(0, N-M):
y = (MT[kk] & HI) | (MT[kk+1] & LO)
MT[kk] = MT[kk+M] ^ LShR(y,1) ^ ((y&1)*A)
for kk in range(N-M-1, N-1):
y = (MT[kk] & HI) | (MT[kk+1] & LO)
MT[kk] = MT[kk+(M-N)] ^ LShR(y,1) ^ ((y&1)*A)
y = (MT[N-1]&HI)|(MT[0]&LO)
MT[N-1] = MT[M-1] ^ LShR(y,1) ^ ((y&1)*A)
index = 0

def extract():
global index
if index >= 624:
regen()
r = MT[index]
r = r ^ LShR(r, 11)
r = r ^ ((r << 7) & 0x9d2c5680)
r = r ^ ((r << 15) & 0xefc60000)
r = r ^ LShR(r, 18)
index += 1
return r&0xFFFFFFFF

def regen_int():
global MT
global index

N, M = 624, 397
A = 0x9908b0df
LO, HI = 0x7FFFFFFF, 0x80000000

for kk in range(0, N-M):
y = (MT[kk] & HI) | (MT[kk+1] & LO)
MT[kk] = MT[kk+M] ^ (y>>1) ^ ((y&1)*A)
for kk in range(N-M-1, N-1):
y = (MT[kk] & HI) | (MT[kk+1] & LO)
MT[kk] = MT[kk+(M-N)] ^ (y>>1) ^ ((y&1)*A)
y = (MT[N-1]&HI)|(MT[0]&LO)
MT[N-1] = MT[M-1] ^ (y>>1) ^ ((y&1)*A)
index = 0

def extract_int():
global index
r = MT[index]
r = r ^ (r >> 11)
r = r ^ ((r << 7) & 0x9d2c5680)
r = r ^ ((r << 15) & 0xefc60000)
r = r ^ (r >> 18)
index += 1
return r

### Now solve it

solver = Solver()

start = minnum-(minnum%312) # align min num
end = maxnum
for i in range(start, end):
x1 = extract()
x2 = extract()

expected = pws.get(i, None)
if expected != None:

if solver.check() == sat:
model = solver.model()
MT = [model[x].as_long() if model[x] != None else 0 for x in MTO]
#regen_int()
#regen_int()
index = 0
x = b"".join([bytes.fromhex(hex(extract_int())[2:].rjust(8,'0')) for i in range(624)])
print(x)
flag = x[x.find(b"ictf"):]
flag = flag[:flag.find(b"}")+1]
print(flag)
else:
print("Nay")


and after only 40 seconds this prints the flag.... Or rather almost the flag, it prints ictf{m3rs3nn3_tw1st3rs_c4n_b\xe8\x06\x02Pck_g3N3r4t3d}

But I just guessed the four missing characters to be 3_b4 because that made the most sense (And since almost all e are 3 and a are 4 I just guessed this first and it was actually correct).

I have no idea what's wrong with my solve script, but too lazy to debug that now.

ictf{m3rs3nn3_tw1st3rs_c4n_b3_b4ck_g3N3r4t3d}

## Bullet Time

We get a C++ binary and there are ton's of functions calls to functions which seemingly do nothing. So I instead searched for strings and found that we have two functions which tell us what they are (A matrix times matrix method and a matrix times a vector method). And after staring at some functions for enough, I figured out that all elements are calculated modulo 0xFB and that we generate two matrices using random elements (After seeding with 0x1337), and then multiply the flag with that matrix and then write the output to a file. So I wrote a quick C file to print me the matrices:

#include <stdio.h>
#include <stdlib.h>

int main() {
srand(0x1337);
//for(int i = 0; i < 24*24; i++) {rand();} // if uncommented, we want to print the second matrix
for(int i = 0; i < 24; i++) {
printf("[");
for(int j = 0; j < 24; j++) {
printf("gf(0x%x),", ((rand()%0xfb)+0xfb)%0xfb);
}
printf("],\n");
}
}


and then I went to sage and put everything into a Matrix:

gf=GF(0xFB)
m1=Matrix([<first_run>])
m2=Matrix([<second_run>])
x=Matrix([gf(i) for i in [0x81,0xa3,0x97,0xd3,0xb8,0xcd,0xb3,0x24,0x4e,0xc7,0x33,0x23,0x19,0x20,0xf1,0xe9,0xa8,0x27,0x6f,0x21,0x4e,0xe1,0x2c,0xc7]])
y=x*(m1*m2).inverse().transpose()
print("".join([chr(i) for i in y[0]]))


which gives us the flag:

ictf{r4nd0m_m4tr1x_mul+}

## Ay Yi Yi

We are given a file to encode pngs into some custom format and also embed a string into the png. So we look at the icicle code and see that it first skips the first eight bytes then inserts one bit of the flag into the next byte (red) then skips a byte, inserts another bit into the next byte, then skips three bytes and repeats the process until the flag is zero.

So we just need to reverse that by extracting the bits and reading them. For that I modified the convertion function which takes the .iii file and converts it to a png like this:

def iii_to_png(fname):
assert fname[-4:] == ".iii"
assert iii[:4] == b"\x7fIiI"
iii = iii[4:]
w = bytes_to_long(iii[:2])
h = bytes_to_long(iii[2:4])
iii = iii[4:]
assert len(iii)%3 == 0
png = Image.new("RGB", (w, h))
bitstring = ""
curstr = ""
now = True
for i in range(0, len(iii), 3):
idx = i//3
if now:
curstr += str(iii[i+0]&0x1)+str((iii[i+2]>>2)&1)
now = False
else:
now = True
if len(curstr) == 8:
bitstring += curstr[::-1]
curstr = ""
png.putpixel((idx//h, idx%h), (iii[i], iii[i+1], iii[i+2]))
print(bitstring)
png.save(fname[:-4] + ".png")


Then renaming the chall.iii.enc to chall.iii and then converting that to a png prints a binary string, which decoded yields the flag:

ictf{idky_yall_asked_for_this_but_here_you_go_have_fun}

< ImaginaryCTF Round 11 Writeup | PBCTF: NP - Not Password >