🐌 SQL Slammer — '376바이트 패킷 한 개'가 10분 만에 전 세계를 멈춰 세운 초고속 웜 (2003)

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

SQL 슬래머(SQL Slammer)는 2003년 1월 25일 05:30(UTC) 무렵, 마이크로소프트 SQL Server 2000 · MSDE 2000의 취약점을 노리고 등장한 자기복제형 웜이다. 별칭으로 사파이어(Sapphire), 헬컨(Helkern)이라고도 불렸다. 제작자는 지금까지 밝혀지지 않았지만, 그 결과만으로 2003년 최악의 인터넷 대란을 일으켰다.

취약점: SQL Server 2000/ MSDE 2000의 Resolution Service(SQL 인스턴스 조회 서비스, UDP 1434)에 존재하던 스택 버퍼 오버플로우다. 마이크로소프트는 2002년 7월 MS02-039 보안 공지로 이미 패치를 배포했고 (CVE-2002-0649), 슬래머는 패치가 나온 지 약 6개월 뒤에 나타났다. 즉 '알려진 취약점'이 화근이었다.
압도적 속도: 초기에는 약 8.5초마다 감염 대수가 2배로 늘었고, 등장 약 3분 만에 최대 스캔률에 도달해 10분 안에 최소 75,000대의 서버를 감염시켰다. 역사상 가장 빠르게 퍼진 웜으로 꼽힌다.
왜 유명한가: ① 웜 전체가 단 하나의 376바이트 UDP 패킷이었다(파일도, 별도 전파 코드도 없이 '패킷 자체가 웜'). ② 디스크에 아무 파일도 만들지 않아 메모리에서만 살았다(재부팅만으로도 사라짐). ③ 한국을 포함한 전 세계 인터넷 인프라를 실제로 마비시켰다.
시대 배경: 2003년 초에는 SQL Server 2000이 기업·공공·통신망에 깔려 있었고, 데이터베이스 서버가 인터넷에 직접 노출된 경우도 드물지 않았다. 패치 관리 문화가 자리 잡기 전이라, '이미 고칠 수 있었던' 취약점 하나가 인터넷 전체의 대역폭을 삼켰다.

2. 감염·전파 경로 — 어떻게 퍼졌나

슬래머의 확산은 어지럽게 단순하다. 취약한 서비스의 UDP 포트로 '한 개의 패킷'을 보내면 감염되고, 감염된 프로세스가 스스로 같은 패킷을 쏟아낸다. 그게 전부다.

무작위 스캐닝(scanning): 감염된 서버는 IPv4 전체 주소공간(2³²)을 무작위로 대상으로 삼아 UDP/1434 패킷을 뿌렸다. 일부는 같은 서브넷·같은 대역에 편향돼 내부 확산을 앞당겼지만, 본질은 '전 지구 무작위 스캔'이었다.
벡터는 단일 UDP 데이터그램: 연결 수립(3-way handshake)도, 인증도, 후속 대화도 없었다. 한 개의 UDP 패킷만 취약한 서비스에 도달하면 감염이 완료됐다. 그래서 'Connectionless' 웜이라 불린다.
파일 무흔적(memory-only): 디스크에 실행 파일을 떨어뜨리지 않고 이미 실행 중인 sqlservr.exe 프로세스의 메모리 안에서만 살았다. 그래서 백신도, 파일 스캔도, 재부팅 전까지는 조용했다. 반대로 메모리에서만 살기에 재부팅만으로도 흔적이 사라졌다.
프로세스가 곧 스캐너: 별도의 전파 프로그램을 설치하는 대신, 감염된 SQL Server 프로세스가 스스로 ws2_32.dll의 전송 함수를 호출해 다음 희생자에게 같은 패킷을 재전송했다. '감염 = 즉시 확산'이었다.
자기 제한이 없다: 슬래머는 확산을 멈추는 조건(전파 상한·정지 스위치)이 없었다. 취약 호스트가 존재하는 한, 네트워크 대역폭이 버티지 못할 때까지 계속 퍼졌다.
감염되지 않는 경우: SQL Server/MSDE가 실제로 실행 중일 때만 취약 코드가 메모리에 올라간다. 그래서 일반 데스크톱(윈도우 워크스테이션)은 대체로 안전했고, 피해는 DB를 운영하던 서버에 집중됐다.

