[💠 Platinum 4] 1099줄짜리 컨트랙트에서 진짜 코드는 40줄 — DreamHack dreamthereum 풀이

file challenge.sol; wc -l challenge.sol; grep -c "function dummy" challenge.sol; grep -oE "dummy[0-9A-F]\(" challenge.sol | sort -u | tr "\n" " "; echo

selector = keccak256("transfer(address,uint256)")[0:4] = 0xa9059cbb

grep -n "function \|TABLE1 =\|TABLE2 =\|keccak256" challenge.sol | grep -v dummy

string[] TABLE1 = ["uint256", "bytes", "bytes4", "bytes1", "bytes32", "uint8",
                   "uint16", "uint248", "string", "uint240", "uint224", "uint192",
                   "uint24", "uint32", "uint56", "uint72"];
uint8[] TABLE2 = [0x41,0x42,0x43,0x44,0x45,0x46,0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39];

function dummyA(uint192) external view returns (uint8) {
    return TABLE2[uint32(msg.sig) % TABLE2.length];
}

function getArgsFromB(uint8 x) internal view returns (string memory) {
    require(x >= 0x41 && x < 0x41+6 || x >= 0x30 && x <= 0x39, "BOOOOM!");
    if (x>=0x41)
        return TABLE1[x-0x41 + 0xa];
    return TABLE1[x-0x30];
}

function internalCall(uint8 A, uint8 B) internal onlyOwner returns (uint8) {
     string memory callMethod = "dummy";
     callMethod = concatenate(callMethod, A);              // 이름 한 글자
     callMethod = concatenate(callMethod, "(");
     callMethod = concatenate(callMethod, getArgsFromB(B)); // 인자 타입
     callMethod = concatenate(callMethod, ")");
 
    (bool success, bytes memory returnData) = address(this).call(abi.encodeWithSignature(callMethod, 0x0));
    require(success, "Bamb!");
 
    return uint8(sliceUint(returnData, 0));
}

function flagChecker(bytes calldata flag) external returns (bool) {
    uint8 ret;
    bytes memory output = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"; // output.length == 31
 
    for(uint i=0; i<output.length - 2; i++) {
        ret = internalCall(uint8(flag[i]), uint8(flag[i+1]));
        output[i] = flag[i];
        output[i+1] = flag[i+1];
        output[i+2] = bytes1(ret);
        require(ret == uint8(flag[i+2]), "BOBOBOBO!!!");
    }
 
    // https://emn178.github.io/online-tools/keccak_256.html
    return keccak256(abi.encodePacked("DH{", output, "}")) == bytes32(0xe6a9e5bcd806b56f7ab007dbb1e881f5b5746f00cb940b8083be861a257f7806);
}

f(A, B) = TABLE2[ uint32(keccak256("dummy" + A + "(" + TABLE1[hex(B)] + ")")[:4]) % 16 ]

for s in "dummyA(uint192)" "dummy0(uint72)" "dummyD(bytes1)"; do printf "%-18s -> " "$s"; docker run --rm -e FOUNDRY_DISABLE_NIGHTLY_WARNING=1 --entrypoint cast ghcr.io/foundry-rs/foundry:latest sig "$s"; done; docker run --rm -e FOUNDRY_DISABLE_NIGHTLY_WARNING=1 --entrypoint cast ghcr.io/foundry-rs/foundry:latest keccak "DH{ABCB69B964FA423A7BCB69B964FA423}"

docker run --rm -e FOUNDRY_DISABLE_NIGHTLY_WARNING=1 -v "$PWD":/w -w /w --entrypoint forge ghcr.io/foundry-rs/foundry:latest inspect src/Challenge.sol:Challenge methods | tee methods.txt | grep -E "dummyA\(uint192\)|dummy0\(uint72\)|dummyD\(bytes1\)|flagChecker"; grep -c "| dummy" methods.txt

require(ret == uint8(flag[i+2]), "BOBOBOBO!!!");

#!/usr/bin/env python3
"""internalCall(A,B) 전이표를 16x16 으로 출력한다. solve.py 와 같은 로직."""
from solve import ALPHABET, TABLE1, TABLE2, hexval, selector
 
print("  예시 시그니처 → 셀렉터 → %16 → 반환문자")
for a, b in (("A", "B"), ("0", "F"), ("D", "3")):
    sig = "dummy%s(%s)" % (a, TABLE1[hexval(b)])
    sel = selector(sig)
    print("    %-22s 0x%08x  %%16=%2d  -> '%s'"
          % (sig, sel, sel % 16, chr(TABLE2[sel % 16])))
 
