[🥉 Bronze 1] 헤더에 박히는 두 바이트 — DreamHack [CodeEngn] Malware L03 풀이

# show_desc.sh
#!/bin/sh
# 드림핵 API 에서 이 문제의 제목·분류·설명만 뽑아 본다
python3 ~/Dev/Hacking_Project/_도구/dreamhack_auto/fetch_desc.py 370 | 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

file extracted/03.txt; wc -lc extracted/03.txt; sha256sum extracted/03.txt; cat extracted/03.txt

u_short Malware_L03(u_short * data,u_short length) 
{
        register long value;
        u_short i;
        for(i=0;i<(length>>1);i++)
                value+=data[i];
        if((length&1)==1)
                value+=(data[i]<<8);
        value=(value&65535)+(value>>16);
        return(~value);
}

/* 03.txt (배포본) 원문 그대로. CRLF 만 LF 로 바꿨고 그 밖엔 한 글자도 손대지 않았다. */
#include <sys/types.h>   /* u_short */
 
u_short Malware_L03(u_short * data,u_short length) 
{
        register long value;
        u_short i;
        for(i=0;i<(length>>1);i++)
                value+=data[i];
        if((length&1)==1)
                value+=(data[i]<<8);
        value=(value&65535)+(value>>16);
        return(~value);
}

/* driver.c — 배포본 함수를 그대로 호출해 보는 껍데기.
 * 사용법: ./cksum <hex문자열>          (예: ./cksum 4500003ca1b64000400600000a000001)
 *         hex 를 바이트로 풀어 Malware_L03(buf, len) 을 부르고 결과를 16진수로 찍는다. */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
 
u_short Malware_L03(u_short * data, u_short length);   /* snippet.c */
 
int main(int argc, char **argv)
{
    static unsigned char buf[65536];
    size_t n = 0;
    const char *h;
 
    if (argc != 2) { fprintf(stderr, "usage: %s <hex>\n", argv[0]); return 2; }
    h = argv[1];
    if (strlen(h) % 2) { fprintf(stderr, "hex 길이가 홀수다\n"); return 2; }
 
    while (*h) {
        char b[3] = { h[0], h[1], 0 };
        buf[n++] = (unsigned char)strtoul(b, NULL, 16);
        h += 2;
    }
    printf("len=%zu  Malware_L03=0x%04x\n", n, Malware_L03((u_short *)buf, (u_short)n));
    return 0;
}

gcc -O0 -g -Wall -Wextra -o cksum snippet.c driver.c; ./cksum 0001f203f4f5f6f7; ./cksum 4500003c1c46400040060000ac100a63ac100a0c

sed -n "254,269p" rfc1071.txt; ./cksum 0001f203f4f5f6f7

# annotate.sed — objdump 출력에 주석만 얹는다(명령·주소는 손대지 않는다).
s/\(movzx  eax,WORD PTR \[rax\]\)$/\1                 <-- 16비트 워드 하나를 호스트 순서로 읽는다/
s/\(add    rbx,rax\)$/\1                          <-- value 는 rbx. 여기서 누산한다/
s/\(shr    ax,1\)$/\1                            <-- length>>1 = 워드 개수/
s/\(and    eax,0x1\)$/\1                        <-- length \& 1 : 홀수 바이트가 남았나/
s/\(shl    eax,0x8\)$/\1                        <-- 문제의 data\[i\]<<8. 8비트 밀어 올린다/
s/\(movzx  eax,bx\)$/\1                        <-- value \& 65535/
s/\(sar    rdx,0x10\)$/\1                       <-- value >> 16/
s/\(lea    rbx,\[rax+rdx\*1\]\)$/\1               <-- 캐리 폴딩. 딱 한 번뿐이다/
s/\(not    eax\)$/\1                           <-- ~value, 반환은 ax 16비트로 잘린다/

objdump -d --no-show-raw-insn -M intel cksum | sed -n "/<Malware_L03>:/,/ret/p" | sed -f annotate.sed