3. 동작 원리 상세 분석 — 코드/구조 레벨에서

슬래머는 '웜 본체 + 여러 개의 취약점'이라는 고전적 구도가 아니라, '취약점 하나 = 웜 하나'라는 극단적으로 압축된 구조를 택했다. 그래서 376바이트 안에 전파에 필요한 모든 것이 들어 있었다.

① 트리거 — 0x04 바이트: Resolution Service는 UDP/1434로 오는 패킷의 첫 바이트를 보고 동작을 결정했다. 슬래머는 첫 바이트를 0x04(응답/조회 응답 계열)로 시작해, 서비스가 자신을 '정상 요청'으로 파싱하도록 유도했다.
② 스택 오버플로우: 해당 핸들러는 요청 데이터를 길이 검사 없이 고정 크기 스택 버퍼에 복사했다 (CVE-2002-0649). 슬래머의 약 376바이트는 이 버퍼를 넘겨 복귀 주소를 장악했고, 결과적으로 공격자 코드가 SQL Server 프로세스 권한으로 실행됐다.
③ 라이브러리 로드: 주입된 코드는 LoadLibrary/GetProcAddress로 ws2_32.dll(윈도우 소켓 라이브러리)을 불러와 sendto() 주소를 얻었다. 별도 파일 설치가 필요 없도록, 네트워크 전송 능력을 '이미 있는 DLL'에서 즉석으로 확보하는 방식이다.
④ 재전파 루프: 그다음은 GetTickCount 등으로 시드를 만든 의사난수 생성기로 다음 목표 IP를 계산해, UDP/1434로 자기 자신과 '똑같은 376바이트 패킷'을 전송했다. 새 희생자가 감염되면 그 프로세스가 같은 일을 반복 — 지수적 확산이 완성된다.
⑤ 메모리 상주: 전체 웜 논리가 단일 데이터그램의 페이로드에 압축돼 있고 디스크에는 아무것도 쓰지 않았다. '감염 상태'는 프로세스 메모리에만 존재했으므로, 서버 재부팅이 사실상 가장 확실한 '청소' 수단이었다.
⑥ 왜 네트워크가 '죽었나': 슬래머는 데이터를 파괴하거나 암호화하지 않았다. 피해는 스캔 트래픽 폭주에서 왔다 — 초당 수천만 개의 패킷이 회선·방화벽·라우터를 포화시켜 정상 트래픽이 통과하지 못했다. 즉 '웜 자체'보다 '웜이 만든 트래픽'이 무기였다.
⑦ 압축의 대가: 겨우 376바이트였기에 방어할 시간도 함께 압축됐다. 슬래머의 교훈은 명확하다 — 웜의 속도(분 단위)는 사람의 패치 속도(일 단위)를 압도한다.

4. 피해 규모/영향 — 실제 사례 수치

