【Daily AlpacaHack】2026/01/24 Paca Paca Authenticator - official writeup

Daily AlpacaHackという毎日0時に1題ずつ公開される常設CTFの1月24日の問題、「Paca Paca Authenticator」の作問を担当したので、公式writeupを書きます。当日に解けた方も解けなかった方もぜひ復習に利用していただけると嬉しいです。

alpacahack.com

問題ソースコードは以下の通り。

from Crypto.Util.Padding import pad, unpad
from Crypto.Cipher import AES
import os
import json

aes_key = os.urandom(16)
flag = os.environ.get("FLAG", "Alpaca{dummy}")

def register(username, message):
    data = json.dumps({"name": username, "message": message}).encode()
    cipher = AES.new(aes_key, AES.MODE_CBC)
    token = cipher.encrypt(pad(data, 16))
    print("[debug]", cipher.iv.hex())
    return token

def login(iv, token):
    data = unpad(AES.new(aes_key, AES.MODE_CBC, iv=iv).decrypt(token), 16)
    data = json.loads(data)
    return data["name"], data["message"]


token = register("alpaca", "paca paca!")
print("This is your login token:", token.hex())

print("Oops! I forgot to save the iv, so I can't decrypt the token! Do you know it?")
iv = bytes.fromhex(input("help me> "))

try:
    username, message = login(iv, token)
except Exception as e:
    print("something wrong:", e)
    exit(1)

if username == "alpaca":
    print("paca paca!")
    print("Thanks! That really helped!")
elif username == "llama":
    print("llama!?!!?", flag)
    print("Oh no, I accidentally leaked the flag...")
else:
    print(f"{username}... who are you?")

AESという共通鍵暗号を使った認証システムのコードです。
json.dumps({"name": "alpaca", "message": "paca paca!"}).encode()
をAES-CBCモードで暗号化してトークンとして返しています。
それをaes_keyとユーザーから与えられたivを使って復号し、得られたjsonのnameがllamaであればフラグを返すようになっています。

AES暗号（特に今回使われているAES128）は16byteの鍵と16byteの平文ブロックをもとに16byteの暗号文ブロックを生成する共通鍵暗号です。

ja.wikipedia.org

今回は中でもCBCモード（Cipher Block Chaining mode）という動作モードが使われています。CBCモードでは、暗号化の際に各平文ブロックを前の暗号文ブロックとXORしたものを暗号化します。最初のブロックについては前の暗号文ブロックが存在しないため、IV（Initialization Vector）と呼ばれる値を使ってXORします。
復号の際には、各暗号文ブロックを復号した後に、前の暗号文ブロック（最初のブロックについてはIV）とXORすることで平文ブロックを得ます。
つまり、最初の暗号文ブロックは、最初の平文ブロックを、IVを、最初の暗号文ブロックをとすると、以下のように復号されます。

ここで、はC1を復号した値を表します。
IVが単純にXORされているため、例えばIVのあるビットを反転させると、復号後の平文ブロックの同じビットも反転します。
今回の問題では、IVとしてユーザーから与えられた値を使っているかつ、元のIVが出力されているため、復号後の最初の平文ブロックを任意の値に書き換えることが可能です。
を自由に決められる場合、新しく復号結果としたい平文ブロックをとして、

