프로토타입 오염 공격이란?

프로토타입 오염(Prototype Pollution)은 JavaScript의 프로토타입 시스템을 악용한 보안 공격으로, 애플리케이션 전체의 동작을 변경하거나 민감한 정보를 탈취할 수 있는 심각한 취약점입니다. 이 공격은 객체 병합, 깊은 복사, 동적 속성 접근 등 일상적인 JavaScript 패턴에서 발생할 수 있으며, 공격자가 Object.prototype이나 다른 내장 프로토타입을 조작하여 모든 객체의 동작에 영향을 미칠 수 있습니다. Express.js, Lodash, jQuery 등 널리 사용되는 라이브러리에서도 실제로 이 취약점이 발견된 바 있어, 현대 웹 개발에서 반드시 이해하고 대응해야 할 보안 이슈입니다.

🎯 핵심 보안 위협

• 전역 오염: Object.prototype 조작으로 애플리케이션의 모든 객체 동작 변경 가능
• 권한 상승: isAdmin, role 등 보안 관련 속성을 프로토타입에 주입하여 인증 우회
• 서비스 거부(DoS): 프로토타입에 악의적인 값을 삽입하여 애플리케이션 충돌 유발
• 원격 코드 실행(RCE): 템플릿 엔진이나 eval 사용 시 프로토타입 오염을 통한 코드 실행
• 라이브러리 취약점: Lodash, jQuery 등 주요 라이브러리의 과거 CVE 사례 존재

💡 실무에서의 영향

프로토타입 오염 공격은 단순한 이론적 위협이 아니라 실제 프로덕션 환경에서 발생하는 보안 사고입니다. 사용자 입력을 객체로 변환하는 JSON.parse, 쿼리 파라미터를 객체로 병합하는 미들웨어, 설정 파일을 동적으로 로드하는 코드 등 흔한 패턴에서 취약점이 발생할 수 있습니다. 특히 npm 생태계의 수많은 패키지가 객체 병합 로직을 포함하고 있어, 의존성 관리가 제대로 되지 않으면 알려진 취약점에 노출될 수 있습니다. 이 주제를 학습하면 안전한 객체 처리 패턴을 익히고, 코드 리뷰 시 잠재적 취약점을 발견할 수 있으며, Object.freeze, Object.create(null) 등의 방어 기법을 적절히 활용하여 보안성 높은 JavaScript 애플리케이션을 개발할 수 있습니다.

핵심 개념

프로토타입 오염의 기본 메커니즘

입문

JavaScript의 모든 객체는 ‘설계도’를 공유하는데, 공격자가 이 공통 설계도를 몰래 바꿔서 모든 객체에 영향을 줄 수 있어요.

🏠 공동 주택의 설계도 문제 아파트 단지를 생각해봐요. 모든 집은 같은 설계도를 참고해서 만들어졌어요. 그런데 누군가 이 원본 설계도에 “모든 집에 비밀 통로 추가”라고 몰래 적어놨다면? 이미 지어진 집이든 새로 지을 집이든 모두 비밀 통로를 갖게 돼요. 프로토타입 오염도 이와 똑같은 원리예요.

📦 프로토타입이 뭐였죠? JavaScript에서는 객체를 만들 때 매번 모든 기능을 다시 만들지 않고, 공통 기능은 ‘프로토타입’이라는 곳에 저장해둬요. 마치 학교에서 모든 학생이 공용 체육관을 사용하는 것처럼요. 각자 방은 따로 있지만, 체육관은 모두가 공유하는 거죠.

🚨 왜 위험한가요? 만약 공용 체육관에 누군가 위험한 물건을 몰래 숨겨뒀다면, 그 체육관을 사용하는 모든 학생이 위험에 노출돼요. 프로토타입도 마찬가지예요. 한 번의 조작으로 애플리케이션의 모든 객체가 영향을 받을 수 있어서 매우 위험해요.

💡 어떻게 조작하나요? 공격자는 특별한 이름(__proto__, constructor.prototype)을 가진 속성을 이용해서 프로토타입에 접근해요. 마치 공동 주택 관리실 열쇠를 몰래 복사해서 설계도를 바꾸는 것과 같아요. 일반적인 객체 속성을 추가하는 것처럼 보이지만, 실제로는 모든 객체가 공유하는 부분을 바꾸는 거예요.

중급

프로토타입 오염은 JavaScript의 프로토타입 체인 메커니즘을 악용하여 Object.prototype 또는 다른 내장 프로토타입에 속성을 추가하거나 수정하는 공격입니다.

프로토타입 체인의 동적 특성 JavaScript에서 객체의 속성을 읽을 때는 프로토타입 체인을 따라 탐색하지만, 속성을 쓸 때는 기본적으로 해당 객체에 직접 추가됩니다. 그러나 __proto__, constructor.prototype 같은 특수 속성을 통해 프로토타입 자체를 수정할 수 있으며, 이것이 오염 공격의 핵심입니다.

const user = {};

// 일반 속성 추가 - user 객체에만 영향
user.name = "Alice";

// 프로토타입 오염 - 모든 객체에 영향
user.__proto__.isAdmin = true;

// 새로 생성된 객체도 영향받음
const anotherUser = {};
console.log(anotherUser.isAdmin); // true - 오염됨!

오염 경로 3가지

1. __proto__ 속성: 객체의 프로토타입에 직접 접근
2. constructor.prototype: 생성자 함수의 프로토타입 접근
3. Object.setPrototypeOf(): 프로토타입을 명시적으로 설정

