[🥉 Bronze 1] 31줄 발췌본이 base64 인코더라는 걸 증명하기 — DreamHack [CodeEngn] Malware L05 풀이

# show_desc.sh
#!/bin/sh
# show_desc.sh — 드림핵 API 에서 이 문제의 제목·분류·설명만 뽑아 본다
python3 ~/Dev/Hacking_Project/_도구/dreamhack_auto/fetch_desc.py 372 | python3 -c '
import sys, json
d = json.load(sys.stdin)
print("제목    :", d["title"].strip())
print("분류    :", ", ".join(d["tags"]))
print("난이도  :", d["tier_display"])
print("푼 사람 :", d["cnt_solvers"], "명")
print()
print("[문제 설명]")
print(d["description"].strip())
print()
print("[힌트]", d["hints"] or "없음")
'

./show_desc.sh

# rfc_evidence.sh
#!/bin/sh
# rfc_evidence.sh — 76열·패딩 규정이 어느 문서에서 오는지 원문으로 확인
#   문서: curl -sS -o rfc2045.txt https://www.rfc-editor.org/rfc/rfc2045.txt
echo "rfc2045.txt = $(wc -c < rfc2045.txt) B / $(wc -l < rfc2045.txt) 줄"
echo
echo '--- 6.8 절 제목 ---'
sed -n '1295,1297p' rfc2045.txt
echo
echo '--- 줄 길이 규정 ---'
sed -n '1372,1374p' rfc2045.txt
echo
echo '--- 패딩 규정 (배포본에 없는 부분) ---'
sed -n '1380,1385p' rfc2045.txt

sh rfc_evidence.sh

# recon.sh
#!/bin/sh
# recon.sh — 배포본 정찰: 무엇이 들어 있고 줄끝이 무엇인가
ls -l extracted/
file extracted/05.txt
wc -lc extracted/05.txt
echo '--- 앞 5줄 (cat -A 로 줄끝까지) ---'
head -5 extracted/05.txt | cat -A
echo '--- 가려진 부분 "..." 이 몇 군데인가 ---'
grep -n '\.\.\.' extracted/05.txt

sh recon.sh

