🐛 Morris Worm — 인터넷을 처음 멈추게 한 최초의 자기복제 웜, 6,000대 감염과 최초의 유죄 판결 (1988)

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

모리스 웜(Morris Worm)은 1988년 11월 2일, 미국 코넬대 대학원생 로버트 태펀 모리스(Robert Tappan Morris, 당시 24세)가 인터넷에 풀어놓은, 역사상 처음으로 대규모로 퍼진 자기복제형 컴퓨터 웜이다. '웜(worm)'이라는 개념은 1982년 제록스 PARC의 존 슈크(John Shoch)와 존 하퍼(Jon Hupp)가 정리했지만, 그것을 실제 인터넷 전체 규모에서 처음으로 대재앙으로 만든 사건이 바로 이 웜이었다. 제작자는 출처를 숨기려 코넬이 아닌 MIT에서 웜을 실행했지만, 파급은 인터넷을 며칠간 사실상 마비시켰다.

• 무엇을 노렸나: 모리스의 진술에 따르면 파괴가 목적이 아니라 "인터넷에 실제로 취약한 호스트가 얼마나 있는지 조용히 측정"하려는 실험이었다. 그러나 설계에 결함이 있어 측정하려던 웜 자체가 통제를 벗어나 인터넷을 멈춰 세웠다.
• 규모: 당시 인터넷에 연결된 컴퓨터는 약 6만 대 수준이었다. 웜은 그중 약 6,000대(약 10%)를 감염시켰다(MIT·하버드·프린스턴·스탠퍼드, NASA 에임스, 로렌스 리버모어 국립연구소, 군 시설 등).
• 왜 유명한가: ① '최초의 인터넷 웜'이자 대규모 사이버 사고의 원형 ② 피해 대응의 필요성 때문에 CERT/CC(현 CISA 계열, 카네기멜런 SEI)가 창설됨 ③ 1986년 제정된 컴퓨터 부정사용 및 남용 방지법(CFAA)이 처음으로 적용된 유죄 판결(1990) ④ 이후 모든 웜·봇넷·랜섬웨어 전파 연구의 교과서가 됨.
• 법적 결말: 모리스는 1990년 CFAA 위반으로 유죄 판결을 받아 집행유예 3년, 벌금 10,050달러, 사회봉사 400시간을 선고받았다. (지금은 MIT CSAIL 교수로 재직 중이라는 사실도 이 사건의 아이러니로 자주 회자된다.)
• 시대 배경: 1988년의 인터넷은 대학·연구소·정부가 느슨하게 연결된 신뢰 기반 네트워크였다. 인증·암호화·패치 관리 개념이 사실상 없었고, 이메일·원격 로그인 서비스가 무방비로 열려 있었다 — 웜에게는 최적의 환경이었다.

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

모리스 웜의 핵심은 "하나의 취약점을 노린 웜"이 아니라, 서로 다른 세 가지 침투 경로를 동시에 시도하는 멀티벡터 웜"이었다는 점이다. 세 경로는 모두 당시 널리 쓰이던 인터넷 서비스(메일·finger·원격 셸)의 허점을 찔렀고, 하나라도 열려 있으면 감염됐다.

• 경로 A — sendmail DEBUG 명령 주입: 당시 sendmail에는 문제 진단용 DEBUG 모드가 있었는데, 이 모드로 동작 중인 sendmail에 특수한 SMTP 명령(DEBUG → RCPT/RSET)을 보내면 임의의 셸 명령을 실행시킬 수 있었다. 웜은 이 통로로 코드를 전송하고 부트스트랩 스크립트를 실행시켰다.
• 경로 B — fingerd 버퍼 오버플로우: 원격 사용자 정보를 알려주던 fingerd는 입력을 받을 때 경계 검사가 없는 gets()를 사용했다. 웜은 약 536바이트가 넘는 요청을 보내 스택의 반환 주소를 덮어쓰고, 작은 셸코드를 실행시켜 원격 셸을 얻었다. (1971년 최초의 웜 실험도 gets()류의 입력 문제와 닮아 있다.)
• 경로 C — rsh/rexec + 비밀번호 크래킹: 웜은 /etc/hosts.equiv·.rhosts로 맺어진 신뢰 관계를 따라 무인증으로 rsh/rexec를 실행하려 시도했다. 더 나아가 감염된 호스트의 /etc/passwd(당시 암호 해시가 전원 읽기 가능)를 훔쳐, 흔한 단어·사용자 이름 목록으로 오프라인 사전 공격을 수행한 뒤 뚫린 계정으로 다음 호스트에 로그인했다.
• 연쇄 확산: 한 호스트가 감염되면 그 호스트의 신뢰 관계·라우팅 정보를 이용해 이웃 호스트로 즉시 복제됐다. MIT에서 시작된 감염은 불과 몇 시간 만에 전국 연구망으로 퍼져, 각 기관이 네트워크를 끊어버리는 '수동 격리'로 겨우 진화했다.
• 감염 표시와 탐지: 웜은 새 호스트에서 동작하기 전에 잠금(lock) 파일과 메모리 내 표식으로 '이미 감염됨'을 확인하려 했지만, 뒤에서 설명할 결함 때문에 제대로 동작하지 않았다.

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