# cmds.gdb — 배포본 함수가 실행되는 동안 value(=rbx) 를 실제로 들여다본다.
# 정적 분석에서 "value 는 rbx 에 잡혔고 초기화가 없다"고 읽은 것을 런타임으로 확인한다.
set confirm off
set pagination off
break Malware_L03
break *(Malware_L03 + 0x73)
run 4500003c1c46400040060000ac100a63ac100a0c
 
printf "[1] 진입 직후  rbx(=value 초기값) = 0x%lx\n", $rbx
continue
 
printf "[2] 누산 끝난 뒤 rbx(=value)      = 0x%lx\n", $rbx
printf "    value & 65535 = 0x%04lx,  value >> 16 = 0x%lx\n", $rbx & 0xffff, $rbx >> 16
printf "    폴딩 1회 결과  = 0x%lx  (여기서 멈춘다)\n", ($rbx & 0xffff) + ($rbx >> 16)
x/4i $pc
finish

gdb -q -batch -x cmds.gdb --args ./cksum 4500003c1c46400040060000ac100a63ac100a0c

gcc -O0 -g -o uninit_demo snippet.c dirty_rbx.S uninit_demo.c; ./uninit_demo

#!/usr/bin/env python3
"""reference.py — RFC 1071 인터넷 체크섬을 규격 그대로 독립 구현한 것.
배포본 함수(03.txt)와 비교하기 위한 '정답지' 역할만 한다.
 
RFC 1071 §1:
  (1) 데이터를 16비트 빅엔디언 워드로 끊어 1의 보수 합을 구한다(캐리는 되돌려 더한다).
  (2) 길이가 홀수면 마지막 바이트 오른쪽을 0으로 채워 16비트 워드로 만든다.
  (3) 합의 1의 보수가 체크섬이다.
반환값은 '전선 위에 그대로 실리는' 빅엔디언 16비트 정수다.
"""
 
 
def rfc1071(data: bytes) -> int:
    if len(data) & 1:
        data = data + b"\x00"          # (2) 오른쪽 0 패딩
    total = 0
    for off in range(0, len(data), 2):
        total += (data[off] << 8) | data[off + 1]      # (1) 빅엔디언 워드
        total = (total & 0xFFFF) + (total >> 16)       #     캐리 되돌리기
    while total >> 16:
        total = (total & 0xFFFF) + (total >> 16)
    return (~total) & 0xFFFF                            # (3)
 
 
def snippet_model(data: bytes) -> int:
    """03.txt 를 리틀엔디언 기계에서 돌렸을 때를 파이썬으로 옮긴 것.
    - 워드는 호스트(LE) 순서로 읽는다
    - 홀수 바이트 처리는 data[i]<<8 그대로 (버퍼 밖 1바이트를 같이 읽는다)
    - 캐리 폴딩은 원문대로 '단 한 번'
    - 반환은 u_short 절단
    이 함수가 뱉는 값은 호스트 순서다. 전선 위 값과 비교하려면 바이트를 뒤집어야 한다.
    """
    n = len(data)
    buf = data + b"\x00"               # OOB 1바이트를 0으로 가정(정적버퍼의 흔한 경우)
    value = 0                          # 원문은 초기화가 없다. 여기서는 0 으로 둔다
    i = 0
    while i < (n >> 1):
        value += buf[2 * i] | (buf[2 * i + 1] << 8)     # LE u_short
        i += 1
    if n & 1:
        value += (buf[2 * i] | (buf[2 * i + 1] << 8)) << 8
    value = (value & 65535) + (value >> 16)             # 폴딩 1회뿐
    return (~value) & 0xFFFF                            # u_short 절단
 
 
def to_wire(host_u16: int) -> int:
    """LE 기계에서 u_short 를 메모리에 그대로 쓰면 전선 위에서는 바이트가 뒤집혀 보인다."""
    return ((host_u16 & 0xFF) << 8) | (host_u16 >> 8)
 
 
if __name__ == "__main__":
    import sys
    raw = bytes.fromhex(sys.argv[1])
    print(f"len={len(raw)}  rfc1071(wire)=0x{rfc1071(raw):04x}  "
          f"snippet(host)=0x{snippet_model(raw):04x}  "
          f"snippet(wire)=0x{to_wire(snippet_model(raw)):04x}")