print()
print("  f(A,B) 전이표   (행=A: 함수이름, 열=B: 인자타입)")
print("      " + "  ".join(ALPHABET))
for a in ALPHABET:
    row = []
    for b in ALPHABET:
        sig = "dummy%s(%s)" % (a, TABLE1[hexval(b)])
        row.append(chr(TABLE2[selector(sig) % 16]))
    print("   %s  %s" % (a, "  ".join(row)))

python3 table.py

#!/usr/bin/env python3
"""dreamthereum (Dreamhack, Platinum 4 / reversing) — solver
 
challenge.sol 의 flagChecker 는 flag 를 31바이트로 읽으면서
    flag[i+2] == internalCall(flag[i], flag[i+1])   (i = 0 .. 28)
을 강제한다. internalCall 은 "dummy<A>(<TABLE1[hex(B)]>)" 라는 시그니처를 문자열로
조립해 자기 자신을 call 하고, 불린 더미 함수는 TABLE2[uint32(msg.sig) % 16] 을 돌려준다.
 
즉 f(A,B) = TABLE2[ uint32(keccak256("dummy"+A+"("+TABLE1[hex(B)]+")")[:4]) % 16 ] 이고,
31글자 전체가 앞 두 글자만으로 결정된다 → 후보는 16*16 = 256개뿐.
마지막 관문 keccak256("DH{" + output + "}") == 0xe6a9...7806 로 하나를 고른다.
"""
from Crypto.Hash import keccak
 
TABLE1 = ["uint256", "bytes", "bytes4", "bytes1", "bytes32", "uint8",
          "uint16", "uint248", "string", "uint240", "uint224", "uint192",
          "uint24", "uint32", "uint56", "uint72"]
# 0x41..0x46 = 'A'..'F', 0x30..0x39 = '0'..'9'
TABLE2 = [0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
          0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39]
 
ALPHABET = "0123456789ABCDEF"          # getArgsFromB 가 허용하는 문자 집합
TARGET = 0xe6a9e5bcd806b56f7ab007dbb1e881f5b5746f00cb940b8083be861a257f7806
 
 
def k256(data: bytes) -> bytes:
    h = keccak.new(digest_bits=256)
    h.update(data)
    return h.digest()
 
 
def hexval(ch: str) -> int:
    """getArgsFromB: '0'-'9' -> 0..9, 'A'-'F' -> 10..15"""
    o = ord(ch)
    if 0x41 <= o < 0x41 + 6:
        return o - 0x41 + 0xa
    if 0x30 <= o <= 0x39:
        return o - 0x30
    raise ValueError("BOOOOM!")
 
 
def selector(sig: str) -> int:
    """abi.encodeWithSignature 의 앞 4바이트 = uint32(msg.sig)"""
    return int.from_bytes(k256(sig.encode())[:4], "big")
 
 
def build_table():
    """f[A][B] = internalCall(A, B) 의 반환 문자"""
    table = {}
    for a in ALPHABET:
        for b in ALPHABET:
            sig = "dummy%s(%s)" % (a, TABLE1[hexval(b)])
            table[(a, b)] = chr(TABLE2[selector(sig) % len(TABLE2)])
    return table
 
 
def expand(c0: str, c1: str, table, length: int = 31) -> str:
    s = [c0, c1]
    while len(s) < length:
        s.append(table[(s[-2], s[-1])])
    return "".join(s)
 
 
def main():
    table = build_table()
 
    # 256개 시작쌍 전수
    hits = []
    for c0 in ALPHABET:
        for c1 in ALPHABET:
            out = expand(c0, c1, table)
            digest = k256(b"DH{" + out.encode() + b"}")
            if int.from_bytes(digest, "big") == TARGET:
                hits.append(out)
 
    for out in hits:
        flag = "DH{%s}" % out
        print("[+] output   =", out, "(len %d)" % len(out))
        print("[+] keccak   =", k256(flag.encode()).hex())
        print("[+] FLAG     =", flag)
 
    if not hits:
        print("[-] 후보 없음")
        return
 
    # 자체검산: 찾은 flag 를 flagChecker 로직 그대로 다시 돌려 본다
    out = hits[0]
    for i in range(len(out) - 2):
        assert table[(out[i], out[i + 1])] == out[i + 2], i
    print("[+] self-check: flag[i+2] == f(flag[i], flag[i+1]) for all i — OK")
 
 