감염 서버 — 10분 내 75,000대 이상: CAIDA(데이비드 무어 등)의 분석에 따르면 슬래머는 초기 약 8.5초마다 감염 대수가 2배로 늘었고, 등장 후 10분 이내에 전 세계 취약 서버 대부분을 감염시켰다.
최대 스캔률 — 초당 약 5,500만 패킷: 최고조에서 슬래머는 초당 5,500만 개에 달하는 스캔 패킷을 쏟아냈다. 이는 당시 인터넷이 감당할 수 있는 수준을 넘어섰다.
DNS 루트 서버 — 13대 중 5대 영향: 인터넷의 최상위 이름 해석을 담당하던 루트 DNS 서버 13대 중 5대가 스캔 트래픽으로 영향을 받았다.
금융·교통 마비: 보도에 따르면 뱅크오브아메리카의 ATM 일부가 먹통이 됐고, 컨티넨탈 항공의 발권 시스템이 영향을 받았으며, 미국 일부 지역의 911 응급 서비스도 타격을 입었다.
한국 인터넷 대란: 국내에서도 슬래머는 수도권을 중심으로 인터넷 대규모 장애를 일으켜, 수백만 가입자의 접속이 느려지거나 끊겼다. 방송·언론·금융·공공기관이 잇달아 피해를 호소하며 하루 이상 복구에 매달렸다.
원전 네트워크 침해 — 데이비스-베시(오하이오): 슬래머는 원자력발전소의 안전 파라미터 표시 시스템(SPDS)을 약 5시간 동안 마비시켰다. 감염 경로는 인터넷이 아니라, 방화벽을 우회해 연결돼 있던 협력업체 T1 회선이었다. (안전계통 자체는 영향을 받지 않았지만, '에어갭이 아니다'라는 사실을 보여준 사례로 유명하다.)
복구의 핵심: 피해 복구는 화려한 도구가 아니라 ① 방화벽에서 UDP/1434 차단 ② 감염 서버 재부팅(메모리 정리) ③ MS02-039 패치 적용이었다. 즉 '알고도 안 한 패치'와 '열린 포트'가 피해 규모를 결정했다.

5. PoC — 교육용 모의 코드로 동작 원리 재현

⚠️ 안전 규칙: 아래 코드는 실제 슬래머 페이로드(376바이트 셸코드)나 CVE-2002-0649 익스플로잇 코드가 아니라, "동작 원리만 재현한 교육용 모의 코드"다. 실제 악성코드 복사·배포, 실제 네트워크 스캔·공격은 일절 포함하지 않으며, 공격 대상은 항상 가상의 로컬 실습 환경(메모리 속 가상 호스트 / 가상 랩)을 전제로 한다. 아래 코드는 이 글 작성 시 실제로 실행해 출력을 그대로 옮겼다.

PoC 1 — '폭발적 확산 속도' 재현: 슬래머의 확산 역학(무작위 스캔 + 초기 8.5초마다 2배)을 수식으로 모의한다. 사람이 패치를 배포할 시간조차 주지 않는 속도를 보여준다.

#!/usr/bin/env python3
"""
PoC 1 (교육용) — SQL Slammer(2003)의 '폭발적 확산 속도' 재현 모의.

실제 취약점/패킷/스캐너가 아니라, Slammer의 확산 역학을 수식으로 재현한다.
Slammer는 UDP/1434로 '한 개의 패킷'을 보내 감염시키는 랜덤 스캐닝 웜이었다.
- 주소공간 2^32 (IPv4 전체)를 무작위로 스캔
- 감염 호스트당 초당 수천 개 패킷
- 결과: 초기 8.5초마다 감염 대수 2배, 10분 내 취약 호스트 대부분 감염

모두 '가상의 호스트 개체'에 대한 계산이며 실제 네트워크 호출은 없다.
"""
import math

N = 75_000          # 전 세계 취약 호스트(가상) — 널리 인용되는 감염 규모
A = 2 ** 32         # IPv4 전체 주소공간
DOUBLE = 8.5        # 초기 감염 대수 2배 주기(초) — 문헌 보고값
# 초기 1대가 8.5초마다 2배가 되도록 스캔률 산정: rate = ln2/DOUBLE = scan*N/A
SCAN_PER_HOST = (math.log(2) / DOUBLE) * A / N       # 호스트당 초당 스캔 수
AGG_CAP = 55_000_000                                  # 관측된 최대 총 스캔률 55M/초(대역폭 포화)

dt = 0.1
S = 1          # 감염 대수 (단일 시드)
t = 0.0
marks = {}
targets = [0.01, 0.10, 0.50, 0.90, 0.99]
prev = S
doubling_seen = []

while S < N * 0.999 and t < 3600:
    per_host = min(SCAN_PER_HOST, AGG_CAP / S)       # 호스트/네트워크 대역폭 상한
    p_hit = (N - S) / A                              # 무작위 스캔이 '아직 안 걸린 취약 호스트'를 맞출 확률
    new = S * per_host * p_hit * dt
    S += new
    t += dt
    if prev > 0 and S >= 2 * prev:
        doubling_seen.append(round(t, 1)); prev = S
    for f in targets:
        if f not in marks and S >= N * f:
            marks[f] = round(t, 1)

