framework-source-security-analyzer

name	framework-source-security-analyzer
description	프레임워크와 언어의 소스코드 및 개발자 가이드를 직접 분석하여 메타적 보안 구조를 파악하는 스킬. Spring의 mass assignment, Java getHost()의 URL Confusion처럼 프레임워크/언어 설계상의 보안 함의를 소스코드 레벨에서 추출한다. GitHub 소스, 공식 문서, 보안 가이드를 직접 조회하고, 아키텍처 패턴-취약점 매핑을 생성한다. 대상: Spring, Django, Rails, Express, ASP.NET 등 프레임워크와 Java, Python, JavaScript, C# 등 언어의 표준 라이브러리. '프레임워크 보안 분석', '소스코드 보안 분석', '메타 구조 취약점', '언어 설계 취약점' 같은 표현에 트리거된다.

Framework Source Security Analyzer

프레임워크와 언어의 소스코드와 개발자 가이드를 직접 분석하여 메타적 보안 구조와 설계상 취약점을 파악하는 스킬이다.

일반적인 보안 가이드와의 차이점: 개별 취약점이 아닌, 프레임워크/언어의 설계 철학과 아키텍처 패턴이 어떻게 보안 취약점으로 이어지는지를 소스코드 레벨에서 분석한다.

핵심 원칙

"왜 이 프레임워크는 이런 방식으로 설계되었는가?"
"이 편의성/추상화가 어떤 보안 리스크를 숨기는가?"
"개발자가 의도치 않게 범하는 실수는 어디서 오는가?"

---

작업 흐름 개요

1. 대상 식별      → 어떤 프레임워크/언어/라이브러리를 분석할 것인가
2. 위협 조사      → CVE, 보안 연구, 실제 공격 사례 수집
3. 소스 분석      → GitHub 소스코드, 공식 문서, 개발자 가이드 조회
4. 메타 패턴 추출 → 설계 패턴과 보안 취약점의 구조적 관계 매핑
5. 문서 생성      → 프레임워크별 보안 아키텍처 분석 보고서

---

1단계: 대상 식별과 범위 설정

분석 대상 카테고리

A. 웹 프레임워크

• Backend: Spring (Java), Django (Python), Rails (Ruby), Express (Node.js), ASP.NET (C#), Laravel (PHP), FastAPI (Python)
• Frontend: React, Vue, Angular, Next.js, Nuxt.js

B. 언어 표준 라이브러리

• Java: java.net.URL, java.io, java.security, serialization
• Python: pickle, eval, exec, os, subprocess
• JavaScript/Node.js: eval, vm, child_process, URL parsing
• C#: System.Net, System.Xml, deserialization

C. ORM/데이터 접근 레이어

• Hibernate, JPA, SQLAlchemy, ActiveRecord, Entity Framework, Sequelize, TypeORM

D. 보안/인증 라이브러리

• Spring Security, Passport.js, Django Auth, ASP.NET Identity, JWT libraries

E. 직렬화/파싱 라이브러리

• Jackson, Gson, PyYAML, XML parsers, JSON parsers

범위 설정

하나의 분석에서 다루는 범위:

• 단일 컴포넌트 심층 분석: 예) Spring Data Binding, Jackson deserialization
• 프레임워크 전체 아키텍처: 예) Spring Framework 전체의 보안 메타 구조
• 언어별 위험 패턴: 예) Java Deserialization 생태계 전체

범위 결정 기준: 10-20개의 메타 패턴을 식별할 수 있는 크기가 적절

---

2단계: 위협 조사 (Threat Intelligence)

프레임워크/언어 특화 위협 정보를 수집한다.

검색 전략

카테고리 A: 프레임워크별 CVE와 취약점

검색어 패턴:
  "{프레임워크} CVE 2023 2024 2025"
  "{프레임워크} security vulnerability"
  "{프레임워크} {컴포넌트} exploit"
  
예시:
  "Spring Boot CVE 2024"
  "Django ORM SQL injection"
  "Express.js prototype pollution"
  
