🔥 Flame (2012) — 'MD5 충돌로 MS 인증서를 위조한' 20MB 스파이 플랫폼

1. 배경/역사 — 언제, 누가, 왜 유명한가

2012년 5월 28일, 이란 국가 CERT 산하 MAHER 센터와 카스퍼스키 랩, 헝가리 부다페스트공대 CrySyS 랩이 동시에 하나의 악성코드를 공개했다. 이름은 Flame(별칭 Flamer·sKyWIper). CrySyS 랩의 표현은 이랬다 — "우리 실무에서 만난 가장 정교한 악성코드이며, 어쩌면 지금까지 발견된 가장 복잡한 악성코드다." 카스퍼스키는 "Stuxnet보다 20배 복잡하다"고 표현했고, 전체 분석에는 10년이 걸릴 수도 있다고 덧붙였다.

출발점은 2012년 4월 이란 석유부의 사고였다. 이란 당국은 정유 터미널을 인터넷에서 물리적으로 분리했고, 국영통신사는 그 원인을 "Wiper"라고 불렀다. 국제전기통신연합(ITU)의 요청을 받은 카스퍼스키가 조사에 들어갔고, 곧 중동 국가 고객들에서만 나타나는 특정 MD5 해시·파일명 패턴을 발견한다. 내부 모듈 이름(FROG.DefaultAttacks.A-InstallFlame)에서 따온 "Flame"이 그렇게 세상에 나왔다. 카스퍼스키는 이 암호화된 대형 플랫폼이 Stuxnet(2010)과 강한 계보 관계에 있다고 결론지었다 — 초기 Stuxnet에 들어 있던 USB 전파 코드가 Flame의 특정 모듈과 거의 동일했고, 두 악성코드는 같은 제로데이 취약점 2개를 그대로 재사용하고 있었다.

Flame이 보안사에 남긴 결정적 유산은 크기가 아니다. MD5 해시 충돌(chosen-prefix collision)로 마이크로소프트의 코드서명 인증서를 위조해, 악성 구성요소를 "마이크로소프트가 서명한 것"처럼 보이게 만든 사건이다. 해시 알고리즘 하나가 PKI 신뢰 사슬 전체를 떠받치고 있음을 실전에서 증명했고, 그 결과 업계의 MD5 → SHA-2 전면 전환이 앞당겨졌다.

2. 감염·전파 경로 — 석유부 책상에서 같은 층 사무실로

Flame은 웜처럼 대량으로 퍼지는 것을 목표로 하지 않았다. 표적은 감청·수집이었고, 그래서 전파 경로도 "조직 내부"에 맞춰 설계됐다.

• ① 스피어피싱 + 제로데이: 표적 맞춤형 문서(Word RTF 계열 등)로 초기 침투. 카스퍼스키는 Flame이 최소 4~5개의 제로데이를 조합했다고 분석했다 — 초기 감염용 문서 취약점(CVE-2010-3333 계열), 권한 상승용 취약점, 그리고 뒤에 나올 네트워크 전파용 취약점이다.
• ② LAN 자동 전파 (이 문서의 핵심): 같은 서브넷의 다른 PC를 찾아내면 인쇄 스풀러 결함(MS10-061 계열, Stuxnet이 썼던 것과 같은 취약점)을 다시 사용해 원격으로 코드를 넣은 것으로 보고됐다. 여기에 NBNS/WINS 이름 조회와 WPAD(자동 프록시 탐색) 스푸핑을 결합해, 자기를 "사내 정품 업데이트 서버"로 위장했다.
• ③ 위조 인증서 배포: 위장한 업데이트 서버가 내려주는 구성요소는 MD5 충돌로 위조한 마이크로소프트 인증서로 서명돼 있었다. 피해 PC의 Windows Update 클라이언트는 "MS가 서명한 정품"으로 판단하고 스스로 설치·실행했다 — 즉 패치 인프라 자체가 감염 경로로 전환됐다.
• ④ USB·블루투스 확산: 이동식 저장매체 감염 모듈(Frog 계열)과 함께, 감염 PC를 블루투스 비콘처럼 동작시켜 주변 기기에서 연락처·기기 정보를 수집했다.
• ⑤ 조직 밖으로: 수집 데이터는 아시아·유럽·북미에 흩어진 약 80개 C2로 전송됐다. 카스퍼스키가 이 C2들을 싱크홀한 결과, "압도적 다수의 표적이 이란 내부"이며 요구 데이터는 AutoCAD 도면·PDF·텍스트 문서에 집중돼 있었다.

3. 동작 원리 상세 — 규모가 아니라 구조가 무기였다