int Malware_L05(char *StartOfData,char *Output,int SizeOfData)
{
	int encoded=0,i,l=0;
	char Table[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
	long buffer,buffer2;
	do
	{
		...
		for(i=3;i>=0;i--,l++)
		{
			buffer2=buffer;
			buffer2 &= 0x3f;
			*(Output + i)=Table[buffer2];
			buffer>>=6;
		}
		Output+=4;
		encoded+=4;
		SizeOfData-=3;
		if(l==76 && SizeOfData>3)
		{
			*Output=0xd;
			Output++;
			*Output=0xa;
			Output++;
			encoded+=2;
			l=0;
		}
		...
		
	}while(SizeOfData!=0);
	return encoded;
}

#!/usr/bin/env python3
"""table_check.py — 배포본의 Table[] 이 RFC 4648 표준 알파벳인지 인덱스별로 대조.
 
배포본에서 문자열 리터럴을 직접 긁어 쓴다(손으로 옮겨 적지 않는다).
"""
import re
import string
 
src = open("extracted/05.txt", "rb").read().decode("ascii")
m = re.search(r'char\s+Table\[\]\s*=\s*"([^"]*)"', src)
table = m.group(1)
 
rfc4648 = string.ascii_uppercase + string.ascii_lowercase + string.digits + "+/"
 
print(f"배포본 Table[] 길이 : {len(table)}")
print(f"RFC 4648 Table 1    : {len(rfc4648)}")
print(f"전체 일치           : {table == rfc4648}")
print(f"패딩문자 '=' 포함   : {'=' in table}")
 
diff = [(i, a, b) for i, (a, b) in enumerate(zip(table, rfc4648)) if a != b]
print(f"인덱스별 불일치     : {len(diff)}건")
 
print("\n  idx  chr  |   idx  chr  |   idx  chr  |   idx  chr")
for r in range(16):
    row = []
    for c in range(4):
        i = r + 16 * c
        row.append(f"  {i:3d}  '{table[i]}' ")
    print("|".join(row))

python3 table_check.py

for(i=3;i>=0;i--,l++)
{
	buffer2=buffer;
	buffer2 &= 0x3f;
	*(Output + i)=Table[buffer2];
	buffer>>=6;
}

/* snippet.c — DreamHack #372 [CodeEngn] Malware L05 배포본 재구성
 *
 * 배포본 extracted/05.txt 는 함수 본문 두 곳이 "..." 로 가려져 있다.
 * 가려지지 않은 줄은 공백/탭까지 그대로 두고, "..." 두 곳만 채웠다.
 *   (A) do { 직후  — 입력 3바이트를 buffer 로 적재
 *   (B) l=0; } 뒤  — 입력 포인터 전진
 * 무엇을 채워야 하는지는 아래 for 루프가 이미 결정한다.
 *
 * LOAD_LITTLE_ENDIAN 을 정의해 빌드하면 (A)를 반대 바이트순서로 채운
 * 대조군이 만들어진다 — 오독 변형이 base64 가 아님을 보이는 용도.
 */
#include "snippet.h"
 
int Malware_L05(char *StartOfData,char *Output,int SizeOfData)
{
	int encoded=0,i,l=0;
	char Table[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
	long buffer,buffer2;
	do
	{
		/* ---- (A) 가려진 부분: 3바이트 적재 ---- */
#ifdef LOAD_LITTLE_ENDIAN
		buffer =  (long)(unsigned char)StartOfData[2] << 16
		       |  (long)(unsigned char)StartOfData[1] <<  8
		       |  (long)(unsigned char)StartOfData[0];
#else
		buffer =  (long)(unsigned char)StartOfData[0] << 16
		       |  (long)(unsigned char)StartOfData[1] <<  8
		       |  (long)(unsigned char)StartOfData[2];
#endif
		/* --------------------------------------- */
		for(i=3;i>=0;i--,l++)
		{
			buffer2=buffer;
			buffer2 &= 0x3f;
			*(Output + i)=Table[buffer2];
			buffer>>=6;
		}
		Output+=4;
		encoded+=4;
		SizeOfData-=3;
		if(l==76 && SizeOfData>3)
		{
			*Output=0xd;
			Output++;
			*Output=0xa;
			Output++;
			encoded+=2;
			l=0;
		}
		/* ---- (B) 가려진 부분: 입력 포인터 전진 ---- */
		StartOfData+=3;
		/* ------------------------------------------- */
	}while(SizeOfData!=0);
	return encoded;
}

/* driver.c — 배포본 함수를 그대로 호출하는 최소 구동기.
 *   stdin 의 바이트 전부를 StartOfData 로, 결과를 stdout 으로 그대로 흘린다.
 *   반환값(encoded)은 stderr 에 "encoded=N" 으로 찍는다 — stdout 을 오염시키지 않는다.
 * 사용:  ./l05 < 입력파일 > 출력파일
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "snippet.h"
 
int main(void)
{
	static char in[1 << 20];
	size_t n = 0, r;
	while ((r = fread(in + n, 1, sizeof(in) - n, stdin)) > 0) n += r;
 
	/* 4/3 배 + 76열마다 CRLF 2바이트 + 넉넉한 여유 */
	size_t cap = n * 2 + 4096;
	char *out = calloc(1, cap);
	if (!out) return 2;
 
	int encoded = Malware_L05(in, out, (int)n);
 
	fwrite(out, 1, (size_t)encoded, stdout);
	fprintf(stderr, "encoded=%d\n", encoded);
	return 0;
}

# firstrun.sh
#!/bin/sh
# firstrun.sh — 재구성본 빌드 후 3바이트 하나로 최소 검증
gcc -O0 -g -Wall -o l05 driver.c snippet.c && echo 'BUILD OK'
printf 'Man' > t3.bin
echo '--- 배포본 함수의 출력 ---'
./l05 < t3.bin | xxd
echo '--- coreutils base64 의 출력 ---'
base64 -w0 < t3.bin; echo

sh firstrun.sh

s|shl    rax,0x10|&          <-- byte0 << 16|
s|shl    rax,0x8|&           <-- byte1 << 8|
s|and    QWORD PTR \[rbp-0x58\],0x3f|&   <-- buffer2 \&= 0x3f : 하위 6비트만|
s|sar    QWORD PTR \[rbp-0x60\],0x6|&    <-- buffer >>= 6 : 다음 6비트로|
s|sub    DWORD PTR \[rbp-0x84\],0x3|&    <-- SizeOfData -= 3 : 3바이트 소비|
s|cmp    DWORD PTR \[rbp-0x64\],0x4c|&   <-- l == 76 : MIME 한 줄 상한|
s|cmp    DWORD PTR \[rbp-0x84\],0x3|&    <-- SizeOfData > 3 : 마지막 그룹이면 접기 생략|
s|mov    BYTE PTR \[rax\],0xd|&          <-- 0x0d CR|
s|mov    BYTE PTR \[rax\],0xa|&          <-- 0x0a LF|
s|cmp    DWORD PTR \[rbp-0x84\],0x0|&    <-- SizeOfData != 0 : ">0" 이 아니다|

# disasm.sh
#!/bin/sh
# disasm.sh — Malware_L05 디스어셈블 발췌 + annotate.sed 주석
#   사용: sh disasm.sh <시작줄> <끝줄>   (함수 첫 줄이 1)
objdump -d --no-show-raw-insn -M intel l05 \
  | sed -n '/<Malware_L05>:/,/^$/p' \
  | sed -n "${1:-1},${2:-200}p" \
  | sed -f annotate.sed

sh disasm.sh 30 66

# strings_probe.sh
#!/bin/sh
# strings_probe.sh — base64 알파벳이 문자열 테이블에 남는가
echo '--- strings 로 알파벳 찾기 (매치 수) ---'
strings -a l05 | grep -c 'ABCDEFGHIJKLMNOP'
echo '--- .rodata 전체 ---'
objdump -s -j .rodata l05 | tail -4
echo '--- 알파벳은 movabs 즉치값 8개로 스택에 깔린다 ---'
objdump -d --no-show-raw-insn -M intel l05 | grep 'movabs'
echo '--- 즉치값을 리틀엔디언으로 되돌리면 ---'
python3 -c "import struct,sys; print(b''.join(struct.pack('<Q',int(x,16)) for x in sys.argv[1:]).decode())" \
  0x4847464544434241 0x504f4e4d4c4b4a49 0x5857565554535251 0x6665646362615a59 \
  0x6e6d6c6b6a696867 0x767574737271706f 0x333231307a797877 0x2f2b393837363534

sh strings_probe.sh

# cmds.gdb — 배포본 for 루프를 한 바퀴씩 멈춰 6비트 그룹 -> Table 색인을 실측한다.
#   실행: gdb -q -batch -x cmds.gdb --args ./l05
#   입력 "Man"(0x4D 0x61 0x6E) 은 run 의 리다이렉션으로 준다.
set pagination off
set confirm off
 
break snippet.c:32
commands
  silent
  printf "[적재] StartOfData 3바이트 = %02x %02x %02x   buffer = 0x%06lx\n", \
         (unsigned char)StartOfData[0], (unsigned char)StartOfData[1], \
         (unsigned char)StartOfData[2], buffer
  continue
end
 
break snippet.c:37
commands
  silent
  printf "  i=%d  buffer=0x%06lx  buffer2(=buffer&0x3f)=%2ld  -> Table[%2ld]='%c'  Output[%d]\n", \
         i, buffer, buffer2, buffer2, Table[buffer2], i
  continue
end
 
break snippet.c:55
commands
  silent
  printf "[반환] encoded=%d  Output 앞 4바이트 = \"%c%c%c%c\"\n", \
         encoded, Output[-4], Output[-3], Output[-2], Output[-1]
  continue
end
 
run < t3.bin > /dev/null

gdb -q -batch -x cmds.gdb --args ./l05

sh disasm.sh 67 86

#!/usr/bin/env python3
"""reference.py — 배포본을 대조할 '정답지' 두 벌.
 
  b64_raw(data)  : RFC 4648 순수 base64 (줄바꿈 없음)
  b64_mime(data) : RFC 2045 MIME — 76열마다 CRLF, 마지막 줄 뒤에는 CRLF 없음
 
배포본 05.txt 는 Table 에 '=' 가 없고 SizeOfData 를 3씩만 깎으므로
길이가 3의 배수인 입력만 다룰 수 있다. 정답지도 같은 조건에서만 쓴다.
"""
import base64
import sys
 
 
def b64_raw(data: bytes) -> bytes:
    assert len(data) % 3 == 0, "배포본은 3의 배수 길이만 처리한다"
    return base64.b64encode(data)
 
 
def b64_mime(data: bytes, width: int = 76) -> bytes:
    s = b64_raw(data)
    lines = [s[i:i + width] for i in range(0, len(s), width)]
    return b"\r\n".join(lines)
 
 
if __name__ == "__main__":
    raw = sys.stdin.buffer.read()
    mode = sys.argv[1] if len(sys.argv) > 1 else "mime"
    sys.stdout.buffer.write(b64_mime(raw) if mode == "mime" else b64_raw(raw))

#!/usr/bin/env python3
"""difftest.py — 배포본 함수 vs 표준 base64 전수 대조.
 
판정 두 갈래로 나눠 본다.
  (1) CRLF 를 걷어낸 '알파벳 스트림' 이 RFC 4648 base64 와 같은가  → 인코딩 정체
  (2) CRLF 위치까지 포함해 RFC 2045 MIME 과 같은가                → 줄바꿈 규격 준수
"""
import random
import subprocess
import sys
 
from reference import b64_mime, b64_raw
 
BIN = sys.argv[1] if len(sys.argv) > 1 else "./l05"
MAXLEN = int(sys.argv[2]) if len(sys.argv) > 2 else 900
 
 
def run(data: bytes) -> bytes:
    return subprocess.run([BIN], input=data, capture_output=True).stdout
 
 
def main() -> int:
    random.seed(20260819)
    cases = []
    # 결정적 패턴 + 무작위
    for n in range(3, MAXLEN + 1, 3):
        cases.append(bytes(random.randrange(256) for _ in range(n)))
    cases.append(b"\x00" * 300)
    cases.append(b"\xff" * 300)
    cases.append(bytes(range(256)) * 3)          # 768B, 모든 바이트값
    cases.append(b"CodeEngn" * 24)               # 192B, ASCII
 
    raw_bad, mime_bad = [], []
    for data in cases:
        got = run(data)
        if got.replace(b"\r\n", b"") != b64_raw(data):
            raw_bad.append(len(data))
        if got != b64_mime(data):
            mime_bad.append(len(data))
 
    print(f"입력 {len(cases)}종 (최대 {max(len(c) for c in cases)}B)")
    print(f"(1) 알파벳 스트림 == RFC4648 base64 : 불일치 {len(raw_bad)}건")
    print(f"(2) 줄바꿈까지    == RFC2045 MIME   : 불일치 {len(mime_bad)}건")
    if mime_bad:
        print("    불일치 길이:", mime_bad[:12], "..." if len(mime_bad) > 12 else "")
        print("    전부 57k+3 인가:", all((n - 3) % 57 == 0 for n in mime_bad))
    return 0 if not raw_bad else 1
 
 
if __name__ == "__main__":
    raise SystemExit(main())

python3 difftest.py ./l05 900

# roundtrip.sh
#!/bin/sh
# roundtrip.sh — 제3의 도구가 배포본 출력을 되돌리는가 (900B 무작위)
head -c 900 /dev/urandom > rt900.bin
echo "입력 rt900.bin = $(stat -c%s rt900.bin) B"
./l05 < rt900.bin > rt900.b64
echo "배포본 출력 rt900.b64 = $(stat -c%s rt900.b64) B  (줄 $(grep -c '' rt900.b64)개)"
base64 -d < rt900.b64 > rt900.out
cmp rt900.bin rt900.out && echo 'coreutils base64 -d : 원본과 완전 일치'
tr -d '\r\n' < rt900.b64 | openssl base64 -d -A > rt900.ssl
cmp rt900.bin rt900.ssl && echo 'openssl base64 -d   : 원본과 완전 일치'

sh roundtrip.sh

#!/usr/bin/env python3
"""mime_demo.py — 배포본 출력을 진짜 메일 파서에 먹여 본다.
 
76열 CRLF 접기는 RFC 2045(MIME) 규격이다. 이 함수가 왜 메일 첨부 인코더인지
말로 주장하지 말고, 파이썬 표준 email 파서가 그대로 첨부파일로 뜯어내는지 본다.
 
  1) 첨부할 페이로드를 ./l05 로 인코딩 (배포본 함수 그대로)
  2) 그 결과를 Content-Transfer-Encoding: base64 본문으로 붙여 메일을 조립
  3) email.message_from_bytes 로 다시 파싱 -> get_payload(decode=True)
  4) 원본 바이트와 완전 일치하는지 비교
"""
import email
import email.policy
import subprocess
import sys
 
# 실제 악성코드를 배포하지 않기 위한 더미 PE 스텁 (MZ 헤더 + DOS stub 문구)
PAYLOAD = (b"MZ\x90\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\x00\x00"
           b"This program cannot be run in DOS mode.\r\n"
           b"[DUMMY PE STUB - not a real sample] ") * 3
PAYLOAD = PAYLOAD[:len(PAYLOAD) // 3 * 3]          # 배포본은 3의 배수만 처리한다
 
body = subprocess.run(["./l05"], input=PAYLOAD, capture_output=True).stdout
 
msg = (b"From: <postmaster@example.invalid>\r\n"
       b"To: <victim@example.invalid>\r\n"
       b"Subject: Delivery notification\r\n"
       b"MIME-Version: 1.0\r\n"
       b"Content-Type: application/octet-stream; name=\"price.exe\"\r\n"
       b"Content-Transfer-Encoding: base64\r\n"
       b"Content-Disposition: attachment; filename=\"price.exe\"\r\n"
       b"\r\n") + body + b"\r\n"
 
open("worm_mail.eml", "wb").write(msg)
 
parsed = email.message_from_bytes(msg, policy=email.policy.default)
back = parsed.get_payload(decode=True)
 
print(f"페이로드 원본        : {len(PAYLOAD)} B   앞 2바이트 = {PAYLOAD[:2]!r}")
print(f"./l05 인코딩 결과    : {len(body)} B")
print(f"본문 줄 길이         : {[len(x) for x in body.split(b'CRLF'.replace(b'CRLF', b'\r\n'))]}")
print(f"CTE 헤더             : {parsed['Content-Transfer-Encoding']}")
print(f"첨부 파일명          : {parsed.get_filename()}")
print(f"파서가 복원한 바이트 : {len(back)} B   앞 2바이트 = {back[:2]!r}")
print(f"원본과 완전 일치     : {back == PAYLOAD}")
sys.exit(0 if back == PAYLOAD else 1)

python3 mime_demo.py && echo "--- worm_mail.eml 앞 12줄 ---" && head -12 worm_mail.eml

# hangtest.sh
#!/bin/sh
# hangtest.sh — while(SizeOfData!=0) 가 3의 배수 아닌 길이에서 멈추는가
for n in 2 3 4 5 6; do
  head -c $n /dev/zero > hang_$n.bin
  timeout 3 ./l05 < hang_$n.bin > /dev/null 2>&1
  rc=$?
  case $rc in
    0)   msg='정상 종료' ;;
    124) msg='3초 타임아웃 — 루프가 안 끝난다' ;;
    139) msg='SIGSEGV — 버퍼 밖으로 계속 쓴다' ;;
    *)   msg="종료코드 $rc" ;;
  esac
  echo "입력 ${n}B (3의 배수: $([ $((n%3)) -eq 0 ] && echo yes || echo no))  ->  rc=$rc  $msg"