/* oob_demo.c — 길이가 홀수일 때 data[i] 가 정말 버퍼 밖을 읽는지 확인한다.
 *
 * 메시지는 7바이트뿐인데 data 는 u_short* 라 data[3] 은 8번째 바이트까지 끌어온다.
 * 그 8번째 바이트만 바꿔 가며 같은 7바이트 메시지의 체크섬이 흔들리는지 본다.
 *
 * 빌드:  gcc -O0 -g -o oob_demo snippet.c oob_demo.c
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
 
u_short Malware_L03(u_short *data, u_short length);   /* snippet.c */
 
int main(void)
{
    static const unsigned char msg[7] = { 0x01,0x02,0x03,0x04,0x05,0x06,0x07 };
    unsigned char guards[] = { 0x00, 0x41, 0xff };
    size_t g;
 
    printf("메시지 7바이트: 01 02 03 04 05 06 07  (길이 인자 length=7 로 고정)\n\n");
    printf("버퍼 밖 8번째 바이트   반환값(호스트)\n");
    for (g = 0; g < sizeof(guards); g++) {
        unsigned char *p = malloc(8);
        memcpy(p, msg, 7);
        p[7] = guards[g];                       /* 메시지가 아닌 자리 */
        printf("0x%02x                   0x%04x\n", guards[g], Malware_L03((u_short *)p, 7));
        free(p);
    }
    printf("\n같은 메시지인데 값이 달라지면, 함수가 메시지 밖 1바이트를 같이 더한 것이다.\n");
    return 0;
}

gcc -O0 -g -Wall -o oob_demo snippet.c oob_demo.c; ./oob_demo

#!/usr/bin/env python3
"""difftest.py — 배포본 함수(컴파일한 ./cksum)와 RFC 1071 정답지를 무작위 입력으로 맞대 본다.
 
'이 함수가 인터넷 체크섬이다'를 눈이 아니라 실측으로 확정하는 게 목적이다.
길이대(짝수 소형 / 홀수 / 짝수 대형)마다 일치 개수를 세고, 어긋난 것은 차이값 분포로 요약한다.
"""
import collections
import random
import subprocess
 
from reference import rfc1071, to_wire
 
random.seed(20261208)          # 재현 가능하게 고정 (문제 공개일)
BIN = "./cksum"
 
 
def run_c(raw: bytes) -> int:
    """컴파일한 배포본 함수를 실제로 실행해 호스트 순서 u_short 를 받아온다."""
    out = subprocess.run([BIN, raw.hex()], capture_output=True, text=True, check=True).stdout
    return int(out.split("=")[-1], 16)
 
 
def sweep(lengths, label):
    ok = 0
    deltas = collections.Counter()
    sample = None
    for n in lengths:
        raw = bytes(random.randrange(256) for _ in range(n))
        got, want = to_wire(run_c(raw)), rfc1071(raw)
        if got == want:
            ok += 1
        else:
            deltas[want - got] += 1
            if sample is None:
                sample = (raw, got, want)
    bad = sum(deltas.values())
    print(f"[{label:<22}] 표본 {ok + bad:>3}  일치 {ok:>3}  불일치 {bad:>3}")
    if bad:
        top = ", ".join(f"{d:+d}: {c}회" for d, c in deltas.most_common(4))
        print(f"      차이(RFC1071 - 배포본) 분포: {top}")
        raw, got, want = sample
        print(f"      첫 사례 len={len(raw)} data={raw[:12].hex()}...  "
              f"배포본=0x{got:04x}  RFC1071=0x{want:04x}")
    return ok, bad
 
 
print("=== 배포본 함수 vs RFC 1071 정답지 (입력은 시드 고정 난수) ===")
sweep([random.randrange(1, 400) * 2 for _ in range(300)], "짝수 2~798B")
sweep([random.randrange(0, 400) * 2 + 1 for _ in range(300)], "홀수 1~799B")
sweep([random.randrange(20000, 60000) & ~1 for _ in range(120)], "짝수 20K~60KB")