20 MB는 2012년 기준으로 말도 안 되는 크기다. 당시 악성코드는 보통 수십~수백 KB였고, 표적 스파이는 "작고 조용한" 것이 상식이었다. Flame은 정반대로 갔다.

• 플러그인 플랫폼: 본체는 로더에 가깝다. Lua 스크립트 + 컴파일된 C++로 작성되어 있고, 침투 후 필요한 기능만 모듈로 내려받아 실행한다. 감청(Munch — 키로깅·네트워크 스니핑), 스크린샷, 오디오 녹음, 스카이프 대화 기록, USB 전파(Frog), 스캐너(Snack) 등이 모듈로 분리돼 있다.
• 은닉 실행: 모듈을 프로세스에 주입하되, 프로세스가 스스로 보고하는 로드된 모듈 목록에는 나타나지 않게 했다. 해당 메모리 영역은 사용자 모드에서 읽기·쓰기·실행 권한이 제한되도록 보호됐다. 즉 "모듈 목록을 물어보는" 전통적 탐지가 무력화됐다.
• 지속성: 가짜 오디오 드라이버 서비스를 설치해 부팅 때마다 살아났다. 사용자는 "사운드 드라이버"로 보지만 실제로는 Flame의 상주 지점이다.
• 데이터 관리: 수집 결과는 SQLite 데이터베이스에 구조화해 저장했다. 수집·분류·보고가 한 덩어리의 정보 시스템으로 돌아간 셈이다.
• 낮은 시그니처: 내부 코드는 알려진 악성코드와 유사점이 거의 없고, 암호화 방식을 5종 혼용했다. 안티바이러스 제품을 식별해 파일 확장자 등 자기 행동을 제품별로 바꾸는 회피 로직도 있었다.
• 자폭(kill): 통제 서버가 "suicide" 모듈을 보내면 감염 흔적을 스스로 전부 지운다. 2012년 6월 8일, 노출된 지 10일 만에 실제로 이 명령이 관측됐다 — 증거 인멸이 설계에 포함돼 있었던 것이다.

4. 핵심 기술 — MD5 충돌로 마이크로소프트 인증서를 위조하다

Flame의 백미는 위조 코드서명 인증서다. 절차는 이렇다.

• 공격자들은 마이크로소프트가 발급한 "Microsoft Enforced Licensing Intermediate PCA" 관련 인증서 중 하나, 즉 터미널 서버 라이선싱 서비스용 인증서가 (설계 의도와 달리) 코드서명이 가능하게 설정돼 있고 여전히 MD5를 쓰고 있다는 사실을 찾아냈다.
• 그 인증서의 TBSCertificate(서명 대상 본문)와 해시가 충돌하는 다른 본문을 만들어 위조 인증서를 만들었다. 두 본문은 바이트열이 서로 다르지만 MD5 값이 같으므로, 기존 서명값이 위조 인증서에도 그대로 유효한 것처럼 통과된다.
• 그 결과 위조 인증서는 마이크로소프트 루트 CA까지 신뢰 사슬이 이어졌다. 2008년 연구진이 위조 CA 인증서로 개념을 증명했지만, 실전 공격에 쓰인 것은 Flame이 처음이었다(게다가 기존 기법을 개량한 새 변형 선택 접두사 충돌이었다).
• 여기에 WPAD/NBNS 스푸핑이 결합되면서, 같은 네트워크의 PC들이 "신뢰할 수 있는 MS 업데이트"를 스스로 설치하는 자동 확산 경로가 완성됐다.

마이크로소프트는 2012년 6월 3일 보안 공지 2718704(KB2718704)로 무단 발급된 인증서들을 폐기하고, 코드서명·업데이트 검증에서 MD5 사용을 중단(SHA-2로 전환)했다. MD5는 이때 "연구실 이야기"에서 "실전 무기"로 넘어갔다.

5. 피해 규모/영향 — 숫자는 작고, 파급은 컸다