done

sh hangtest.sh

#!/usr/bin/env python3
"""linebreak_trap.py — 76열 접기 조건의 `&& SizeOfData>3` 이 만드는 규격 위반.
 
RFC 2045 §6.8: "The encoded output stream must be represented in lines of no more
than 76 characters each."  배포본은 마지막 그룹 하나만 남은 경계에서 줄바꿈을
건너뛰므로, 입력 길이가 57k+3 일 때 80자짜리 줄이 나온다.
"""
import subprocess
 
from reference import b64_mime
 
CRLF = b"\r\n"
 
for n in (57, 60, 63, 114, 117):
    data = bytes((i * 37 + 11) & 0xFF for i in range(n))
    got = subprocess.run(["./l05"], input=data, capture_output=True).stdout
    exp = b64_mime(data)
    gl = [len(x) for x in got.split(CRLF)]
    el = [len(x) for x in exp.split(CRLF)]
    verdict = "일치" if got == exp else f"불일치 (>76 인 줄 {sum(1 for x in gl if x > 76)}개)"
    print(f"입력 {n:4d}B | 배포본 줄길이 {str(gl):16s} | 표준 MIME {str(el):16s} | {verdict}")

python3 linebreak_trap.py

#!/usr/bin/env python3
"""solve.py — DreamHack #372 [CodeEngn] Malware L05 최종 판정.
 
문제: "다음은 악성코드 소스의 일부분이다. 무엇을 하는 함수인가"
배포본 05.txt 는 함수 본문 두 곳이 "..." 로 가려진 31줄짜리 발췌본이다.
 
모양만 보고 찍지 않는다. 가려진 곳을 채운 재구성본(snippet.c)을 컴파일해
네 가지를 실측하고, 넷이 다 통과할 때만 답을 출력한다.
 
  1) Table[] 이 RFC 4648 표준 알파벳과 인덱스별로 완전 일치하는가
  2) 출력의 알파벳 스트림이 표준 base64 와 바이트 단위로 같은가 (전수 스윕)
  3) 제3의 도구(coreutils base64 -d / openssl)가 그 출력을 되돌리는가
  4) 76열 CRLF 접기가 RFC 2045 MIME 이어서, 진짜 메일 파서가 첨부로 뜯는가
 
전제: `gcc -O0 -o l05 driver.c snippet.c` 로 l05 가 빌드돼 있어야 한다.
"""
import random
import re
import string
import subprocess
import sys
from pathlib import Path
 