python3 difftest.py

#!/usr/bin/env python3
"""minimal_carry.py — '캐리 폴딩 1회' 결함을 터뜨리는 가장 짧은 입력을 찾는다.
 
value = 65536*q + r 로 두면 (value&65535)+(value>>16) = q+r 이다.
이 값이 다시 65536 을 넘으면 폴딩이 한 번 더 필요한데 배포본은 거기서 멈춘다.
q+r >= 65536 이 되려면 워드 수 k >= q+2 여야 하므로 최소 k=3, 즉 6바이트다.
"""
import itertools
import subprocess
 
from reference import rfc1071, to_wire
 
 
def run_c(raw: bytes) -> int:
    out = subprocess.run(["./cksum", raw.hex()], capture_output=True, text=True, check=True).stdout
    return int(out.split("=")[-1], 16)
 
 
def le(w):                      # 호스트(LE) u_short 를 메모리 바이트로
    return bytes([w & 0xFF, w >> 8])
 
 
print("워드 수 k 를 2부터 올리며 반례가 나오는 첫 지점을 찾는다")
for k in range(2, 6):
    hit = None
    # 각 워드를 0xffff 로 채우고 마지막 하나만 훑는 것으로 충분하다
    for last in range(0, 0x10000):
        raw = le(0xFFFF) * (k - 1) + le(last)
        value = 0xFFFF * (k - 1) + last
        if ((value & 65535) + (value >> 16)) >> 16:
            hit = (raw, last)
            break
    if hit is None:
        print(f"  k={k} ({k*2}B): 반례 없음")
        continue
    raw, last = hit
    got, want = to_wire(run_c(raw)), rfc1071(raw)
    print(f"  k={k} ({k*2}B): 반례 발견  data={raw.hex()}  (마지막 워드 0x{last:04x})")
    print(f"      배포본(전선순서)=0x{got:04x}   RFC1071=0x{want:04x}   →  {'다름' if got != want else '같음'}")
    break

python3 minimal_carry.py

#!/usr/bin/env bash
# capture_live.sh — 진짜 패킷을 하나 잡아 온다.
# 루프백으로 ping 을 3번 쏘고 tcpdump 로 pcap 을 남긴다. 만들어낸 데이터가 아니라
# 커널이 직접 체크섬을 채워 전선에 올린 바이트여야 비교에 의미가 있다.
set -euo pipefail
cd "$(dirname "$0")"
OUT=${1:-live_icmp.pcap}
 
sudo -n tcpdump -i lo -c 6 -s 0 -w "$OUT" icmp >/dev/null 2>&1 &
TD=$!
sleep 1
ping -c 3 -i 0.3 -s 32 127.0.0.1 >/dev/null
wait $TD || true
sudo -n chown "$(id -un)":"$(id -gn)" "$OUT"
ls -l "$OUT"
tcpdump -r "$OUT" -n -c 6 2>/dev/null

rm -f live_icmp.pcap && ./capture_live.sh

#!/usr/bin/env python3
"""verify_live.py — 실제로 전선을 지나간 패킷의 체크섬을 배포본 함수로 다시 계산해 본다.
 
capture_live.sh 가 tcpdump 로 남긴 pcap 을 읽어
  · IP 헤더 체크섬
  · ICMP 메시지 체크섬
두 자리를 0 으로 되돌린 뒤 컴파일한 배포본 함수(./cksum)에 그대로 먹인다.
커널이 실제로 써 넣은 값과 한 비트라도 다르면 '인터넷 체크섬이다'라는 결론이 무너진다.
"""
import struct
import subprocess
import sys
 
from reference import to_wire
 
PCAP = sys.argv[1] if len(sys.argv) > 1 else "live_icmp.pcap"
 
 
def run_c(raw: bytes) -> int:
    out = subprocess.run(["./cksum", raw.hex()], capture_output=True, text=True, check=True).stdout
    return int(out.split("=")[-1], 16)
 
 