• 감염 규모: 약 1,000대. 웜이 아니었기에 "대량"은 아니지만, 표적의 성격이 달랐다 — 정부기관·교육기관·특정 개인, 싱크홀 분석상 압도적 다수가 이란 내부였다.
• 수집 범위: 키보드 입력, 화면, 마이크 오디오, 스카이프 통화, 주변 블루투스 기기 연락처, 문서 파일까지. 스파이 도구로는 이례적인 '전방위 수집 플랫폼'이었다.
• 정책적 파장: 2012년 6월 19일 워싱턴포스트는 Flame이 미국 NSA·CIA와 이스라엘 군이 최소 5년 전부터 공동 개발했다고 보도했다(코드네임 Olympic Games, 이란 핵 프로그램을 겨눈 사이버 작전 준비 단계). 미국은 공식 부인했다.
• 업계 영향: ① 코드서명·PKI에서 MD5 퇴출이 가속됐고, ② "서명이 있으면 안전하다"는 운영 관행이 재검토됐으며, ③ 표적형 스파이 플랫폼에 대한 모듈 단위 추적·귀속(attribution) 분석이 정착됐다.
• 게임의 연장: 2019년 Guerrero-Saade·Cutler가 Flame 2.0을 발표했다. 파일 시각을 위조(타임스톰핑)해 '자폭 이전'에 만들어진 것처럼 꾸몄지만, 컴파일 오류로 실제 컴파일 시점(2014년경)이 드러났다. 검거되지 않은 코드는 계속 진화한다.

6. PoC — 교육용 모의 코드 4종 (실제 악성코드 아님)

아래 코드는 동작 원리 재현용 모의 코드다. 실제 Flame 샘플·실제 MD5 충돌쌍·실제 익스플로잇·C2 주소는 포함하지 않는다. 모두 인터넷과 분리된 격리 랩(로컬 VM, 루프백 전용)에서 실행을 전제로 하며, PoC #4의 서버는 127.0.0.1에만 바인딩된다.

PoC ① 선택 접두사 충돌의 골격 — 축소 해시에서 직접 찾아본다

MD5 충돌 코드를 그대로 쓰는 대신, 표준 해시 출력을 20비트로 자른 축소 모델을 만들어 같은 생일 공격(meet-in-the-middle) 골격을 실행한다. 서로 다른 두 인증서 본문 (정품/위조)에 각각 충돌 접미사를 붙여 같은 해시값을 얻는 것이 목표다.

#!/usr/bin/env python3
"""Flame(2012) 교육용 PoC #1 — '선택 접두사 충돌(chosen-prefix collision)'의 구조 재현.

실제 MD5 충돌쌍이나 Flame 인증서 자료는 포함하지 않는다.
여기서는 '충돌을 찾을 수 있을 만큼 약한 해시'를 만드는 대신, 표준 해시(SHA-256)의
출력을 20비트로 잘라 축소 모델을 만든다. MD5 처럼 '충돌 저항성이 사실상 없는'
해시 위에서 선택 접두사 충돌이 어떻게 계산되는지, 그 골격(생일 공격 /
meet-in-the-middle)을 그대로 실행해 보는 것이 목적이다.

        H(A || suffix_A) == H(B || suffix_B)  인 접미사 쌍 찾기

실행: python3 poc1_collision.py     (격리 랩 전용, 네트워크 접근 없음)
"""
import hashlib

OUT_BITS = 20                              # MD5=128비트였던 것을 20비트로 축소
OMASK = (1 << OUT_BITS) - 1


def toy_hash(data: bytes) -> int:
    """축소 해시 모델: SHA-256 출력을 20비트로 자른다.
    (출력이 짧아 충돌이 흔하며, '해시가 깨진 해시'의 거동을 흉내낸다.)"""
    return int.from_bytes(hashlib.sha256(data).digest()[:4], "big") & OMASK


def chosen_prefix_collision(prefix_a: bytes, prefix_b: bytes, tries=1 << 16):
    """A 접두사용 접미사 사전을 만든 뒤 B 접두사에서 조회(meet-in-the-middle).
    MD5 공격도 동일한 구조로, Stevens 등의 알고리즘은 이 탐색을
    'Joux 특성 + 근접 충돌 블록' 으로 최적화한 것이다."""
    table = {}
    for i in range(tries):
        s = i.to_bytes(3, "big")
        table.setdefault(toy_hash(prefix_a + s), s)
    for j in range(tries):
        s = j.to_bytes(3, "big")
        h = toy_hash(prefix_b + s)
        if h in table:
            return table[h], s, h
    raise SystemExit("충돌 미발견 — OUT_BITS 를 줄이세요")