HERE = Path(__file__).resolve().parent
BIN = HERE / "l05"
 
 
def run(data: bytes) -> bytes:
    return subprocess.run([str(BIN)], input=data, capture_output=True).stdout
 
 
def b64_raw(data: bytes) -> bytes:
    import base64
    return base64.b64encode(data)
 
 
def b64_mime(data: bytes) -> bytes:
    s = b64_raw(data)
    return b"\r\n".join(s[i:i + 76] for i in range(0, len(s), 76))
 
 
def check1_table() -> bool:
    src = (HERE / "extracted" / "05.txt").read_bytes().decode("ascii")
    table = re.search(r'char\s+Table\[\]\s*=\s*"([^"]*)"', src).group(1)
    rfc = string.ascii_uppercase + string.ascii_lowercase + string.digits + "+/"
    ok = table == rfc and len(table) == 64 and "=" not in table
    print(f"[1] Table[] == RFC4648 Table 1        : {ok}  (64자, 패딩 '=' 없음)")
    return ok
 
 
def check2_sweep() -> bool:
    random.seed(20260819)
    cases = [bytes(random.randrange(256) for _ in range(n)) for n in range(3, 901, 3)]
    cases += [b"\x00" * 300, b"\xff" * 300, bytes(range(256)) * 3, b"CodeEngn" * 24]
    bad = [len(d) for d in cases if run(d).replace(b"\r\n", b"") != b64_raw(d)]
    print(f"[2] 알파벳 스트림 == base64 (입력 {len(cases)}종) : 불일치 {len(bad)}건")
    return not bad
 
 
