[🥈 Silver 3] 프리젠터를 70번 누르면 모스부호가 된다 — DreamHack My Nervous PPT 풀이

문제: DreamHack — My Nervous PPT 분류: Misc / Forensics 난이도: 🥈 Silver 3 FLAG: KHK{LOOK_AT_MY_PPT}

문제 설명이 짧다.

Umm.. 난 PPT 발표를 하기 전, 긴장된 마음을 풀고자 프리젠터를 막 누르곤 하지.. :( FLag 형식은 KHK{} 입니다. *수정 — 모든 Flag는 대문자입니다.

주어진 파일은 My_PPT.pcapng 하나. 21KB짜리 패킷 캡쳐다. 설명에 나온 "프리젠터"가 곧 힌트다 — 발표용 무선 리모컨은 호스트 입장에서 그냥 USB 키보드로 보이고, 버튼을 누르면 키 입력이 올라간다. 그러니 이 캡쳐는 네트워크 트래픽이 아니라 USB 트래픽이고, 우리가 복원해야 할 건 누군가 156초 동안 누른 버튼의 순서다.

"막 누르곤 하지"라는 말이 무의미한 연타를 뜻하는 것처럼 읽히지만, 실제로는 그 반대다. 누른 패턴 자체가 메시지다.

문제 개요

항목	내용
문제명	My Nervous PPT (id 1757)
난이도	🥈 Silver 3
분류	Misc / Forensics
제공 파일	`My_PPT.pcapng` (21,500 바이트, 패킷 310개)
캡쳐 환경	Windows 11 23H2 + USBPcap2 + Dumpcap 4.4.3
서버	없음 (완전 오프라인 문제)
핵심 기법	USB HID 부트 키보드 리포트 복원 → 눌림 간격으로 글자 분할 → 모스부호 복호

풀이 흐름은 네 단계다. ① pcapng에서 USB 인터럽트 전송의 8바이트 HID 리포트만 뽑고 ② 그중 keycode가 0이 아닌 "눌림"만 남기고 ③ 눌림 사이 시간 간격으로 글자를 자른 뒤 ④ 두 키를 점과 선에 대응시켜 모스부호로 읽는다.

🧩 배경 — USBPcap 이 남긴 pcapng

pcap이라고 하면 대개 이더넷 프레임을 떠올리는데, pcapng의 링크 타입에는 USB도 있다. 윈도우에서는 USBPcap 드라이버가 USB 스택 사이에 끼어 앉아 IRP(I/O Request Packet)를 그대로 떠 준다. Wireshark가 그걸 usb-usbpcap 인캡슐레이션(152번)으로 저장한다.

먼저 파일이 무엇인지부터 확인한다.

file extracted/My_PPT.pcapng && capinfos extracted/My_PPT.pcapng

file 과 capinfos 로 본 My_PPT.pcapng — 인캡슐레이션이 USB packets with USBPcap header 이고 패킷 310개, 캡쳐 길이 156.5초, Windows 11 23H2 에서 Dumpcap 4.4.3 으로 떴다는 것까지 파일 메타데이터에 그대로 남아 있다

읽을 값이 여럿 나온다. 인캡슐레이션이 USB packets with USBPcap header라 USB 캡쳐가 맞고, 인터페이스 이름이 \\.\USBPcap2라 특정 USB 루트 허브 하나만 떴다. 156.498초 동안 310개니까 초당 두 개꼴 — 대역폭을 쓰는 장치는 없고 누군가 버튼을 띄엄띄엄 누른 흔적에 가깝다.

Capture oper-sys에 64-bit Windows 11 (23H2), build 22631까지 박혀 있다. 출제자가 자기 노트북에서 그대로 떠서 올린 파일이다.

🔬 정찰 — 이 버스에 누가 붙어 있나

USBPcap은 그 허브에 붙은 장치를 전부 담기 때문에, 먼저 "어느 장치가 말하고 있나"를 갈라야 한다. tshark로 앞부분을 읽어 보면 열거(enumeration) 과정이 그대로 보인다.

cp extracted/My_PPT.pcapng /tmp/mnp.pcapng && tshark -r /tmp/mnp.pcapng -c 18

tshark 로 읽은 앞 18개 패킷 — host 와 2.2.0, 2.31.0, 2.32.0 사이에서 GET DESCRIPTOR DEVICE, GET DESCRIPTOR CONFIGURATION, SET CONFIGURATION 이 세 쌍씩 반복되는 전형적인 USB 장치 열거 과정이 찍혀 있다

GET DESCRIPTOR DEVICE → GET DESCRIPTOR CONFIGURATION → SET CONFIGURATION 이 장치별로 한 세트씩 반복된다. 캡쳐를 시작한 시점에 이미 꽂혀 있던 장치들을 USBPcap이 뒤늦게 훑은 것이다.

/tmp 로 복사하는 이유는 뒤의 삽질 토글에 적었다. 파일을 그 자리에서 읽을 수가 없었다.

여기서부터는 tshark 출력을 눈으로 좇는 대신, 캡쳐를 직접 파싱하는 스크립트를 하나 만들어 두고 계속 쓰기로 했다. 나중에 복호까지 이 파서를 그대로 재활용한다.

▸📄 analyze.py 전문 — 장치 목록 · 디스크립터 · 간격 히스토그램

#!/usr/bin/env python3
"""My Nervous PPT — 캡쳐 전 정찰용 분석 스크립트.
 
solve.py 의 파서를 그대로 재사용해서 캡쳐에 쓸 세 가지를 뽑는다.
  [1] 캡쳐에 잡힌 USB 장치 목록 (디바이스 디스크립터의 VID/PID)
  [2] 32번 장치의 설정 디스크립터 파싱 — 왜 8바이트 부트 키보드 리포트인가
  [3] HID 리포트 통계 + 눌림 간격 히스토그램 — 글자 경계가 어디서 갈리나
 
사용법:  python3 analyze.py extracted/My_PPT.pcapng [devices|config|reports]
        (섹션 이름을 빼면 셋 다 출력한다)
"""
import struct
import sys
from collections import Counter
 
from solve import parse_pcapng, hid_reports
 
CLASS = {0x00: "(인터페이스별)", 0x03: "HID", 0x09: "Hub", 0xE0: "Wireless", 0xFF: "Vendor"}
PROTO = {0: "None", 1: "Keyboard", 2: "Mouse"}
 
 
def usbpcap_split(pkt):
    """USBPcap 의사헤더에서 (device, endpoint, transfer, 페이로드) 를 꺼낸다."""
    hlen = struct.unpack_from("<H", pkt, 0)[0]
    device = struct.unpack_from("<H", pkt, 19)[0]
    endpoint, transfer = pkt[21], pkt[22]
    return device, endpoint, transfer, pkt[hlen:]
 
 
def show_devices(packets):
    print("[1] 캡쳐에 잡힌 USB 장치 (디바이스 디스크립터 응답)")
    seen = {}
    for _, pkt in packets:
        dev, _, transfer, data = usbpcap_split(pkt)
        # bLength=18, bDescriptorType=0x01 인 것이 디바이스 디스크립터
        if transfer == 0x02 and len(data) == 18 and data[0] == 18 and data[1] == 0x01:
            vid, pid = struct.unpack_from("<HH", data, 8)
            seen.setdefault(dev, (vid, pid, data[4]))
    for dev, (vid, pid, cls) in sorted(seen.items()):
        print(f"    device {dev:>3}  VID:PID = {vid:04x}:{pid:04x}   "
              f"bDeviceClass=0x{cls:02x} {CLASS.get(cls, '')}")
    print()
 
 
def show_config(packets, want_dev):
    print(f"[2] device {want_dev} 의 설정 디스크립터")
    for _, pkt in packets:
        dev, _, transfer, data = usbpcap_split(pkt)
        if dev != want_dev or transfer != 0x02 or len(data) < 9 or data[1] != 0x02:
            continue
        off = 0
        while off + 2 <= len(data):
            blen, btype = data[off], data[off + 1]
            if blen == 0:
                break
            b = data[off:off + blen]
            if btype == 0x02:
                print(f"    CONFIGURATION  총길이={struct.unpack_from('<H', b, 2)[0]}  "
                      f"인터페이스={b[4]}개  최대전류={b[8] * 2}mA")
            elif btype == 0x04:
                print(f"    INTERFACE {b[2]}    class=0x{b[5]:02x} {CLASS.get(b[5], '')}  "
                      f"subclass=0x{b[6]:02x}{' (Boot)' if b[6] == 1 else ''}  "
                      f"protocol=0x{b[7]:02x} {PROTO.get(b[7], '')}  endpoint={b[4]}개")
            elif btype == 0x21:
                print(f"      HID          bcdHID=0x{struct.unpack_from('<H', b, 2)[0]:04x}  "
                      f"리포트 디스크립터 {struct.unpack_from('<H', b, 7)[0]}바이트")
            elif btype == 0x05:
                # bmAttributes 하위 2비트: 00=Control 01=Isochronous 10=Bulk 11=Interrupt
                tt = {0: "Control", 1: "Isochronous", 2: "Bulk", 3: "Interrupt"}[b[3] & 3]
                print(f"      ENDPOINT     0x{b[2]:02x} {'IN' if b[2] & 0x80 else 'OUT'}  "
                      f"{tt}  wMaxPacketSize={struct.unpack_from('<H', b, 4)[0]}  "
                      f"bInterval={b[6]}ms")
            off += blen
        print()
        return
 
 
def show_reports(packets):
    reports = list(hid_reports(packets))
    print(f"[3] 8바이트 HID 키보드 리포트 {len(reports)}개")
    print("    modifier 분포:", dict(Counter(f"0x{r[0]:02x}" for _, r in reports)))
    print("    keycode  분포:", dict(Counter(f"0x{r[2]:02x}" for _, r in reports)))
    print("    2~7번 바이트가 항상 0인가:",
          all(r[1] == 0 and r[3:] == b"\x00" * 5 for _, r in reports))
    print()
 
    presses = [ts for ts, r in reports if r[2] != 0]
    gaps = sorted(round(b - a, 3) for a, b in zip(presses, presses[1:]))
    print(f"    눌림 {len(presses)}회 / 눌림 사이 간격 {len(gaps)}개")
    print(f"    글자 안  : 최소 {gaps[0]:.3f}s ~ 최대 "
          f"{max(g for g in gaps if g < 2):.3f}s  ({sum(1 for g in gaps if g < 2)}개)")
    print(f"    글자 사이: 최소 {min(g for g in gaps if g >= 2):.3f}s ~ 최대 "
          f"{gaps[-1]:.3f}s  ({sum(1 for g in gaps if g >= 2)}개)")
    print("    → 0.9s 와 3.1s 사이가 텅 비어 있어 임계값 2s 로 안전하게 자른다")
 
 
def main():
    path = sys.argv[1] if len(sys.argv) > 1 else "extracted/My_PPT.pcapng"
    want = sys.argv[2] if len(sys.argv) > 2 else "all"
    packets = parse_pcapng(path)
    if want in ("all", "devices"):
        show_devices(packets)
    if want in ("all", "config"):
        show_config(packets, 32)
    if want in ("all", "reports"):
        show_reports(packets)
 
 
if __name__ == "__main__":
    main()

먼저 장치 목록부터.

python3 analyze.py extracted/My_PPT.pcapng devices

analyze.py 가 디바이스 디스크립터에서 뽑은 USB 장치 다섯 개 — 인텔 블루투스, 마이크로소프트 복합장치, 리얼텍, 허브가 하나씩 있고 device 32 만 VID PID 가 3243 0131 로 정체가 불분명한 장치다

다섯 개 중 넷은 벤더 ID만 봐도 대충 갈린다. 8087은 인텔, 045e는 마이크로소프트, 0bda는 리얼텍이고 214b:7250은 bDeviceClass=0x09, 즉 허브다. 남는 건 3243:0131 하나. bDeviceClass가 0이라는 건 클래스를 장치가 아니라 인터페이스가 정한다는 뜻이라, 실제로 뭔지 보려면 설정 디스크립터를 펼쳐야 한다.

그 32번 장치의 설정 디스크립터를 펼쳐 본다.

python3 analyze.py extracted/My_PPT.pcapng config

device 32 의 설정 디스크립터 파싱 결과 — HID 클래스 인터페이스 두 개가 모두 subclass 0x01 Boot, protocol 0x01 Keyboard 로 선언돼 있고 엔드포인트 0x81 과 0x82 가 각각 bInterval 10ms 인터럽트 IN 이다

이 화면이 이번 풀이에서 가장 중요한 근거다. 인터페이스가 둘인데 둘 다 subclass=0x01 (Boot) · protocol=0x01 Keyboard 로 선언돼 있다. 무선 프리젠터가 흔히 쓰는 구성이다 — 하나는 일반 키(방향키·F5), 다른 하나는 멀티미디어 키를 올린다.

Boot 프로토콜이라는 게 왜 중요하냐면, 리포트 디스크립터를 읽지 않아도 리포트 형식이 확정되기 때문이다. USB HID 명세 부록 B가 부트 키보드 리포트를 8바이트로 못 박아 뒀다. 캡쳐에는 리포트 디스크립터를 실제로 받아 오는 패킷이 없는데(206바이트짜리가 있다고 선언만 돼 있다), 그래도 해석이 막히지 않는 이유가 이것이다.

엔드포인트는 0x81 IN 인터럽트, bInterval=10ms. 실제 데이터는 전부 여기로 올라온다.

🧱 배경 — 부트 키보드 리포트 8바이트

부트 키보드 리포트의 구조는 이렇다.

바이트	이름	뜻
0	modifier	Ctrl·Shift·Alt·GUI 비트맵 (좌우 8종)
1	reserved	항상 0
2~7	keycode 1~6	지금 눌려 있는 키의 usage ID, 최대 6개 동시

여기서 자주 헷갈리는 점 하나. 이 리포트는 "키를 눌렀다"는 이벤트가 아니라 "지금 이 순간 눌려 있는 키의 목록" 이다. 그래서 키를 떼면 keycode 자리가 0으로 채워진 리포트가 한 번 더 올라온다. 캡쳐에 리포트가 140개인데 실제 눌림이 70회인 건 그래서다 — 누를 때 하나, 뗄 때 하나.

부트 키보드 리포트 8바이트의 자리별 의미와 이번 문제의 복호 흐름을 정리한 도식 — modifier 는 140개 전부 0x02 로 고정이고 keycode 자리만 0x51 과 0x52 로 갈리며, 눌림 70회를 간격으로 잘라 19덩어리를 만들고 모스로 읽으면 플래그가 된다

이제 실제 리포트를 본다.

tshark -r /tmp/mnp.pcapng -c 60 -Y usbhid.data -T fields -e frame.time_relative -e usb.src -e usbhid.data

tshark 로 뽑은 usbhid.data 필드 — 2.32.1 에서 올라온 8바이트 리포트가 0200520000000000 과 0200510000000000 그리고 0200000000000000 세 종류뿐이고, 누른 리포트와 뗀 리포트가 40밀리초 간격으로 짝을 이룬다

패턴이 한눈에 들어온다. 값이 딱 세 종류다.

02 00 52 00 00 00 00 00 — Left Shift + UpArrow 를 누름
02 00 51 00 00 00 00 00 — Left Shift + DownArrow 를 누름
02 00 00 00 00 00 00 00 — Shift 는 잡은 채 키를 뗌

0x51과 0x52는 HID Usage Tables 키보드 페이지에서 각각 DownArrow와 UpArrow다. 그리고 누름과 뗌이 약 40밀리초 간격으로 붙어 다닌다. 사람이 손으로 누른 것치고는 짧은데, 리모컨 펌웨어가 버튼 한 번에 눌림/뗌을 붙여 쏘기 때문이다.

modifier가 항상 0x02(Left Shift)로 고정이라는 것도 중요하다. 값이 변하지 않으니 정보를 담고 있지 않다. 즉 의미를 나르는 건 keycode 한 바이트뿐이고, 그 값은 두 가지밖에 없다.

🐛 삽질

여기까지 오는 동안 세 번 헛돌았다.

▶🐛 삽질 1 — tshark 가 내 파일을 못 읽는다

처음에 문제 폴더에서 곧장 tshark를 돌렸더니 이랬다.

tshark: You don't have permission to read the file "My_PPT.pcapng".

파일 소유자도 나고 권한도 -rw-rw-r--인데 못 읽는다고 한다. 소유권 문제가 아니라 AppArmor 문제였다. 우분투 24.04부터 /etc/apparmor.d/tshark 프로파일이 붙는데, 바깥쪽 tshark 프로파일은 abstractions/user-tmp만 include하고 홈 디렉토리는 아예 열어 주지 않는다. pcap 읽기 규칙(owner rw /**.pcap{,ng}{,.gz})은 안쪽 dumpcap 서브프로파일에만 들어 있다.

커널 감사 로그를 보면 명확하다.

apparmor="DENIED" operation="open" profile="tshark"
  name="/home/jinho/tsh_test/mp.pcapng" requested_mask="r" denied_mask="r"
  fsuid=1000 ouid=1000

시스템 프로파일을 고치는 대신 허용된 /tmp로 복사해 쓰기로 했다. 그래서 이 글의 tshark 명령이 전부 /tmp/mnp.pcapng를 읽는다. capinfos는 프로파일이 없어서 원래 자리에서 그냥 읽힌다.

파일 권한을 아무리 들여다봐도 답이 안 나오면 dmesg | grep -i apparmor 를 먼저 볼 것.

▶🐛 삽질 2 — usb.capdata 는 비어 있다

리포트 페이로드를 꺼내려고 습관적으로 -e usb.capdata를 썼는데 컬럼이 통째로 비어서 나왔다. 패킷은 분명히 있는데 데이터가 없다는 뜻이라 한참 헤맸다.

원인은 필드 이름이었다. Wireshark가 인터페이스 클래스를 HID로 인식하면 페이로드를 usb 계층이 아니라 usbhid 계층에 붙인다. 그래서 필드가 usb.capdata가 아니라 usbhid.data 다. 패킷 하나를 -T json으로 통째로 찍어 보고서야 알았다.

"usbhid.data": "02:00:52:00:00:00:00:00"

필드 이름을 기억에 의존하지 말고, 막히면 패킷 하나를 통째로 덤프해 실제 트리를 보는 게 빠르다.

▶🐛 삽질 3 — USBPcap 헤더 필드 위치를 눈대중으로 셌다

자체 파서를 짜면서 전송 타입 필드를 pkt[26]으로 읽었더니 인터럽트 전송이 하나도 안 걸려서 이렇게 죽었다.

HID 눌림 이벤트가 없다

USBPcap 의사헤더의 실제 배치는 이렇다.

오프셋	크기	필드
0	2	headerLen
2	8	irpId
10	4	status
14	2	function
16	1	info
17	2	bus
19	2	device
21	1	endpoint
22	1	transfer
23	4	dataLength

transfer는 22번이지 26번이 아니다. 26번은 dataLength의 중간이라 항상 0이 나왔고, 그래서 조건이 한 번도 참이 되지 않았다.

같은 실수를 한 번 더 했다. 엔드포인트의 bmAttributes 하위 2비트를 {0:Control, 1:Interrupt, 2:Bulk, 3:Isochronous}로 매핑했는데, 명세의 순서는 Control / Isochronous / Bulk / Interrupt 다. 인터럽트 엔드포인트가 "Isochronous"로 출력돼도 코드는 멀쩡히 돌기 때문에 출력을 눈으로 읽다가 이상해서 발견했다.

바이트 오프셋과 enum 순서는 외운 걸 쓰지 말고 명세를 열어 세는 게 결국 빠르다. 특히 후자처럼 틀려도 크래시가 안 나는 종류가 위험하다.

💣 핵심 — 간격이 글자를 가른다

신호가 두 종류라는 걸 알았으니, 이제 이걸 어떻게 문자로 바꾸느냐가 남는다.

가장 먼저 떠오르는 건 이진법이다. Down을 0, Up을 1로 놓고 70비트를 8비트씩 끊으면 8글자 남짓 나온다. 그런데 70은 8로 나누어떨어지지 않고, 무엇보다 눌림 시각을 보면 덩어리가 이미 눈에 보인다. 5.6초·5.9초·6.4초에 세 번 몰아치고 나서 9.6초까지 조용하다. 이진법이라면 그럴 이유가 없다.

간격을 실제로 세어 본다.

python3 analyze.py extracted/My_PPT.pcapng reports

analyze.py 의 리포트 통계 — 8바이트 리포트 140개 중 modifier 는 전부 0x02 이고 keycode 는 0x52 가 41회, 0x51 이 29회, 0x00 이 70회다. 눌림 사이 간격은 글자 안이 0.328초에서 0.880초, 글자 사이가 3.184초에서 7.808초로 완전히 갈라진다

깔끔하게 갈린다.

글자 안의 간격: 0.328s ~ 0.880s (51개)
글자 사이의 간격: 3.184s ~ 7.808s (18개)

0.9초와 3.1초 사이에 값이 하나도 없다. 이렇게 뚜렷하게 비어 있으면 임계값을 어디로 잡든 결과가 같다는 뜻이라, 2초로 잡았다. 간격 18개가 경계이므로 글자는 19개다.

2~7번 바이트가 항상 0인가: True 도 같이 확인해 뒀다. 동시 입력이 한 번도 없었다는 뜻이라, keycode 자리 하나만 봐도 정보를 빠뜨리지 않는다.

두 종류 신호 + 글자 단위 구분 + 글자마다 길이가 1~6으로 제각각. 이 세 가지가 겹치면 답은 모스부호다. 고정 길이 부호였다면 덩어리 크기가 전부 같아야 한다.

🧱 배경 — 모스부호

모스부호는 점(dot)과 선(dash) 두 기호로 글자를 만든다. 규칙은 길이의 비율로 정의돼 있다.

국제 모스부호 표 — 점 하나가 1단위, 선은 3단위, 같은 글자 안의 간격은 1단위, 글자 사이는 3단위, 단어 사이는 7단위라는 규칙과 함께 A부터 Z, 0부터 9까지의 부호가 정리돼 있다

출처: Wikimedia Commons, public domain

원래 모스는 하나의 신호선에서 "눌린 시간의 길이"로 점과 선을 구별한다. 이번 문제는 그걸 조금 바꿔서 버튼 두 개에 점과 선을 하나씩 배정했다. 프리젠터에는 이전/다음 버튼밖에 없으니 자연스러운 변형이고, 덕분에 눌린 시간을 잴 필요 없이 어느 키인지만 보면 된다.

글자 사이 간격은 그대로 살아 있다. 표의 4번 규칙이 실제 캡쳐에서 3.18초 이상의 공백으로 나타난 것이다.

다만 단어 사이 간격은 쓰이지 않았다. 7단위짜리 더 큰 공백이 있어야 하는데 간격 최댓값이 7.8초로 글자 사이 범위 안에 들어온다. 그래서 띄어쓰기는 부호로 표현했다 — 뒤에 나오는 언더스코어가 그 역할을 한다.

🎯 점과 선의 방향 정하기

여기서 한 번 더 갈린다. 두 키 중 어느 쪽이 점이고 어느 쪽이 선인가? 캡쳐 어디에도 안 적혀 있다.

추측하지 않고 둘 다 돌려서 골랐다. 플래그 형식이 KHK{} 로 시작한다는 게 문제 설명에 있으니, 첫 세 글자가 KHK로 떨어지는 쪽이 정답이다.

#!/usr/bin/env python3
"""My Nervous PPT — 어느 키가 점(dot)이고 어느 키가 선(dash)인가.
 
키가 0x51/0x52 둘뿐이라 모스로 읽는 방법은 두 가지다. 둘 다 돌려 보고
플래그 형식(KHK)이 나오는 쪽을 고른다. 추측이 아니라 대조로 정한다.
 
사용법:  python3 orientation.py extracted/My_PPT.pcapng
"""
import sys
 
from solve import KEY_DOWN, KEY_UP, LETTER_GAP, MORSE, hid_reports, parse_pcapng
 
 
def groups(path):
    presses = [(ts, r[2]) for ts, r in hid_reports(parse_pcapng(path)) if r[2] != 0]
    out, cur, prev = [], [], None
    for ts, key in presses:
        if prev is not None and ts - prev > LETTER_GAP:
            out.append(cur)
            cur = []
        cur.append(key)
        prev = ts
    out.append(cur)
    return out
 
 
def decode(gs, dot_key):
    letters = ["".join("." if k == dot_key else "-" for k in g) for g in gs]
    return "".join(MORSE.get(c, "?") for c in letters), letters
 
 
def main():
    path = sys.argv[1] if len(sys.argv) > 1 else "extracted/My_PPT.pcapng"
    gs = groups(path)
    for label, dot_key in (("Down(0x51)=점 / Up(0x52)=선", KEY_DOWN),
                           ("Up(0x52)=점 / Down(0x51)=선", KEY_UP)):
        text, letters = decode(gs, dot_key)
        bad = sum(1 for c in text if c == "?")
        print(f"[{label}]")
        print(f"    앞 세 글자 모스: {' '.join(letters[:3])}")
        print(f"    복호 결과      : {text}")
        print(f"    모스표에 없는 글자: {bad}개 "
              f"→ {'플래그 형식 KHK 로 시작, 채택' if text.startswith('KHK') else '형식 불일치, 기각'}")
        print()
 
 
if __name__ == "__main__":
    main()

python3 orientation.py extracted/My_PPT.pcapng

orientation.py 실행 결과 — Down 을 점으로 놓으면 첫 세 글자가 -.- .... -.- 즉 KHK 로 떨어지고 모스표에 없는 글자가 0개인 반면, 반대로 놓으면 첫 글자부터 ---- 처럼 존재하지 않는 부호가 나와 물음표가 5개 생긴다

한쪽은 물음표가 0개, 다른 쪽은 5개다. 뒤집힌 쪽에서 두 번째 글자가 ----로 나오는데, 이건 모스 표에 아예 없는 부호다. 우연히 둘 다 그럴듯하게 나올 여지가 없다.

DownArrow가 점, UpArrow가 선. 프리젠터 기준으로는 "다음 슬라이드"가 점이다. 짧게 톡 치는 쪽을 점으로 배정한 셈이라 감각적으로도 맞는다.

🚀 Full Exploit

정찰에서 쓰던 파서에 모스 복호를 붙이면 끝이다. tshark 없이 pcapng를 직접 읽으므로 파이썬만 있으면 돌아간다.

#!/usr/bin/env python3
"""My Nervous PPT (DreamHack, Silver 3 / misc-forensics) — solver.
 
My_PPT.pcapng 는 USBPcap 으로 뜬 USB 캡쳐다. 프리젠터(무선 리모컨)는 호스트에
평범한 USB HID 키보드로 보이고, "다음 슬라이드"/"이전 슬라이드" 버튼은 각각
Shift+Down(0x51) / Shift+Up(0x52) 리포트를 올린다.
 
이 스크립트는 tshark 없이 pcapng 를 직접 파싱해서
  1) Enhanced Packet Block 에서 USBPcap 의사헤더를 벗기고
  2) 8바이트 HID 키보드 리포트 중 keycode != 0 인 것(=키 눌림)만 골라
  3) 눌림 사이 시간 간격으로 글자 경계를 자른 뒤
  4) Down=dot / Up=dash 로 모스부호를 복호한다.
 
사용법:  python3 solve.py extracted/My_PPT.pcapng
"""
import struct
import sys
 
# ── pcapng 블록 타입
SHB = 0x0A0D0D0A          # Section Header Block
IDB = 0x00000001          # Interface Description Block
EPB = 0x00000006          # Enhanced Packet Block
 
# ── USB HID 키보드 usage ID (HID Usage Tables, Keyboard/Keypad page 0x07)
KEY_DOWN = 0x51           # Keyboard DownArrow  → 프리젠터 "다음 슬라이드"
KEY_UP = 0x52             # Keyboard UpArrow    → 프리젠터 "이전 슬라이드"
 
LETTER_GAP = 2.0          # 초. 이보다 크면 글자 경계
 
MORSE = {
    ".-": "A", "-...": "B", "-.-.": "C", "-..": "D", ".": "E", "..-.": "F",
    "--.": "G", "....": "H", "..": "I", ".---": "J", "-.-": "K", ".-..": "L",
    "--": "M", "-.": "N", "---": "O", ".--.": "P", "--.-": "Q", ".-.": "R",
    "...": "S", "-": "T", "..-": "U", "...-": "V", ".--": "W", "-..-": "X",
    "-.--": "Y", "--..": "Z",
    "-----": "0", ".----": "1", "..---": "2", "...--": "3", "....-": "4",
    ".....": "5", "-....": "6", "--...": "7", "---..": "8", "----.": "9",
    ".-.-.-": ".", "--..--": ",", "..--..": "?", "-..-.": "/", "-....-": "-",
    "-.--.": "(", "-.--.-": ")", "..--.-": "_", "-...-": "=", ".-.-.": "+",
    "---...": ":", ".----.": "'", ".-..-.": '"', "...-..-": "$", ".--.-.": "@",
}
 
 
def parse_pcapng(path):
    """pcapng 를 훑어 (타임스탬프[초], 페이로드 bytes) 리스트를 돌려준다."""
    raw = open(path, "rb").read()
    endian, tsres = "<", 1e-6
    out, off = [], 0
    while off + 12 <= len(raw):
        btype = struct.unpack_from(endian + "I", raw, off)[0]
        if btype == SHB:
            # byte-order magic 으로 엔디안을 확정한 뒤 블록 길이를 다시 읽는다
            endian = "<" if raw[off + 8:off + 12] == b"\x4d\x3c\x2b\x1a" else ">"
            btype = struct.unpack_from(endian + "I", raw, off)[0]
        blen = struct.unpack_from(endian + "I", raw, off + 4)[0]
        if blen < 12 or off + blen > len(raw):
            break
        body = raw[off + 8: off + blen - 4]
        if btype == IDB:
            # if_tsresol 옵션(코드 9)이 있으면 타임스탬프 해상도를 갱신
            opt = 8
            while opt + 4 <= len(body):
                ocode, olen = struct.unpack_from(endian + "HH", body, opt)
                if ocode == 0:
                    break
                if ocode == 9 and olen >= 1:
                    v = body[opt + 4]
                    tsres = 2.0 ** -(v & 0x7F) if v & 0x80 else 10.0 ** -v
                opt += 4 + ((olen + 3) & ~3)
        elif btype == EPB:
            hi, lo, caplen = struct.unpack_from(endian + "III", body, 4)
            ts = ((hi << 32) | lo) * tsres
            out.append((ts, body[20:20 + caplen]))
        off += blen
    return out
 
 
def hid_reports(packets):
    """USBPcap 의사헤더를 벗기고 8바이트 HID 키보드 리포트만 추린다."""
    for ts, pkt in packets:
        if len(pkt) < 2:
            continue
        hlen = struct.unpack_from("<H", pkt, 0)[0]   # USBPcap headerLen
        if hlen < 27 or len(pkt) < hlen:
            continue
        transfer = pkt[22]                           # 0x01 = interrupt
        data = pkt[hlen:]
        if transfer == 0x01 and len(data) == 8:
            yield ts, data
 
 
def main():
    path = sys.argv[1] if len(sys.argv) > 1 else "extracted/My_PPT.pcapng"
    packets = parse_pcapng(path)
 
    # keycode 가 0 인 리포트는 "떼기(release)" 라 버리고 눌림만 남긴다
    presses = [(ts, r[2]) for ts, r in hid_reports(packets) if r[2] != 0]
    if not presses:
        sys.exit("HID 눌림 이벤트가 없다")
    print(f"[*] 패킷 {len(packets)}개 / HID 눌림 {len(presses)}회 "
          f"/ 사용 keycode {sorted({k for _, k in presses})}")
 
    # 눌림 사이 간격이 LETTER_GAP 을 넘으면 글자를 끊는다
    letters, cur, prev = [], "", None
    for ts, key in presses:
        if prev is not None and ts - prev > LETTER_GAP:
            letters.append(cur)
            cur = ""
        cur += "." if key == KEY_DOWN else "-" if key == KEY_UP else "?"
        prev = ts
    letters.append(cur)
 
    print(f"[*] 글자 {len(letters)}개로 분할")
    decoded = ""
    for i, code in enumerate(letters):
        ch = MORSE.get(code, "?")
        decoded += ch
        print(f"    {i:2d}  {code:<8}  {ch}")
 
    # 모스에는 중괄호가 없다. 출제자는 괄호 (…) 로 대신 썼다.
    flag = "KHK{" + decoded.split("(", 1)[1].rsplit(")", 1)[0] + "}" if "(" in decoded else decoded
    print(f"\n[*] 모스 복호 결과: {decoded}")
    print(f"[+] FLAG: {flag}")
 
 
if __name__ == "__main__":
    main()

python3 solve.py extracted/My_PPT.pcapng

solve.py 실행 결과 — 패킷 310개에서 눌림 70회를 뽑아 19덩어리로 자르고 각 덩어리의 모스 부호와 대응 글자를 차례로 출력한 뒤, 마지막 줄에 복호 결과와 플래그가 찍힌다

19글자가 순서대로 떨어진다. K H K ( L O O K _ A T _ M Y _ P P T ).

마지막에 손을 한 번 대야 한다. 모스부호에는 중괄호가 없다. 그래서 출제자는 여는 괄호 -.--. 와 닫는 괄호 -.--.- 를 대신 썼다. 이 둘은 실제로 모스 표에 있는 부호다(각각 KN, KK 로도 읽힌다). 괄호를 중괄호로 바꾸면 형식이 맞는다.

띄어쓰기 자리에 들어간 ..--.- 는 언더스코어다. 앞에서 단어 간격이 안 쓰였다고 했던 게 여기서 맞아떨어진다 — 출제자가 공백 대신 부호를 넣었기 때문에 굳이 7단위 간격을 만들 필요가 없었다.

KHK(LOOK_AT_MY_PPT)  →  KHK{LOOK_AT_MY_PPT}

플래그는 KHK{LOOK_AT_MY_PPT}. "내 PPT 좀 봐줘"라는, 문제 설명과 이어지는 문장이다.

✅ 교차 검증 — tshark 로 한 번 더

자체 파서가 pcapng를 잘못 읽었을 가능성을 없애려고, 파서를 전혀 공유하지 않는 경로로 한 번 더 복호했다. tshark가 뽑아 준 필드를 awk로 훑어 점과 선을 만드는 방식이다.

#!/usr/bin/env bash
# My Nervous PPT — tshark 로 독립 복호. solve.py 의 자체 파서와 결과가 같은지 대조한다.
#
# 우분투 24.04 이후 tshark 는 AppArmor 프로파일(/etc/apparmor.d/tshark)에 묶여
# 홈 디렉토리의 pcap 을 못 읽는다. 허용된 곳이 /tmp 라 거기로 복사해서 돌린다.
set -eu
cd "$(dirname "$(readlink -f "$0")")"
 
PCAP=${1:-extracted/My_PPT.pcapng}
cp "$PCAP" /tmp/mnp.pcapng
 
tshark -r /tmp/mnp.pcapng -Y usbhid.data \
       -T fields -e frame.time_relative -e usbhid.data 2>/dev/null |
awk '
  # 리포트 8바이트 중 3번째(keycode) 자리만 본다. 00 이면 키를 뗀 것이라 버린다.
  { key = substr($2, 5, 2) }
  key == "00" { next }
  {
    if (prev != "" && $1 - prev > 2.0) printf " "   # 2초 넘게 쉬면 글자 경계
    printf "%s", (key == "51" ? "." : "-")          # Down=점  Up=선
    prev = $1
  }
  END { printf "\n" }
' | tee /tmp/mnp_morse.txt
 
python3 - /tmp/mnp_morse.txt <<'PY'
import sys
from solve import MORSE
codes = open(sys.argv[1]).read().split()
text = "".join(MORSE.get(c, "?") for c in codes)
print(f"글자 {len(codes)}개 → {text}")
print("FLAG: KHK{" + text.split("(", 1)[1].rsplit(")", 1)[0] + "}")
PY

./crosscheck_tshark.sh

crosscheck_tshark.sh 실행 결과 — tshark 와 awk 만으로 만든 모스 문자열 19덩어리가 한 줄로 출력되고, 그것을 복호한 결과와 플래그가 자체 파서 쪽과 정확히 같게 나온다

19덩어리, 같은 문자열, 같은 플래그. 두 경로가 일치하니 pcapng 파싱과 임계값 선택이 모두 맞다고 봐도 된다.

🔁 재현

문제 폴더만 있으면 한 방에 다시 돌아가도록 스크립트를 남겼다. 서버도 VM도 필요 없고 파이썬 3만 있으면 된다.

#!/usr/bin/env bash
# My Nervous PPT (DreamHack 1757, Silver 3 misc/forensics) — 한 방 재현.
# 배포본 pcapng 에서 flag 를 뽑아 기대값과 대조한다. 외부 서버·VM 불필요.
set -eu
cd "$(dirname "$(readlink -f "$0")")"
 
EXPECT=$(python3 -c "import json;print(json.load(open('문제.json'))['flag'])" 2>/dev/null \
         || echo 'KHK{LOOK_AT_MY_PPT}')
 
OUT=$(timeout 120 python3 solve.py extracted/My_PPT.pcapng 2>&1) || true
echo "$OUT" | tail -8
 
FLAG=$(printf '%s' "$OUT" | grep -aoE 'KHK\{[^}]+\}' | head -1)
if [ -n "$FLAG" ] && [ "$FLAG" = "$EXPECT" ]; then
  echo; echo "✅ PASS  $FLAG"; exit 0
fi
echo; echo "❌ FAIL (얻은 값: '${FLAG:-없음}' / 기대: '$EXPECT')"; exit 1

./reproduce.sh

reproduce.sh 실행 결과 — solve.py 출력의 마지막 여덟 줄에 이어 얻은 플래그와 기대값이 일치한다는 PASS 표시가 찍힌다

로컬 환경은 Ubuntu 25.10 · Python 3.13 · tshark 4.4.x 다. solve.py는 표준 라이브러리만 쓰므로 tshark가 없어도 되고, 교차 검증 스크립트만 tshark를 요구한다.

📝 결론

키보드 캡쳐는 "무엇을 쳤나"보다 "언제 쳤나"가 답일 때가 있다

USB HID 문제라고 하면 보통 keycode를 문자로 매핑해서 문장을 복원한다. 이 문제는 그 길이 막혀 있다 — 등장하는 키가 방향키 두 개뿐이라 매핑할 게 없다.

대신 타임스탬프가 살아 있었다. 눌림 간격이 0.9초와 3.1초 사이에서 완전히 갈라진다는 사실 하나로 글자 경계가 정해졌고, 그때부터는 그냥 모스부호였다. 패킷 캡쳐의 시간 정보를 페이로드만큼 진지하게 볼 것.

부트 프로토콜이 리포트 형식을 보증한다

이 캡쳐에는 HID 리포트 디스크립터를 실제로 받아 오는 패킷이 없다. 206바이트짜리가 있다고 선언만 돼 있을 뿐이다. 그런데도 8바이트 리포트를 정확히 해석할 수 있었던 건 인터페이스가 subclass=0x01 (Boot)로 선언돼 있었기 때문이다.

디스크립터를 파싱해 보는 건 귀찮아 보여도, "이 8바이트를 이렇게 읽어도 되는가"에 대한 답을 준다. 추측으로 넘어갔다면 modifier 바이트를 keycode로 오해하는 식의 사고가 났을 것이다.

애매한 결정은 두 갈래 다 돌려서 고른다

점과 선의 방향은 캡쳐 어디에도 없었다. 감으로 정하고 결과가 이상하면 뒤집는 방식으로도 풀리긴 하지만, 두 경우를 다 돌려서 "모스 표에 없는 부호가 몇 개 나오나"로 판정하면 근거가 남는다. 실제로 뒤집은 쪽은 ---- 같은 존재하지 않는 부호를 뱉었다.

방어 관점 — 무선 프리젠터는 무선 키보드다

문제와 별개로, 이 캡쳐가 보여 주는 그림 자체가 한 번쯤 생각해 볼 만하다. 발표용 리모컨은 bInterfaceProtocol=0x01, 즉 호스트에게 키보드로 자기를 소개한다. 화면을 넘기는 권한만 있는 게 아니라 임의의 키 입력을 올릴 수 있다는 뜻이다.

USB 캡쳐가 남으면 그 키 입력이 전부 평문으로 복원된다는 것도 같이 봐야 한다. 이번엔 방향키뿐이라 무해했지만, 같은 자리에 비밀번호를 쳤다면 usbhid.data 몇 줄로 그대로 새어 나온다. 강의장이나 회의실에 놓인 정체불명의 USB 동글을 그냥 꽂는 습관이 왜 위험한지에 대한 꽤 구체적인 그림이다.

[🥈 Silver 3] 프리젠터를 70번 누르면 모스부호가 된다 — DreamHack My Nervous PPT 풀이

댓글

관련 글

[🥈 Silver 4] JPEG 끝 뒤의 tar.bz2 와 IEND 뒤의 AES 키 — DreamHack Gyul Box 풀이

[🥉 Bronze 2] 6523개 CAN 프레임 중 튀는 하나 — DreamHack Read My Car 풀이

[🥈 Silver 4] 줄 끝 공백에 숨은 플래그 — SNOW 스테가노그래피 (DreamHack Snowing! 풀이)