def packets(path):
    blob = open(path, "rb").read()
    magic = blob[:4]
    endian = "<" if magic in (b"\xd4\xc3\xb2\xa1", b"\x4d\x3c\xb2\xa1") else ">"
    linktype = struct.unpack(endian + "I", blob[20:24])[0]
    off = 24
    while off + 16 <= len(blob):
        _, _, caplen, _ = struct.unpack(endian + "IIII", blob[off:off + 16])
        yield linktype, blob[off + 16: off + 16 + caplen]
        off += 16 + caplen
 
 
L2LEN = {0: 4, 1: 14, 113: 16, 101: 0}          # NULL / EN10MB / LINUX_SLL / RAW
 
print(f"pcap: {PCAP}")
rows = 0
for linktype, frame in packets(PCAP):
    ip = frame[L2LEN.get(linktype, 14):]
    if not ip or ip[0] >> 4 != 4:
        continue
    ihl = (ip[0] & 0xF) * 4
    hdr, payload = ip[:ihl], ip[ihl:]
    proto = hdr[9]
 
    # --- IP 헤더 ---
    on_wire_ip = struct.unpack("!H", hdr[10:12])[0]
    zeroed_ip = hdr[:10] + b"\x00\x00" + hdr[12:]
    calc_ip = to_wire(run_c(zeroed_ip))
 
    # --- ICMP 메시지 (의사헤더 없음) ---
    on_wire_l4 = calc_l4 = None
    if proto == 1 and len(payload) >= 4:
        on_wire_l4 = struct.unpack("!H", payload[2:4])[0]
        zeroed_l4 = payload[:2] + b"\x00\x00" + payload[4:]
        calc_l4 = to_wire(run_c(zeroed_l4))
 
    kind = {8: "echo request", 0: "echo reply"}.get(payload[0] if payload else -1, "?")
    okip = "일치" if calc_ip == on_wire_ip else "★불일치"
    print(f"  [{kind:<13}] IP헤더 {ihl}B  전선=0x{on_wire_ip:04x} 배포본=0x{calc_ip:04x} {okip}")
    if calc_l4 is not None:
        okl4 = "일치" if calc_l4 == on_wire_l4 else "★불일치"
        print(f"  {'':<16} ICMP {len(payload)}B  전선=0x{on_wire_l4:04x} 배포본=0x{calc_l4:04x} {okl4}")
    rows += 1
 
print(f"검사한 패킷 {rows}개")

python3 verify_live.py

/* craft_send.c — 배포본 함수를 '원래 자리'에 그대로 꽂아 본다.
 *
 * IP_HDRINCL 로 IP 헤더를 직접 쓰는 로우소켓에서는 커널이 IP·TCP 체크섬을
 * 채워 주지 않는다. 출발지 주소를 위조하는 플러더가 03.txt 같은 함수를
 * 반드시 들고 다니는 이유가 이것이다. 여기서는 SYN 한 개만 만들어
 * 127.0.0.2 -> 127.0.0.1:9 로 루프백에만 흘린다(외부로 나가지 않는다).
 *
 * 빌드:  gcc -O0 -g -o craft_send snippet.c craft_send.c
 * 실행:  sudo ./craft_send            (로우소켓이라 root 필요)
 */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/ip.h>
#include <netinet/tcp.h>
#include <sys/socket.h>
#include <sys/types.h>
 
u_short Malware_L03(u_short *data, u_short length);   /* snippet.c — 배포본 그대로 */
 
/* TCP 체크섬은 IP 헤더에서 빌려 온 의사헤더(12B)까지 포함해 계산한다 (RFC 793) */
struct pseudo {
    u_int32_t src, dst;
    u_int8_t  zero, proto;
    u_int16_t len;
};
 