if __name__ == "__main__":
    # '정품 인증서 본문'과 '위조 인증서 본문' 역할을 하는 서로 다른 두 접두사
    CERT_GOOD = b"TBSCertificate|issuer=Microsoft Enforced Licensing PCA|key=GOOD|"
    CERT_EVIL = b"TBSCertificate|issuer=Microsoft Enforced Licensing PCA|key=EVIL|"

    sa, sb, h = chosen_prefix_collision(CERT_GOOD, CERT_EVIL)
    good, evil = CERT_GOOD + sa, CERT_EVIL + sb

    print("[축소 해시: 출력 %d비트] 선택 접두사 충돌 발견" % OUT_BITS)
    print("  접미사 A :", sa.hex(), "| 접미사 B :", sb.hex())
    print("  H(정품||A) =", hex(h), " H(위조||B) =", hex(h))
    print("  동일 해시? ->", toy_hash(good) == toy_hash(evil))
    print("  두 바이트열 자체는 다른가? ->", good != evil)
    print()
    print("[검증] 같은 두 바이트열을 '자르지 않은' SHA-256 으로 계산하면 즉시 갈라진다")
    print("  sha256(정품||A) =", hashlib.sha256(good).hexdigest()[:32])
    print("  sha256(위조||B) =", hashlib.sha256(evil).hexdigest()[:32])
    print("  -> 출력을 20비트에서 256비트로 되돌리는 것만으로 이 공격은 사라진다")

실행 결과(이번 실행 실제 출력):

[축소 해시: 출력 20비트] 선택 접두사 충돌 발견
  접미사 A : 00aa64 | 접미사 B : 000000
  H(정품||A) = 0x66956  H(위조||B) = 0x66956
  동일 해시? -> True
  두 바이트열 자체는 다른가? -> True

sha256(정품||A) = a9966956aca8d181f8319a164568b2ff
sha256(위조||B) = 62b66956033f8262f5d2af119f10f635
  -> 출력을 20비트에서 256비트로 되돌리는 것만으로 이 공격은 사라진다

PoC ② 검증기는 왜 위조 인증서를 통과시켰나 (모의)

같은 충돌쌍을 축소 X.509 검증기에 통과시킨다. 검증기는 "인증서 본문 해시 == 서명에 담긴 해시"면 통과로 판정한다 — Flame이 실제로 뚫은 지점이 바로 이 전제다. 취약 해시 모델과 SHA-256 모델을 나란히 돌려 차이를 본다.

#!/usr/bin/env python3
"""Flame(2012) 교육용 PoC #2 — '해시 충돌로 코드서명 검증을 통과시키는' 흐름(모의).

Flame 의 핵심은 코드서명 인증서를 해시 충돌로 위조해 마이크로소프트 루트 CA
까지 신뢰 사슬이 이어지게 만든 것이다. 여기서는 PoC #1 의 축소 해시를
'당시의 취약 해시(MD5 계열)' 모델로, SHA-256 을 '강화 이후(SHA-2)' 모델로 두고
같은 검증기를 두 번 돌린다.

  - 취약 모델 : 위조 인증서가 '서명 일치' 로 승인된다   (2012년 6월 이전 상황)
  - 강화 모델 : 위조 인증서가 거부된다                  (KB2718704 이후 상황)

실행: python3 poc2_verify_bypass.py   (격리 랩 전용, 네트워크 접근 없음)
"""
import hashlib
import sys

sys.path.insert(0, "/tmp")
from poc1_collision import OUT_BITS, toy_hash, chosen_prefix_collision  # 축소 해시 재사용


def verify(cert_body: bytes, signed_digest, hashfn) -> bool:
    """축소 X.509 검증기. 실제 검증은 RSA 서명 검증까지 포함하지만,
    Flame 이 실제로 뚫은 지점은 '인증서 본문 해시 == 서명에 담긴 해시'
    라는 전제였으므로 그 지점만 모델링한다."""
    return hashfn(cert_body) == signed_digest


if __name__ == "__main__":
    GOOD = b"TBSCertificate|serial=0x1B|key=MS_TERMINAL_SERVER_GOOD|"
    EVIL = b"TBSCertificate|serial=0x1B|key=ATTACKER_CONTROLLED_EVIL|"

    sa, sb, _ = chosen_prefix_collision(GOOD, EVIL)
    good_cert, evil_cert = GOOD + sa, EVIL + sb

    # 마이크로소프트가 '정품' 인증서에 대해 서명했을 때 담긴 다이제스트
    ms_digest = toy_hash(good_cert)

    print("[2012년 6월 이전 — MD5 계열 취약 해시 (여기서는 %d비트 축소 모델)]" % OUT_BITS)
    print("  서명에 담긴 다이제스트 :", hex(ms_digest))
    print("  정품 인증서 검증       :", verify(good_cert, ms_digest, toy_hash))
    print("  위조 인증서 검증       :", verify(evil_cert, ms_digest, toy_hash), " <-- 통과 (문제!)")
    print()
    sha = lambda d: hashlib.sha256(d).hexdigest()[:16]
    print("[KB2718704 이후 — SHA-256 강제]")
    ms_digest_sha = sha(good_cert)
    print("  서명에 담긴 다이제스트 :", ms_digest_sha)
    print("  정품 인증서 검증       :", verify(good_cert, ms_digest_sha, sha))
    print("  위조 인증서 검증       :", verify(evil_cert, ms_digest_sha, sha), " <-- 거부 (정상)")
    print()
    print("교훈: 해시 알고리즘은 '서명 체계 전체'를 떠받치는 부품이다.")
    print("      MD5→SHA-2 전환 + 문제 인증서 폐기(KB2718704)로만 닫혔고,")
    print("      같은 계열의 충돌 공격은 2008년(위조 CA 인증서), 2017년(SHA-1, SHAttered)에 반복됐다.")