def check3_thirdparty() -> bool:
    data = bytes((i * 131 + 7) & 0xFF for i in range(900))
    enc = run(data)
    core = subprocess.run(["base64", "-d"], input=enc, capture_output=True).stdout
    flat = enc.replace(b"\r\n", b"")
    ssl = subprocess.run(["openssl", "base64", "-d", "-A"],
                         input=flat, capture_output=True).stdout
    ok = core == data and ssl == data
    print(f"[3] coreutils base64 -d / openssl 왕복 : {ok}  (900B)")
    return ok
 
 
def check4_mime() -> bool:
    """메일 파서가 첨부로 뜯어내는지가 판정 대상이다.
    76열 상한 준수 여부는 별도로 찍기만 한다 — 57k+3 길이에서는 일부러 깨진다."""
    import email
    import email.policy
 
    def roundtrip(payload: bytes):
        body = run(payload)
        msg = (b"MIME-Version: 1.0\r\n"
               b"Content-Type: application/octet-stream\r\n"
               b"Content-Transfer-Encoding: base64\r\n\r\n") + body + b"\r\n"
        parsed = email.message_from_bytes(msg, policy=email.policy.default)
        return body, parsed.get_payload(decode=True)
 
    ok = True
    for n in (279, 288):                       # 288 = 57*5+3 (접기 건너뛰는 길이)
        payload = bytes((i * 17 + 3) & 0xFF for i in range(n))
        body, back = roundtrip(payload)
        lines = [len(x) for x in body.split(b"\r\n")]
        rfc = all(x <= 76 for x in lines)
        ok &= back == payload
        print(f"[4] MIME 첨부 왕복 {n:3d}B : {back == payload}"
              f"   | 줄 길이 {lines} -> RFC2045 76열 준수 {rfc}")
    return bool(ok)
 
 