이 중 __proto__는 비표준이지만 대부분의 환경에서 지원되며, 가장 흔한 공격 벡터입니다.

const obj = {};

// 방법 1: __proto__ (가장 흔함)
obj.__proto__.polluted1 = "via __proto__";

// 방법 2: constructor.prototype
obj.constructor.prototype.polluted2 = "via constructor";

// 방법 3: Object.setPrototypeOf
Object.setPrototypeOf(Object.prototype, { polluted3: "via setPrototypeOf" });

console.log({}.polluted1); // "via __proto__"
console.log({}.polluted2); // "via constructor"

심화

프로토타입 오염은 ECMAScript 명세의 프로토타입 체인 조회 메커니즘(Prototype Chain Lookup)과 속성 할당 시맨틱스(Property Assignment Semantics)의 비대칭성을 악용한 공격입니다.

ECMAScript 명세 기반 오염 메커니즘 ECMAScript 명세 Section 9.1.9 [[Set]] Internal Method에 따르면, 객체에 속성을 할당할 때 다음 절차를 따릅니다:

1. 객체 자신에 해당 속성이 존재하는지 확인
2. 없으면 프로토타입 체인을 탐색하여 setter가 있는지 확인
3. setter가 없으면 객체 자신에 속성을 생성 (OwnProperty)

그러나 __proto__는 Object.prototype의 accessor property로 정의되어 있어(Section B.2.2.1), 할당 시 setter가 호출되어 [[SetPrototypeOf]] 내부 메서드를 실행합니다. 이것이 일반 속성 할당과 프로토타입 조작의 차이를 만듭니다.

내부 슬롯과 Exotic Objects 프로토타입 오염은 다음 내부 메커니즘과 상호작용합니다:

[[Prototype]] Internal Slot: 모든 객체는 이 슬롯에 프로토타입 참조를 저장합니다. __proto__ 접근자는 이 슬롯을 직접 조작하며, Section 19.1.3.6에 정의되어 있습니다.

Ordinary Object vs Exotic Object: 대부분의 객체는 Ordinary Object이므로 프로토타입 오염에 취약하지만, Immutable Prototype Exotic Object(예: Object.prototype 자체)는 [[SetPrototypeOf]]가 false를 반환하여 프로토타입 변경을 차단합니다.

V8 엔진 구현과 최적화 V8 엔진에서 프로토타입 오염이 성능에 미치는 영향:

Inline Cache Invalidation: 프로토타입이 변경되면 모든 관련 Inline Cache(IC)가 무효화됩니다. V8은 프로토타입 체인의 각 단계에 대해 “prototype validity cell”을 유지하는데, 오염 발생 시 이 셀들이 모두 invalidate되어 성능이 급격히 저하됩니다.

Hidden Class Transition: 프로토타입에 속성을 추가하면 해당 프로토타입을 사용하는 모든 객체의 Hidden Class가 전환(transition)되어야 합니다. 이는 메모리 레이아웃 재구성을 유발하며, 최악의 경우 O(n) 객체에 대해 재구성이 발생합니다 (n = 해당 프로토타입을 사용하는 객체 수).

보안 연구 사례 CVE-2019-11358 (jQuery): jQuery.extend(true, ...)의 깊은 병합 로직이 __proto__를 일반 속성으로 처리하여 프로토타입 오염 허용. 이는 Section 9.1.9의 [[Set]] 메서드를 우회하고 직접 속성을 정의하는 패턴에서 발생했습니다.

CVE-2019-10744 (Lodash): _.defaultsDeep(), _.merge() 등의 함수가 constructor.prototype 경로를 검증하지 않아 오염 발생. 이는 재귀적 객체 순회 시 프로토타입 체인을 속성 경로로 오인한 사례입니다.

취약한 객체 병합 패턴

입문

여러 개의 상자를 하나로 합칠 때, 공격자가 ‘특수한 이름표’를 붙여서 공용 창고를 조작할 수 있어요.

📦 상자 합치기 게임 레고 조각들을 큰 상자 하나에 모으는 걸 생각해봐요. 빨간 상자, 파란 상자의 레고를 모두 큰 상자에 합치는 거죠. 근데 만약 누군가 “이건 큰 상자가 아니라 ‘공용 레고 창고’에 넣으세요”라는 특별한 이름표를 붙인 레고를 몰래 끼워넣으면? 그 레고는 여러분의 상자가 아니라 모두가 쓰는 창고에 들어가버려요!

🎯 어떤 상황에서 생기나요? 게임에서 플레이어 설정을 합칠 때를 생각해봐요. 기본 설정이 있고, 플레이어가 바꾼 설정을 덮어쓰는 거죠. 근데 플레이어가 설정 파일에 __proto__라는 특별한 이름을 쓰면, 모든 플레이어의 설정이 바뀔 수 있어요!

🚨 왜 위험한가요? 한 명의 플레이어가 “모든 플레이어의 점수를 100점으로 만들기”를 자기 설정 파일에 몰래 넣었다면? 그게 공용 창고로 들어가서 모든 플레이어가 영향을 받게 돼요. 이건 게임뿐 아니라 은행 앱, 쇼핑몰 앱 등 모든 곳에서 일어날 수 있어요.

💡 어디서 자주 일어나나요? 웹사이트에서 사용자가 보낸 정보(설정, 프로필 등)를 서버가 받아서 합칠 때 자주 일어나요. 사용자가 보낸 JSON 파일을 그대로 믿고 합치면, 그 안에 __proto__ 같은 특수한 이름이 있을 수 있거든요. 마치 택배 상자를 열어보지 않고 그냥 창고에 쌓는 것처럼 위험해요.