실행 결과(이번 실행 실제 출력):

[2012년 6월 이전 — MD5 계열 취약 해시 (여기서는 20비트 축소 모델)]
  서명에 담긴 다이제스트 : 0xf3fe1
  정품 인증서 검증       : True
  위조 인증서 검증       : True  <-- 통과 (문제!)

[KB2718704 이후 — SHA-256 강제]
  서명에 담긴 다이제스트 : b5ef3fe168bbc968
  정품 인증서 검증       : True
  위조 인증서 검증       : False  <-- 거부 (정상)

PoC ③ 숨은 모듈 찾기 — "모듈 목록"을 믿지 않는 탐지

Flame의 모듈은 프로세스가 보고하는 모듈 목록에 나타나지 않는다. 그래서 탐지의 출발점은 "무엇이 로드됐나"가 아니라 "설명되지 않는 메모리·디스크 흔적이 있나"다. 합성 데이터로 그 대조 로직을 실행한다.

#!/usr/bin/env python3
"""Flame(2012) 교육용 PoC #3 — 모듈형 악성코드의 '은닉 모듈' 탐지 (모의 데이터).

Flame 의 모듈은 프로세스가 스스로 보고하는 '로드된 모듈 목록'에 나타나지 않게
메모리에만 존재했다. 즉 정상적인 모듈 열거 API 로는 안 보인다. 이 PoC 는
'보고된 모듈 목록' 과 '실제 메모리 흔적' 을 대조해 그 간극을 찾아내는
탐지 로직을 합성 데이터로 실행한다. (실제 주입/은닉 기법 코드는 없음)

실행: python3 poc3_hidden_module_audit.py   (격리 랩 전용)
"""
import json

# ── 1. 합성(toy) 데이터: 침해 호스트 한 대를 흉내낸다 ─────────────────────────
HOST = {
    "name": "win-lab-07",
    "reported_modules": [                       # 프로세스가 '보고하는' 모듈 (정상 열거 결과)
        {"name": "kernel32.dll", "path": r"C:\Windows\System32\kernel32.dll"},
        {"name": "user32.dll",   "path": r"C:\Windows\System32\user32.dll"},
        {"name": "ws2_32.dll",   "path": r"C:\Windows\System32\ws2_32.dll"},
    ],
    "memory_regions": [                         # 실제 메모리 스캔 결과 (가상 주소 기준)
        {"base": "0x400000", "size": 262144, "prot": "RX",  "backed_by_file": True,  "name": "app.exe"},
        {"base": "0x7A0000", "size": 131072, "prot": "RWX", "backed_by_file": False, "name": None},
        {"base": "0x9C0000", "size": 624640, "prot": "RWX", "backed_by_file": False, "name": None},
        {"base": "0xB00000", "size": 40960,  "prot": "RW",  "backed_by_file": True,  "name": "config.db"},
    ],
    "disk_artifacts": [                         # 디스크에 남은 흔적(파일/레지스트리류)
        {"path": r"C:\Windows\system32\msvcrt10.dll", "type": "file", "note": "서명 없음"},
        {"path": r"HKLM\SYSTEM\CurrentControlSet\Services\mssndsrv", "type": "registry",
         "note": "가짜 오디오 드라이버 서비스(지속성)"},
    ],
}

MIN_ANON_RWX = 64 * 1024                        # 익명 RWX 영역 크기 임계값