목적: 프레임워크의 실제 취약점 역사 파악

카테고리 B: 프레임워크 설계 결함 연구

검색어 패턴:
  "{프레임워크} security design flaw"
  "{프레임워크} insecure defaults"
  "{프레임워크} security architecture"
  
예시:
  "Spring mass assignment vulnerability"
  "Rails parameter binding security"
  "Django template injection"
  
목적: 개별 버그가 아닌 구조적 설계 문제 식별

카테고리 C: 언어 레벨 취약점

검색어 패턴:
  "{언어} {기능} security vulnerability"
  "{언어} deserialization attack"
  "{언어} URL parsing confusion"
  
예시:
  "Java getHost URL confusion"
  "Python pickle deserialization"
  "JavaScript prototype pollution"
  
목적: 언어 설계 자체의 보안 함의

카테고리 D: 컨퍼런스 발표 및 연구

검색어 패턴:
  "{프레임워크} security BlackHat OWASP"
  "{프레임워크} attack research paper"
  
목적: 체계적 공격 분류 및 신규 공격 벡터

카테고리 E: 실무 보안 패턴

검색어 패턴:
  "{프레임워크} security best practices"
  "{프레임워크} secure coding guide"
  "{프레임워크} security checklist OWASP"
  
목적: 실무에서 자주 발생하는 잘못된 사용 패턴

위협 정보 정리

다음 항목을 추출하여 정리:

## 위협 조사 결과

### 알려진 취약점 패턴
- [Mass Assignment, SQL Injection, Template Injection 등]

### 주요 CVE 및 사건
| CVE | 연도 | 영향 | 근본 원인 |
|-----|------|------|----------|
| CVE-XXXX-YYYY | 2024 | ... | Framework design flaw |

### 구조적 설계 문제
- [프레임워크의 철학/추상화가 숨기는 보안 리스크]

### 실무 오용 패턴
- [개발자가 자주 범하는 실수와 그 원인]

### 조사할 소스 위치
- [GitHub 리포지토리, 문서 URL, 핵심 코드 파일]

---

3단계: 소스코드 직접 분석 (Source Deep Dive)

이 단계가 이 스킬의 핵심 차별점이다.

소스 분석 대상

A. GitHub 소스코드

web_fetch를 사용하여 실제 구현 코드 조회:
  https://github.com/{org}/{repo}/blob/main/{path}
  
주요 분석 대상:
  - 핵심 보안 로직 (인증, 권한, 검증)
  - 데이터 바인딩/파싱 로직
  - 기본값(defaults) 설정
  - 보안 관련 어노테이션/데코레이터

B. 공식 개발자 가이드

프레임워크 공식 문서:
  - Security Guide
  - Best Practices
  - Configuration Reference
  - Migration Guide (보안 변경 사항)

C. 이슈 트래커 및 커밋 히스토리

보안 패치 커밋에서 학습:
  - 어떤 설계가 문제였는가
  - 어떻게 수정되었는가
  - Breaking change인가 호환성 유지인가

소스 분석 시 추출할 패턴

패턴 1: Insecure Defaults (불안전한 기본값)

// 예시: Spring Boot의 기본 설정
@ConfigurationProperties
public class ServerProperties {
    // 기본값이 보안에 미치는 영향
    private boolean exposeErrorDetails = true; // 개발 편의 vs 정보 노출
}

추출 내용:

• 기본값이 무엇인가
• 왜 이 기본값인가 (편의성, 호환성, 성능 등)
• 보안 리스크는 무엇인가
• 안전하게 변경하는 방법

패턴 2: Implicit Trust (암묵적 신뢰)

# 예시: Django ORM
class User(models.Model):
    # 필드가 자동으로 바인딩됨
    is_admin = models.BooleanField(default=False)
    
# 개발자가 의도하지 않은 필드가 업데이트될 수 있음

추출 내용:

• 프레임워크가 무엇을 "자동"으로 처리하는가
• 어떤 입력을 신뢰하는가
• 신뢰 경계(trust boundary)는 명확한가