if __name__ == "__main__":
    main()

python3 solve.py

DH{ABCB69B964FA423A7BCB69B964FA423}

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
 
import "../src/Challenge.sol";
 
// forge-std 없이 도는 테스트. 이 컨트랙트가 Challenge 를 배포하므로 owner == 이 컨트랙트가 되어
// internalCall 의 onlyOwner 를 통과한다.
contract FlagTest {
    Challenge c;
 
    function setUp() public {
        c = new Challenge();
    }
 
    // 정답 flag → flagChecker 가 true
    function test_correct_flag_returns_true() public {
        bool ok = c.flagChecker(bytes("ABCB69B964FA423A7BCB69B964FA423"));
        require(ok, "flagChecker returned false");
    }
 
    // 마지막 한 글자만 바꿔도 i=28 의 require 에서 BOBOBOBO!!! 로 revert
    function test_last_byte_flipped_reverts_BOBOBOBO() public {
        try c.flagChecker(bytes("ABCB69B964FA423A7BCB69B964FA424")) returns (bool ok) {
            require(!ok, "tampered flag was accepted");
        } catch Error(string memory reason) {
            require(
                keccak256(bytes(reason)) == keccak256(bytes("BOBOBOBO!!!")),
                "unexpected revert reason"
            );
        }
    }
 
    // 16진 문자가 아닌 바이트가 인자타입 자리에 오면 getArgsFromB 가 BOOOOM!
    function test_non_hex_byte_reverts_BOOOOM() public {
        try c.flagChecker(bytes("AZCB69B964FA423A7BCB69B964FA423")) returns (bool ok) {
            require(!ok, "non-hex flag was accepted");
        } catch Error(string memory reason) {
            require(
                keccak256(bytes(reason)) == keccak256(bytes("BOOOOM!")),
                "unexpected revert reason"
            );
        }
    }
}

docker run --rm -e FOUNDRY_DISABLE_NIGHTLY_WARNING=1 -v "$PWD":/w -w /w --entrypoint forge ghcr.io/foundry-rs/foundry:latest test -vv

docker run --rm -e FOUNDRY_DISABLE_NIGHTLY_WARNING=1 -v "$PWD":/w -w /w --entrypoint forge ghcr.io/foundry-rs/foundry:latest test --match-test test_correct_flag_returns_true -vvvv > trace.txt 2>&1; sed -n "/^Traces:/,+13p" trace.txt; echo "    ...(중략: dummy 호출은 모두 29회)..."; tail -9 trace.txt

#!/usr/bin/env bash
# dreamthereum (Dreamhack, Platinum 4 / reversing) — 한 방 재현.
#   solve.py 로 flag 를 복원하고, docker foundry 가 있으면 실제 EVM 으로 한 번 더 검증한다.
set -eu
cd "$(dirname "$(readlink -f "$0")")"
EXPECT=$(python3 -c "import json;print(json.load(open('문제.json'))['flag'])" 2>/dev/null || echo '')
 
# 1) 오프라인 복원 — keccak256 만 있으면 된다 (pycryptodome)
OUT=$(timeout 300 python3 solve.py 2>&1) || true
echo "$OUT"
FLAG=$(printf '%s' "$OUT" | grep -aoE 'DH\{[^}]+\}' | head -1)
 
# 2) (선택) 실제 EVM 검증 — foundry 이미지가 이미 받아져 있을 때만 돈다
if command -v docker >/dev/null 2>&1 && docker image inspect ghcr.io/foundry-rs/foundry:latest >/dev/null 2>&1; then
  echo
  echo "--- forge test (실제 EVM) ---"
  ( cd evm && timeout 600 docker run --rm -v "$PWD":/w -w /w \
      --entrypoint forge ghcr.io/foundry-rs/foundry:latest test -vv ) || true
  docker run --rm -v "$PWD/evm":/w alpine:latest rm -rf /w/out /w/cache >/dev/null 2>&1 || true
else
  echo
  echo "(docker/foundry 없음 — EVM 검증은 건너뛴다. solve.py 만으로 flag 는 나온다)"
fi
 
echo
if [ -n "$FLAG" ] && { [ -z "$EXPECT" ] || [ "$FLAG" = "$EXPECT" ]; }; then
  echo "✅ PASS  $FLAG"; exit 0
fi
echo "❌ FAIL (얻은 값: '${FLAG:-없음}' / 기대: '$EXPECT')"; exit 1

./reproduce.sh