def audit(host, min_size=MIN_ANON_RWX):
    """정상 열거 목록에 없는 '이름 없는 RWX 메모리' 를 찾아낸다."""
    findings = []
    listed = {m["path"].lower() for m in host["reported_modules"]}
    for r in host["memory_regions"]:
        anon = (r["name"] is None) and (not r["backed_by_file"])
        if anon and r["size"] >= min_size and "W" in r["prot"] and "X" in r["prot"]:
            findings.append({
                "host": host["name"], "rule": "anon_rwx_region",
                "severity": "high",
                "detail": "파일로 설명되지 않는 %s 영역 %d bytes @ %s"
                          % (r["prot"], r["size"], r["base"]),
            })
    for a in host["disk_artifacts"]:
        if a["type"] == "file" and "서명 없음" in a["note"]:
            findings.append({"host": host["name"], "rule": "unsigned_module_on_disk",
                             "severity": "medium", "detail": a["path"]})
        if a["type"] == "registry" and "오디오" in a["note"]:
            findings.append({"host": host["name"], "rule": "suspicious_persistence",
                             "severity": "medium",
                             "detail": "%s — %s" % (a["path"], a["note"])})
    # 모듈 수 자체의 이상: 메모리 흔적 대비 열거 목록이 지나치게 짧음
    named = sum(1 for r in host["memory_regions"] if r["name"])
    if len(listed) < named:
        findings.append({"host": host["name"], "rule": "module_enum_mismatch",
                         "severity": "high",
                         "detail": "열거 %d개 < 명명된 영역 %d개" % (len(listed), named)})
    return findings


if __name__ == "__main__":
    res = audit(HOST)
    print("호스트:", HOST["name"])
    print(json.dumps(res, ensure_ascii=False, indent=2))
    print("\n탐지 건수:", len(res), "→ '모듈 열거 결과'만 믿으면 0건, 메모리+RWX+서명 대조로 %d건" % len(res))

실행 결과(이번 실행 실제 출력, 요약):

호스트: win-lab-07
  [anon_rwx_region]        파일로 설명되지 않는 RWX 영역 131072 bytes @ 0x7A0000   (high)
  [anon_rwx_region]        파일로 설명되지 않는 RWX 영역 624640 bytes @ 0x9C0000   (high)
  [unsigned_module_on_disk] C:\Windows\system32\msvcrt10.dll                     (medium)
  [suspicious_persistence]  HKLM\SYSTEM\...\Services\mssndsrv — 가짜 오디오 드라이버 (medium)

탐지 건수: 4 → '모듈 열거 결과'만 믿으면 0건, 메모리+RWX+서명 대조로 4건

PoC ④ WPAD/NBNS 스푸핑 + "가짜 업데이트 서버" 전파 (127.0.0.1 한정)

Flame의 LAN 전파를 루프백 안에서만 재현한다. 가짜 업데이트 서버(모의 매니페스트만 제공)를 띄우고, WPAD 자동 프록시 탐색을 흉내 낸 클라이언트가 그 서버에서 매니페스트를 받는다. 이어서 방어 스크립트가 "WPAD가 사내 접미사로 해석되지 않음" + "업데이트를 사내 WSUS가 아닌 호스트에서 받음" 두 신호로 탐지한다. 실제 페이로드 배포·설치는 하지 않는다.

#!/usr/bin/env python3
"""Flame(2012) 교육용 PoC #4 — WPAD/NBNS 스푸핑 + '가짜 업데이트 서버' LAN 전파(모의).

Flame 은 같은 LAN 안에서 WINS/NBNS 이름 조회와 WPAD(자동 프록시 설정)를 악용해
자신을 '정품 마이크로소프트 업데이트 서버' 로 위장했고, 위조 인증서로 서명된
구성 요소를 배포해 다른 PC 가 스스로 설치하게 만들었다.

이 PoC 는 그 메커니즘을 **127.0.0.1 안에서만** 재현한다.
  1) 127.0.0.1:8412 에 '가짜 업데이트 서버' 를 띄운다 (mock 매니페스트만 제공)
  2) 자동 프록시(WPAD) 탐색을 흉내 낸 클라이언트가 그 서버에서 매니페스트를 받는다
  3) 방어 스크립트가 'WPAD 질의 + 비인가 업데이트 서버 접속' 을 로그에서 탐지한다
실제 아티팩트 배포·설치·실행은 하지 않으며, 외부 네트워크로 나가지 않는다.

실행: python3 poc4_wpad_rogue_wsus.py   (격리 랩 전용)
"""
import http.server
import json
import socketserver
import threading
import urllib.request

ROGUE_PORT = 0                     # 0 = 운영체제가 빈 포트를 배정(랩 환경 충돌 방지)
CORP_WSUS = "10.20.30.11"          # 가상의 사내 정품 업데이트 서버
LOG = []                           # 합성 로그(탐지 대상)