패턴 3: Abstraction Leaks (추상화 누수)

// Express.js의 body-parser
app.use(express.json());
// 내부적으로 JSON.parse() 사용
// → prototype pollution 가능

추출 내용:

• 추상화가 숨기는 저수준 동작
• 저수준 취약점이 추상화를 통해 노출되는 경로
• 개발자가 인지하기 어려운 보안 결정

패턴 4: Confused Deputy (혼동된 대리인)

// Java URL.getHost()
URL url = new URL("http://[e-mail]");
String host = url.getHost(); // "attacker.com" 반환
// 하지만 브라우저는 example.com으로 해석할 수 있음

추출 내용:

• 같은 데이터를 다르게 해석하는 컴포넌트
• 파싱 불일치로 인한 보안 우회
• 표준 불일치 또는 모호성

패턴 5: Serialization Hazards (직렬화 위험)

// Java ObjectInputStream
ObjectInputStream ois = new ObjectInputStream(input);
Object obj = ois.readObject(); // RCE 위험

추출 내용:

• 직렬화 포맷의 메타데이터 신뢰
• Type confusion 가능성
• 역직렬화 시 자동 실행되는 코드 (gadgets)

패턴 6: Template Injection Surface

# Django/Jinja2
template = Template("Hello {{ name }}")
# 사용자 입력이 템플릿 컨텍스트에 들어가면?

추출 내용:

• 템플릿 엔진의 표현식 평가 능력
• Sandbox 탈출 방법
• 안전한 컨텍스트 분리 방법

소스 읽기 실행 방법

1. web_search로 GitHub 리포지토리 찾기
2. web_fetch로 핵심 소스 파일 조회
   - Security 관련 클래스/모듈
   - Configuration defaults
   - 데이터 바인딩/파싱 로직
3. 공식 문서의 Security 섹션 조회
4. 2단계에서 식별한 CVE의 패치 커밋 확인
5. 코드와 문서 간 불일치 식별

중요: 소스코드 인용 시 GitHub 링크와 파일명, 라인 번호 명시 예: SpringMVC DataBinder.java:245 또는 링크

---

4단계: 메타 패턴 추출 (Meta-Pattern Analysis)

개별 취약점이 아닌, 프레임워크의 철학과 설계가 만드는 보안 구조를 추출한다.

분석 프레임워크

각 메타 패턴에 대해:

### [번호]. [메타 패턴 이름] ([프레임워크/언어])

**설계 철학**: 이 패턴이 왜 존재하는가 (편의성, 성능, 추상화 등)

**구현 메커니즘**: 
- 소스코드 레벨에서 어떻게 구현되는가
- 관련 클래스/함수/모듈 (소스 링크)

**보안 함의**: 이 설계가 만드는 보안 리스크

**공격 벡터**:
- 구체적 공격 시나리오
- 코드 예제 (취약한 코드 vs 안전한 코드)

**실제 사례**: CVE, 보안 사건

**근본 원인 분석**: 
- 왜 이렇게 설계되었는가
- 대안은 무엇이었는가
- 왜 이 대안을 선택하지 않았는가

**완화 방법**: 
- 프레임워크 설정 변경
- 코드 패턴 변경
- 추가 보안 레이어

메타 패턴 카탈로그

다음은 자주 발견되는 메타 패턴들이다:

1. Convenience over Safety (편의성 > 안전성)

프레임워크가 개발 속도를 위해 보안을 희생한 설계
예: Auto-binding, Magic methods, Implicit conversions

2. Backward Compatibility Tax (하위 호환성 부담)

레거시 지원을 위해 불안전한 기능 유지
예: Insecure defaults maintained, Deprecated but available

3. Abstraction Opacity (불투명한 추상화)

추상화가 보안 결정을 숨김
예: ORM SQL generation, Template auto-escaping assumptions

4. Implicit Trust Boundaries (암묵적 신뢰 경계)