int main(void)
{
    unsigned char pkt[sizeof(struct iphdr) + sizeof(struct tcphdr)];
    unsigned char pbuf[sizeof(struct pseudo) + sizeof(struct tcphdr)];
    struct iphdr  *ip  = (struct iphdr *)pkt;
    struct tcphdr *tcp = (struct tcphdr *)(pkt + sizeof(struct iphdr));
    struct pseudo  ph;
    struct sockaddr_in to;
    int s, on = 1;
 
    memset(pkt, 0, sizeof(pkt));
 
    ip->version = 4;  ip->ihl = 5;  ip->tos = 0;
    ip->tot_len = htons(sizeof(pkt));
    ip->id      = htons(0xC0DE);
    ip->frag_off = 0;  ip->ttl = 64;  ip->protocol = IPPROTO_TCP;
    ip->saddr = inet_addr("127.0.0.2");        /* 위조한 출발지 */
    ip->daddr = inet_addr("127.0.0.1");
    ip->check = 0;
    ip->check = Malware_L03((u_short *)ip, sizeof(struct iphdr));   /* ← 배포본 함수 */
 
    tcp->source = htons(31337);
    tcp->dest   = htons(9);                    /* discard 포트 */
    tcp->seq    = htonl(0x1337BEEF);
    tcp->doff   = 5;
    tcp->syn    = 1;
    tcp->window = htons(1024);
    tcp->check  = 0;
 
    ph.src = ip->saddr;  ph.dst = ip->daddr;
    ph.zero = 0;  ph.proto = IPPROTO_TCP;  ph.len = htons(sizeof(struct tcphdr));
    memcpy(pbuf, &ph, sizeof(ph));
    memcpy(pbuf + sizeof(ph), tcp, sizeof(struct tcphdr));
    tcp->check = Malware_L03((u_short *)pbuf, sizeof(pbuf));        /* ← 배포본 함수 */
 
    printf("IP  체크섬(배포본 계산) = 0x%04x\n", ntohs(ip->check));
    printf("TCP 체크섬(배포본 계산) = 0x%04x\n", ntohs(tcp->check));
 
    if ((s = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) { perror("socket"); return 1; }
    if (setsockopt(s, IPPROTO_IP, IP_HDRINCL, &on, sizeof(on)) < 0) { perror("HDRINCL"); return 1; }
 
    to.sin_family = AF_INET;  to.sin_port = 0;  to.sin_addr.s_addr = ip->daddr;
    if (sendto(s, pkt, sizeof(pkt), 0, (struct sockaddr *)&to, sizeof(to)) < 0) {
        perror("sendto"); return 1;
    }
    puts("SYN 1개 전송 완료 (127.0.0.2 -> 127.0.0.1:9, 루프백 한정)");
    close(s);
    return 0;
}

#!/usr/bin/env bash
# craft_demo.sh — 배포본 함수로 채운 체크섬을 커널/tcpdump 가 인정하는지 본다.
# tcpdump -vv 는 체크섬을 스스로 재계산해 (correct)/(incorrect) 를 붙여 준다.
set -uo pipefail
cd "$(dirname "$0")"
sudo -n tcpdump -i lo -c 1 -nvv 'tcp port 9' >craft_dump.txt 2>/dev/null &
TD=$!
sleep 1
sudo -n ./craft_send
wait $TD
echo "--- tcpdump 가 본 패킷 ---"
cat craft_dump.txt

gcc -O0 -g -Wall -o craft_send snippet.c craft_send.c; ./craft_demo.sh

#!/usr/bin/env python3
"""solve.py — 03.txt 가 무슨 함수인지 실측으로 확정하고 정답 한 단어를 출력한다.
 
문제는 "무엇을 하는 함수인가"를 묻는다. 눈으로 보고 '체크섬 같다'로 끝내지 않고
아래 네 가지를 실제로 돌려서 결론을 낸다.
 
  [1] RFC 1071 이 문서에 직접 적어 둔 예제와 맞는가
  [2] 교과서 IP 헤더 예제와 맞는가
  [3] tcpdump 로 잡은 진짜 패킷의 IP·ICMP 체크섬 자리를 그대로 재현하는가
  [4] 무작위 입력 200개에서 규격 구현과 한 비트도 안 어긋나는가 (짝수 길이)
 
넷 다 통과해야 답을 찍는다. 하나라도 어긋나면 이유를 적고 종료코드 1 로 끝낸다.
"""
import random
import struct
import subprocess
import sys
from pathlib import Path
 
HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE))
from reference import rfc1071, to_wire        # noqa: E402
 