print("=== SQL Slammer 확산 모의 (단일 시드, 취약 호스트 %d대, 주소공간 2^32) ===" % N)
print("호스트당 초당 스캔(초기)            : %.0f packets/s" % SCAN_PER_HOST)
print("총 스캔 대역폭 상한(포화)           : %s packets/s" % format(AGG_CAP, ','))
print("초기 감염 대수 2배 주기             : %.1f 초" % DOUBLE)
print("-" * 60)
for f in targets:
    lbl = {0.01: "취약 호스트 1% 감염", 0.10: "10% 감염", 0.50: "50% 감염(중간값)",
           0.90: "90% 감염", 0.99: "99% 감염"}[f]
    print("%-28s : %6.1f 초 (%.2f 분)" % (lbl, marks.get(f, -1), marks.get(f, -1) / 60))
print("-" * 60)
print("첫 3회 '2배 증가'까지 걸린 시간       :", doubling_seen[:3], "초")
print("90%% 감염까지 걸린 시간              : %.1f 분" % (marks[0.90] / 60))
print("\n교훈: 전파가 '분 단위'로 끝난다 — 사람이 패치를 배포할 시간이 없다.")
print("      느린(사람) 대응 vs 빠른(웜) 전파의 속도 경쟁에서 자동화·네트워크 차단만이 이긴다.")

실행 출력:

=== SQL Slammer 확산 모의 (단일 시드, 취약 호스트 75000대, 주소공간 2^32) ===
호스트당 초당 스캔(초기)            : 4670 packets/s
총 스캔 대역폭 상한(포화)           : 55,000,000 packets/s
초기 감염 대수 2배 주기             : 8.5 초
------------------------------------------------------------
취약 호스트 1% 감염                 :   81.7 초 (1.36 분)
10% 감염                       :  111.2 초 (1.85 분)
50% 감염(중간값)                  :  158.3 초 (2.64 분)
90% 감염                       :  283.9 초 (4.73 분)
99% 감염                       :  463.6 초 (7.73 분)
------------------------------------------------------------
첫 3회 '2배 증가'까지 걸린 시간       : [8.6, 17.2, 25.8] 초
90% 감염까지 걸린 시간              : 4.7 분

교훈: 전파가 '분 단위'로 끝난다 — 사람이 패치를 배포할 시간이 없다.
      느린(사람) 대응 vs 빠른(웜) 전파의 속도 경쟁에서 자동화·네트워크 차단만이 이긴다.

PoC 2 — '파일 없는 단일 패킷 메모리 웜'과 격리: 디스크에 아무것도 남기지 않고 메모리에서만 사는 웜이 네트워크 경계 통제(UDP/1434 egress 차단 + 세그멘테이션) 한 줄로 멈추는 모습을 대비해 보여준다.

#!/usr/bin/env python3
"""
PoC 2 (교육용) — '파일 없는 단일 패킷 메모리 웜'의 전파/격리 재현 모의.

Slammer의 두 가지 특징을 안전하게 흉내 낸다:
  (1) 디스크에 파일을 만들지 않는다 — 코드가 sqlservr.exe '메모리 안'에서만 산다.
      (그래서 재부팅만으로도 흔적이 사라졌다.)
  (2) '한 개의 패킷'이 곧 웜 본체 + 감염 코드다 — 받는 순간 그 프로세스가
      또 다른 임의 호스트로 같은 패킷을 계속 재전송하며 스스로 복제된다.

여기서는 실제 소켓/패킷을 전혀 쓰지 않는다. '네트워크'와 '호스트'는 모두
메모리 안의 가상 객체이며, 공격 대상은 가상의 로컬 실습 랩(10.0.0.0/24)이다.
"""
import os, random

random.seed(20030125)  # 2003-01-25 (Slammer 발생일)

VIRTUAL_WORM = b"SLAM" * 94   # 376바이트 패킷을 상징하는 자리표시자(실제 페이로드 아님)
SCAN_BURST = 30               # 감염 1대가 뿜는 스캔 패킷 수(높은 스캔률을 상징)