어디가 신뢰/비신뢰 경계인지 명확하지 않음
예: Request parameter auto-binding, Session data assumptions

5. Serialization as API (직렬화를 API로 사용)

직렬화 포맷을 통신/저장 포맷으로 사용
예: Java Serialization, Python Pickle, .NET BinaryFormatter

6. Parser Differential (파서 불일치)

같은 입력을 다르게 해석하는 컴포넌트들
예: URL parsing differences, HTTP header interpretation

7. Magic Method Invocation (매직 메소드 실행)

프레임워크가 자동으로 호출하는 메소드들
예: __wakeup(), __destruct(), lifecycle hooks

8. Configuration Complexity (설정 복잡성)

보안 설정이 너무 복잡하여 실수 유발
예: Spring Security DSL, CORS configuration

9. Defaults for Development (개발용 기본값)

개발 편의를 위한 기본값이 프로덕션에 유지됨
예: Debug mode, Error details, Sample credentials

10. Framework Lock-in Risk (프레임워크 종속 리스크)

프레임워크의 보안 메커니즘에만 의존
예: Framework-only validation, Built-in auth only

---

5단계: 문서 생성

출력 형식

# {프레임워크/언어} 소스코드 보안 분석: 메타 구조 직접 추출

> **분석 대상**: [프레임워크/언어 버전]
> **소스 조사**: [GitHub 리포지토리, 문서 URL]
> **분석 시점**: [날짜]
> **주요 CVE 반영**: [CVE 범위]

---

## Executive Summary

[3-5문장으로 핵심 발견사항 요약]

---

## 제1부: 프레임워크 설계 철학과 보안 트레이드오프

### 1. [메타 패턴 1]
### 2. [메타 패턴 2]
...

## 제2부: 소스코드 레벨 취약 구조

### N. [메타 패턴 N]
...

## 제3부: 언어 레벨 설계 문제 (해당 시)

### Language-Specific Hazards
...

## 제4부: 최신 CVE 및 실제 공격 사례

| CVE | 연도 | 근본 원인 | 영향받는 버전 | 메타 패턴 |
|-----|------|----------|--------------|----------|
| ... | ... | ... | ... | ... |

---

## 부록 A: 메타 패턴 ↔ 공격 ↔ 방어 매핑표

| 메타 패턴 | 대표 취약점 | 공격 기법 | 소스 위치 | 완화 방법 |
|----------|------------|----------|----------|----------|
| ... | ... | ... | ... | ... |

## 부록 B: 소스코드 보안 체크리스트

**설정 검증**
- [ ] 프로덕션에서 debug mode 비활성화
- [ ] 에러 상세 정보 노출 비활성화
...

**코드 패턴 검증**
- [ ] Mass assignment 방지 (whitelist 사용)
- [ ] 직렬화 사용 시 type 검증
...

## 부록 C: 안전한 코드 패턴 예제

### 취약한 패턴 vs 안전한 패턴