모리스 웜은 크게 ① 갈고리(bootstrap) ② 본체(main worm) 로 나뉜 2단 구조였다. 이식성과 은밀성을 동시에 노린 설계였지만, '재감염 확률' 로직 하나가 웜을 자멸로 몰고 간 것이 가장 유명한 기술적 교훈이다.

• 1단계 — '갈고리(grappling hook)': 웜의 부트스트랩은 약 99줄의 짧은 C 프로그램(l1.c)이었다. 세 가지 경로 중 하나로 대상 호스트에서 셸 명령을 실행할 수 있게 되면, 가짜 파일명으로 위장해 컴파일·실행한 뒤 본체를 통째로 끌어와(pull) 설치했다. '갈고리'라는 이름 그대로, 본체를 매달아 끌어올리는 역할이다.
• 2단계 — 이종(異種) 아키텍처 대응: 웜 본체는 VAX/BSD와 Sun 3 등 여러 아키텍처용으로 각각 컴파일된 바이너리와, 소스가 없는 환경에서도 스스로를 컴파일·링크해 실행하는 로직을 포함했다. 즉 대상 시스템의 CPU·OS에 맞춰 자신을 재빌드할 수 있었다.
• 3단계 — 비밀번호 크래킹: 웜은 훔친 /etc/passwd의 솔트와 해시에 대해 약 432개의 흔한 단어 + 사용자 이름을 후보로 한 오프라인 사전 공격을 돌렸다. 현대 기준으론 소박한 목록이지만, 당시엔 이것만으로도 수많은 계정이 뚫렸다.
• 4단계 — '재감염 확률'이라는 치명적 버그 (핵심): 웜은 이미 감염된 호스트를 만나면 무조건 물러나는 대신, 1/7 확률로 다시 감염시키도록 설계됐다. 설계자의 의도는 "가끔 다시 심어야 관리자가 백신(패치)을 놓았을 때도 살아남는다"였다. 그러나 이 확률 로직은 한 호스트가 수십~수백 개의 웜 복제본을 떠안게 만들었고, 그 결과 CPU·메모리·프로세스 테이블이 고갈돼 시스템이 다운됐다. 웜이 퍼진 게 아니라 웜이 만든 부하가 시스템을 죽인 것이다.
• 5단계 — 은밀성과 실패: 웜은 대상 호스트가 이미 감염됐는지 확인하려 잠금 파일을 썼지만, 버그와 경쟁 조건(race)으로 확인이 자주 실패했다. 또 로그·에러 메시지를 남기지 않으려 한 시도도 오히려 진단을 어렵게 만들어, 관리자들이 원인을 파악하기까지 시간이 걸렸다.
• 설계 의도 vs 실제 결과: "취약점을 세어보려던" 코드가 스스로 통제 불능의 부하를 만들어 네트워크를 마비시켰다. 이 사건은 "안전하다고 믿는 실험 코드도 운영망에서 실행하면 웜이 될 수 있다"는 교훈의 원형이다. (PoC 2에서 재현)

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

