+

Author: Eveheeero

_posts/2025-10-28-osugamingCTF2025.md

@@ -88,7 +88,272 @@ dddfasdsasdasdd
 
 ### 분석 과정
 
-.
+![_](/assets/img/posts/2025-10-28-14.png){: style="max-width: 100%; height: auto;"}
+
+`tosu-1`문제와 로직 나머지는 비슷하지만, 올 콤보를 해야하는것이 아닌 특정 값을 맞춰야 하는 문제입니다.
+
+`GIVEN`값은 변하지 않으며, `CALCED`값은 지난 성공 처리하던 곳에 인자로 들어갑니다.
+
+![_](/assets/img/posts/2025-10-28-15.png){: style="max-width: 100%; height: auto;"}
+
+![_](/assets/img/posts/2025-10-28-16.png){: style="max-width: 100%; height: auto;"}
+
+점수 타입 및 노트 인덱스를 이용해 연산하는 로직이 보입니다. `4c00`함수와 `1670`함수, `53c0`함수 및 초기값, 기대값을 ai에 넣어주면 바로 풀어주긴 합니다만 손으로 직접 다시 풀어보겠습니다.
+
+ai가 짜준 코드는 아래와 같습니다.
+
+```python
+# -*- coding: utf-8 -*-
+# HIT/MISS 스케줄을 계산하는 레퍼런스 구현
+# - 상태는 128바이트
+# - M: out[p] = in[p-1] XOR in[p+1] (경계 밖은 0)
+# - HIT: 위치 (t & 0x7F)에 c_t = (t*0x1B + 0x37) & 0xFF 를 XOR한 뒤 M
+# - MISS: M 만 수행
+# - 최종 상태를 목표 바이트열(Target)과 같게 만드는 h_t ∈ {0,1} 시퀀스를 Gaussian 소거로 풂 (GF(2))
+
+from typing import List, Tuple
+
+L = 128  # bytes
+MASK_128 = (1 << L) - 1
+
+# ---------- 비트-평면 표현 도우미 ----------
+
+def bytes_to_planes(bs: bytes) -> List[int]:
+    """128바이트 -> 8개 비트평면(각 128비트 int). plane[b]의 bit p는 bs[p]의 b번째 비트."""
+    assert len(bs) == L
+    planes = [0]*8
+    for p, val in enumerate(bs):
+        for b in range(8):
+            if (val >> b) & 1:
+                planes[b] |= (1 << p)
+    return planes
+
+def planes_to_bytes(planes: List[int]) -> bytes:
+    """8개 비트평면 -> 128바이트"""
+    out = bytearray(L)
+    for p in range(L):
+        v = 0
+        for b in range(8):
+            if (planes[b] >> p) & 1:
+                v |= (1 << b)
+        out[p] = v & 0xFF
+    return bytes(out)
+
+def pack_planes_to_bigint(planes: List[int]) -> int:
+    """8개 평면을 1024비트 정수로 패킹(plane 0이 낮은 비트 구간). 열(column) 벡터로 취급한다."""
+    big = 0
+    for b in range(8):
+        big ^= (planes[b] << (b * L))
+    return big
+
+def bigint_to_planes(big: int) -> List[int]:
+    """1024비트 정수를 8개 평면으로 역변환"""
+    planes = []
+    for b in range(8):
+        planes.append( (big >> (b * L)) & MASK_128 )
+    return planes
+
+# ---------- 변환 M (FUN_1400053c0) ----------
+
+def mix_planes(planes: List[int]) -> List[int]:
+    """M: out[p] = in[p-1] XOR in[p+1] on each bit-plane with zero boundary."""
+    out = []
+    for b in range(8):
+        x = planes[b]
+        out.append( ((x << 1) ^ (x >> 1)) & MASK_128 )
+    return out
+
+def advance_planes(planes: List[int], steps: int) -> List[int]:
+    """M^steps (naive). T가 매우 크면 시간이 늘어남."""
+    cur = planes[:]
+    for _ in range(steps):
+        cur = mix_planes(cur)
+    return cur
+
+# ---------- 한 스텝 HIT 효과 U_t 계산 ----------
+
+def hit_injection_vector(t: int) -> bytes:
+    """U_t: 위치 (t & 0x7F)에 c_t = (t*0x1B + 0x37) & 0xFF 만 비트가 있는 128바이트"""
+    j = t & 0x7F
+    c = (t * 0x1B + 0x37) & 0xFF
+    bs = bytearray(L)
+    bs[j] = c
+    return bytes(bs)
+
+# ---------- 가우스 소거 (GF(2))로 A*h = delta 풀기 ----------
+# A = [v_0 ... v_{T-1}] (1024비트 column 들), delta = 1024비트
+
+def solve_gf2_columns(columns: List[int], delta: int) -> Tuple[bool, List[int]]:
+    """
+    columns: 길이 T, 각 원소는 1024비트(int) column
+    delta  : 1024비트(int)
+    반환: (성공여부, h(0/1) 리스트)
+    """
+    T = len(columns)
+    # basis: pivot_bit -> (col_vector, combination_bitmask)
+    basis_vec = {}   # pivot_bit -> int(1024b)
+    basis_comb = {}  # pivot_bit -> int(Tb), 원본 column들의 조합
+    # 각 column에 대한 combination bitmask (초기엔 자기 자신만 1)
+    combs = [1 << i for i in range(T)]
+    # 빌드 (column basis 생성)
+    for i, col in enumerate(columns):
+        v = col
+        c = combs[i]
+        # pivot 낮은 비트부터/높은 비트부터 아무거나 가능. 여기선 높은 비트 우선.
+        while v:
+            p = v.bit_length() - 1  # pivot 위치
+            if p in basis_vec:
+                v ^= basis_vec[p]
+                c ^= basis_comb[p]
+            else:
+                basis_vec[p] = v
+                basis_comb[p] = c
+                break
+        # v==0 이면 기존 basis로 표현 가능(선형 종속)
+    # delta를 basis로 소거
+    w = delta
+    sol_comb = 0
+    while w:
+        p = w.bit_length() - 1
+        if p not in basis_vec:
+            # 해 없음
+            return False, []
+        w ^= basis_vec[p]
+        sol_comb ^= basis_comb[p]
+    # sol_comb 의 각 비트가 해당 column(=스텝)을 사용할지(HIT) 결정
+    hits = [ (sol_comb >> i) & 1 for i in range(T) ]
+    return True, hits
+
+# ---------- 메인: 스케줄 계산 ----------
+
+def compute_schedule(
+    T: int,
+    init_bytes: bytes,
+    target_bytes: bytes
+) -> Tuple[bool, List[int]]:
+    """
+    주어진 T(스텝 수), 초기 상태(init_bytes), 타겟 상태(target_bytes)에 대해
+    HIT/MISS 스케줄(h[t]∈{0,1})을 계산.
+    """
+    assert len(init_bytes) == L and len(target_bytes) == L
+
+    # 1) base = M^T(S0)
+    base_planes = advance_planes(bytes_to_planes(init_bytes), T)
+    base_big = pack_planes_to_bigint(base_planes)
+
+    # 2) columns v_t = M^{T-t}(U_t)
+    columns_big = []
+    for t in range(T):
+        U_bytes = hit_injection_vector(t)
+        U_planes = bytes_to_planes(U_bytes)
+        V_planes = advance_planes(U_planes, T - t)  # M^{T-t}
+        V_big = pack_planes_to_bigint(V_planes)
+        columns_big.append(V_big)
+
+    # 3) delta = TARGET ^ base
+    target_big = pack_planes_to_bigint(bytes_to_planes(target_bytes))
+    delta = target_big ^ base_big
+
+    # 4) Solve A*h = delta
+    ok, hits = solve_gf2_columns(columns_big, delta)
+    return ok, hits
+
+# ---------- 시뮬레이터(검증용) ----------
+
+def simulate_with_schedule(T: int, init_bytes: bytes, hits: List[int]) -> bytes:
+    """계산된 스케줄로 실제 최종 상태를 시뮬레이션해서 검증한다."""
+    planes = bytes_to_planes(init_bytes)
+    for t in range(T):
+        if hits[t]:
+            # inject U_t
+            Ub = hit_injection_vector(t)
+            Ubp = bytes_to_planes(Ub)
+            # XOR
+            for b in range(8):
+                planes[b] ^= Ubp[b]
+        # mix
+        planes = mix_planes(planes)
+    return planes_to_bytes(planes)
+
+# ---------- 입력(초기값/타깃) 세팅 ----------
+
+# 1) 초기 상태 (네가 준 16개 QWORD, little-endian 메모리 순서로 128바이트 구성)
+QWORDS_INIT = [
+    0x2cfe542af6bcdfc9, 0xf827a156b5343296,
+    0xc2cf199748081bd1, 0x6e26919c7c7bf2f9,
+    0x8b5b00d8abffae1b, 0x96e0cde33808f13d,
+    0xc59babdd835b5d0b, 0x6b9e07b75d498495,
+    0xf18c48ce17b46361, 0xf9b94c2601dfe836,
+    0xdc46ed6a800e449c, 0xb67a2df488263a5b,
+    0x6621c22f7d4d5b15, 0xe4b8d8381dc49605,
+    0x82df48ce211e68a5, 0x1a6836a93b27b7e4,
+]
+INIT_BYTES = b''.join(q.to_bytes(8, 'little') for q in QWORDS_INIT)
+
+# 2) 타깃 상태 (예: DAT_140077660) — 네가 올린 128바이트를 그대로 넣으면 됨
+TARGET_HEX = """
+14 64 42 4a 00 cc 14 34 21 43 26 82 98 11 2f 6f
+3e 89 3a b8 d0 1c af 57 ef 3a 6b 23 dd 83 6c d8
+3b ca c1 01 d4 30 52 a4 aa 8f e6 55 b6 c3 6d 1c
+86 c9 2c 94 6b 7a 91 ae 31 e3 7e cd 8f e9 dd 1a
+d1 c5 d0 c0 81 6f ee 9b 78 b0 aa fd 75 80 db 90
+55 ff fd 90 f9 04 e9 54 2a 94 ea be 0e ec 44 35
+28 18 bd 86 51 88 44 b1 d6 2d 27 d5 1b 4d 8d d2
+df a4 f3 cf 94 aa 15 2d 8d 75 99 15 47 10 f7 08
+"""
+TARGET_BYTES = bytes(int(x,16) for x in TARGET_HEX.split())
+
+# 3) 노트 수(T) — 정확한 값으로 채워야 함!
+#    (게임 내부: T = (DAT_140099008 - DAT_140099000) >> 4)
+T = 1080  # TODO: 여기에 실제 노트 개수를 넣으세요 (정확히!)
+
+if __name__ == "__main__":
+    if T <= 0:
+        print("T(노트 수)를 먼저 정확히 설정하세요.")
+    else:
+        ok, hits = compute_schedule(T, INIT_BYTES, TARGET_BYTES)
+        if not ok:
+            print("[!] 주어진 T로는 정확히 맞출 수 없습니다 (선형계 해 없음). T 또는 타깃/초기값을 확인하세요.")
+        else:
+            print("[+] HIT/MISS 시퀀스 산출 완료.")
+            print("    예: 첫 64스텝:", ''.join('1' if h else '0' for h in hits[:64]))
+            print("".join("1" if h else "0" for h in hits))
+            # 검증
+            final_bytes = simulate_with_schedule(T, INIT_BYTES, hits)
+            if final_bytes == TARGET_BYTES:
+                print("[OK] 시뮬레이션 검증 통과: 최종 128바이트가 Target과 정확히 일치합니다.")
+            else:
+                print("[!] 시뮬레이션 검증 실패: 계산/입력 값을 점검하세요.")
+```
+
+---
+
+![_](/assets/img/posts/2025-10-28-17.png){: style="max-width: 100%; height: auto;"}
+
+`1670`함수는 `CALCED + 0x80`위치의 데이터만 건드리고 있는 것으로 보입니다. 계산용 버퍼인듯합니다. 직접적으로 건드리지 않아서 패스합니다. (인자값으로 '0' 혹은 '1'이 들어간것을 보니 노트 히트에 따른 기록을 하는 듯 합니다)
+
+![_](/assets/img/posts/2025-10-28-18.png){: style="max-width: 100%; height: auto;"}
+
+| 변수가 많아 `calced + 1`은 `calcedP1`로 바꿔두었습니다.
+
+로직이 좀 복잡해보일수 있지만, 선택된 블럭이 16개정도 반복된 후 do while루프를 돌고 있습니다.
+
+`if (calcedP1 + ...calced < 0x7f)`은 바운더리 관련 연산이여서 마지막 부분 제외하고는 true로 보고 계산하면 됩니다
+
+치환하면 다음과 같은 코드가 됩니다.
+
+```python
+dat = [None] * 128
+for i in range(128):
+    # 바운더리 오류 날 경우 a나 b를 0으로 처리하면 됩니다.
+    a = dat[i + 1]
+    b = dat[i - 1]
+    dat[i] = a ^ b
+```
+
+이게 로직 전부인데, ai가 출력한 코드는 좀 깁니다. 솔버를 만드느라 그런 듯 합니다.
+
+위 함수 이용해서 `z3`솔버 이용했으면 됐었을것같습니다.
 
 ## modulation-master