```java
// VULNERABLE
@RequestMapping("/user")
public User updateUser(@ModelAttribute User user) {
    return userRepository.save(user); // Mass assignment!
}

// SECURE
@RequestMapping("/user")
public User updateUser(@RequestBody UserUpdateDTO dto) {
    User user = userRepository.findById(dto.getId());
    user.setEmail(dto.getEmail()); // Explicit field mapping
    user.setName(dto.getName());
    return userRepository.save(user);
}

부록 D: 프레임워크 버전별 보안 변경사항

버전	보안 변경	Breaking Change	Migration
...	...	...	...

### 문서 품질 기준

- **메타 패턴 수**: 10-20개
- **소스코드 인용**: 각 패턴에 실제 소스 코드 링크 또는 인용
- **실용성**: 취약한 코드 vs 안전한 코드 비교 예제
- **매핑 테이블**: 메타 패턴↔공격↔방어 종합 매핑
- **체크리스트**: 즉시 적용 가능한 검증 리스트
- **언어**: 사용자 언어로 작성

### 파일 저장

/mnt/user-data/outputs/{프레임워크}_소스코드_보안분석.md

present_files로 사용자에게 제공

---

## 분석 깊이 조절

| 요청 수준 | 검색 횟수 | 소스 fetch | 메타 패턴 수 | 예시 |
|-----------|----------|-----------|------------|------|
| 간단 | 3-5회 | 2-4개 파일 | 5-8개 | "Spring MVC 보안 분석" |
| 보통 | 6-10회 | 5-10개 파일 | 10-15개 | "Spring Framework 전체 보안 구조" |
| 심층 | 10-20회 | 10-20개 파일 | 15-25개 | "Java 생태계 Deserialization 전체" |

---

## 프레임워크별 특화 가이드

### Spring Framework

핵심 분석 대상:

• Spring MVC: DataBinder, @ModelAttribute, @RequestBody
• Spring Security: SecurityContext, Authentication
• Spring Data: JPA, Query DSL, Projections
• Spring Boot: Auto-configuration, Actuator

소스 위치:

• github.com/spring-projects/spring-framework
• docs.spring.io/spring-framework/reference/

주요 메타 패턴:

• Mass Assignment via DataBinder
• SpEL Injection in expressions
• Actuator exposure

### Django

핵심 분석 대상:

• ORM: QuerySet, Model forms
• Template Engine: DTL, auto-escaping
• Middleware: Session, CSRF
• Settings: DEBUG, ALLOWED_HOSTS

소스 위치:

• github.com/django/django
• docs.djangoproject.com/

주요 메타 패턴:

• Mass Assignment via ModelForm
• Template injection via user templates
• Debug mode information disclosure

### Express.js

핵심 분석 대상:

• Middleware: body-parser, cookie-parser
• Routing: Route parameters, Query strings
• Template Engines: EJS, Pug

소스 위치:

• github.com/expressjs/express
• expressjs.com/

주요 메타 패턴:

• Prototype pollution via body-parser
• Path traversal in static file serving
• Template injection

### Java Standard Library

핵심 분석 대상:

• java.net.URL: Parsing, getHost()
• java.io: ObjectInputStream, Serialization
• java.security: XML parsers, XXE

소스 위치:

• github.com/openjdk/jdk
• docs.oracle.com/javase/

주요 메타 패턴:

• URL parsing confusion (getHost vs getAuthority)
• Deserialization RCE
• XXE in XML parsers

---

## 주의사항

### 소스 우선 원칙
- 블로그보다 실제 소스코드가 정확함
- 문서와 소스가 다를 경우 소스가 실제 동작임
- 버전별 차이 주의 (major.minor.patch)

### 설계 의도 이해
- "왜 이렇게 만들었는가"를 먼저 파악
- 보안과 다른 목표(성능, 호환성) 간 트레이드오프 이해
- 비난이 아닌 분석적 접근

### 실용성 중시
- 이론적 취약점보다 실제 exploit 가능성
- 완화 방법은 현실적이어야 함
- Breaking change vs 점진적 개선 고려

### 최신성
- 최근 2년 CVE 우선
- 최신 버전의 소스코드 기준
- Deprecated 기능 명시

### 저작권
- 소스코드 짧은 인용은 허용 (분석 목적)
- 긴 복사는 피하고 핵심만 발췌
- GitHub 링크 제공

---

## 참고 자료 (내부 사용)

### 주요 GitHub 리포지토리
- Spring: github.com/spring-projects/*
- Django: github.com/django/django
- Rails: github.com/rails/rails
- Express: github.com/expressjs/express
- ASP.NET: github.com/dotnet/aspnetcore

### 보안 데이터베이스
- NVD: nvd.nist.gov
- Snyk Vulnerability DB: snyk.io/vuln
- GitHub Security Advisories: github.com/advisories

### 연구 소스
- OWASP: owasp.org
- PortSwigger Research: portswigger.net/research
- BlackHat/DEF CON archives

### 공식 보안 가이드
- Spring Security Docs
- Django Security
- OWASP Framework Security