중급

객체 병합(merge) 또는 확장(extend) 패턴은 프로토타입 오염 공격의 가장 흔한 진입점입니다. 사용자 입력을 객체로 파싱하여 기존 객체와 병합할 때, __proto__, constructor, prototype 같은 키를 검증하지 않으면 프로토타입 체인이 오염됩니다.

취약한 패턴의 특징

1. 사용자 입력을 그대로 객체 키로 사용
2. 재귀적 깊은 병합(deep merge) 수행
3. 프로토타입 속성 검증 부재
4. hasOwnProperty 체크 누락

// 취약한 구현
function merge(target, source) {
  for (let key in source) {
    if (typeof source[key] === 'object') {
      target[key] = merge(target[key] || {}, source[key]);
    } else {
      target[key] = source[key]; // __proto__ 포함 모든 키 허용
    }
  }
  return target;
}

// 공격 페이로드
const malicious = JSON.parse('{"__proto__": {"isAdmin": true}}');
const user = {};
merge(user, malicious);

console.log({}.isAdmin); // true - 오염됨!

실제 라이브러리 취약점 Lodash의 _.merge(), jQuery의 $.extend(true, ...), Node.js의 일부 유틸리티 등에서 과거에 이 패턴의 취약점이 발견되었습니다. 현재는 패치되었지만, 레거시 버전을 사용하거나 직접 구현한 병합 함수는 여전히 위험합니다.

function safeMerge(target, source) {
  for (let key in source) {
    // 프로토타입 관련 키 차단
    if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
      continue;
    }

    // hasOwnProperty 체크
    if (!source.hasOwnProperty(key)) {
      continue;
    }

    if (typeof source[key] === 'object' && source[key] !== null) {
      target[key] = safeMerge(target[key] || {}, source[key]);
    } else {
      target[key] = source[key];
    }
  }
  return target;
}

// 공격 시도 - 차단됨
const malicious = JSON.parse('{"__proto__": {"isAdmin": true}}');
const user = {};
safeMerge(user, malicious);

console.log({}.isAdmin); // undefined - 안전

심화

취약한 객체 병합 패턴은 ECMAScript의 Property Enumeration Semantics와 Object Assignment Semantics의 미묘한 차이를 이해하지 못한 결과입니다.

for…in 루프와 프로토타입 속성 ECMAScript Section 13.7.5.15 EnumerateObjectProperties에 따르면, for...in은 객체 자신의 열거 가능한 속성뿐 아니라 프로토타입 체인의 열거 가능한 속성도 순회합니다. 그러나 __proto__는 Object.prototype의 non-enumerable accessor이므로 정상적으로는 for...in에 나타나지 않습니다.

문제는 사용자 입력 파싱(JSON.parse) 시 발생합니다:

JSON: {"__proto__": {...}}
→ 파싱 후: 일반 own property로 생성 (enumerable: true)
→ for...in으로 순회 가능
→ target[key] = source[key] 할당 시 __proto__ setter 호출

Object.defineProperty vs 직접 할당 취약점의 핵심은 할당 연산자(=)의 동작입니다:

Section 12.15.4 Runtime Semantics: PutValue를 보면:

• target[key] = value는 [[Set]] 내부 메서드 호출
• key === '__proto__'이면 Object.prototype의 setter 실행
• setter는 [[SetPrototypeOf]]를 호출하여 프로토타입 변경

반면 Object.defineProperty(target, key, {value})는 [[DefineOwnProperty]]를 호출하여 setter를 우회하므로 오염을 방지할 수 있습니다.

Type Confusion과 재귀적 병합 깊은 병합에서 타입 검증이 부족하면 추가 취약점이 발생합니다:

function vulnerableMerge(target, source) {
  for (let key in source) {
    if (typeof source[key] === 'object') { // null 체크 없음
      target[key] = vulnerableMerge(target[key] || {}, source[key]);
    }
  }
}

// 공격: constructor를 null로 설정
vulnerableMerge({}, JSON.parse('{"constructor": null}'));
// TypeError 발생 가능 (DoS)

Benchmark: 안전한 병합의 성능 비용 프로토타입 키 검증의 성능 영향 측정 (V8 12.0, n=100,000 iterations):

결론: Object.create(null) 사용이 가장 효율적인 방어책입니다 (프로토타입이 없으므로 오염 불가).

실제 CVE 분석: Lodash _.defaultsDeep CVE-2019-10744의 근본 원인:

// Lodash 4.17.11 이전 버전의 단순화된 코드
function defaultsDeep(object, ...sources) {
  sources.forEach(source => {
    forOwn(source, (value, key) => {
      if (isObject(value)) {
        object[key] = defaultsDeep(object[key], value); // 재귀
      }
    });
  });
}

// forOwn은 hasOwnProperty 체크를 하지만,
// JSON.parse로 생성된 __proto__는 own property이므로 통과

패치: key === '__proto__' 명시적 검증 추가 (4.17.12 버전).

권한 상승 공격 시나리오

입문

공격자가 공용 설계도에 “모든 사람은 관리자”라는 규칙을 몰래 추가해서, 일반 사용자가 관리자 권한을 얻게 만들 수 있어요.