とを決めれば、復号後の最初の平文ブロックをに変更できます。
今回の問題は、jsonのnameの値を"alpaca"から"llama"に変更したいという状況でした。
nameの値は最初のブロックの16byteに収まっているため、前述した最初のブロックを書き換える方法で達成できます。
{"name": "alpacaから{ "name": "llamaに変更すればよい（llamaのほうが一文字短いため、適当に空白をいれることによって16byteに揃えました）ので、新しいIVを以下のように計算します。
iv = xor(b"{\"name\": \"alpaca", b"{ \"name\": \"llama", original_iv)
これを実装したソルバは以下の通りです。pwntoolsのxor関数を使っています。

from pwn import *

sc = remote(..., ...)
sc.recvuntil(b"[debug] ")
original_iv = bytes.fromhex(sc.recvline().decode())
sc.recvuntil(b"token: ")
token = bytes.fromhex(sc.recvline().decode())
iv = xor(b"{\"name\": \"alpaca", b"{ \"name\": \"llama", original_iv)
sc.sendlineafter(b"> ", iv.hex())
print(sc.recvline())

このように、CBCモードのAES暗号では鍵を知らなくてもIVを書き換えることで復号結果を改竄できてしまいます。同様に、暗号文ブロックを書き換えることでも完全に任意ではありませんが復号結果を改竄できます。
おまけとして、この性質を使った有名な攻撃手法としては、他にもpadding oracle attackなどがあります。

ちなみに、フラグの元ネタはこれです。アルパカとラマは似てるけど、アルパカとオカピは別に似てません。
www.youtube.com

【Daily AlpacaHack】2025/12/08 Fully Padded RSA - official writeup

Daily AlpacaHackという毎日0時に1題ずつ公開される常設CTFの8日目の問題、「Fully Padded RSA」の作問を担当したので、公式writeupを書きます。当日に解けた方も解けなかった方もぜひ復習に利用していただけると嬉しいです。

初心者向けCTFということで、Crypto分野で最初の一歩として登場するRSAでよく出題される攻撃を題材にしました。一方で複数の攻撃方法を組み合わせたり少しひねったりしたことで、ただ既知の攻撃方法を実装するだけというのは避けて、中級者にも楽しめる難易度にしたつもりです。

alpacahack.com

問題ソースコードは以下の通り。

import os
from Crypto.Util.number import *
from math import gcd

flag = os.environ.get("FLAG", "Alpaca{dummy}")
assert len(flag) <= 40

e1 = 65517
e2 = 65577
while True:
    p = getPrime(512)
    q = getPrime(512)
    if gcd((p-1)*(q-1), e1) == gcd((p-1)*(q-1), e2) == 1:
        break
n = p * q

padded_flag = long_to_bytes(n)[:-len(flag)] + flag.encode()
m = bytes_to_long(padded_flag)
assert m < n
c1 = pow(m, e1, n)
c2 = pow(m, e2, n)

print(f"{n = }")
print(f"{c1 = }")
print(f"{c2 = }")

以下の記事に、RSAの問題においてよく出題される攻撃手法が列挙されている。

zenn.dev

今回の問題に適用できる攻撃がないか調べてみると、以下が該当する。

Common Modulus Attack
同一の平文を同一の 異なる で暗号化した暗号文を与えてはいけない

この攻撃を適用すると、より小さな の暗号文を作ることができる。実際に適用してみよう。
今回の問題では、e1 = 65517, e2 = 65577となっている。これらについて、拡張ユークリッドの互除法を適用する。

実際に計算すると、
という式が得られる。
これを使って、 という形で の値が計算できる。
e1とe2が互いに素だった場合はこれだけで、つまりフラグが得られるが、今回は最小公倍数 が3なため、が得られた。

再度攻撃可能なケースのリストを見てみると、の値が計算できたことから、以下の状況に合致する。

Low Public Exponent Attack
公開鍵 が小さすぎてはいけない

これは、 という条件を満たす場合に直接 の 乗根を計算することによって の値が計算出来てしまうという攻撃だ。しかし、これは今回の問題には直接は適用できない。の値がパディングによって大きな値となっているためだ。
パディングはflagの前にnと同じビット列を結合することによって計算されている。これだととは上位bitが完全に一致し、がと非常に近い値になることとなる。実際に手元でとの値を計算して出力してみると、がより少し小さい値になっていることがわかる。

n = 0x5080c9faff634e8018c4a6c367b257fad5cb95797a00c663b277af51926b72b41f0aebf8b8d7760842c3b3be9d28da7b50c173deb2017f7c733fa0442ee298a4721311168af7fca9f21d1673d2a64c8948c3e57befad0fff4cb991dedd05f7bf2d9eb3d7803344b6adb5a768bd47b825395c7630f4c3ce665b2dc315665de735
m = 0x5080c9faff634e8018c4a6c367b257fad5cb95797a00c663b277af51926b72b41f0aebf8b8d7760842c3b3be9d28da7b50c173deb2017f7c733fa0442ee298a4721311168af7fca9f21d1673d2a64c8948c3e57befad0fff4cb991dedd05f7bf2d9eb3d7803344b6adb5a768bd47b825395c76416c706163617b64756d6d797d

このとの差をとすると、 という式が立つ。すると、となることから、、つまりがの暗号文となることがわかる。
はフラグが40byte以下という制約から320bit程度のかなり小さい値となる。は1024bitなので、Low Public Exponent Attackが成立する条件であるを満たす。よって、の3乗根を計算すれば、の値が求まり、そこからの値も求めることができる。

ソルバの全体は以下の通り。
拡張ユークリッドの互除法は自分で実装してもいいが、SageMathのxgcd関数や、gmpy2のgcdext関数を利用すると簡単に計算できる。
同様に、3乗根を求めるのにはgmpy2のiroot関数を使うと簡単。int(x**(1/3))のような方法だと精度の問題で正しく計算できないので注意。

from Crypto.Util.number import long_to_bytes
from gmpy2 import gcdext, iroot

n = ...
c1 = ...
c2 = ...

g, x, y = gcdext(65517, 65577)
c = pow(c1, x, n) * pow(c2, y, n) % n
m_dash, _ = iroot(n-c, 3)
m = n-m_dash
print(long_to_bytes(m))

LLMと対話して解いた人や、中級者以上の人の中には、この問題をCoppersmith methodというアルゴリズムを使って解いた方もいるかもしれません。実際、今回説明した方法よりも難しいですが、Coppersmith methodを使うことも想定解法の一つでした。実はこの方法では、パディングがlong_to_bytes(n)[:-len(flag)]でなくても、既知の（攻撃者が計算できる）値であれば解くことが出来ます。

SECCON Beginners CTF 2025 作問者Writeup (Crypto)

SECCON Beginners CTF 2025の01-Translator, Elliptic4b, Golden Ticketの作問をさせていただきました。私の作問した問題の解説()をしたいと思います。

01-Translator (280 solves)

問題ソースコード（クリックで展開）

import os
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
from Crypto.Util.number import bytes_to_long


def encrypt(plaintext, key):
    cipher = AES.new(key, AES.MODE_ECB)
    return cipher.encrypt(pad(plaintext.encode(), 16))

flag = os.environ.get("FLAG", "CTF{dummy_flag}")
flag_bin = f"{bytes_to_long(flag.encode()):b}"
trans_0 = input("translations for 0> ")
trans_1 = input("translations for 1> ")
flag_translated = flag_bin.translate(str.maketrans({"0": trans_0, "1": trans_1}))
key = os.urandom(16)
print("ct:", encrypt(flag_translated, key).hex())

フラグがbytes_to_long関数によって01列に変換されたあと、0と1をそれぞれ別の文字列に置換でき、置換後の文字列をAESのECBモードを使って暗号化された文字列が得られます。
AESのECBモードは16byteごとにブロックに分割し、それぞれ暗号化するという処理になっていますが、このとき同じ16byteの文字列は同じ暗号文に暗号化されるという性質があります。そのため、0と1を16byteの任意の文字列に置換しておくと、各暗号文のブロックが元の01列の文字と対応します。よって、最初のブロックと比較することでブロックごとに平文が0と1のどちらだったかを判別できます。最後のブロックはpaddingによって付加された文字列を暗号化したものなのでスキップする必要があります。
ソルバは以下の通りです。

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

sc = remote("01-translator.challenges.beginners.seccon.jp", 9999)
sc.recvuntil(b"> ")
sc.sendline(b"a"*16)
sc.recvuntil(b"> ")
sc.sendline(b"b"*16)
sc.recvuntil(b": ")
ct = bytes.fromhex(sc.recvline().decode())
binary = ""
for i in range(0, len(ct)-16, 16):
    if ct[:16] == ct[i:i+16]:
        binary += "1"
    else:
        binary += "0"
print(long_to_bytes(int(binary, 2)))

Elliptic4b (171 solves)

問題ソースコード（クリックで展開）

import os
import secrets
from fastecdsa.curve import secp256k1
from fastecdsa.point import Point

flag = os.environ.get("FLAG", "CTF{dummy_flag}")
y = secrets.randbelow(secp256k1.p)
print(f"{y = }")
x = int(input("x = "))
if not secp256k1.is_point_on_curve((x, y)):
    print("// Not on curve!")
    exit(1)
a = int(input("a = "))
P = Point(x, y, secp256k1)
Q = a * P
if a < 0:
    print("// a must be non-negative!")
    exit(1)
if P.x != Q.x:
    print("// x-coordinates do not match!")
    exit(1)
if P.y == Q.y:
    print("// P and Q are the same point!")
    exit(1)
print("flag =", flag)

まずは与えられたy座標を持つ楕円曲線上の点を計算する必要があります。
secp256k1という楕円曲線上の点はという関係式を満たすため、となるようにを選べばよいです。これには上でのの3乗根を計算すればよいです。3乗根の計算にはsympyのnthroot_mod関数やSageMathのnth_root関数などが使えます。3乗根が存在しない場合もあるため、その場合は接続しなおして別ので計算し直します。
次にQ = a * PがP.x == Q.xかつP.y != Q.yを満たす点となるようなaを求めたいです。
をxy平面にプロットしたグラフを考えると、これを満たすのはPをx軸で反転させた点ですが、この点はPの逆元にほかなりません。

wikipediaより

Pの逆元とはつまりPを-1倍した点ですが、aは負にできないためこれを回避する方法を考える必要があります。
有限体上の楕円曲線の点は有限個であり、楕円曲線上の点を倍すると必ず元の点に戻ってくるようなが存在することが知られています（楕円曲線の位数と呼ばれます）。
これを使い、倍の代わりに倍すればよいです。これですべての条件を満たし、フラグが得られます。
ソルバは以下の通りです。

import os
from pwn import *
from sympy.ntheory.residue_ntheory import nthroot_mod
from fastecdsa.curve import secp256k1
from fastecdsa.point import Point

while True:
    with remote("elliptic4b.challenges.beginners.seccon.jp", 9999) as sc:
        sc.recvuntil(b"y = ")
        y = int(sc.recvline())
        x = nthroot_mod(y**2 - 7, 3, secp256k1.p)
        if x is None:
            continue
        sc.recvuntil(b"x = ")
        sc.sendline(str(x).encode())
        sc.recvuntil(b"a = ")
        a = secp256k1.q - 1
        sc.sendline(str(a).encode())
        print(sc.recvline())
        break

楕円曲線の問題を見たらそっ閉じしているとツイートしている方がいたので作問しました。解いてもらえて良かったです。

Golden Ticket (35 solves)

問題ソースコード（クリックで展開）

import os
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad


flag = os.environ.get("FLAG", "ctf4b{dummy_flag}")
iv = os.urandom(16)
key = os.urandom(16)
challenge = os.urandom(16 * 6)
ENC_TICKET = 3
DEC_TICKET = 3
GOLDEN_TICKET = 0

def menu() -> int:
    print("Your tickets:")
    if ENC_TICKET > 0:
        print(f"{ENC_TICKET} encryption ticket(s)")
    if DEC_TICKET > 0:
        print(f"{DEC_TICKET} decryption ticket(s)")
    if GOLDEN_TICKET > 0:
        print(f"{GOLDEN_TICKET} golden ticket(s)")
    print()
    print(f"1. Encrypt")
    print(f"2. Decrypt")
    print(f"3. Get ticket")
    print(f"4. Get flag")
    print(f"5. Quit")
    while True:
        i = int(input("> "))
        if 1 <= i <= 5:
            return i
        print("Invalid input!")

def consume_ticket(enc: int = 0, dec: int = 0, golden: int = 0):
    global ENC_TICKET, DEC_TICKET, GOLDEN_TICKET
    if ENC_TICKET < enc or DEC_TICKET < dec or GOLDEN_TICKET < golden:
        print("Not enough tickets.")
        exit(1)
    ENC_TICKET -= enc
    DEC_TICKET -= dec
    GOLDEN_TICKET -= golden

while True:
    i = menu()

    if i == 1:
        consume_ticket(enc=1)
        pt = bytes.fromhex(input("pt> "))
        if len(pt) > 16:
            print("Input must not be longer than 16 bytes.")
            continue
        cipher = AES.new(key, AES.MODE_CBC, iv=iv)
        print(f"ct:", cipher.encrypt(pad(pt, 16)).hex())

    if i == 2:
        consume_ticket(dec=1)
        ct = bytes.fromhex(input("ct> "))
        if len(ct) > 16:
            print("Input must not be longer than 16 bytes.")
            continue
        cipher = AES.new(key, AES.MODE_CBC, iv=iv)
        print("pt:", cipher.decrypt(pad(ct, 16)).hex())

    if i == 3:
        print("challenge:", challenge.hex())
        answer = bytes.fromhex(input("answer> "))
        if len(answer) != len(challenge) + 16:
            print("Wrong length.")
            continue
        cipher = AES.new(key, AES.MODE_CBC, iv=answer[:16])
        if cipher.decrypt(answer[16:]) == challenge:
            print("Correct!")
            GOLDEN_TICKET += 1337
        else:
            print("Wrong :(")

    if i == 4:
        consume_ticket(golden=1)
        print("flag:", flag)

    if i == 5:
        print("Bye!")
        exit(0)

AES-CBCの3回の暗号化オラクルと3回の復号オラクルを使って byteの特定の平文を暗号化した文字列を計算することができればフラグが得られます。
最初にGet ticketからchallengeの値を取得します。
次に、ivの値を特定しましょう。オラクルに与える文字列がpaddingされていることに注目します。b"\x10"*16を平文として暗号化すると、paddingによってb"\x10"*32が暗号化されます。
このとき、2つの出力されるブロックd1,d2はそれぞれxor(encrypt(b"\x10"*16), iv)とxor(encrypt(b"\x10"*16), b"\x10"*16)になります。よって、xor(d1, d2, b"\x10"*16)としてivを求めることができます。これを使うと、ivのないAES_ECBとしての単純な暗号化/復号オラクルが得られます。
b"\x10"*16を暗号文の3ブロック目として固定します。すると、暗号文の4ブロック目として与えるべき値は
encrypt(xor(b"\x10"*16, chal[3]))と1回の暗号化オラクルを使って計算できます（ここで、encryptはAES-ECBとしての暗号化を表し、問題で与えられているAES-CBCのオラクルを使ってenc_oracle(xor(pt, iv))[:16]と計算できます）
また、暗号文の2ブロック目として与えるべき値はxor(f3, d2, chal[2])で計算できます。同様にして1回の復号/暗号化オラクルを使って一つ前/後のブロックとして与えるべき値を計算することができます。
これを使うと5回の追加のオラクル呼び出しで暗号文全体を計算することができ、golden ticketを得ることができます。
ソルバは以下の通りです。

import os
from pwn import *

sc = remote("golden-ticket.challenges.beginners.seccon.jp", 9999)

def enc_oracle(pt):
    sc.recvuntil(b"> ")
    sc.sendline(b"1")
    sc.recvuntil(b"> ")
    sc.sendline(pt.hex().encode())
    sc.recvuntil(b": ")
    return bytes.fromhex(sc.recvline().decode())

def dec_oracle(pt):
    sc.recvuntil(b"> ")
    sc.sendline(b"2")
    sc.recvuntil(b"> ")
    sc.sendline(pt.hex().encode())
    sc.recvuntil(b": ")
    return bytes.fromhex(sc.recvline().decode())

def get_ticket(answer):
    sc.recvuntil(b"> ")
    sc.sendline(b"3")
    sc.recvuntil(b": ")
    challenge = bytes.fromhex(sc.recvline().decode())
    sc.recvuntil(b"> ")
    sc.sendline(answer.hex().encode())
    sc.recvline()
    return challenge

chal = get_ticket(b"a")
chal = [chal[i:i+16] for i in range(0, len(chal), 16)]

f3 = b"\x10"*16
d = dec_oracle(f3)
iv = xor(b"\x10"*16, d[:16], d[16:])
f2 = xor(f3, d[16:], chal[2])
f1 = xor(dec_oracle(f2)[:16], iv, chal[1])
f0 = xor(dec_oracle(f1)[:16], iv, chal[0])
f4 = enc_oracle(xor(f3, iv, chal[3]))[:16]
f5 = enc_oracle(xor(f4, iv, chal[4]))[:16]
f6 = enc_oracle(xor(f5, iv, chal[5]))[:16]

get_ticket(f0+f1+f2+f3+f4+f5+f6)

sc.recvuntil(b"> ")
sc.sendline(b"4")
print(sc.recvline().decode())

フラグはウォンカのチョコレート工場をイメージしていましたが、気づいた方はいたでしょうか？

mathmyth (79 solves)

作問者ではありませんが、mathmythについても少しだけ面白い解法を紹介しようと思います。
56bitの素数4つの積としてrが生成されており、それを使って, とRSAの鍵が計算されています。
想定解はを考えて各素因数ごとに3乗根を計算し中国剰余定理を使って復元、得られたの値からと表し、の近似値を使って効率的にありえるの値を探索、という流れでした。
SageMathには直接での3乗根を計算する関数が存在します（内部で素因数分解し各素因数ごとに計算しています）。
更に、の値はCoppersmith's methodを使って計算することも可能です。
最近公開されたcusoというライブラリを使うと簡単に計算できます。
このライブラリは多変数版のMultivariate Coppersmithに特化したものですが、機能が充実しており単変数のを使ったCoppersmith's methodも簡単に計算できます。
ソルバは以下の通りです。

from sage.all import *
from Crypto.Util.number import long_to_bytes
import cuso
import ast

with open("output.txt", "r") as f:
    n = ast.literal_eval(f.readline().removeprefix("n = "))
    e = ast.literal_eval(f.readline().removeprefix("e = "))
    c = ast.literal_eval(f.readline().removeprefix("c = "))
    r = ast.literal_eval(f.readline().removeprefix("r = "))

a = next_prime(r) - r
for Q in Zmod(r)(n/a).nth_root(3, all=True):
    Q = int(Q)
    x, p = var("x, p")
    roots = cuso.find_small_roots(
        relations=[Q+x*r],
        bounds={x: (0, 2**61)},
        modulus_multiple=n,
        modulus_lower_bound=2**279,
        modulus_upper_bound=2**280
    )
    for root in roots:
        p = int(root[p])
        q = n // p
        print(long_to_bytes(pow(c, pow(e, -1, (p-1)*(q-1)), n)))
        break

AlpacaHack Round 12 (Crypto) 作問者writeup

AlpacaHack Round 12 (Crypto)の作問を担当しました。
実はこれがほとんど初めてのCTF作問でしたがいかがでしたでしょうか。楽しんでいただけていれば幸いです。
各問題の解説を書いていこうと思います。

RSARSARSARSARSARSA (39 solves)

次のスクリプトとその実行結果が与えられます。

from math import gcd
import os
from Crypto.Util.number import getPrime, bytes_to_long

e = 19
while True:
    p = getPrime(2048)
    q = getPrime(2048)
    if gcd((p - 1) * (q - 1), e) == 1:
        break
n = p * q

flag = os.environ.get("FLAG", "Alpaca{**** REDACTED ****}")
assert len(flag) == 26 and flag.startswith("Alpaca{") and flag.endswith("}")

m = bytes_to_long((flag * 1337).encode())
c = pow(m, e, n)

print(f"{n = }")
print(f"{e = }")
print(f"{c = }")

フラグを1337回繰り返した文字列がRSAによって暗号化されており、公開鍵, と暗号文が与えられています。
フラグの代わりに"flag"という文字列で実験してみましょう。"flag"をbytes_to_long関数で整数に変換するととなります。では2回結合した"flagflag"はどうなるでしょうか。実験してみるととなり、"flag"の場合の倍となります。
同様に3回結合した"flagflagflag"はで"flag"の倍、1337回結合した場合倍となります。
フラグは26文字であることが分かっているので、得られる暗号文はフラグを倍した値を暗号化したものとなります。
よって暗号化はをフラグとして、

と表すことができます。式変形すると、

となり、フラグを直接暗号化した場合の暗号文が計算できました。

更に、が19と小さいことに注目します。一般的にとしては65537が選ばれることが多いです。が小さいことは直接的にはRSAの安全性には影響を与えませんが、
CTF crypto 逆引きなどにもある通り、を満たす場合には、単純にの乗根を計算することによって平文が復元できてしまい脆弱であることが知られています。
実際、フラグは26文字であるため からは3952bitしかなく、これはの4096bitを下回るため条件を満たします。
ソルバは以下の通りです。sympyのroot関数を使って乗根を計算しています。

import ast
from sympy import root
from Crypto.Util.number import long_to_bytes

with open("./output.txt", "r") as f:
    n = ast.literal_eval(f.readline().removeprefix("n = "))
    e = ast.literal_eval(f.readline().removeprefix("e = "))
    c = ast.literal_eval(f.readline().removeprefix("c = "))

t = 0
for _ in range(1337):
    t = t * 256 ** 26 + 1
c_flag = c * pow(t, -e, n) % n
eth_root = root(c_flag, e)
print(long_to_bytes(eth_root).decode())

一問目に置ける難易度の問題を作るのは正直ボス問を作るより難しかったです。典型問題そのままではなくちょっとひねった感じであまり見たことがない問題となっておりお気に入りの一問です。

OTEC (21 solves)

次のスクリプトが与えられます。

import os
import signal
import secrets
from fastecdsa.curve import secp256k1
from fastecdsa.point import Point
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
from Crypto.Util.number import long_to_bytes

signal.alarm(60)

flag = os.environ.get("FLAG", "Alpaca{**** REDACTED ****}").encode()

# Oblivious Transfer using Elliptic Curves
G = secp256k1.G
a = secrets.randbelow(secp256k1.q)
A = a * G

print(f"{A.x = }")
print(f"{A.y = }")

x, y = map(int, input("B> ").split(","))
B = Point(x, y, secp256k1)

k0 = long_to_bytes((a * B).x, 32)
k1 = long_to_bytes((a * (B - A)).x, 32)

def encrypt(message, key):
    return AES.new(key, AES.MODE_ECB).encrypt(pad(message, 16))

print(encrypt(flag[0::3], k0).hex())
print(encrypt(flag[1::3], k1).hex())
print(encrypt(flag[2::3], bytes(c0 ^ c1 for c0, c1 in zip(k0, k1))).hex())

楕円曲線を使った1-out-of-2 Oblivious Transferが実装されています。
1-out-of-2 OTは送信者が持つ2つのメッセージのうち、受信者がどちらか一方を選んで受け取ることができ、

• 送信者は受信者がどちらを受け取ったかはわからない
• 選ばなかったほうのメッセージに関する情報は一切得られない

という性質を満たすプロトコルです。今回の問題においては1つ目の性質は特に関係なく、"選ばなかったほうのメッセージに関する情報は一切得られない"という点が重要になります。

サーバーと複数回通信することができるため、flag[0::3]とflag[1::3]はそれぞれで通常のOblivious Transferのプロトコルに沿って通信することによって求めることができます。
を求めたい場合、を送ると、


となり、の場合にはを、の場合にはをA.xとして求めることができます。*1
もう一方の値を求めるためにはを求める必要がありますが、これには楕円曲線上の離散対数問題を解く必要があり、secp256k1のような安全な楕円曲線のパラメータに対しては現実的な時間では困難であることが知られています。
では、k0とk1のxorされた値を求めることができるでしょうか？というのがこの問題の本質的な部分です。
前述した通り、k0とk1を両方同時に求めることは困難です。よって、それぞれの値を知ることなくk0^k1を求める必要があります。
これを満たす方法として、k0^k1 == 0、つまりk0 == k1となるようにBの値を決めることができないか考えてみましょう。
をとして与えると、, となり、互いに逆数の関係になります。ここで、楕円曲線ではある点とその逆元は共通のx座標を持ち、y座標のみが異なる値となることから、x座標のみを鍵として用いるこのプロトコルにおいてはk0 == k1となります。
よってflag[2::3]は0000...0000で暗号化されることとなり、フラグのすべての部分が復元できます。
を求める際、代わりにsecp256k1.qを法とした2の逆元pow(2, -1, secp256k1.q)を掛けることによって計算する必要があることに注意してください。
ソルバは以下の通りです。

from pwn import *
from fastecdsa.curve import secp256k1
from fastecdsa.point import Point
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad

HOST = os.getenv("HOST", "localhost")
PORT = int(os.getenv("PORT", "9999"))
LOCAL = os.getenv("LOCAL")

G = secp256k1.G

def oracle(b_func):
    if LOCAL: sc = process(["python", "../rawdistfiles/server.py"])
    else: sc = remote(HOST, PORT)
    sc.recvuntil(b"A.x = ")
    x = int(sc.recvline())
    sc.recvuntil(b"A.y = ")
    y = int(sc.recvline())
    A = Point(x, y, secp256k1)
    B = b_func(A)
    sc.sendlineafter(b"B> ", f"{B.x},{B.y}".encode())
    ct0 = bytes.fromhex(sc.recvline().decode())
    ct1 = bytes.fromhex(sc.recvline().decode())
    ct2 = bytes.fromhex(sc.recvline().decode())
    return ct0, ct1, ct2, A

ct0, _, _, A0 = oracle(lambda A: G)
_, ct1, _, A1 = oracle(lambda A: A + G)
_, _, ct2, A2 = oracle(lambda A: A * pow(2, -1, secp256k1.q))

k0 = long_to_bytes(A0.x, 32)
k1 = long_to_bytes(A1.x, 32)
k2 = b"\0" * 32

pt0 = unpad(AES.new(k0, AES.MODE_ECB).decrypt(ct0), 16)
pt1 = unpad(AES.new(k1, AES.MODE_ECB).decrypt(ct1), 16)
pt2 = unpad(AES.new(k2, AES.MODE_ECB).decrypt(ct2), 16)
print(bytes([[pt0, pt1, pt2][i%3][i//3] for i in range(len(pt0) + len(pt1) + len(pt2))]).decode())

よくわからない暗号プロトコルと楕円曲線と、どちらも難しいがちで初心者には忌避されるように思いますが、解法はかなりシンプルで試行錯誤の中でたどり着ける範囲ではあるのかなと思います。
見た目はすごく安全そうでも実は脆弱というのはCryptoジャンルの問題の面白いところの一つで、そんなところを感じていただけたら嬉しいです。

Flag Sharing (6 solves)

次のスクリプトとその実行結果が与えられます。

import os
import secrets
from Crypto.Util.number import getPrime, bytes_to_long

N = 10

def random_poly(t):
    return [secret] + [secrets.randbelow(p) for _ in range(t - 1)]

def evaluate(f, x):
    return sum(c * pow(x, i, p) for i, c in enumerate(f)) % p

p = getPrime(512)
flag = os.environ.get("FLAG", "Alpaca{************* REDACTED *************}")
assert len(flag) == 44 and flag.startswith("Alpaca{") and flag.endswith("}")
secret = bytes_to_long(flag.encode())

xs = [secrets.randbelow(p) for _ in range(N)]
f = random_poly(N)
shares = [evaluate(f, x) for x in xs]

print(f"{p = }")
print(f"{xs = }")

for i, share in enumerate(shares, 1):
    print(hex(share)[:-i] + "?" * i)

定数項にフラグを持つランダムな多項式に対し、10個のとそので評価した値の上位bitが得られています。
これはShamir's secret sharingという秘密分散のアルゴリズムに似ています。
通常のShamir's secret sharingのプロトコルでは多項式の次数+1個のシェア（の組）を集めると共有した値が復元できますが、この際どうやって復元するのかを考えると、ラグランジュ補間を使って以下のように計算されています。

はすべて得られていることから、に関する線形和でフラグを表すことができます。また、シェアのうち未知の部分が小さいことから、LLLを使ってシェアとフラグを復元できそうと考えることができます。では、LLLの格子の基底行列の構成方法について考えましょう。
まず、を既知の部分とに分割してと表します。
フラグのうちAlpaca{}の部分は既知なので、
とおきます。

これで、未知の値はとだけになりました。

先程の式に代入すると、

となります。

（ とおきました。）

ここで、未知数の大きさを計算すると、は bit、は byte（最上位bitは0のため bit）であり、合計で
bit となります。
の大きさは512bitなので、507bitの自由度であれば解が一意に特定できそうです。

とからなるベクトルを含むように格子を構成すると、例えば以下のようにできます。

更に、縮約されたベクトルの各要素の大きさを揃えるため、次のようにスケーリングします。

この行列に対してLLLなどの格子基底簡約を適用したいですが、残念ながらこの行列では目的のベクトルは得られません（この問題はかなりboundが厳しめになるようにしています）。
スケーリング後の目的のベクトルは各値が]に分布します。この値からを引いて]の分布に移動させると目的のベクトルのノルムを平均的に小さくすることができ、より簡約後の格子の基底ベクトルとして現れやすくできます。

この行列にLLLを適用することにより、目的のベクトル、そしてフラグが得られます。
ソルバは以下の通りです。

import ast
import string
from sage.all import *
from Crypto.Util.number import long_to_bytes, bytes_to_long

with open("../distfiles/output.txt", "r") as f:
    p = ast.literal_eval(f.readline().removeprefix("p = "))
    xs = ast.literal_eval(f.readline().removeprefix("xs = "))
    share = []
    for line in f.readlines():
        share.append(int(line.rstrip("?\n"), 16))

N = 10
c = bytes_to_long(b"Alpaca{".ljust(44 - 1, b"\0") + b"}")
lam = [product(-xs[j] * pow(xs[i]-xs[j], -1, p) % p for j in range(N) if i != j) for i in range(N)]

inv256 = pow(256, -1, p)
const = (sum(share[i]*2**(4*(i+1)) * lam[i] for i in range(N)) - c) % p

M = block_matrix([
    [Matrix([lam[i] * inv256 % p for i in range(N)]).T, diagonal_matrix([2**(287-4*(i+1)) for i in range(N)]), zero_matrix(N, 1)],
    [(const*inv256-2**286) % p, Matrix([-2**286]*N), 2**286],
    [p, zero_matrix(1, N), 0]
])

for row in M.LLL():
    f = long_to_bytes(int(row[0]) + 2**286)
    if all(ch in string.printable.encode() for ch in f):
        print(f"Alpaca{{{f.decode()}}}")
        break

を引く方法以外に、フラグの一文字目を全探索することでも目的のベクトルの大きさを小さくすることができ、同様にフラグが得られます。
LLLの問題はboundに余裕を持たせてあることも多いですが、もう少しのところで目的のベクトルが得られないというときにどうしますか？というところを考えるのもなかなかおもしろいと思います。

Zero-sum game (3 solves)

次のスクリプトが与えられます。

import os
import random
import signal
from functools import lru_cache


@lru_cache
def _nimber_mul(x, y, p=512):
    assert x.bit_length() <= p and y.bit_length() <= p
    if x == 0 or y == 0:
        return 0
    if x == 1:
        return y
    if y == 1:
        return x
    p >>= 1
    lx, rx = x >> p, x & (1 << p) - 1
    ly, ry = y >> p, y & (1 << p) - 1
    rr = _nimber_mul(rx, ry, p)
    ll = _nimber_mul(lx, ly, p)
    lz = _nimber_mul(lx ^ rx, ly ^ ry, p) ^ rr
    rz = _nimber_mul(1 << (p - 1), ll, p) ^ rr
    return lz << p | rz

class Nimber:
    def __init__(self, value):
        self.value = value
    def __add__(self, other):
        return Nimber(self.value ^ other.value)
    def __sub__(self, other):
        return Nimber(self.value ^ other.value)
    def __mul__(self, other):
        return Nimber(_nimber_mul(self.value, other.value))
    def __pow__(self, e):
        assert e >= 0
        a = self
        r = Nimber(1)
        while e > 0:
            if e % 2 == 1:
                r = r * a
            a *= a
            e //= 2
        return r
    def __repr__(self):
        return str(self.value)


signal.alarm(90)
flag = os.environ.get("FLAG", "Alpaca{**** REDACTED ****}")
atk = Nimber(random.getrandbits(512))
hp = Nimber(random.getrandbits(512))

print(f"Your ATK: {atk}")
print("Show your power!")
for turn in range(4):
    print(f"Turn #{turn+1}")
    print(f"Enemy HP: {hp}")
    power = int(input("> "))
    assert 0 <= power < 2**512
    hp -= atk ** power
    if hp.value == 0:
        print("You win!")
        print(f"Reward: {flag}")
        exit()
print("You lose...")

atk,hpがランダムな512bitのNimberとして与えられており、
となるような を求める問題です。
ただし和、積はNimberの和、積演算です。
ほとんどの人はNimberというものに初めて触れたと思いますが、Nimberは組み合わせゲーム理論で出てくる謎の体です。競技プログラミングの世界では高度典型として一部で知られて(?)います。
Nimberの世界では、和はビットごとのXORで求まります。一方、積はと定義されています。これは意味が分からないので、謎の演算で定義されているんだなあだとブラックボックス的に理解してもこの問題では特に問題ありません。

この問題で使うNimberの性質は主に以下の5つです。

1. bit以下のNimberは和と積について閉じており、有限体 と同型
2. とすると、 は通常の積 に等しい
3. 任意のNimber は を用いて と一意に表せる
4. bit以下任意のNimber に対して、 は bit以下となる
5. と逆元が計算できる

まず、直接DLPを解くことによってとなるようなが求まるか考えたいです。しかし、これができてしまうとから同型写像で行き来することによって上のDLPも解けてしまうことから、おそらく不可能だと結論付けることができます。逆に、上のDLPが解けるのであれば、同型写像で行き来して bitのNimber上のDLPも解くことができそうです。 のDLPは関数体篩法などの高速なアルゴリズムの実装がすでに存在し、であればSageMathのlog関数などを使って10秒程度で解くことができます*2。
よって、

1. 128bit Nimberからへの同型写像を構成する
2. 128bit NimberのDLP oracleが呼び出せる状況で となるような を構成する

の2つができればこの問題を解くことができます。

1. 同型写像の構成
、つまりから128bit Nimberへの同型写像をとします。
と分解できるとしたとき、 が成り立ちます。つまり、各項があるNimberに対応しており、その和で写像が表せます。
ここで、適当な128bitのNimber がと対応付けられると仮定します。
このとき、に対応するNimberはとなります。よって、
と計算できます。
128bit Nimberからへの同型写像はこの逆写像です。の各ビットを要素とする128要素のベクトルを並べた上の行列を考え、その逆行列を計算すると構成できます。
このとき、の生成多項式はとなります。

2. の構成
まず256bitのNimber に対してDLPオラクル2回の呼び出しによってとなるようなを求めます。
と分解します（は128bitのNimber）。この分解は存在する場合一意で、 と計算できます。
あとは となるような（についても同様）を求めることができればよいですが、が128bitであることからは必ずの倍数となります。よって、との間のDLPをオラクルに問い合わせて解けばが求まります。

さて、この議論は512bitのNimberに対しても同様に適用できます。つまり、512bitのNimber に対して
と分解し、
, となるような〜を求めることでと表すことができます。
ソルバは以下の通りです。

from functools import lru_cache
from sage.all import *
from pwn import *

HOST = os.getenv("HOST", "localhost")
PORT = int(os.getenv("PORT", "9999"))
LOCAL = os.getenv("LOCAL")

@lru_cache
def nimber_mul(x, y, p=512):
    assert x.bit_length() <= p and y.bit_length() <= p
    if x == 0 or y == 0:
        return 0
    if x == 1:
        return y
    if y == 1:
        return x
    p >>= 1
    lx, rx = x >> p, x & (1 << p) - 1
    ly, ry = y >> p, y & (1 << p) - 1
    rr = nimber_mul(rx, ry, p)
    ll = nimber_mul(lx, ly, p)
    lz = nimber_mul(lx ^ rx, ly ^ ry, p) ^ rr
    rz = nimber_mul(1 << (p - 1), ll, p) ^ rr
    return lz << p | rz

def nimber_div(x, y, p=256):
    return nimber_mul(x, nimber_power(y, 2**p-2))

def nimber_power(a, e):
    r = 1
    while e > 0:
        if e % 2 == 1:
            r = nimber_mul(r, a)
        a = nimber_mul(a, a)
        e //= 2
    return r

m = 128
a = random.randrange(1, 1<<m)
mat = []
for i in range(m):
    x = nimber_power(a, i)
    mat.append([x >> i & 1 for i in range(m)])
mat = Matrix(GF(2), mat)
x = nimber_power(a, m)
x = vector(GF(2), [x >> i & 1 for i in range(m)])
u = x * mat ** -1
F = GF(2**m, "a", modulus=list(u) + [1])

def to_field(x):
    x = vector(GF(2), [x >> i & 1 for i in range(m)])
    u = x * mat ** -1
    return F(u)

def to_nimber(x):
    x = x.to_integer()
    x = vector(GF(2), [x >> i & 1 for i in range(m)])
    u = x * mat
    return sum(int(u[i]) << i for i in range(m))

def make(P, Q, p):
    if p == 64:
        return [to_field(Q).log(to_field(P))]
    ph, pl = P>>p, P&(2**p-1)
    qh, ql = Q>>p, Q&(2**p-1)
    n = 2**p
    P2 = nimber_power(P, n+1)
    t = make(P2, nimber_div(qh, ph, p), p>>1)
    a = 0
    for v in t:
        a ^= nimber_power(P, (n+1)*v+1)
    u = make(P2, ql ^ (a % n), p>>1)
    return [(n+1)*v+1 for v in t] + [(n+1)*v for v in u]

while True:
    start = time.time()
    if LOCAL: sc = process(["python", "../rawdistfiles/server.py"])
    else: sc = remote(HOST, PORT)
    sc.recvuntil(b": ")
    P = int(sc.recvline())
    sc.recvuntil(b": ")
    Q = int(sc.recvline())
    try:
        s = make(P, Q, 256)
    except ValueError:
        print("failed")
        sc.close()
        continue
    print(time.time() - start)
    for v in s:
        sc.sendlineafter(b"> ", str(v).encode())
    sc.recvline()
    print(sc.recvline())
    print(time.time() - start)
    break

ところで、この問題はNimberの話を一切出さずにの問題として出題することも可能でした。
その場合からの二次拡大を考えると概ね同様の解法で解くことができるのですが、この問題ではNimberの性質を使うことでより解法の方針が立ちやすくなっています。
最初は「CTFでNimberが出たら面白いやろ！w」みたいなノリで作った問題でしたが、First Bloodのsoon-haariさんにもone of the most memorizable chall to me this yearと言っていただき、結果的にかなり面白い問題に昇華できて良かったと思います。

総評

CTFtime運営の対応が遅くCTFtimeに掲載されなかったようで、参加者数が想定の1/3くらいでした。許せねえ。
最終的に解かれた数は前から39-21-6-3でした。開始前の予想は100-65-20-3だったので全体を3倍したら大体当たってますね。AlpacaHackのRoundは4問しかないのもあって毎回崖ができがちですが、かなり理想的な傾斜になったのではないかと思います。
もともと5問出題予定だったのですが、セット的に5問だとさすがに6時間では重すぎるということで4問目が消え、今の4問になりました。結果的に4問に減らして正解だったように思います。消えた問題はまたいつかどこかで出そうと思います。

また、筑波大学のCTFチームTPCでtkbctfというCTFを冬ごろ開催予定です。そちらにもCryptoなどの問題をいくつか出す予定ですので是非ご参加ください。6時間CTFでは重くて出せない難易度の問題もあり、それなりに骨のあるセットになるかなと思います。よろしくお願いします。

*1:通常はとしますが、この問題では"送信者は受信者がどちらを受け取ったかはわからない"というのを満たす必要はないため単純にとしてよいです

*2:古いバージョンだと遅い実装が使われておりもう少し時間がかかるようです https://github.com/sagemath/sage/issues/32842

Hackceler8 2024 優勝参加記

10/18-20に開催されたHackceler8（Google CTF 2024の決勝イベント）にチームKijitoraとして参加し、優勝することができた。賞金7331ドル*1も得た。これはそのWriteup兼参加記。*2
KijitoraはGoogle CTFのために結成された日本人合同の大きなチームで、私は今年からkeymoonさんに誘われて参加した。

予選は6/22-24に開催された。Kijitoraには強いCTFプレイヤーが沢山おり、私が焼きなマシーンをしていたら*3すごい勢いで問題が解かれて2位になり、ここでも賞金5432.1ドルを獲得した。8位以内だったため決勝に招待される。
決勝のオンサイト参加に立候補する人が全然おらず、他に行く人が居なかったら行きたいけど…と思っていたらkeymoonさんに引っ張り出された*4。結局keymoonさんとptr-yudaiさん、同様に引っ張り出されたArataさんの4人でスペインに行くことになった。内ptr-yudaiさんを除く3人は全員筑波大学生。

Hackceler8は予選とは全くルールが違い、CTFとSpeedrun(日本ではRTAと呼ばれることが多い？)を組み合わせたような感じで、ゲームに埋められたバグを見つけ出し、それを使ってステージをクリアするまでを競うというような大会である。
ルールを聞いただけでもかなり私の好きそうなコンテストで、せっかくスペインまで行くなら頑張ろうという気持ちだった。

~Day0

9/14 にベースとなるゲームが公開された。本番ではこのゲームのステージやギミックの一部が改変されるため、それに対応できるよう予め色々なチートを準備する。
軽く触ってみると、マリオとかのような所謂プラットフォーマーと言われるジャンルのゲームらしい。例として用意されているマップも単純に難易度が高いものが多く、チートなしの人力では確かにクリアするのは厳しそうだった。

いくつかマップがあり、各マップにいるNPCまでたどり着くとスターが貰える。スターを一定数集めるとボスへのポータルが解放されるという感じのようだった。また、毎試合いくつかコインが配置されており、それを取る事で以降の試合で相手チームに対して妨害アイテムが買えるらしい。
とりあえず前年のゲームや配信、公開されている出場チームのツールを見て、どのようなチートを実装する必要があるのか考える。
試合は45分の準備フェーズと、リモートサーバーにつないで実際にステージをクリアする45分の後半フェーズに分かれている。基本的にすべてのチームは準備フェーズ中にローカルでステージをクリアし、そのときのキー入力のリプレイを記録しておいて後半ではそれをリプレイするという流れになる。
そのためにキー入力を記録/再生する機能はほぼ必須である他、当たり判定の表示やゲームを1tickずつ進めるといったチートはどのチームも実装しており、確かにあると便利そうだった。
他に、フィールドにお絵描きできるアイテムがあったので自動でお絵描きできるツールを描いた。色合いがpietっぽいしpietを描かせる問題が出そうだなあと思っていたら本番では本当にpietを書かされた。

その他、ゲームを数tick前の状態に戻すといったUndo機能も実装した。これにはゲームの状態全てを保存しておく必要があり、更にゲームコードの変更にロバストでなければいけない。色々試行錯誤した結果、ゲームオブジェクトを丸々pickleしてunpickleすることにした。中にはネットワークまわりなどいくつかpickleできないオブジェクトも存在するため、それらは別で保存しておいてunpickleする時に元に戻す。

ほかのチームメイトは学園祭実行委員やCTFプラットフォームの運営などで非常に忙しそうにしている中、私はずっと暇人だったので一人ツールづくりに勤しんでいた。結果としてコードベースを一番把握しているのが自分になり、競技中にコードを書く必要があった場合は大体私の担当になった。

Day1

1日目は全チームが同時にプレイする形式の試合が3回行われた。この結果で順位が付き、1,2位、3,4位、はそれぞれ2日目以降のトーナメントで2試合、1試合分のシード権が与えられる。

3試合の結果はそれぞれ2位、1位、6位で、全体2位通過と悪くない結果だった。

面白かったのは2試合目のruinsステージ。鍵付き扉2つの先にNPCがいるが鍵は一つしかなく、どうにか鍵を増殖させるなどして両方の扉を開けなければいけない。
一度開けた扉をもう一度閉じると鍵が再度もらえるが、この際入口側に押し出されるため扉の中から鍵を抜くといったことはできなそうだ。
ここで、扉の開閉状態と鍵の所持状態はsave_fileファイルで管理されているのが気になった。サーバーにつなぎ直した時、扉と所持アイテムの状態はsave_fileファイルから読み取って初期化される。save_fileファイルはサーバー側でtickごとの一番最初で更新されているが、アイテムを取得した際などにも追加でセーブされる処理が走っている。
処理をよく読んでみると、扉を閉じたとき、扉の開閉状態が更新される処理は鍵の再取得の後であり、それがセーブされるのは次tickでのセーブ時である。よって、次tickの情報をサーバーに送信する前にゲームを切断すれば、サーバー側での最後のセーブは鍵を再取得した直後、扉が閉まる直前のものになる。よって、次回のゲーム開始時には鍵を持っていてかつ最初の扉が空いている状態になり、2つ目の扉も開けられるということになる。
この他にもこういうバグ実際のゲームでもありそうだな〜みたいな問題多く出題されており、それこそRTAとかが好きな人は有利だったかもしれない。

3試合目のボスはCTFでよくあるpath traversalでキーワードをリークする問題だった。なんとか倒せたものの、用意していた「サーバーにパケットを送るのを遅延させるチート」にボスを倒すとその後のパケットが送られないというバグがあり、クリアした判定にならなかった。それを直して再度ボスを倒すも、試合終了に数秒の差で間に合わなかった。

開始前は｢2日目で負けると3日目暇になって嫌だな〜｣とか思っていたので、とりあえず3日目まで行けることが確定して安心した。それと同時に、この時点で賞金圏内が確定したらしくびっくりだった。また、この時点で22枚とかなりコインを稼げていたのも良かった。
この日実際にツールを使ってみて、改善が必要な点を一通り洗い出して実装していった。

Day2

2試合分のシード権を得ているのでこの日は試合はないが、問題は全てのチームに配布との事なので練習として本番と同様の状況で問題を解いた。

オンラインで参加していたメンバーが少なかったのもあったが*5、2戦目では実際に対戦していたチームの全てに負けており、かなり次の日が不安になった。

特に、ゲーム内で別プロセスが実行されるarcadeというステージでは色々なチート機能を無効にするようにしており、ほとんど何も対策していなかったため、単純な解法の問題が解けなかった。どんな問題が出るか全く想像できなかったため安全側に倒していたが裏目に出た。その場でコードを書き換えてarcadeでもtickrate変更とtick停止を使えるようにしたが間に合わなかった。

試合後、すでに敗退したチームが既に自分たちのコードを公開していた。マジかよと思ったがどうやらCTFではそういうもんらしい。C4T BuT S4Dのツールを見ていると、経路探索機能のドキュメントとして登れないはずの壁を登っている動画を貼っていた。ベースのゲームには意図されたバグは仕込まれていないはずなのでかなり驚いたが、実際に手元で動かしてみると確かに壁を登れている。
ベースのゲームでそんなことができてしまうといくつかのスターが非想定で簡単に取れてしまうほか、なんなら実は意図的に仕込まれていて最後の大謎として出題されるのではないかと思い、挙動を解析して自分達のツールでも使えるよう組み込んだ。
どうやら2年前にもあらゆる壁を抜けられるバグがベースのゲームに存在しており、その時はすぐにパッチされて使えなくなったらしい。

https://github.com/C4T-BuT-S4D/hackceler8-2024

色々解析した結果、次のようなことがわかった。

まず、このゲームでは重力は移動によってプレイヤーが壁や床に触れてめり込んだ時、上下左右4方向に対して、その方向にどれだけ押し出せばプレイヤーが壁にめり込んでいない状態になるかを計算し、最も小さい方向（min push vectorと呼ぶ）に押し出す というロジックが存在する。

ジャンプ可能かの判定は、プレイヤーの座標を1だけ下にずらした時、min push vectorが上方向であるような当たり判定が存在するならcan_jumpをTrueにする。
というように処理している。

壁に向かってジャンプしてめり込み、ふたつの壁の境目でcan_jump判定を更新すれば壁ジャンプができそうである。ところが、ゲーム処理は、

• ジャンプ可能判定の更新
• プレイヤーの入力を反映
• min push vector方向に押し出してめり込みを解除

という順番で行われているため、ジャンプ可能判定の処理時点ではめり込みが解除されており一見壁ジャンプは不可能である。

しかし、コードをよく読むと、プレイヤーを押し出す時push vectorをintに丸めた値が0であれば押し出さないという処理がある。
これによって、1未満であれば壁にめり込むことができる。*6
プレイヤーの移動速度は2.3/tick、ダッシュすると1.5倍の3.45/tickのため、プレイヤーの座標 mod 1.15は常に一定となる。しかし、壁に当たることによってこの座標 mod 1.15の値(これをsubpixelと呼んでいた)を変えることができる。
これによって、適切な壁があれば、壁にめり込む量を1未満の間で0.05単位で調整することができる。

まとめると、
「上下に重なるふたつの壁境目で、1だけ下にずれたときに横方向のpush vectorより上方向のpush vectorの方が小さくなるように、予め適切な壁にぶつかってsubpixelを揃えておき、ちょうど壁にめり込みむところまで移動し、ちょうどジャンプ可能判定がTrueになるタイミングでジャンプキーを入力する。」

という手順で壁ジャンプが可能となる。

左下の座標の表示を見ると、左方向のpush vectorは 、上方向のpush vectorは であり、 なためcan_jump判定がTrueになる。このタイミングでジャンプキーを押すとジャンプできる。

壁ジャンプするためのsubpixelが揃っている壁のビジュアライズと、ちょうど壁にめり込む所までだけ移動するのの自動化、can_jump判定がTrueになるタイミングでのジャンプの自動化を書いた。

決勝で実際に出題されたが、その時はcan_jumpの判定方法が変更されていて若干簡単になっていたようだった。
また、これについて解析している途中で、can_jumpがTrueになるタイミングですぐにジャンプするとlast_ground_posの値が更新されないバグも見つけ、これも決勝で出題されたため役に立った。

Day3

2日目までとは違いYouTubeに配信されているため、大きな講堂のようなところで箱に入れられて競技をすることになった。2日目までは他のチームの声でオンラインメンバーと繋いでいたVCが全然聞こえなかったが、今度はちゃんと防音されておりその点ではかなり良かった。

会場準備が押したらしく準決勝の開始10分前に会場入りして慌ててpcなどのセットアップをした。

Semifinals

準決勝はKalmarunionenとの対戦だった。
modをゲームクライアントに自動で適用させるpatcherが上手く動かず序盤で躓いたが、準備フェーズ中にocean、ruins、arcadeがクリアされた。

ボスに入った時点ではリードしていたが、相手に先にボスを倒されると負けるため全く油断できなかった。

しかし、オンラインのxrekkusuさんが突然「倒した」と言ってキー入力ファイルを上げた。早すぎて全く意味がわからなかったが、どうやらoceanのステージをクリアするのに使った｢しゃがみながらだと攻撃のクールタイムがなくなり秒間30回攻撃できる｣というバグがボスにも使えたらしい。急いでサーバーに繋いでボスを倒し、こちらのチームが勝利した。

あとから聞いた話だと相手チームも数分差でボス部屋まで到達しており、同じ方法を試そうとしていたところだったとの事で、本当に危なかった。

他のチームが戦っていた2試合目はバグを直しながら客席で観戦した。ボス問としてNPCとインタラクティブに会話するpwnが出るなど、うちのチームが得意そうな問題群が出て｢こっちの問題がやりたかった｣などと話していた。

Finals

決勝はZer0RocketWrecksとの対戦だった。

決勝までは30分ほど時間があると聞いておりゆっくり準備をしていたらいきなり問題ファイルが共有されて試合が始まり、慌ててpcなどのセットアップをした。

開始から15分ほど、ruinsが前日に用意した2段ジャンプチートでクリアできるらしい。
beachも前日に用意した自動ジャンプを使うと上手くいくらしく、25分ほどで準備フェーズ中にクリアされた。
cloudもサーバーに接続可能になる直前にクリアできたらしく、あとはarcadeかmazeのステージがクリアできるとボスポータルを解放できる。
今までのarcade問は全てPythonだったが、ここではバイナリが実行されていた。arcadeは私が担当するつもりだったが、バイナリでpwnっぽいとなると自分より適任がいるのでその人達に任せる。
mazeのpiet問がローカルで解けたと報告が入る。その後リモートでも特にバグらずに動き、これでボスが開放された。この時点で残り30分程度、得たスターの数は7-3で勝っていた。

ボスは一見ベースゲームから何も変更がないように見えたが、hpを半分まで減らすと第2形態に移行し全くダメージが入らなくなった。ボスに重なって攻撃する、近接攻撃する、第1形態の間に弾を貯めて一気に攻撃する、など色々試したが最後まで倒せず、ゲームが終わった。
終わった瞬間はボス倒せなかった……という気持ちだったが、よく考えるとボスに入る時点では勝っており、その後逆転された様子もないのでどうやら勝ったらしい。実感がわかないうちにインタビュワーが部屋に入ってきた。

ボス戦（未だに倒し方がわからない）

優勝できるとは思っておらず、また予選はかなりキャリーされ気味だったので、ちゃんと活躍した結果の優勝というのもありかなり嬉しかった。

書いたツールはかなり便利に動いてくれた。ただし、ノリで適当に機能を継ぎ足していったら自分でも汚いと思う感じのコードになり、チームの人にももうちょっと手加減してくれと言われながらリファクタリングされるなどしたのはかなり反省だった。その割に本番は大きなバグなく動いてくれてよかった。

優勝チームは毎年ツールを公開してるよ！みたいな圧をかけられた(?)ので、作ったツールはGitHubに公開している。cloneして適当にmod.pyを実行すれば動くようになっているはずなのでぜひ触ってみてください。
github.com

Day4

決勝翌日は一日空いていたので、マラガ県内を観光した。ホテル近くの海で海水浴をしたり（めちゃくちゃ寒かった）、ゲームミュージアムに行ってファミコンやCHUNITHMをしたり、デカい砦の前で本物のKijitora猫に挨拶したりした。

*1:もっと欲しい

*2:とはいえ、私が直接解いた問題はそう多くない

*3:https://x.com/Yu_212_MC/status/1804941678173966570

*4:ありがとう

*5:オンサイトでゲームをプレイするのは4人だが、オンラインで他のチームメンバーに問題を共有して大人数で取り組むことが可能

*6:ただし壁に向かって歩き続けているとpush vectorが1以上になるためすぐに押し出される

AlpacaHack Round 3 (Crypto) writeup

2024/9/15に開催されたAlpacaHack Round 3 (Crypto)のwriteupです。全完して6位でした。
主に競技プログラミング界隈から来て最近CTFを始めたという方に向けて、CTF特有の考え方といった部分を丁寧めに書いてみます。

qrime

RSA暗号をベースにした問題ですが、 の素因数 の生成方法が特殊です。
として生成され、 に追加で が与えられています。
RSA暗号は または を求めることができてしまうと任意の暗号文を復号できます。
この式と の つの式を用いて の素因数 を求めることができないでしょうか。
ここで、 が数式として表しにくく邪魔なため、ある整数 を用いて と表すことを考えてみます。
すると、 に関する最初の式は となり、未知数が つ増えてしまう代わりに式として扱いやすくなります。*1
では、式に出てくる値それぞれの大きさ(bit数)を考えてみましょう。 はコードにある通り256ビットのランダムな値を取ります。 が ビットであることから は ビットです。では はどうでしょうか。
次のようなコードを実行すると、 がどれくらいの大きさの値になるかわかります。

x = getRandomNBitInteger(256)
print(nextPrime(x) - x)

何度か実行してみると、高々1000とかなり小さい値をとっています。*2 両方を十分高速に全探索できそうです。*3
ここまでをまとめると、 を未知数として連立方程式

を解くことができればよいです。
これを変形していくと と、 に関する二次方程式が得られます。これを解くことで を求めることができました。

ソルバ

from Crypto.Util.number import long_to_bytes
from math import isqrt

n=200697881793620389197751143658858424075492240536004468937396825699483210280999214674828938407830171522000573896259413231953182108686782019862906633259090814783111593304404356927145683840948437835426703183742322171552269964159917779
e=65537
c=77163248552037496974551155836778067107086838375316358094323022740486805320709021643760063197513767812819672431278113945221579920669369599456818771428377647053211504958874209832487794913919451387978942636428157218259130156026601708
r=30736331670163278077316573297195977299089049174626053101058657011068283335270

def solve_rsa(p, q):
    phi = (p - 1) * (q - 1)
    d = pow(e, -1, phi)
    m = pow(c, d, n)
    return long_to_bytes(m)

def solve():
    for a in range(1000):
        for b in range(1000):
            aa = 2 * r + b
            bb = a * r
            cc = -n
            q = (-bb + isqrt(bb * bb - 4 * aa * cc)) // (aa * 2)
            if q > 0 and n % q == 0:
                p = n // q
                print(p, q)
                print(solve_rsa(p, q))
                return
solve()

Crypto.Util.number は pycryptodome のモジュールです。この問題ではバイト列と整数の間の変換に使われていましたが、pycryptodome はこの問題に限らず多くの問題で使われます。

おまけ

ちなみに、sagemathをうまく使うと、二つの式を求めた後人力で式変形をする必要なく簡単に解くことができます。二つの式の終結式を求めてそれを解かせています。（私はこちらの方法で解きました）

from sage.all import *

PR = PolynomialRing(ZZ, ["p", "q"])
p, q = PR.gens()
for a in range(1000):
    for b in range(1000):
        f1 = n - p * q
        f2 = q * (r + b) + (q + a) * r - p
        rr = f1.resultant(f2).univariate_polynomial().roots()
        if len(rr) > 0:
            q = rr[0][0]
            p = n // q
            print(solve_rsa(p, q))

Rainbow Sweet Alchemist

RSA暗号をベースにした問題で、 の素因数 の生成方法が特殊です。
シードを固定した乱数生成器を用いていくつかの素数を生成した後、 個の値を使って のようにして を生成しています。
random.choice はシードを固定した乱数生成器を使っていないため、同じコードを実行して を得るというのは不可能そうです。
ここで、 の素因数としてあり得るものが全て求まることに注目します。実験してみるとgetPrimeは多めに見積もっても 回程度のループで答えを返すため、deterministicGetPrime が返す最初の 個の値を手元で計算しておくと、 の素因数は とこのリストの中の値のみを含みます。
つまり、 とこのリストすべての値の積を と置くと、これは の倍数となります。この性質の何が嬉しいかというと、オイラーの定理より、 を と互いに素な整数として が成り立ちます。
このリストから素数を一つずつ消していくと、 の素因数 が消された場合にのみ となり、各素数が の生成に使われたかを判定することができます。
逆に、リストに一つずつ素数を追加していき となったタイミングを調べていくという方法でも解くことができ、こちらのほうが高速です。

考え方としてはポラードのp-1因数分解法に近く、このアルゴリズムを知っている人であれば早く思いつけるのかなと思います。

ソルバ

from Crypto.Util.number import long_to_bytes
import random

r = random.Random(0)
def deterministicGetPrime():
    while True:
        if isPrime(p := r.getrandbits(64)):
            return p

def solve_rsa(p, q):
    phi = (p - 1) * (q - 1)
    d = pow(e, -1, phi)
    m = pow(c, d, n)
    return long_to_bytes(m)

assert deterministicGetPrime() == 2710959347947821323

ps = [deterministicGetPrime() for _ in range(2000)]
factors = []
while len(factors) < 16:
    prd = 1
    x = pow(2, 4, n)
    for p in factors:
        x = pow(x, p, n)
    if x == 1:
        break
    for p in ps:
        x = pow(x, p, n)
        if x == 1:
            factors.append(p)
            break
    print(factors)
tmp = 1
for p in factors:
    tmp *= ps[i]
p = tmp * 2 + 1
q = n // p
print(solve_rsa(p, q))

A Dance of Add and Mul

楕円曲線の問題です。
いくつかの有名なパラメータの楕円曲線には名前がついており、問題コードに書いてあるBLS12-381もその一つです*4。検索してみるとペアリングの計算をする際によく用いられるとわかります。
ペアリングについての説明は（私もあんまりよくわかっていないため）省略するので、このページ などを見てください。

さて、隣接する について から共通の値を使っていることから、各 に対して か か求めるよりも、隣接する二つの について同じ値を取るかを求めるほうが見通しがよさそうです。
と の間でペアリングの計算をすることを考えると、例として のとき のようになります。
更に、 のときについて考えると のようになり、先ほどの結果と一致します。
このことから、 とのペアリングを計算した結果が隣接する二つの で一致した場合、その二つの の値は異なることが分かります。 とのペアリングを計算した結果についても同様です。
これと一つ目の が であることから、すべての の値を求めることができます。
上述のサイトでは に拡大した体を用いていましたが、この問題では で十分なようです。

ソルバ

from pwn import *

cs = eval(read("a-dance-of-add-and-mul/chall.txt").decode())

p = 0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab
K = GF(p)
E = EllipticCurve(K, (0, 4))
cs = [E(x, y) for x, y in cs]

G1, G2 = E.gens()
o1, o2 = G1.order(), G2.order()

r = 0x5f19672fdf76ce50d28e776116d47d5841f8c5f1fba8d33881bfa40089fc5bffd1ffffff00010001
A1 = [c.weil_pairing(G1, r) for c in cs]
A2 = [c.weil_pairing(G2, r) for c in cs]

v = 0
vs = []
for i in range(len(A1) - 1):
    vs.append(v)
    if A1[i] == A1[i+1] or A2[i] == A2[i+1]:
        v = 1 - v
vs.append(v)
print(unbits(vs))

readやunbitsはpwntoolsにある関数で、それぞれバイト列としてファイルを読む関数とビットのリストをバイト列に変換する関数です。pwntoolsには他にもいくつか便利な関数があるのでリファレンスに目を通しておくと便利かもしれません。

Hat Trick

三つのRollingHashについてハッシュが特定の値を取るような長さ54以下の英小文字列を求める問題です。

まずは与えられた条件から使えそうな式を立てていきます。
使う文字数については多いほうが考えられる状態が広く条件を満たすように値を取りやすくなるため、とりあえず最大の54文字を決め打ちで考えていきましょう。
は英小文字であることから、 です。
更にRollingHashの式を考えると、 というような式が つ立ちます。
一度ずつしか登場しない値 が法として使われているのはあまりうれしくないので、未知の整数 を用いて というように変形します。
ここで、 が未知の値で、他に出てくる値はすべて既知です。よって、すべての条件は線形な式で表されています。*5

未知数がとる値の範囲が他の値と比べて小さい、出てくる式が線形である、といった点から、LLLを使って解くことができそうだとあたりを付けることができます。

LLLはCTFにおいてかなり頻出のアルゴリズムで、競技プログラマであれば使うのはそれほど難しくないため、早めに慣れておくと便利かなと思います。*6
LLLについて非常に雑に説明すると、行列 に対し、行ベクトル を 　のノルムが"いい感じに小さく"なるようにとったときの の値を求めることができます。
（LLL自体の説明ではなく、LLLを使ってできることについての説明。詳しい説明については他の記事を参照してください。）

計算量は重めの多項式時間で、行列のサイズが くらいまでなら動くと思っておけばいいと思います。
問題に"いい感じに小さい"値が出てきたときは、その値が右辺に来るような線型方程式をうまく立てることによってLLLで解ける形に持っていくことができることが多いです。

それでは、LLLに使う式を立てていきます。

RollingHashの式はそのまま使って です。
更に、 は値域の中心である に近い値を取ってほしい、つまり が小さい値になってほしいです。次のような行列を立てます。

に左から を掛けるとノルムの小さいベクトル になるため、LLLの出力には が現れることが期待できます。LLLは実際には行ベクトルではなく行列を出力としていて、各行が としてありうるノルムの小さいベクトルとなっています。それぞれの行を見て の値域が条件を満たさないものなどを除くと解が得られます。
LLLではベクトルの各要素が同程度の大きさ(bit数)の値になるように重みを調節することが大切です。から列目にはが出てきてほしいため、他の列より小さくなるよう 倍しています（特にという数字に意味があるわけではありません）。
LLLはsagemathのライブラリを使うのが簡単です。

ソルバ

from sage.all import *
from pwn import *
import json

so = remote("xxx.xxx.xxx.xxx", 0)
params = json.loads(so.recvline().removeprefix(b"params: "))
for _ in range(3):
    target_hash = json.loads(so.recvline().removeprefix(b"target: "))
    print(target_hash)

    MAX_LEN = 54
    B = 128
    M = Matrix(ZZ, MAX_LEN+4, MAX_LEN+4)
    for i in range(MAX_LEN):
        M[i, i] = 1
        M[MAX_LEN+3, i] = 109
        M[i, MAX_LEN+0] = pow(params[0]["base"], i, params[0]["p"]) * B
        M[i, MAX_LEN+1] = pow(params[1]["base"], i, params[1]["p"]) * B
        M[i, MAX_LEN+2] = pow(params[2]["base"], i, params[2]["p"]) * B
    M[MAX_LEN+0,MAX_LEN+0] = params[0]["p"] * B
    M[MAX_LEN+1,MAX_LEN+1] = params[1]["p"] * B
    M[MAX_LEN+2,MAX_LEN+2] = params[2]["p"] * B
    M[MAX_LEN+3,MAX_LEN+0] = target_hash[0] * B
    M[MAX_LEN+3,MAX_LEN+1] = target_hash[1] * B
    M[MAX_LEN+3,MAX_LEN+2] = target_hash[2] * B
    M[MAX_LEN+3,MAX_LEN+3] = 1

    M = M.LLL()
    for row in M:
        if row[-1] != -1:
            continue
        s = [chr(ch + 109) for ch in row[:MAX_LEN]]
        if not ('a' <= min(s) and max(s) <= 'z'):
            continue
        if list(row[MAX_LEN:-1]) != [0, 0, 0]:
            continue
        s = "".join(s)
        print(s)
        so.sendlineafter(b"> ", s.encode())
        break
print(so.recvline())

*1:当たり前ですが重要なこととして、未知数は少ないほうが嬉しいです

*2:素数定理から言えますが、こういうのは色々実験して発見するほうが早いと思います

*3:この問題では 以外の値の大きさは重要ではありませんが、出てくるの値の大きさを考えるというのはCTFにおいてはかなり重要な考察です

*4:Cryptoに限らないCTF典型として、ソースコードに書かれているコメントは大体ヒントです

*5:未知数に関する二次式は条件 としてかなり扱いにくく、線形だと結構うれしいことが多いです。そういう場合はCoppersmith's Methodとかを持ち出したりすることもあります

*6:アルゴリズム自体の理論や証明は難しめです

Crypto CTF 2024 writeup

6/8～6/9に開催されたCrypto CTF 2024に参加して33位だった。久しぶりにwriteupを書く。結構楽しみにしてたけど色々あってあまり時間が取れず、24時間のうち8時間くらいしか参加できなかった。
もうちょっと時間かけたら解けたかなという問題もあったので残念、upsolveしたら追記するかも？

Alibos [181 solved]

問題

#!/usr/bin/env python3

from Crypto.Util.number import *
from gmpy2 import *
from secret import d, flag

get_context().precision = 1337

def pad(m, d):
	if len(str(m)) < d:
		m = str(m) + '1' * (d - len(str(m)))
	return int(m)

def genkey(d):
	skey = getRandomRange(10 ** (d - 1), 10 ** d)
	pkey = int(10**d * (sqrt(skey) - floor(sqrt(skey))))
	return pkey, skey

def encrypt(m, pkey):
	m = pad(m, len(str(pkey)))
	d = len(str(pkey))
	c = (pkey + d ** 2 * m) % (10 ** d)
	return c

pkey, skey = genkey(d)

m = bytes_to_long(flag)
c = encrypt(m, pkey)

print(f'pkey = {pkey}')
print(f'enc  = {c}')

解法

で が与えられている。 もlen(str(pkey))と等しいのでわかり、
として が復号できる。あとはpaddingを外せばフラグが得られる。

d = len(str(pkey))
m = (enc - pkey) * pow(d ** 2, -1, 10 ** d) % (10 ** d)
while m > 0:
    if l2b(m).startswith(b"CCTF"):
        print(l2b(m))
    m //= 10

Joe-19 [120 solved]

問題

#!/usr/bin/env sage

from GPT import GPT6 # deep fake 
from Crypto.Util.number import *
from flag import flag

P = [GPT6('A 512-bit prime appears in consecutive digits of e') for _ in range(4)]
n, m = prod(P), bytes_to_long(flag)
c = pow(m, 0x10001, n)
print(f'n = {n}')
print(f'c = {c}')

解法

Pは の連続する512ビットの部分文字列4つを素因数に持つらしい。適当なサイト から の値をとってきて前から順番に試していけばよい。

rem = n
ps = []
for i in range(len(E)):
    ln = 150
    while True:
        p = int(E[i:i+ln])
        if p.bit_length() >= 512:
            break
        ln += 1
    if rem % p == 0:
        ps.append(p)
        rem //= p
    if len(ps) == 3:
        break
ps.append(rem)
phi = (ps[0]-1)*(ps[1]-1)*(ps[2]-1)*(ps[3]-1)
d = pow(65537, -1, phi)
print(l2b(pow(c, d, n)))

Mashy [68 solved]

問題

#!/usr/bin/env python3

import sys
from hashlib import md5
from binascii import *
from secret import salt, flag

def die(*args):
	pr(*args)
	quit()

def pr(*args):
	s = " ".join(map(str, args))
	sys.stdout.write(s + "\n")
	sys.stdout.flush()

def sc():
	return sys.stdin.buffer.readline()

def xor(s1, s2):
	return bytes([s1[_] ^ s2[_] for _ in range(len(s1))])

def main():
	border = "┃"
	pr(        "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓")
	pr(border, ".: Hi all, she did Mashy, you should do it too! Are you ready? :. ", border)
	pr(        "┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛")

	REC = []
	cnt, STEP = 0, 7
	sh = md5(salt).digest()
	
	while True:
		pr(border, f'Please send your first input:  ')
		d1 = sc().strip()
		pr(border, f'Please send your second input: ')
		d2 = sc().strip()
		try:
			d1 = hexlify(unhexlify(d1))
			d2 = hexlify(unhexlify(d2))
			h1 = md5(unhexlify(d1)).digest()
			h2 = md5(unhexlify(d2)).digest()
		except:
			die(border, 'Your inputs are not valid! Bye!!!')
		if d1 != d2 and d1 not in REC and d2 not in REC:
			if md5(xor(d1, d2)).hexdigest() != 'ae09d7510659ca40eda3e45ca70e9606':
				if hexlify(xor(xor(h1, h2), sh)) == b'a483b30944cbf762d4a3afc154aad825':
					REC += [d1, d2]
					if cnt == STEP:
						die(border, f'Congrats! the flag: {flag}')
					pr(border, 'Good job, try next level :P')
					cnt += 1
				else:
					die(border, 'Your input is not correct! Bye!')
			else:
				die(border, 'No this one! Sorry!!')
		else:
			die(border, 'Kidding me!? Bye!!')

if __name__ == '__main__':
	main()

解法

md5で衝突するハッシュを8回見つければフラグが得られる。ggると
4dc968ff0ee35c209572d4777b721587d36fa7b21bdc56b74a3dc0783e7b9518afbfa200a8284bf36e8e4b55b35f427593d849676da0d1555d8360fb5f07fea2
4dc968ff0ee35c209572d4777b721587d36fa7b21bdc56b74a3dc0783e7b9518afbfa202a8284bf36e8e4b55b35f427593d849676da0d1d55d8360fb5f07fea2
の二つのハッシュが衝突するらしい。これらは長さが64バイト(=1ブロック)なので内部状態が一致しており、後ろに任意の文字列を追加してもハッシュ値が一致する。

d1 = bytes.fromhex("4dc968ff0ee35c209572d4777b721587d36fa7b21bdc56b74a3dc0783e7b9518afbfa200a8284bf36e8e4b55b35f427593d849676da0d1555d8360fb5f07fea2")
d2 = bytes.fromhex("4dc968ff0ee35c209572d4777b721587d36fa7b21bdc56b74a3dc0783e7b9518afbfa202a8284bf36e8e4b55b35f427593d849676da0d1d55d8360fb5f07fea2")

s = remote("01.cr.yp.toc.tf", 13771)
for i in range(8):
    s.sendlineafter(b":  ", (d1+p64(i)).hex().encode())
    s.sendlineafter(b": ", (d2+p64(i)).hex().encode())
print(s.recvall())

Melek [66 solved]

問題

#!/usr/bin/env sage

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

def encrypt(msg, nbit):
	m, p = bytes_to_long(msg), getPrime(nbit)
	assert m < p
	e, t = randint(1, p - 1), randint(1, nbit - 1)
	C = [randint(0, p - 1) for _ in range(t - 1)] + [pow(m, e, p)]
	R.<x> = GF(p)[]
	f = R(0)
	for i in range(t): f += x**(t - i - 1) * C[i]
	P = [list(range(nbit))]
	shuffle(P)
	P = P[:t]
	PT = [(a, f(a)) for a in [randint(1, p - 1) for _ in range(t)]]
	return e, p, PT

nbit = 512
enc = encrypt(flag, nbit)
print(f'enc = {enc}')

解法

項からなる多項式 を 個のランダムな点で評価した結果が与えられる。
ラグランジュ補間で が復元できるので定数項を復号すればフラグが得られる。

output = open("Melek/output.txt", "r").read()
output = list(map(int, re.findall(r"\d+", output)))
e, p, *a = output
t = len(a) // 2
a = [(a[i*2], a[i*2+1]) for i in range(t)]

R.<x> = GF(p)[]
f = R.lagrange_polynomial(a)

d = pow(e, -1, (p-1)//2)
print(l2b(int(pow(f[0], d, p))))

RM2 [64 solved]

問題

#!/usr/bin/env python3

import sys
from Crypto.Util.number import *
from string import *
from random import *
from flag import flag
	
def die(*args):
	pr(*args)
	quit()
	
def pr(*args):
	s = " ".join(map(str, args))
	sys.stdout.write(s + "\n")
	sys.stdout.flush()
	
def sc(): 
	return sys.stdin.buffer.readline()

def randstr(l):
	return ''.join([printable[randint(0, 90)] for _ in range(l)])

def encrypt(msg, p, q):
	e = 65537
	m1, m2 = msg[:len(msg) >> 1], msg[len(msg) >> 1:]
	m1, m2 = bytes_to_long(m1), bytes_to_long(m2)
	c1, c2 = pow(m1, e, (p - 1) * (q - 1)), pow(m2, e, (2*p + 1) * (2*q + 1))
	return (c1, c2)

def main():
	border = "┃"
	pr(        "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓")
	pr(border, ".: Welcome to RM2 task! Your mission is break our cryptosystem :. ", border)
	pr(        "┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛")
	nbit, _b = 1024, False
	pr(border, f"Please provide your desired {nbit}-bit prime numbers p, q:")
	inp = sc().decode()
	try:
		p, q = [int(_) for _ in inp.split(',')]
		if p.bit_length() == q.bit_length() == nbit and isPrime(p) and isPrime(q) and p != q:
			_b = True
	except:
		die(border, f"The input you provided is is not valid!")
	if _b:
		e, n =  65537, p * q
		s = randstr(nbit >> 4).encode()
		m = bytes_to_long(s)
		assert m < n >> 2
		c1, c2 = encrypt(s, p, q)
		pr(border, f'c1 = {c1}')
		pr(border, f'c2 = {c2}')
		pr(border, f'Now, send us the secret string to get the flag: ')
		_m = sc().strip()
		if _m == s:
			die(border, f'Congrats, you got the flag: {flag}')
		else:
			die(border, f'The secret string is not correct! Bye!!')
	else:
		die(border, f"Your input does not meet the requirements!!!")

if __name__ == '__main__':
	main()

解法

メッセージを と の二つで暗号化していて、両方を復号できればフラグが得られる。
がわかれば復号できるので、を素因数分解したい。 と の両方がB-smoothになるように を選べばよさそうだ。
SECCON CTF 2023で似たような話を見たのでdiscordサーバーを見てみると、次のような方針があった。

この時の問題では と がB-smoothになるように を選んでいたが、今回は と がB-smoothになるように選ぶ。
を適当に選んで とすると、、となり、どちらも高い確率で小さい素因数をたくさん持つ。
次のようなコードで出てきた値を http://factordb.com/ に投げつけるとうまく素因数分解できる が3つ見つかった。

for x in range(2^(1024//120), 2^(1024//120)*4):
    p = (3 * x^120 - 3) // 2 + 1
    if p.nbits() == 1024 and isPrime(int(p)):
        print(p - 1)
        print(2 * p + 1)
        print()

for x in range(2^(1024//80), 2^(1024//80)*4):
    p = (3 * x^80 - 3) // 2 + 1
    if p.nbits() == 1024 and isPrime(int(p)):
        print(p - 1)
        print(2 * p + 1)
        print()

が小さい素因数をたくさん持つため となることがあるのに注意。何度か試すとうまく動く。

p = 165674320538257119618935777569264633493104025830012248611472894731246968925696662635145647004418760425271620056052110213831898075813625940406354655699229763954183325349451697961823730258851477789232732720256524106366149483534442882933118436805397696618238112020186478083571097834483155523153453888627684702401
p1 = [2,2,2,2,2,2,3,5,5,7,11,13,19,23,31,37,61,71,181,229,233,241,401,433,1021,1033,5237,15601,15881,77621,101701,136531,600241,675889,39785017,18590197861,2110175168929,62270035466201,708791106674191,3388917958905421,297934315348629678161,343722324162224502721,4258346124311062016361408601,196833670484920623077625618471272401,3277953273564812642861575873943801232248811019050895081]
p2 = [3] * 241 + [41] * 120

q = 136319579751776446060762594173031311688966678940151526541501511333981751346927563082795749698154881610675192169672633902518187425468160661847068557813564166633080060747936338201910247175316115399953152558661099756476138183615339201940322678359899950385796675849521347379659664940470524326676056070490217094401
q1 = [2,2,2,2,2,2,2,2,3,5,5,7,11,13,17,41,73,101,113,401,1321,4481,12401,36913,46861,54497,204311,261071,8652401,24999521,1357901521,3961916417,29040743441,41589844801,17122630828217,45459230802631,4602336982581694499761,25659752338627001628771761,59522626340600884948348798081,133240651584560734013410462245281,214523217697063175741941761486481,375423311348937549351028930453201]
q2 = [3] * 81 + [2357] * 80

def phi(pr):
    mp = defaultdict(lambda: 0)
    for pp in pr:
        mp[pp] += 1
    ph = 1
    for k, v in mp.items():
        ph *= (k - 1) * k ** (v - 1)
    return ph

s = remote("01.cr.yp.toc.tf", 13371)
s.recvlines(4)
s.sendline(f"{p},{q}".encode())
s.recvuntil(b"c1 = ")
c1 = int(s.recvline())
s.recvuntil(b"c2 = ")
c2 = int(s.recvline())
phi1 = phi(p1 + q1)
phi2 = phi(p2 + q2)
n1 = (p - 1) * (q - 1)
n2 = (2*p + 1) * (2*q + 1)

print(gcd(c1, n1), gcd(c2, n2))

d1 = pow(65537, -1, phi1)
d2 = pow(65537, -1, phi2)
m1 = pow(c1, d1, n1)
m2 = pow(c2, d2, n2)
s.sendline(l2b(m1) + l2b(m2))
print(s.recvall())

Alilbols [59 solved]

問題

#!/usr/bin/env python3

from Crypto.Util.number import *
from gmpy2 import *
from secret import d, flag

def genkey(d):
	while True:
		f = getRandomRange(1, int(sqrt(2) * 10 ** d))
		g = getRandomRange(10 ** d, int(sqrt(2) * 10 ** d))
		if gcd(f, 10 * g) == 1:
			q = 4 * 100 ** d
			h = inverse(f, q) * g % q
			if gcd(h, 10 * d) == 1:
				break
	pkey, skey = (d, h), (f, g)
	return pkey, skey

def encrypt(m, pkey):
	d, h = pkey
	q = 4 * 100 ** d
	assert m < 10 ** d
	r = getRandomRange(1, 10 ** d // 2)
	c = (r * h + m + r) % q
	return c

pkey, _ = genkey(d)
m = bytes_to_long(flag)
c = encrypt(m, pkey)

print(f'h = {pkey[1]}')
print(f'c = {c}')

解法

として暗号化されている。まずは から を求めたい。
これは式変形して と表せるが、 は に対して小さいので、次のような行列に対してLLLを適用すると求められる。

あとは を求める部分。 を式変形して とすると、両辺の絶対値は より小さく、結局modを取らずに が成り立つ。
これはextgcdの形なのでextgcdで解けばよい。

d = 563
q = 4 * 100 ** d
M = Matrix(ZZ, [
    [q * 10**d, 0, 0],
    [-h * 10**d, 1, 0],
    [10**d, 0, 1]
])
M = M.LLL()
for row in M[1:]:
    _, f, g = row
    fc = int(f * c % q)
    _, a, b = xgcd(g + f, f)
    a = a * fc % f
    b = b * fc % (g + f)
    print(l2b(abs(b)))
    break

Vantuk [51 solved]

問題

#!/usr/bin/env sage

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

def u(a, x, y):
	assert a.is_integer() and x.is_rational() and y.is_rational()
	return x + Rational((a * x - y)/(x ** 2 + y ** 2))

def v(a, x, y):
	assert a.is_integer() and x.is_rational() and y.is_rational()
	return y - Rational((x + a * y)/(x ** 2 + y ** 2))

m1 = Integer(bytes_to_long(flag[:len(flag)//2]))
m2 = Integer(bytes_to_long(flag[len(flag)//2:]))
a = Integer(randint(1, 1 << 512))

print(f'A = {u(5, a, 4*a)}')
print(f'U = {u(a, m1, m2)}')
print(f'V = {v(a, m1, m2)}')

解法

と が定義されており、 が与えられている。
なので の分母から は求まる。
から、分母と分子で と に関する式が二つ得られるので、これを解くことによって が求まる。
あたえられる は約分されているので 小さい範囲で分母分子を 倍して試す。実装にはsagemathのresultantを使うと人力で について解く必要がなくて楽できる。

a = A2 // 17
for k in range(1, 100):
    PR.<x,y> = PolynomialRing(ZZ)
    fa = x^2+y^2 - Ud*k
    fb = x*Ud*k+a*x-y - Un*k

    fd = fb.resultant(fa, y)
    r = fd.univariate_polynomial().roots()
    if len(r) >= 1:
        x = r[0][0]
        y = fb(x=x).univariate_polynomial().roots()[0][0]
        break
print(l2b(x) + l2b(y))

Bada [51 solved]

問題

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Hey! It's time to solve the equation of a function f: N x N -> Z.    ┃
┃ Function f has given certain conditions. In each step, solve the     ┃
┃ equation f(x, y) = z with the given value of z. We know f(a+1, b) =  ┃
┃ f(a, b) + a, and f(a, b+1) = f(a, b) - b, for every `a' and `b'.     ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
┃ We know: f(1, 1) = 438080133526 and f(x, y) = 1017215874263
┃ Please send x, y separated by comma:

解法

ソースコードはなく、ncすると問題が出てくる。条件を満たす関数は なので、 となるような を求めればよい。
がんばって算数すると が条件を満たすことがわかる。

s = remote("01.cr.yp.toc.tf", 17113)
s.recvlines(6)
for _ in range(20):
    line = s.recvline()
    f11 = int(line[line.index(b"f(1, 1) = ") + 10:line.index(b" and")])
    fxy = int(line[line.index(b"f(x, y) = ") + 10:])
    s.recvline()
    print(line)
    a = fxy - f11 + 1
    b = fxy - f11
    assert a * (a - 1) // 2 - b * (b - 1) // 2 + f11 == fxy
    s.sendline(f"{a},{b}".encode())
    s.recvline()
print(s.recvline())

Honey [48 solved]

問題

#!/usr/bin/env python3

from Crypto.Util.number import *
from math import sqrt
from flag import flag

def gen_params(nbit):
	p, Q, R, S = getPrime(nbit), [], [], []
	d = int(sqrt(nbit << 1))
	for _ in range(d):
		Q.append(getRandomRange(1, p - 1))
		R.append(getRandomRange(0, p - 1))
		S.append(getRandomRange(0, p - 1))
	return p, Q, R, S

def encrypt(m, params):
	p, Q, R, S = params
	assert m < p
	d = int(sqrt(p.bit_length() << 1))
	C = []
	for _ in range(d):
		r, s = [getRandomNBitInteger(d) for _ in '01']
		c = Q[_] * m + r * R[_] + s * S[_]
		C.append(c % p)
	return C


nbit = 512
params = gen_params(512)
m = bytes_to_long(flag)
C = encrypt(m, params)
f = open('params_enc.txt', 'w')
f.write(f'p = {params[0]}\n')
f.write(f'Q = {params[1]}\n')
f.write(f'R = {params[2]}\n')
f.write(f'S = {params[3]}\n')
f.write(f'C = {C}')
f.close()

解法

p, Q, R, S, Cが512ビットなのに対し未知数r, sは32ビットと小さく、LLLができそう。実際次のような行列を作るとできる。

は右辺の各値が同じくらいの大きさになるように くらいを選ぶ。

d = 32
M = Matrix(ZZ, d*3+2, d*3+2)
B1 = 2^768
B2 = 2^512
B3 = 2^(512-32)
M[0, d] = 1
M[1, d+1] = B2
for i in range(d):
    M[0, i] = Q[i] * B1
    M[1, i] = C[i] * B1
    M[2+i, i] = R[i] * B1
    M[d+2+i, i] = S[i] * B1
    M[d+d+2+i, i] = p * B1
    M[2+i, d+2+i] = B3
    M[d+2+i, d+d+2+i] = B3
M = M.LLL()
for row in M:
    flag = l2b(abs(row[d]))
    if flag.startswith(b"CCTF"):
        print(flag)
        break

Soufia [36 solved]

問題

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ .::   Soufia is a random oracle, your mission is to break it   ::. ┃
┃ We know that f: Z → Z and for all integers `x' and `y' we have:    ┃
┃     f(t * x) + t * f(y) = f(f(x + y)) for constant integer `t'.    ┃
┃ Also, f(0) = 152308255043072524838402620274259353263,              ┃
┃ and   f(47) = 5863519591712360420248155854856998139426             ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
┃ Please send the f(13):

解法

またソースコードなし問。 で考えると なので、 が成り立つ。
実験すると になっていて、何度か実行しても同じ式が成り立つので、二つ目に与えられている値が だとエスパーする。
は扱いにくいので、 を使う。
が分かっていることから として各値を順に求めていくことができる。

s = remote("03.cr.yp.toc.tf", 13377)
s.recvuntil(b"f(0) = ")
f0 = s.recvline()
s.recvuntil(b"f(")
line = s.recvline()
f0 = int(f0[:f0.index(b",")])
t = int(line[:line.index(b")")])
ft = int(line[line.index(b"= ")+2:line.index(b"  ")])

f = [0] * (t + 1)
f[0], f[t] = f0, ft
for i in reversed(range(1, t)):
    f[i] = (f[0] + t * f[i + 1] - f[t]) // t

for i in range(20):
    s.recvuntil(b"send the f(")
    line = s.recvline()
    x = int(line[:line.index(b")")])
    while len(f) <= x:
        f.append((f[-1] * t + f[t] - f[0]) // t)
    s.sendline(str(f[x]).encode())
    print(t, x, f[x], s.recvline())
print(s.recvline())

Nazdone [35 solved]

問題

#!/usr/bin/env python3

from Crypto.Util.number import *
from random import *
from secret import params, flag

def sol(m, a, z):
	p = m * (a - 1) % 2 + 1
	while True:
		R = list(range(1, a))
		shuffle(R)
		for r in R[:z]:
			p += getRandomRange(0, 2) * m ** r
		if isPrime(p):
			return p
		else:
			p = m * (a - 1) % 2 + 1


p, q, r = [sol(*params) for _ in '007']
n = p * q * r
m = bytes_to_long(flag)
c = pow(m, params[0] ** 3 + params[2] - 2, n)
print(f'n = {n}')
print(f'c = {c}')

解法

は 進数で1の位高々z桁が1であるような素数を返している。
まずはmを特定する。1の位がすべて1またはすべて2であることから、 は または の約数であることが分かる。適当に試すと がそれっぽい。
mをxと置き換えて多項式だと思うことにすると、 は3つの多項式の積なので、因数分解すると が得られる。あとは を小さい範囲で全探索するとフラグが得られる。

m = 19
nn = n
ms = []
while nn > 0:
    ms.append(nn % m)
    nn //= m
PR.<x> = PolynomialRing(ZZ)
f = 0
for i in range(len(ms)):
    f += ms[i] * x ^ i
ps = [g[0](m) for g in factor(f)]
phi = (ps[0]-1) * (ps[1]-1) * (ps[2]-1)
assert ps[0] * ps[1] * ps[2] == n
for z in range(1, 1000):
    e = int(m ** 3 + z - 2)
    if gcd(e, phi) != 1:
        continue
    d = pow(e, -1, phi)
    pt = l2b(int(pow(c, d, n)))
    if b"CCTF" in pt:
        print(pt)

Beheaded [32 solved]

問題

#!/bin/bash

source secrets.sh

FLAGS="all_flags.txt"
rm -f "all_flags.enc"

while read flag; do
	magick -background white -fill blue -pointsize 72 -size "$X"x"$Y" -gravity North caption:"$flag" flag.ppm
	tail -n +4 flag.ppm > tail
	openssl enc -aes-256-ecb -pbkdf2 -nosalt -pass pass:"$KEY" -in tail >> "all_flags.enc"
done < "$FLAGS"

解法

フラグが書かれた画像を次のコマンドで暗号化している。

openssl enc -aes-256-ecb -pbkdf2 -nosalt -pass pass:"$KEY" -in tail >> "all_flags.enc"

AESのモードがECBなので同じ値を持つブロックが同じ暗号文に暗号化される。.ppmファイルを見ると背景が白なので、文字と重なっていないすべて白のブロックはすべて最初の16バイトと同じdb4e86ff76e9183f97a95d7720dc1d31に暗号化されているはず。
1ピクセルが6バイトなので1ブロックあたり2.6ピクセル程度の情報が入っている。すべて白ではなかったブロックはすべて青だったことにしても問題なさそう。
widthとheightがわからないので適当にwidthを1000として復号してみるとこのようになった。（デカいので一部抜粋）

白が多い部分と黒が多い部分に分かれていて、黒の部分それぞれがall_flags.txtの一行に対応していそう。widthが間違っているので文字は判別できない。
色々widthを変えて試した結果widthが1623の時に正しく復元できた。

enc = read("Beheaded/all_flags.enc")

pixel_values = []
for i in range(0, len(enc), 16):
    if enc[i:i+16] == enc[:16]:
        pixel_values += [1] * 16
    else:
        pixel_values += [0] * 16
pixel_values = [any(pixel_values[i:i+6]) for i in range(0, len(pixel_values), 6)]

width = 1623
height = len(pixel_values) // width
pixel_values = pixel_values[:height * width]
image = Image.new("1", (width, height))
pixels = image.getdata()
image.putdata(pixel_values)
image.save(f"Beheaded/out.png")