• 감염 호스트 — 약 6,000대: 당시 인터넷 연결 약 6만 대의 약 10%가 감염됐다(모리스 본인의 추산이자 가장 널리 인용되는 수치). 감염 기관에는 MIT, 하버드, 프린스턴, 스탠퍼드, NASA 에임스 연구센터, 로렌스 리버모어 국립연구소, 미군 시설 등이 포함됐다.
• 복구 비용 — 미 회계감사원(GAO) 추정 10만~1,000만 달러: 추정 편차가 매우 컸는데, 이는 '직접 정리 비용'과 '네트워크 중단 손실'을 어떻게 계산하느냐에 따라 갈렸기 때문이다. 컴퓨팅 역사상 처음으로 '사이버 사고의 비용'이 공식적으로 추정된 사례 중 하나다.
• 인터넷 마비: 이메일이 며칠간 지연·유실되고, 감염된 시스템은 반응 없이 멈췄다. 각 기관은 피해 확산을 막으려 네트워크 연결을 물리적으로 끊는 것 외에 방법이 없었다.
• 제도적 영향 — CERT 창설: 사고 직후 미국 DARPA의 지원으로 CERT/CC(Computer Emergency Response Team Coordination Center)가 카네기멜런대 SEI에 설립됐다. 국가 단위 사이버 사고 대응 조직의 출발점이다.
• 법·제도의 영향: CFAA가 처음 적용된 대표 사건이 되며, '의도가 없어도 피해를 내면 처벌된다'는 판례를 남겼다. 이후 사이버 보안 법제·연구 윤리 논의의 기준점이 됐다.
• 기술사적 영향: 웜의 전파 벡터(sendmail·fingerd·rsh)를 따라 서비스별 입력 검증·인증 강화·신뢰 관계 최소화가 보안의 기본 원칙으로 자리 잡았고, 이후 Nimda·Code Red·Slammer·Conficker 등으로 이어지는 '웜의 계보'의 시조가 됐다.

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

PoC 1 — '3대 전파 벡터' 구조: 하나의 웜이 서로 다른 세 허점(sendmail DEBUG, fingerd gets() 오버플로우, rsh+크래킹된 암호)을 동시에 노려 "어느 하나만 열려 있어도 감염"되는 구조를 재현한다. 단일 패치로 웜을 멈출 수 없는 이유를 보여준다.

#!/usr/bin/env python3
"""
PoC 1 — 모리스 웜의 '3대 전파 벡터' 구조 모의 (교육용)

1988년 11월 2일, 모리스 웜은 서로 다른 세 취약점을 조합해 퍼졌다:
  A) sendmail DEBUG 명령 주입 — 디버그 모드로 떠 있던 sendmail에
     'DEBUG' 명령을 보내 임의 명령을 실행시키고 코드를 전송
  B) fingerd 버퍼 오버플로우 — gets()가 입력 길이를 검사하지 않는
     고전적 버그를 이용해 finger 서비스에 셸코드를 주입
  C) rsh/rexec + 비밀번호 크래킹 — /etc/passwd(당시엔 전원 읽기 가능)를
     훔쳐 약한 암호를 오프라인 크래킹한 뒤 rsh/rexec로 이동

아래 코드는 실제 네트워크/서비스 호출 없이 '가상의 호스트' 객체에 대해
각 벡터의 성립 조건만 재현한다. 실제 시스템은 전혀 건드리지 않는다.
"""
from dataclasses import dataclass


@dataclass
class FakeHost:
    """실습용 가상 호스트(실제 컴퓨터가 아님)."""
    name: str
    sendmail_debug: bool   # sendmail이 DEBUG 모드로 실행 중인가
    fingerd_gets: bool     # fingerd가 경계검사 없는 gets()를 쓰는가
    rsh_open: bool         # rsh/rexec 신뢰 관계가 열려 있는가
    weak_password: bool    # 비밀번호가 사전 공격에 뚫리는가
    infected: bool = False


def vector_sendmail(h: FakeHost) -> bool:
    """A) sendmail DEBUG 모드로 한 번의 SMTP 세션에서 원격 실행."""
    return h.sendmail_debug


def vector_fingerd(h: FakeHost) -> bool:
    """B) fingerd gets() 오버플로우로 셸 획득(512바이트 초과 입력)."""
    return h.fingerd_gets


def vector_rsh(h: FakeHost) -> bool:
    """C) rsh/rexec + 크래킹된 암호로 무인증/암호 기반 실행."""
    return h.rsh_open and h.weak_password