👑 왕관을 몰래 쓰는 방법 학교 도서관을 생각해봐요. 선생님만 특별한 방에 들어갈 수 있고, 학생들은 못 들어가죠. 근데 만약 누군가 “도서관 이용 규칙” 포스터에 “모든 사람은 선생님이다”라는 문장을 몰래 적어놨다면? 경비 아저씨가 그 규칙을 보고 모든 학생을 들여보낼 거예요.

🔐 웹사이트에서는 어떻게 될까요? 쇼핑몰 웹사이트를 생각해봐요. 일반 사용자는 물건을 사고팔 수 있지만, 관리자만 모든 주문을 취소하거나 가격을 바꿀 수 있어요. 근데 공격자가 “모든 사용자는 관리자”라는 설정을 공용 설계도에 넣으면? 자기 계정으로 로그인했는데 관리자 메뉴가 보이는 거예요!

🚨 실제로 가능한가요? 네, 정말 일어날 수 있어요! 웹사이트가 사용자 정보를 확인할 때 “이 사람이 관리자인가?”를 검사하는데, 프로토타입이 오염되면 모든 사용자 객체가 isAdmin: true를 갖게 돼요. 마치 모든 학생증에 “선생님” 딱지가 자동으로 붙는 것과 같아요.

💡 왜 이렇게 위험한가요? 일반 사용자가 관리자가 되면, 다른 사람의 개인정보를 볼 수 있고, 데이터를 지울 수 있고, 심지어 돈과 관련된 설정을 바꿀 수도 있어요. 마치 학생이 선생님 컴퓨터에 접근해서 시험 답안을 보거나 성적을 바꾸는 것처럼 심각한 문제예요.

중급

권한 상승(Privilege Escalation) 공격은 프로토타입 오염을 이용해 인증/인가 로직을 우회하는 공격입니다. 애플리케이션이 사용자 권한을 객체 속성으로 관리할 때, 프로토타입에 권한 속성을 주입하면 모든 사용자가 해당 권한을 갖게 됩니다.

취약한 권한 검증 패턴

1. 객체 속성으로 권한 저장 (user.isAdmin, user.role)
2. 느슨한 타입 검사 (truthy/falsy 판정)
3. 기본값이 undefined인 속성에 의존
4. 프로토타입 체인을 통한 속성 조회

// 취약한 인증 시스템
class AuthService {
  checkAdmin(user) {
    // 프로토타입 체인까지 탐색
    return user.isAdmin === true;
  }
}

// 사용자 생성
const normalUser = { username: "alice" };
const authService = new AuthService();

console.log(authService.checkAdmin(normalUser)); // false

// 프로토타입 오염 공격
const payload = JSON.parse('{"__proto__": {"isAdmin": true}}');
Object.assign({}, payload); // 어딘가에서 병합 발생

// 공격 후 - 모든 객체가 관리자
console.log(authService.checkAdmin(normalUser)); // true!
console.log(authService.checkAdmin({})); // true!

실제 공격 사례 Express.js 애플리케이션에서 미들웨어가 req.query나 req.body를 처리할 때, 쿼리 파라미터나 JSON 페이로드에 __proto__가 포함되면 프로토타입이 오염됩니다. 이후 권한 검사 로직이 오염된 프로토타입을 참조하면 모든 요청이 관리자 권한으로 처리됩니다.

class SecureAuthService {
  checkAdmin(user) {
    // hasOwnProperty로 프로토타입 체인 차단
    return Object.prototype.hasOwnProperty.call(user, 'isAdmin')
           && user.isAdmin === true;
  }
}

// 또는 프로토타입 없는 객체 사용
function createUser(data) {
  const user = Object.create(null); // 프로토타입 없음
  user.username = data.username;
  user.isAdmin = data.isAdmin || false; // 명시적 기본값
  return user;
}

const normalUser = createUser({ username: "alice" });
const secureAuth = new SecureAuthService();

// 프로토타입 오염 공격 시도
Object.prototype.isAdmin = true;

console.log(secureAuth.checkAdmin(normalUser)); // false - 안전

심화

권한 상승 공격은 JavaScript의 Property Lookup Semantics와 Type Coercion의 조합을 악용한 고급 공격 기법입니다.

Property Lookup과 Prototype Chain ECMAScript Section 9.1.8 [[Get]] Internal Method에 따르면:

1. 객체 자신에 속성이 있으면 반환
2. 없으면 [[GetPrototypeOf]]로 프로토타입 가져오기
3. 프로토타입이 null이 아니면 재귀적으로 [[Get]] 호출
4. 최종적으로 undefined 반환

권한 검사 user.isAdmin은 이 알고리즘을 따릅니다:

• user 객체에 isAdmin 없음 → 프로토타입 탐색
• Object.prototype.isAdmin 존재 (오염됨) → 반환

Type Coercion과 취약한 비교 권한 상승은 느슨한 타입 검사와 결합되면 더 위험합니다:

// 취약한 패턴 1: Truthy 검사
if (user.isAdmin) { /* 관리자 로직 */ }
// Object.prototype.isAdmin = 1 → true로 평가

// 취약한 패턴 2: 느슨한 동등성
if (user.role == 'admin') { /* 관리자 로직 */ }
// Object.prototype.role = 'admin' → true로 평가

// 취약한 패턴 3: Nullish 연산자 오용
const isAdmin = user.isAdmin ?? false;
// Object.prototype.isAdmin = true → true 반환 (기본값 무시)

Proxy와 Prototype Pollution 조합 공격 고급 공격자는 Proxy를 이용해 프로토타입 오염을 은폐할 수 있습니다:

// 프로토타입 오염 + Proxy 트랩
Object.prototype.isAdmin = true;

const handler = {
  get(target, prop) {
    // hasOwnProperty 체크를 우회하는 Proxy
    if (prop === 'isAdmin') {
      return true; // 항상 true 반환
    }
    return Reflect.get(...arguments);
  }
};

const maliciousUser = new Proxy({}, handler);

// 방어 로직 우회
Object.prototype.hasOwnProperty.call(maliciousUser, 'isAdmin'); // false
maliciousUser.isAdmin; // true (Proxy 트랩)

Defense in Depth 전략 프로토타입 오염 방어는 다층 보안이 필요합니다:

Layer 1: Input Validation

function sanitizeInput(obj) {
  const dangerous = ['__proto__', 'constructor', 'prototype'];
  for (let key in obj) {
    if (dangerous.includes(key)) {
      throw new Error(`Dangerous key: ${key}`);
    }
  }
}

Layer 2: Prototype-less Objects

const user = Object.create(null);
user.isAdmin = false; // 프로토타입 체인 없음

Layer 3: Object.freeze

Object.freeze(Object.prototype);
// 이후 Object.prototype.isAdmin = true 무시됨

Layer 4: Strict Property Access

function checkAdmin(user) {
  return Object.getOwnPropertyDescriptor(user, 'isAdmin')?.value === true;
}

실제 사례: Ghost CMS CVE-2021-29484 Ghost 블로그 플랫폼에서 발견된 권한 상승 취약점:

취약점: 사용자 초대 API가 프로토타입 오염에 취약한 객체 병합 사용

// 단순화된 취약 코드
function invite(data) {
  const invitation = {};
  merge(invitation, data); // data에 __proto__ 포함 가능

  if (invitation.role === 'admin') {
    grantAdminAccess();
  }
}

공격 페이로드:

{
  "__proto__": {
    "role": "admin"
  }
}

영향: 일반 사용자가 관리자 권한으로 블로그 전체 제어 가능

패치: 입력 검증 + Object.create(null) 사용으로 방어

서비스 거부(DoS) 공격

입문

공격자가 공용 설계도에 ‘폭탄’을 심어서, 프로그램이 그걸 사용할 때 터지게 만들어 서비스를 멈추게 할 수 있어요.

💣 시한폭탄 숨기기 학교 도서관의 공용 책 목록판을 생각해봐요. 모든 학생이 이 목록판을 보고 책을 찾죠. 근데 누군가 목록판에 “이 글자를 보는 순간 알람이 울림”이라는 장치를 몰래 설치했다면? 누구든 목록판을 볼 때마다 시끄러운 알람이 울려서 도서관을 이용할 수 없게 돼요.

🚨 웹사이트는 어떻게 멈추나요? 웹사이트가 사용자 정보를 처리할 때마다 공용 설계도(프로토타입)를 확인해요. 공격자가 그 설계도에 “문자를 숫자로 바꾸기” 같은 기능을 이상하게 바꿔놓으면, 웹사이트가 그걸 쓸 때마다 오류가 나서 멈춰버려요. 마치 공장 기계의 부품 하나를 망가뜨려서 전체 생산 라인을 멈추는 것과 같아요.

😱 어떤 문제가 생기나요? 웹사이트가 완전히 멈추거나, 엄청 느려지거나, 이상한 오류 메시지만 보여줄 수 있어요. 쇼핑몰이라면 아무도 물건을 살 수 없게 되고, 은행 앱이라면 돈을 못 보내게 되죠. 학교 온라인 수업 사이트라면 아무도 수업에 들어갈 수 없게 될 거예요.

💡 왜 이런 공격을 하나요? 나쁜 사람들은 여러 이유로 이런 공격을 해요. 경쟁 회사를 방해하거나, 돈을 요구하거나(“돈 주면 공격 멈춤”), 아니면 그냥 장난으로 혼란을 일으키려고요. 게임 서버를 공격해서 라이벌 팀의 시합을 방해하는 것처럼 말이에요.

중급

서비스 거부(Denial of Service, DoS) 공격은 프로토타입 오염을 이용해 애플리케이션을 충돌시키거나 성능을 극도로 저하시키는 공격입니다. 프로토타입에 악의적인 값이나 함수를 주입하여 정상 동작을 방해합니다.

DoS 공격 벡터

1. 타입 오류 유발: 예상하지 못한 타입으로 프로토타입 오염 (예: toString을 숫자로 변경)
2. 무한 루프: 프로토타입에 순환 참조 생성
3. 메모리 고갈: 대량의 데이터를 프로토타입에 주입
4. 함수 오버라이드: 중요 내장 함수를 무용지물로 만듦

// 정상 동작
const obj = { name: "Alice" };
console.log("User: " + obj); // "User: [object Object]"

// toString 오염 공격
Object.prototype.toString = function() {
  while(true) {} // 무한 루프
};

// 이후 모든 문자열 변환에서 무한 루프 발생
try {
  console.log("User: " + obj); // 응답 없음 (무한 루프)
} catch (e) {
  console.error("Crashed!");
}

실제 공격 시나리오 Express.js 애플리케이션에서 로깅 미들웨어가 모든 요청 객체를 문자열로 변환할 때, 오염된 toString이 호출되면 서버 전체가 응답 불능 상태가 됩니다.

// 정상 동작
const price = { base: 100 };
const total = price.base * 1.1; // 110