BIN = HERE / "cksum"
PCAP = HERE / "live_icmp.pcap"
 
 
def build():
    subprocess.run(["gcc", "-O0", "-g", "-Wall", "-Wextra", "-o", str(BIN),
                    str(HERE / "snippet.c"), str(HERE / "driver.c")], check=True)
 
 
def snippet(raw: bytes) -> int:
    """컴파일한 배포본 함수를 실행하고, 전선(빅엔디언) 순서로 바꿔 돌려준다."""
    out = subprocess.run([str(BIN), raw.hex()], capture_output=True, text=True, check=True).stdout
    return to_wire(int(out.split("=")[-1], 16))
 
 
def pcap_packets(path: Path):
    blob = path.read_bytes()
    endian = "<" if blob[:4] in (b"\xd4\xc3\xb2\xa1", b"\x4d\x3c\xb2\xa1") else ">"
    linktype = struct.unpack(endian + "I", blob[20:24])[0]
    l2 = {0: 4, 1: 14, 113: 16, 101: 0}.get(linktype, 14)
    off = 24
    while off + 16 <= len(blob):
        _, _, caplen, _ = struct.unpack(endian + "IIII", blob[off:off + 16])
        yield blob[off + 16 + l2: off + 16 + caplen]
        off += 16 + caplen
 
 
ok = True
 
print("[1] RFC 1071 3장 예제 (00 01 f2 03 f4 f5 f6 f7)")
build()
got = snippet(bytes.fromhex("0001f203f4f5f6f7"))
print(f"    RFC 문서가 적은 1의 보수 합 0xddf2 -> 그 보수 0x220d 가 체크섬")
print(f"    배포본=0x{got:04x}  ->", "일치" if got == 0x220D else "불일치")
ok &= got == 0x220D
 
print("[2] IP 헤더 예제 (체크섬 필드를 0 으로 둔 20바이트)")
hdr = bytes.fromhex("4500003c1c46400040060000ac100a63ac100a0c")
got = snippet(hdr)
print(f"    배포본=0x{got:04x}  기대값=0xb1e6  ->", "일치" if got == 0xB1E6 else "불일치")
ok &= got == 0xB1E6
 
print(f"[3] 실제로 전선을 지나간 패킷 ({PCAP.name})")
if not PCAP.exists():
    print("    pcap 이 없다. ./capture_live.sh 를 먼저 돌린다.")
    ok = False
else:
    n = miss = 0
    for ip in pcap_packets(PCAP):
        if not ip or ip[0] >> 4 != 4:
            continue
        ihl = (ip[0] & 0xF) * 4
        hdr, payload = ip[:ihl], ip[ihl:]
        n += 1
        if snippet(hdr[:10] + b"\x00\x00" + hdr[12:]) != struct.unpack("!H", hdr[10:12])[0]:
            miss += 1
        if hdr[9] == 1 and len(payload) >= 4:
            n += 1
            if snippet(payload[:2] + b"\x00\x00" + payload[4:]) != struct.unpack("!H", payload[2:4])[0]:
                miss += 1
    print(f"    체크섬 자리 {n}곳 중 {n - miss}곳 재현, 어긋난 곳 {miss}")
    ok &= n > 0 and miss == 0
 
print("[4] 무작위 짝수 길이 200개 — 규격 구현과 전수 대조")
random.seed(1071)
miss = 0
for _ in range(200):
    raw = bytes(random.randrange(256) for _ in range(random.randrange(1, 300) * 2))
    if snippet(raw) != rfc1071(raw):
        miss += 1
print(f"    불일치 {miss} / 200")
ok &= miss == 0
 
print()
if ok:
    print("결론: 03.txt 는 RFC 1071 인터넷 체크섬(in_cksum) 이다.")
    print("      IP_HDRINCL 로우소켓으로 헤더를 직접 만드는 코드가 커널 대신 채워야 하는 값이다.")
    print()
    print("FLAG: checksum")
else:
    print("결론 보류 — 위에서 어긋난 항목을 먼저 확인할 것")
    sys.exit(1)

python3 solve.py