if __name__ == "__main__":
    hosts = [
        FakeHost("smtp-gw",   sendmail_debug=True,  fingerd_gets=False, rsh_open=False, weak_password=False),
        FakeHost("cs-lab-3",  sendmail_debug=False, fingerd_gets=True,  rsh_open=True,  weak_password=True),
        FakeHost("db-old",    sendmail_debug=False, fingerd_gets=False, rsh_open=True,  weak_password=True),
        FakeHost("bastion",   sendmail_debug=True,  fingerd_gets=True,  rsh_open=True,  weak_password=False),
        FakeHost("hardened",  sendmail_debug=False, fingerd_gets=False, rsh_open=False, weak_password=False),
    ]
    print("== 모리스 웜: 호스트별 성립 가능한 전파 벡터 ==")
    total = 0
    for h in hosts:
        paths = []
        if vector_sendmail(h):
            paths.append("A: sendmail DEBUG")
        if vector_fingerd(h):
            paths.append("B: fingerd gets() 오버플로우")
        if vector_rsh(h):
            paths.append("C: rsh + 크래킹된 암호")
        h.infected = bool(paths)
        total += h.infected
        tag = ", ".join(paths) if paths else "전파 불가"
        print(f"  {h.name:9s} -> 감염={h.infected} ({tag})")
    print()
    print(f"결론: 5대 중 {total}대가 '서로 다른 이유'로 감염됨 "
          "-> 단일 취약점 패치로는 웜을 멈출 수 없다.")

# 실행 결과
== 모리스 웜: 호스트별 성립 가능한 전파 벡터 ==
  smtp-gw   -> 감염=True (A: sendmail DEBUG)
  cs-lab-3  -> 감염=True (B: fingerd gets() 오버플로우, C: rsh + 크래킹된 암호)
  db-old    -> 감염=True (C: rsh + 크래킹된 암호)
  bastion   -> 감염=True (A: sendmail DEBUG, B: fingerd gets() 오버플로우)
  hardened  -> 감염=False (전파 불가)

결론: 5대 중 4대가 '서로 다른 이유'로 감염됨 -> 단일 취약점 패치로는 웜을 멈출 수 없다.

PoC 2 — '재감염 확률'과 과잉 복제: 모리스 웜을 자멸시킨 1/7 재감염 로직을 가상의 네트워크 그래프에서 '재감염 없음'과 대조한다. 같은 '감염 대수'라도 복제본 총량·호스트당 부하가 얼마나 폭증하는지 확인한다.

#!/usr/bin/env python3
"""
PoC 2 — '자가 복제 + 재감염' 전파 동역학 모의 (교육용)

모리스 웜의 치명적 구현 실수는 '이미 감염된 호스트도 확률적으로 다시
감염시키는' 로직이었다. 설계자는 "가끔 다시 심어야 백신을 우회한다"고
판단해 1/7 확률로 재감염을 시도했는데, 이 때문에 한 호스트가 수십~수백
개의 웜 프로세스를 떠안아 메모리·CPU가 고갈되고 시스템이 다운됐다.
(웜 자신이 만든 '부하'가 웜의 가장 큰 피해였다는 점이 아이러니.)

아래 코드는 '가상의 네트워크 그래프'에서
  (a) 재감염 없음 (올바른 설계)
  (b) 1/7 확률 재감염 (모리스 웜)
을 대조해, 같은 '감염 호스트 수'라도 '복제본 총량'이 얼마나 달라지는지 본다.
"""
import random

# 가상의 네트워크: 노드 -> 이웃 목록 (실제 컴퓨터 아님)
NET = {
    "host-01": ["host-02", "host-03", "host-04"],
    "host-02": ["host-01", "host-03", "host-05"],
    "host-03": ["host-02", "host-04", "host-05"],
    "host-04": ["host-01", "host-03", "host-05"],
    "host-05": ["host-02", "host-03", "host-04", "host-06"],
    "host-06": ["host-05", "host-07"],
    "host-07": ["host-05", "host-06"],
}


def simulate(reinfect_prob, steps=10, seed=42):
    rng = random.Random(seed)
    copies = {h: 0 for h in NET}   # 호스트별 웜 복제본 수
    copies["host-01"] = 1          # 최초 감염 지점
    attempts = 0
    for _ in range(steps):
        for h in list(NET):
            if copies[h] == 0:
                continue
            for nb in NET[h]:
                attempts += 1
                if copies[nb] == 0 or rng.random() < reinfect_prob:
                    copies[nb] += 1
    infected = sum(1 for v in copies.values() if v > 0)
    return copies, infected, attempts


if __name__ == "__main__":
    for label, prob in (("재감염 없음 (올바른 설계)", 0.0),
                        ("1/7 확률 재감염 (모리스 웜)", 1 / 7)):
        copies, infected, attempts = simulate(prob)
        total = sum(copies.values())
        print(f"[{label}]  {10}스텝")
        print(f"  감염 호스트: {infected}/{len(NET)}  |  총 감염 시도: {attempts}")
        print(f"  웜 복제본 총량: {total}")
        heaviest = max(copies.items(), key=lambda kv: kv[1])
        print(f"  최다 중복 호스트: {heaviest[0]} ({heaviest[1]}개 복제본)")
        print(f"  -> 호스트당 평균 부하: {total / max(infected, 1):.1f}")
        print()
    print("결론: 재감염 확률 로직 하나가 '감염 대수'는 비슷해도")
    print("      '복제본 총량'과 '호스트당 부하'를 폭증시킨다. 웜은")
    print("      퍼지는 것보다 '과잉 복제'로 시스템을 먼저 죽였다.")