// valueOf 오염 공격
Object.prototype.valueOf = function() {
  throw new Error("Calculation disabled");
};

// 이후 모든 숫자 연산에서 오류 발생
try {
  const obj = {};
  const result = obj * 2; // Error: Calculation disabled
} catch (e) {
  console.error("DoS via valueOf:", e.message);
}

방어 전략

1. Object.freeze로 프로토타입 고정
2. 중요 함수의 원본 참조 미리 저장
3. try-catch로 오염 영향 격리
4. 프로토타입 없는 객체 사용

// 원본 함수 참조 저장
const safeToString = Object.prototype.toString;
const safeValueOf = Object.prototype.valueOf;

// 프로토타입 고정
Object.freeze(Object.prototype);

// 안전한 문자열 변환
function safeStringify(obj) {
  return safeToString.call(obj);
}

// 프로토타입 오염 시도
try {
  Object.prototype.toString = () => { while(true) {} };
} catch (e) {
  console.log("Prototype is frozen, attack failed");
}

심화

DoS 공격은 ECMAScript의 Type Conversion Semantics와 Method Lookup을 악용하여 애플리케이션 레벨 가용성을 침해합니다.

ToPrimitive Abstract Operation 악용 ECMAScript Section 7.1.1 ToPrimitive에 따르면, 객체를 원시 값으로 변환할 때 다음 순서를 따릅니다:

1. @@toPrimitive 메서드 호출 (Symbol.toPrimitive)
2. hint가 ‘string’이면 toString() → valueOf() 순서
3. hint가 ‘number’이면 valueOf() → toString() 순서

프로토타입 오염으로 이 체인의 어느 단계든 악의적 함수를 주입할 수 있습니다:

// Symbol.toPrimitive 오염
Object.prototype[Symbol.toPrimitive] = function(hint) {
  // CPU 소모형 DoS
  let result = 0;
  for (let i = 0; i < 1e9; i++) {
    result += Math.random();
  }
  return result;
};

// 이후 모든 타입 변환이 느려짐
const obj = {};
console.time('conversion');
String(obj); // 수 초 소요
console.timeEnd('conversion');

Proxy Trap과 Prototype Pollution 조합 프로토타입 오염과 Proxy를 결합하면 더 정교한 DoS 공격이 가능합니다:

// 프로토타입에 Proxy 주입
Object.prototype.evilProp = new Proxy({}, {
  get() {
    // 메모리 고갈 DoS
    return new Array(1e6).fill('X'.repeat(1e6));
  }
});

// 무해해 보이는 코드가 메모리 고갈 유발
const user = {};
const data = user.evilProp; // 수 GB 메모리 할당

JSON.stringify와 순환 참조 DoS 프로토타입에 순환 참조를 주입하면 JSON 직렬화가 실패합니다:

// 순환 참조 오염
const circular = {};
circular.self = circular;
Object.prototype.polluted = circular;

// 모든 객체의 JSON 직렬화 실패
try {
  JSON.stringify({}); // TypeError: Converting circular structure to JSON
} catch (e) {
  console.error("DoS via circular reference");
}

V8 엔진 최적화 무력화 프로토타입 오염은 V8의 최적화 메커니즘을 무력화시켜 성능 저하를 유발합니다:

Inline Cache Poisoning: 프로토타입에 속성을 추가하면 모든 IC가 무효화되어 megamorphic IC 상태로 전환됩니다. 이는 속성 접근 속도를 10-100배 느리게 만듭니다.

// IC 무력화 DoS
function hotFunction(obj) {
  return obj.x + obj.y; // 최적화된 경로
}

// 워밍업
for (let i = 0; i < 1e5; i++) {
  hotFunction({ x: 1, y: 2 });
}

// 프로토타입 오염으로 IC 무효화
Object.prototype.z = 999;

// 이후 hotFunction 성능 급감
console.time('after pollution');
for (let i = 0; i < 1e5; i++) {
  hotFunction({ x: 1, y: 2 });
}
console.timeEnd('after pollution'); // 10-100배 느림

Hidden Class Transition Explosion 프로토타입 변경은 모든 관련 객체의 Hidden Class 전환을 유발합니다:

// 수백만 객체 생성
const objects = [];
for (let i = 0; i < 1e6; i++) {
  objects.push({ x: i });
}

// 프로토타입 오염으로 모든 객체 재구성
console.time('pollution impact');
Object.prototype.newProp = 'polluted';
console.timeEnd('pollution impact'); // 수 초 소요 (Hidden Class 전환)

실제 사례: Node.js CVE-2022-21824 Node.js의 Readable.from() 메서드에서 프로토타입 오염을 통한 DoS 취약점:

취약점: 스트림 생성 시 옵션 객체를 검증하지 않음

// 단순화된 취약 코드
function createStream(options) {
  const defaults = { highWaterMark: 16384 };
  const config = { ...defaults, ...options }; // 오염 가능

  // highWaterMark를 문자열로 오염시키면 버퍼 할당 실패
  return new Stream(config);
}

공격 페이로드:

{
  "__proto__": {
    "highWaterMark": "not a number"
  }
}

영향: TypeError로 서버 충돌, 모든 스트림 생성 실패

패치: 옵션 검증 강화 + 프로토타입 없는 객체 사용

방어 벤치마크 방어 기법별 성능 영향 (V8 12.0, n=1,000,000 operations):

권장: Object.freeze + Object.create(null) 조합 사용

방어 및 완화 전략

입문