def main() -> int:
    if not BIN.exists():
        print("l05 가 없다.  gcc -O0 -o l05 driver.c snippet.c", file=sys.stderr)
        return 2
    results = [check1_table(), check2_sweep(), check3_thirdparty(), check4_mime()]
    print()
    if all(results):
        print("판정: 3바이트 -> 4문자, RFC4648 알파벳, RFC2045 76열 CRLF 접기")
        print("ANSWER: base64")
        return 0
    print("판정 보류 — 위 항목 중 실패가 있다")
    return 1
 
 
if __name__ == "__main__":
    raise SystemExit(main())

python3 solve.py

# reproduce.sh (발췌)
#!/bin/sh
set -e
cd "$(dirname "$0")"
sh recon.sh                                   # 1. 배포본 정찰
sh firstrun.sh                                # 2. 재구성본 빌드 + 최소 검증
python3 table_check.py | head -4              # 3. 알파벳 대조
sh disasm.sh 67 86                            # 4. 정적 분석
gdb -q -batch -x cmds.gdb --args ./l05        # 5. 런타임 검증
python3 difftest.py ./l05 900                 # 6. 표준과 전수 대조
sh le_control.sh                              # 7. 바이트순서 오독 대조군
sh roundtrip.sh                               # 8. 제3의 도구 왕복
python3 mime_demo.py                          # 9. MIME 첨부 왕복
sh hangtest.sh && python3 linebreak_trap.py   # 10. 구현 결함 2종
python3 solve.py | tail -3                    # 11. 최종 판정
echo 'PASS base64'