# 실행 결과
[재감염 없음 (올바른 설계)]  10스텝
  감염 호스트: 7/7  |  총 감염 시도: 200
  웜 복제본 총량: 7
  최다 중복 호스트: host-01 (1개 복제본)
  -> 호스트당 평균 부하: 1.0

[1/7 확률 재감염 (모리스 웜)]  10스텝
  감염 호스트: 7/7  |  총 감염 시도: 200
  웜 복제본 총량: 36
  최다 중복 호스트: host-02 (10개 복제본)
  -> 호스트당 평균 부하: 5.1

결론: 재감염 확률 로직 하나가 '감염 대수'는 비슷해도
      '복제본 총량'과 '호스트당 부하'를 폭증시킨다. 웜은
      퍼지는 것보다 '과잉 복제'로 시스템을 먼저 죽였다.

PoC 3 — 약한 암호 오프라인 크래킹: 웜이 /etc/passwd를 훔쳐 흔한 단어와 사용자 이름만으로 계정을 뚫고 다음 호스트로 이동하던 구조를, 가상 passwd 레코드에 대한 사전 공격으로 재현한다(실제 crypt 대신 재현용 해시 사용).

#!/usr/bin/env python3
"""
PoC 3 — '약한 암호 오프라인 크래킹' 전파 벡터 모의 (교육용)

모리스 웜은 감염된 호스트에서 /etc/passwd를 읽어(당시 암호 해시가 전원
읽기 가능한 파일에 있었다) 흔한 단어·사용자 이름 기반 후보로 '오프라인
사전 공격'을 수행했고, 뚫린 계정으로 rsh/rexec를 타고 다른 호스트로
이동했다. 즉 약한 암호 하나가 '다음 호스트로 가는 열쇠'였다.

아래 코드는 실제 시스템 암호가 아니라, 가상의 passwd 레코드에 대해
'솔트 + 약한 비밀번호'가 어떻게 사전 공격에 무너지는지 재현한다.
실제 crypt(3) 대신 재현용 단순 해시를 쓴다(교육 목적).
"""
import hashlib

def mock_crypt(password: str, salt: str) -> str:
    """실제 crypt(3) 대신 쓰는 재현용 단순 해시(교육 목적)."""
    return hashlib.sha256((salt + password).encode()).hexdigest()[:16]

# 실제 등록된 (가상의) 비밀번호
REAL_PW = {
    "root":  "password",
    "alice": "qwerty",
    "bob":   "Zx9!pLm2#vQ",
    "carol": "carol",
}
SALTS = {"root": "aa", "alice": "bb", "bob": "cc", "carol": "dd"}

# 웜이 쓰던 것으로 알려진 후보군: 흔한 단어 + 사용자 이름(+변형)
WORDLIST = ["password", "admin", "letmein", "dragon", "monkey",
            "secret", "123456", "qwerty"]

def crack(username, salt, target):
    candidates = WORDLIST + [username, username + "123", username.capitalize()]
    for c in candidates:
        if mock_crypt(c, salt) == target:
            return c
    return None

if __name__ == "__main__":
    print("== 가상 /etc/passwd 대상 오프라인 사전 공격 ==")
    print(f"{'user':6s} {'salt':4s} {'크래킹 결과':14s} 이동 가능?")
    cracked = 0
    for user, salt in SALTS.items():
        target = mock_crypt(REAL_PW[user], salt)
        pw = crack(user, salt, target)
        if pw:
            cracked += 1
        print(f"{user:6s} {salt:4s} {str(pw):14s} {'예' if pw else '아니오'}")
    print()
    print(f"결과: 4계정 중 {cracked}개가 흔한 단어/이름만으로 크래킹됨")
    print("결론: '해시 파일은 비밀이 아니다' + '약한 암호는 곧 원격 실행'임을")
    print("      보여준다. 솔트가 있어도 사전 공격에는 무력했다.")

# 실행 결과
== 가상 /etc/passwd 대상 오프라인 사전 공격 ==
user   salt 크래킹 결과         이동 가능?
root   aa   password       예
alice  bb   qwerty         예
bob    cc   None           아니오
carol  dd   carol          예