def rogue_server():
    class H(http.server.BaseHTTPRequestHandler):
        def do_GET(self):                                    # noqa: N802
            # 프록시 경유 요청은 절대 URI(http://wpad/...)로 들어온다
            if "/updates/manifest" in self.path:
                body = json.dumps({
                    "note": "교육용 모의 매니페스트 — 실제 페이로드 없음",
                    "server": "ROGUE-WSUS(127.0.0.1)",
                    "artifact": {"name": "mock-update.cab", "sha256": "0" * 64},
                }).encode()
                self.send_response(200)
                self.send_header("Content-Type", "application/json")
                self.end_headers()
                self.wfile.write(body)
            else:
                self.send_response(404)
                self.end_headers()

        def log_message(self, *a):                           # 콘솔 잡음 억제
            pass

    socketserver.TCPServer.allow_reuse_address = True
    srv = socketserver.TCPServer(("127.0.0.1", ROGUE_PORT), H)
    threading.Thread(target=srv.serve_forever, daemon=True).start()
    return srv


def victim_client(victim, proxy_ip, proxy_port):
    """WPAD 자동 프록시 탐색 → 프록시를 통해 업데이트 매니페스트 요청."""
    LOG.append({"evt": "wpad_query", "host": victim, "answer": proxy_ip, "suffix": "local"})
    import urllib.error
    proxy = urllib.request.ProxyHandler({"http": "http://%s:%d" % (proxy_ip, proxy_port)})
    opener = urllib.request.build_opener(proxy)
    url = "http://wpad/updates/manifest.xml"          # 이름 해석은 프록시가 대신 수행
    try:
        with opener.open(url, timeout=5) as r:
            data = json.loads(r.read().decode())
    except Exception as e:                            # 프록시 미사용 시 실패 → 정상
        data = {"error": str(e)}
    LOG.append({"evt": "update_fetch", "host": victim,
                "server_ip": proxy_ip, "url": url,
                "artifact": data.get("artifact", {}).get("name", "none")})
    return data


def detect(log, corp_wsus=CORP_WSUS):
    """WPAD 질의가 사내 접미사로 해석되지 않았거나, 업데이트를 사내 WSUS 가 아닌
    호스트에서 받은 경우를 '고신뢰' 이상으로 분류한다."""
    alerts = []
    wpad_hosts = {e["host"] for e in log if e["evt"] == "wpad_query" and e["suffix"] != "corp.example.com"}
    for e in log:
        if e["evt"] == "wpad_query" and e["suffix"] != "corp.example.com":
            alerts.append({"rule": "wpad_resolved_outside_corp", "host": e["host"],
                           "detail": "wpad 질의 응답=%s (사내 접미사 아님)" % e["answer"]})
        if e["evt"] == "update_fetch" and e["server_ip"] != corp_wsus:
            alerts.append({"rule": "update_from_untrusted_host", "host": e["host"],
                           "detail": "업데이트 서버=%s (사내 WSUS=%s 아님)" % (e["server_ip"], corp_wsus)})
    return alerts, wpad_hosts


if __name__ == "__main__":
    srv = rogue_server()
    port = srv.server_address[1]
    print("가짜 업데이트 서버 기동: 127.0.0.1:%d (교육용 모의)" % port)
    try:
        victim_client("pc-sales-04", "127.0.0.1", port)  # 로컬 루프백 = '공격자 프록시' 역할
    finally:
        srv.shutdown()
        srv.server_close()

    print("── 합성 로그 ──")
    for e in LOG:
        print(" ", e)
    alerts, hosts = detect(LOG)
    print("\n── 탐지 결과 ──")
    for a in alerts:
        print(" [%s] %s — %s" % (a["rule"], a["host"], a["detail"]))
    print("\nWPAD 를 사내 밖으로 해석한 호스트:", ", ".join(sorted(hosts)) or "없음")
    print("→ 교훈: 'WPAD 자동 탐색 끄기 + NBNS 차단 + 업데이트 서버 고정(정책)' 이")
    print("  이 전파 경로를 통째로 닫는다 (KB2718704 는 신뢰 사슬의 마지막 구멍을 막았다).")

실행 결과(이번 실행 실제 출력):

가짜 업데이트 서버 기동: 127.0.0.1:41127 (교육용 모의)
── 합성 로그 ──
  {'evt': 'wpad_query', 'host': 'pc-sales-04', 'answer': '127.0.0.1', 'suffix': 'local'}
  {'evt': 'update_fetch', 'host': 'pc-sales-04', 'server_ip': '127.0.0.1',
   'url': 'http://wpad/updates/manifest.xml', 'artifact': 'mock-update.cab'}

── 탐지 결과 ──
 [wpad_resolved_outside_corp]  pc-sales-04 — wpad 질의 응답=127.0.0.1 (사내 접미사 아님)
 [update_from_untrusted_host]  pc-sales-04 — 업데이트 서버=127.0.0.1 (사내 WSUS=10.20.30.11 아님)