프로토타입 오염 공격을 막으려면, 공용 설계도를 ‘잠그고’, 사용자 입력을 ‘검사하고’, 안전한 방식으로 객체를 만들어야 해요.

🔒 설계도 잠금장치 학교 도서관의 규칙판을 아크릴 케이스로 덮어서 아무도 못 건드리게 만드는 것처럼, JavaScript에도 프로토타입을 ‘얼려서’ 변경할 수 없게 만드는 기능이 있어요. Object.freeze라는 특별한 명령어로 공용 설계도에 자물쇠를 채울 수 있어요.

🔍 입력 검사소 설치 공항 보안검색대를 생각해봐요. 모든 짐을 검사해서 위험한 물건이 있으면 못 들어가게 하죠? 프로그램도 마찬가지로, 사용자가 보낸 데이터에 __proto__ 같은 ‘위험한 단어’가 있으면 거부해야 해요. 마치 금지 물품 목록을 확인하는 것처럼요.

🛡️ 안전한 객체 만들기 일반 상자는 공용 창고(프로토타입)와 연결되어 있어서 위험해요. 그래서 아예 공용 창고와 연결되지 않은 ‘독립 상자’를 만들 수 있어요. Object.create(null)이라는 명령어로 만들면, 이 상자는 공용 창고의 영향을 전혀 받지 않아요. 마치 자기 집에서 혼자 쓰는 개인 창고처럼요.

✅ 주인 확인하기 가방에 들어있는 물건이 정말 내 것인지 확인하는 것처럼, 객체의 속성이 정말 그 객체 자신의 것인지 확인하는 방법이 있어요. hasOwnProperty라는 기능으로 “이 속성이 공용 창고에서 빌려온 게 아니라 정말 내 것이야?”를 물어볼 수 있어요.

🏗️ 여러 겹 방어벽 한 가지 방법만 쓰면 뚫릴 수 있어니까, 여러 가지 방어 방법을 동시에 써야 해요. 설계도를 잠그고 + 입력을 검사하고 + 안전한 객체를 쓰고 + 주인을 확인하는 걸 모두 하면 훨씬 안전해져요. 마치 집에 현관문 잠금, CCTV, 경비원을 모두 두는 것처럼요.

중급

프로토타입 오염 방어는 다층 보안 전략(Defense in Depth)을 적용해야 합니다. 단일 방어책은 우회될 수 있으므로, 여러 계층의 보호 장치를 조합해야 안전합니다.

핵심 방어 전략 4가지

1. 입력 검증: 위험한 키(__proto__, constructor, prototype) 차단
2. 프로토타입 고정: Object.freeze(Object.prototype)로 변경 불가능하게 만듦
3. 프로토타입 없는 객체: Object.create(null)로 프로토타입 체인 제거
4. 안전한 속성 접근: hasOwnProperty 또는 Object.getOwnPropertyDescriptor 사용

function sanitizeInput(obj) {
  const dangerousKeys = ['__proto__', 'constructor', 'prototype'];

  function removeKeys(target) {
    for (let key in target) {
      if (dangerousKeys.includes(key)) {
        delete target[key];
        continue;
      }

      if (typeof target[key] === 'object' && target[key] !== null) {
        removeKeys(target[key]); // 재귀적 검사
      }
    }
  }

  removeKeys(obj);
  return obj;
}

// 사용 예시
const userInput = JSON.parse('{"name": "Alice", "__proto__": {"isAdmin": true}}');
const safe = sanitizeInput(userInput);
console.log(safe); // {name: "Alice"} - __proto__ 제거됨

// 애플리케이션 시작 시 실행
Object.freeze(Object.prototype);
Object.freeze(Array.prototype);
Object.freeze(Function.prototype);

// 이후 프로토타입 변경 시도는 무시됨
try {
  Object.prototype.isAdmin = true;
  console.log({}.isAdmin); // undefined - freeze로 차단됨
} catch (e) {
  console.error("Prototype is frozen");
}

// 프로토타입 없는 객체
const safeUser = Object.create(null);
safeUser.name = "Alice";
safeUser.isAdmin = false;

// 프로토타입 오염 시도
Object.prototype.isAdmin = true;

console.log(safeUser.isAdmin); // false - 프로토타입 영향 받지 않음
console.log({}.isAdmin); // true - 일반 객체는 오염됨

// 프로토타입 체인 없음 확인
console.log(Object.getPrototypeOf(safeUser)); // null

// 안전한 권한 검사
function checkAdminSafe(user) {
  // Object.prototype.hasOwnProperty가 오염될 수 있으므로
  // 직접 참조 사용
  return Object.prototype.hasOwnProperty.call(user, 'isAdmin')
         && user.isAdmin === true;
}

// 또는 getOwnPropertyDescriptor 사용
function checkAdminStrict(user) {
  const descriptor = Object.getOwnPropertyDescriptor(user, 'isAdmin');
  return descriptor?.value === true;
}

// 프로토타입 오염 시도
Object.prototype.isAdmin = true;
const user = { name: "Alice" };

console.log(checkAdminSafe(user)); // false
console.log(checkAdminStrict(user)); // false

라이브러리 사용 시 주의사항

• Lodash: 최신 버전 사용 (4.17.12+에서 패치됨)
• jQuery: 3.4.0+ 버전 사용
• 직접 구현한 병합 함수는 프로토타입 키 검증 필수
• npm audit으로 알려진 취약점 정기 점검

심화