결과: 4계정 중 3개가 흔한 단어/이름만으로 크래킹됨
결론: '해시 파일은 비밀이 아니다' + '약한 암호는 곧 원격 실행'임을
      보여준다. 솔트가 있어도 사전 공격에는 무력했다.

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

• 입력 경계 검사 (gets() → fgets()): fingerd 사고의 직접 원인은 경계 검사 없는 gets()였다. 모든 외부 입력은 길이를 제한하고 범위를 검증해야 한다. 오늘날의 버퍼 오버플로우·메모리 안전 언어(예: Rust) 논의로 이어지는 출발점이다.
• 불필요한 기능·디버그 모드 제거: sendmail의 DEBUG 모드는 진단용 편의 기능이었지만 원격 명령 실행 통로가 됐다. 운영 환경에서는 최소 기능 원칙으로 디버그·관리 인터페이스를 끄거나 인가된 접근만 허용해야 한다.
• 신뢰 관계의 최소화 (rsh/.rhosts 폐기): 비밀번호 없이 통과시키는 .rhosts·hosts.equiv 신뢰 관계는 웜의 '고속도로'였다. 오늘날 SSH 키 + 개별 인증으로 대체됐고, 제로 트러스트(Zero Trust) 원칙의 전신으로 볼 수 있다.
• 암호 해시의 보호 (shadow): 암호 해시가 전원 읽기 가능한 /etc/passwd에 있던 시절에는 한 대만 뚫려도 오프라인 크래킹으로 계정이 대량 탈취됐다. 해시를 /etc/shadow로 분리하고(그림자 암호) 강한 암호 정책·다중 인증을 적용해야 한다.
• 다층 방어와 신속 패치: 세 벡터 중 하나만 막아도 웜은 죽지 않았다. '단일 통제로 안전'을 가정하지 말고, 패치 관리·서비스 최소화·네트워크 분리를 겹겹이 쌓아야 한다. (PoC 1의 'hardened' 호스트가 그 예다.)
• 자원 소진(부하)을 견디는 설계: 모리스 웜의 최대 피해는 취약점 자체가 아니라 웜이 유발한 과잉 복제 부하였다. 서비스 설계 시 프로세스·메모리·연결 수 상한과 레이트 리미팅을 두어 자기 증식형 부하를 견뎌야 한다. (PoC 2의 교훈)
• 사고 대응 체계 (CERT의 탄생): 이 사건은 '문제를 빠르게 공유하고 협력해 대응하는 조직'으로서 CERT를 낳았다. 오늘날의 취약점 공개(coordinated disclosure)·CISA KEV·ISAC 정보 공유의 뿌리다.
• 교훈 요약:
  • "의도"는 피해를 면제하지 않는다: 파괴를 원치 않았던 실험이 인터넷을 멈췄다. 위험한 코드는 격리된 실습 환경에서만 검증해야 한다.
  • 자가 복제 코드에는 반드시 '정지 조건'을: 재감염 확률 하나가 통제 불능을 낳았다. 자기 증식 로직은 전파 속도·복제 상한을 명시적으로 제한해야 한다. (PoC 2)
  • 웜의 계보가 여기서 시작됐다: Morris(1988) → Code Red(2001) → Slammer(2003) → Conficker(2008) → WannaCry/NotPetya(2017). 전파 원리는 30년 넘게 반복됐고, 지금도 반복되고 있다.

출처

• Wikipedia — Morris worm — https://en.wikipedia.org/wiki/Morris_worm
• RFC 1135 — The Helminthiasis of the Internet (IETF, 1989) — https://www.rfc-editor.org/rfc/rfc1135.html
• Eugene H. Spafford — The Internet Worm Program: An Analysis (Purdue, 1988) — https://docs.lib.purdue.edu/cstech/213/
• Donn Seeley — A Tour of the Worm (USENIX Winter 1989) — A Tour of the Worm
• FBI — The Morris Worm: 30 Years Since First Major Attack on the Internet — https://www.fbi.gov/news/stories/morris-worm-30-years-since-first-major-attack
• Wikipedia — Robert Tappan Morris — https://en.wikipedia.org/wiki/Robert_Tappan_Morris

함께 읽기: 🪱 Conficker (2008) — SMB 취약점 웜의 고전 · 🦠 Mirai (2016) — IoT를 무기로 삼은 봇넷 · 💀 WannaCry (2017) — EternalBlue로 전 세계를 강타한 자가전파형 웜