또 하나의 특징 — Flame은 Lua로 기능을 확장했다. 아래는 그 구조를 흉내 낸 무해한 모듈 예시다(로컬 감사 로그 한 줄을 남길 뿐이며, 수집·전송 기능은 없다).

-- flame_like_module.lua : 플러그인 구조 재현용 (교육용·무해)
local M = {}

function M.tick(cfg)                    -- 로더가 주기적으로 호출하는 진입점
  local f = assert(io.open(cfg.audit_log, "a"))
  f:write("[audit] module tick ", os.date("%Y-%m-%d %H:%M:%S"), "\n")
  f:close()
  return true                           -- 실패해도 본체는 계속 동작(모듈 격리)
end

return M

7. 방어 방법/교훈 — Flame이 남긴 체크리스트

• 해시·서명 알고리즘을 현대화하라: MD5·SHA-1 기반 서명 검증은 "서명이 있다"는 이유만으로 신뢰를 주지 못한다. 코드서명·TLS·업데이트 매니페스트의 해시를 SHA-256 이상으로 강제하고, 신뢰 저장소의 취약 CA·만료 인증서를 정리한다. (Flame의 교훈이 그대로 KB2718704다.)
• 자동 프록시 탐색을 끄고 이름 해석을 통제하라: WPAD 자동 탐색 비활성화, NBNS/WINS 차단, 업데이트 서버를 정책으로 고정. "업데이트는 항상 사내 WSUS에서만" 이 한 줄이 Flame의 LAN 전파 경로를 통째로 닫는다.
• 모듈 열거를 신뢰하지 마라: 탐지 신호는 '이름 있는 목록'이 아니라 파일로 설명되지 않는 RWX 메모리, 서명 없는 시스템 경로 파일, 정체불명의 서비스 등록이다. PoC ③의 4가지 규칙이 최소 세트다.
• 드라이버·서비스 변경을 감시하라: 가짜 오디오 드라이버 같은 위장 지속성은 무결성 모니터링(드라이버 로드·서비스 생성 이벤트)으로 잡힌다.
• 네트워크 분리만으로는 부족하다: 표적 조직은 이미 터미널을 인터넷에서 분리한 상태였지만, 내부 LAN·USB·블루투스가 남아 있었다. 에어갭은 "인터넷 차단"이 아니라 모든 매체의 통제를 뜻한다.
• 증거 보존을 설계하라: 자폭(kill) 기능은 사고 대응의 적이다. 로그를 오프호스트로 즉시 전송·보존하지 않으면, 공격자는 흔적을 스스로 지우고 사라진다.

8. 출처

• Wikipedia — Flame (malware) — en.wikipedia.org/wiki/Flame_(malware)
• Wikipedia — Duqu / Stuxnet 계보 — en.wikipedia.org/wiki/Duqu · en.wikipedia.org/wiki/Stuxnet
• CrySyS Lab (BME) — sKyWIper (a.k.a. Flame) analysis report (2012-05-28) — crysys.hu/skywiper/skywiper.pdf
• Microsoft 보안 공지 2718704 — Unauthorized Digital Certificates Could Allow Spoofing (2012-06-03) — learn.microsoft.com/…/2718704
• 카스퍼스키 시큐어리스트 — Flame 관련 분석 시리즈(MD5 충돌·전파·자폭) — securelist.com
• Washington Post (2012-06-19) — U.S., Israel developed Flame computer virus to slow Iranian nuclear efforts — washingtonpost.com/…/gJQA6xBPoV_story.html
• Guerrero-Saade & Cutler — Flame 2.0 재발견(2019) — virusbulletin.com

※ 본문의 PoC 코드는 구조 이해 목적의 교육용 모의 코드이며, 실제 Flame 샘플·실제 MD5 충돌쌍· 실제 익스플로잇·C2 주소·유포 기능은 포함하지 않습니다. 모든 실습은 인터넷과 분리된 격리 랩 VM을 전제로 합니다.

함께 읽기: ⚛️ Stuxnet (2010) — 에어갭을 넘은 세계 최초의 사이버 무기 · 🟥 Code Red (2001) — 파일리스 메모리 상주 웜의 원형 · ⚡ Industroyer (2016) — 프로토콜을 그대로 말한 ICS 악성코드 · 🦅 SolarWinds SUNBURST (2020) — 공급망·서명 신뢰의 붕괴 · ☠️ NotPetya (2017) — 신뢰받는 업데이트 채널을 무기로 쓴 와이퍼