class FakeHost:
    """가상의 로컬 실습 호스트. 취약 서비스(UDP:1434)가 떠 있다고 가정."""
    def __init__(self, ip):
        self.ip = ip
        self.infected = False
        self.mem_payload = None   # 메모리 상주 웜(디스크 아님)
        self.emitted = 0          # 이 호스트가 밖으로 보낸 패킷 수

    def service_1434(self, datagram, lab, egress_blocked):
        """취약 서비스가 패킷을 받으면 '경계검사 없이' 그대로 실행/전파한다고 가정."""
        if datagram == VIRTUAL_WORM and not self.infected:
            self.infected = True
            self.mem_payload = datagram           # 파일로 저장하지 않음 → 메모리 전용
            self.spread(lab, egress_blocked)

    def spread(self, lab, egress_blocked):
        """감염 즉시 무작위 호스트로 '같은 패킷'을 여러 개 보낸다(스캔 폭주)."""
        if egress_blocked:
            return                                # 세그멘테이션/egress 필터가 막으면 확산 정지
        for _ in range(SCAN_BURST):
            candidates = [h for h in lab if not h.infected]
            if not candidates:
                return
            target = random.choice(candidates)
            self.emitted += 1
            target.service_1434(self.mem_payload, lab, egress_blocked)


def run_scenario(egress_blocked):
    lab = [FakeHost("10.0.0.%d" % i) for i in (11, 12, 13, 14, 15, 16, 17, 18)]
    lab[0].service_1434(VIRTUAL_WORM, lab, egress_blocked)   # 최초 1개 패킷이 시드
    infected = [h.ip for h in lab if h.infected]
    packets = sum(h.emitted for h in lab)
    return infected, packets


print("=== 가상 로컬 랩(10.0.0.0/24, 호스트 8대, UDP/1434 취약) ===")
print("웜 본체(가상 페이로드) 길이: %d bytes (실제 악성코드 아님, 자리표시자)\n" % len(VIRTUAL_WORM))

for mode, blocked in [("A. 격리/필터 없음", False),
                      ("B. UDP/1434 egress 차단 + 세그멘테이션", True)]:
    infected, packets = run_scenario(blocked)
    print("[%s]" % mode)
    print("  감염 호스트 : %d / 8  -> %s" % (len(infected), infected))
    print("  발생 패킷   : %d 개" % packets)
    print("  디스크 파일 : 없음 (메모리 전용 웜 → 재부팅 시 소멸)")
    print()

# 디스크 흔적이 정말 '없음'인지 실제로 확인 (실습 디렉터리에 웜 파일이 안 생겼는지)
dropped = [f for f in os.listdir('.')
           if f.lower().startswith(('sqlexp', 'helkern', 'msworm'))]
print("실습 디렉터리에서 발견된 웜 파일:", dropped if dropped else "없음 (예상대로 디스크 무흔적)")
print("\n교훈: 네트워크 경계 통제(1434 egress 차단 + 세그멘테이션)만이")
print("      '메모리 전용·단일 패킷' 웜의 확산을 즉시 끊는다. 호스트 백신만으론 늦다.")

실행 출력:

=== 가상 로컬 랩(10.0.0.0/24, 호스트 8대, UDP/1434 취약) ===
웜 본체(가상 페이로드) 길이: 376 bytes (실제 악성코드 아님, 자리표시자)

[A. 격리/필터 없음]
  감염 호스트 : 8 / 8  -> ['10.0.0.11', '10.0.0.12', '10.0.0.13', '10.0.0.14', '10.0.0.15', '10.0.0.16', '10.0.0.17', '10.0.0.18']
  발생 패킷   : 7 개
  디스크 파일 : 없음 (메모리 전용 웜 → 재부팅 시 소멸)

[B. UDP/1434 egress 차단 + 세그멘테이션]
  감염 호스트 : 1 / 8  -> ['10.0.0.11']
  발생 패킷   : 0 개
  디스크 파일 : 없음 (메모리 전용 웜 → 재부팅 시 소멸)