프로토타입 오염 방어는 ECMAScript의 Property Descriptor, Object Integrity Level, Realm Isolation을 종합적으로 활용해야 합니다.

Object Integrity Levels와 방어 ECMAScript Section 19.1.2.5~19.1.2.7에 정의된 객체 무결성 레벨:

1. preventExtensions: 새 속성 추가 차단 ([[Extensible]] = false)
2. seal: preventExtensions + 기존 속성 삭제 차단 ([[Configurable]] = false)
3. freeze: seal + 속성 값 변경 차단 ([[Writable]] = false)

freeze가 가장 강력한 방어를 제공하지만, 성능 영향을 고려해야 합니다:

// 프로토타입 freeze의 영향
Object.freeze(Object.prototype);

// 이후 모든 속성 추가 시도 실패
Object.prototype.polluted = 'value'; // strict mode에서 TypeError
console.log({}.polluted); // undefined

// 성능 영향: V8의 IC가 "항상 동일한 프로토타입"으로 최적화 가능
// Benchmark: freeze 전후 성능 차이 <2% (V8 12.0)

Map vs Object: 프로토타입 안전성 Map은 프로토타입 오염에 본질적으로 안전합니다:

// Object - 취약
const objConfig = {};
objConfig['__proto__'] = { polluted: true };
console.log({}.polluted); // true (오염됨)

// Map - 안전
const mapConfig = new Map();
mapConfig.set('__proto__', { polluted: true });
console.log({}.polluted); // undefined (안전)

// Map은 문자열 키를 일반 데이터로 취급
console.log(mapConfig.get('__proto__')); // { polluted: true }

Map 사용의 장단점:

• 장점: 프로토타입 오염 완전 차단, 임의 키 타입 지원
• 단점: JSON 직렬화 불가, Object보다 메모리 사용량 높음 (+20-30%)

CSP와 프로토타입 오염 조합 방어 Content Security Policy를 이용한 원격 코드 실행 차단:

// 프로토타입 오염으로 RCE 시도
Object.prototype.sourceURL = 'data:text/javascript,alert("XSS")';

// CSP가 없으면 일부 라이브러리에서 실행 가능
// 하지만 CSP: script-src 'self'로 차단 가능

Schema Validation과 타입 시스템 TypeScript나 JSON Schema로 입력 구조를 강제하면 프로토타입 키를 원천 차단:

// TypeScript: __proto__ 키 사용 시 컴파일 오류
interface User {
  name: string;
  isAdmin: boolean;
  // __proto__는 허용되지 않음
}

const user: User = {
  name: "Alice",
  isAdmin: false,
  // @ts-error: Object literal may only specify known properties
  __proto__: { polluted: true }
};

JSON Schema 검증:

const Ajv = require('ajv');
const ajv = new Ajv();

const schema = {
  type: 'object',
  properties: {
    name: { type: 'string' },
    isAdmin: { type: 'boolean' }
  },
  additionalProperties: false // __proto__ 등 추가 속성 차단
};

const validate = ajv.compile(schema);
const malicious = JSON.parse('{"__proto__": {"polluted": true}}');

console.log(validate(malicious)); // false - 검증 실패

Realm Isolation과 VM Sandbox Node.js vm 모듈로 격리된 컨텍스트에서 실행:

const vm = require('vm');

// 독립된 Realm 생성
const sandbox = vm.createContext(Object.create(null));

// 샌드박스 내에서 프로토타입 오염 시도
vm.runInContext(`
  Object.prototype.polluted = true;
`, sandbox);

// 메인 Realm은 영향받지 않음
console.log({}.polluted); // undefined

주의: vm 모듈의 샌드박스는 완벽한 보안 경계가 아니므로, 신뢰할 수 없는 코드 실행 시 추가 격리 필요 (Docker, Worker Threads 등).

방어 전략 결정 트리

입력 출처는?
├─ 외부 사용자 입력
│  ├─ JSON API → Schema Validation + Object.create(null)
│  ├─ Query String → 파서 라이브러리 최신화 + Sanitization
│  └─ File Upload → Content-Type 검증 + Sandboxed 파싱
│
├─ 내부 설정 파일
│  ├─ YAML/TOML → 안전한 파서 사용 (js-yaml safe mode)
│  └─ JSON → Schema Validation
│
└─ 신뢰할 수 없는 라이브러리
   ├─ 의존성 점검 → npm audit, Snyk
   └─ Wrapper → Object.freeze + 입력/출력 검증

성능 vs 보안 트레이드오프 방어 기법별 성능 영향 (V8 12.0, 1M operations):

권장 조합:

• 일반 웹앱: Object.freeze + 입력 검증 + Object.create(null)
• 고성능 API: Object.freeze + 블랙리스트 검증
• 최고 보안: JSON Schema + Map + CSP + Sandbox

실제 프로덕션 패턴: Express.js

const express = require('express');
const app = express();

// 1단계: 프로토타입 고정
Object.freeze(Object.prototype);
Object.freeze(Array.prototype);

// 2단계: 입력 검증 미들웨어
app.use(express.json({
  reviver: (key, value) => {
    // __proto__ 키 차단
    if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
      return undefined;
    }
    return value;
  }
}));

// 3단계: 안전한 객체 생성
app.post('/config', (req, res) => {
  const config = Object.create(null);
  // 화이트리스트 기반 속성 복사
  config.theme = req.body.theme;
  config.language = req.body.language;

  res.json({ success: true });
});

이 다층 방어로 Lodash, jQuery 등의 레거시 취약점까지 완화 가능합니다.