Archived Challenges - March 2022

copy and paste

ictf{w3lc0m3_t0_r0und_20!!}

Every 4 characters of b64 data encode 3 "original" characters. It's possible to simply enumerate all possible case combinations of the encoded data in blocks of 4, and see what blocks come out as printable and are most likely to be valid. Even without using a language model to score possibilities, the number of options is small enough to go through manually and find the correct flag.

https://imaginaryctf.org/f/eaqOn

ictf{1t's_e4s13r_t0_r3c0ver_th4n_it_s33ms}

Search image to text on Yandex.com, you get something in some other language which is “Чивита ди Баньореджо ”so translate to English you get - Civita di Bagnoregio so search that on google maps and u get roughly 42.627802, 12.113735

ictf{42.63_12.11}

Go to the website, and look at the source on GitHub. Then find the most recent commit and there should be a suspicious file, figure out it's a Wireshark file, and then extract data from it. It is an archived file.

ictf{why_d0_p30p1e_c0mm17_pc4p_f1l3s???}

Open a websocket connection to wss://eye-sight.ictf.iciaran.com/ws, use the initial message on connection to request the first character then keep passing the next value as the key until you have the whole flag. https://imaginaryctf.org/f/IUqpx

ictf{3y3_5py_w17h_my_l1ttl3_i}

The login form is vulnerable to xpath injection, using a password like ' or '1'='1 we can log in to the site, however we need the admin password for the next step so this isn't enough. Instead we can use the xpath injection to get the admin's password one character at a time. Once we have the admin password can use xxe to get the contents of flag.txt

Solve script: https://imaginaryctf.org/f/JRoE3

ictf{1n_4_l4nd_b3f0r3_js0n}

Encrypt the same message twice, then bruteforce key1 (24 bits, 3 bytes) using a meet-in-the-middle attack. When the correct key1 was found xor(enc(plain),dec(cipher1)) == xor(enc(plain),dec(cipher2)) == key2. Use that to decrypt the flag. Solve script: https://imaginaryctf.org/f/H3dkv

ictf{m33t_in_the_m1ddl3_go_brrrr}

Rabin cryptosystem, take square roots mod p and mod q, reconstruct the square root mod p*q via CRT. https://imaginaryctf.org/f/h6yk3

ictf{r4B1n_1s_4ls0_c0ol_4nd_s0m3_n0ns3ns3_640378904673357282}

Explanation: https://imaginaryctf.org/f/aK49H Script: https://imaginaryctf.org/f/6Xjzz

ictf{w34k_n0nc3_gEn3r4t1on_smh}

Find the correct testnet, ropsten, locate the contract. It checks the flag against a stored hash, but the stored hash was computed during contract deployment. Find the deploying transaction, dump the data, get the flag.

ictf{d4t4_1n_t3h_c0nstruct0r_c4n_st1ll_b3_f0und...}

First some part reverse engineering: you can kinda decompile the bytecode directly on etherscan. For reference, here's the full original source: https://imaginaryctf.org/f/C29qK From there, it's mostly a matter of finding the base index of the merkle tree, and building the proof. The base can be found from data of the deploying transaction. The last 32 bytes of the input there is what you're looking for. To build the proof: it's a classic merkle tree, except you need to xor in hashes of your address + the iteration in certain places, see the contract source for details. Performing the actual transaction to claim your winnings can be then done either through some interface like myetherwallet or remix, or you could try to script it.

ictf{Building_merkle_proofs_for_fun_and_profit_hope_you_learned_something_new_today}

Use after free, read fd to get a leak, overwrite fd to get ealloc to return a GOT address, overwrite puts got with one gadget

ictf{i_made_a_custom_malloc_what_could_go_wrong}

Use the overflow to set rbp to somewhere in bss section, and return to read part to write rop chain to it. After stack pivot, you can let it return to read part again to have /bin/sh in bss, and pivot it to rop chain. Since read syscall will put the length in rax, you can use SROP to execute execve

ictf{system_call_is_fun_isnt_it}

Custom "bignum" implementation that is then used to perform a very inefficient modular exponentiation. Taking the discrete logarithm with e.g. cado-nfs allows to recover the flag. Original source: https://imaginaryctf.org/f/0fq88

ictf{cado_nfs_t1m3_g0go}