실습 디렉터리에서 발견된 웜 파일: 없음 (예상대로 디스크 무흔적)

교훈: 네트워크 경계 통제(1434 egress 차단 + 세그멘테이션)만이
      '메모리 전용·단일 패킷' 웜의 확산을 즉시 끊는다. 호스트 백신만으론 늦다.

6. 방어 방법/교훈 — 어떻게 막았고, 무엇을 배우나

즉시 패치가 '언제'가 아니라 '했는지'의 문제다: 슬래머의 취약점은 이미 6개월 전(MS02-039)에 패치가 나와 있었다. 사고는 '모르는 취약점'이 아니라 미적용 패치에서 왔다. 패치를 '적용 완료까지' 추적하는 것이 핵심이다.
노출된 서비스 최소화: DB의 인스턴스 조회 서비스(UDP/1434)를 인터넷에 그대로 노출하지 않는다. 불필요한 서비스는 끄고, 외부 노출은 최소화한다. (SQL Server 2000 SP3a 이후에는 기본적으로 비활성화됐다.)
네트워크 경계 통제 — 최후의 방어선: 다시 말하지만 UDP/1434 ingress·egress 차단과 세그멘테이션만으로도 이 웜은 국지적 사고로 끝난다(PoC 2). 메모리 전용·단일 패킷 웜일수록 호스트 백신보다 네트워크 차단이 먼저 듣는다.
메모리 안전성과 경계 검사: 근본 원인은 길이 검사 없는 스택 복사였다. 외부 입력은 항상 길이·범위를 검증해야 하며, 장기적으로는 메모리 안전 언어(Rust 등)가 같은 부류의 버그를 구조적으로 줄인다.
대역폭/레이트 리미팅: 슬래머의 '무기'는 데이터 파괴가 아니라 트래픽 폭주였다. 스캔·브로드캐스트성 트래픽을 제한하고, 서비스에 연결·레이트 상한을 두어 자기 증식형 부하를 견뎌야 한다.
속도의 비대칭을 인정하라: 웜은 '분' 단위, 사람은 '일' 단위로 움직인다. 그래서 방어는 자동화된 탐지·차단(경계 필터, 네트워크 격리)에 의존해야 한다. 손으로 대응하는 순간 이미 늦는다.
교훈 요약:
- '작은 패킷'이 거대한 피해를 낸다: 376바이트가 전 세계 대역폭을 삼켰다. 위협의 크기와 코드 줄 수는 비례하지 않는다.
- 파괴하지 않아도 치명적이다: 데이터 삭제·암호화 없이도 확산 트래픽만으로 인프라를 마비시킬 수 있다.
- 웜의 계보의 '속도 사건': Morris(1988) → Code Red(2001) → Slammer(2003) → Sasser(2004) → Conficker(2008) → WannaCry/NotPetya(2017). 슬래머는 그중 전파 속도 자체를 무기로 만든 대표 사례다.

출처

Wikipedia — SQL slammer — https://en.wikipedia.org/wiki/SQL_slammer
Microsoft Security Bulletin MS02-039 (2002-07-24) — https://learn.microsoft.com/en-us/security-updates/securitybulletins/2002/ms02-039
NVD — CVE-2002-0649 (SQL Server Resolution Service 버퍼 오버플로우) — https://nvd.nist.gov/vuln/detail/CVE-2002-0649
CAIDA — The Spread of the Sapphire/Slammer Worm (Moore et al., 2003) — https://www.caida.org/publications/papers/2003/sapphire/sapphire.html
SecurityFocus — Slammer worm crashed Ohio nuke plant network (Kevin Poulsen, 2003-08-19, 웨이백 아카이브) — https://web.archive.org/web/20030920055617/http://www.securityfocus.com/news/6767
CAIDA 연구 자료 모음 — Sapphire/Slammer — https://www.caida.org/catalog/papers/2003_sapphire/

함께 읽기: 🐛 Morris Worm (1988) — 최초의 인터넷 웜 · 🪱 Conficker (2008) — SMB 웜의 정점 · 💀 WannaCry (2017) — EternalBlue로 전 세계를 강타한 웜