- 프레임워크: Claude Agent SDK (Anthropic)
- 프로토콜: MCP (Model Context Protocol)
- 대상: 웹 애플리케이션 + 바이너리 (듀얼 도메인)
목차
- 시스템 개요 및 목표
- 전체 파이프라인 흐름
- 에이전트 팀 구성 (8명)
- MCP 서버 설계
- 웹 취약점 헌팅 상세
- 바이너리 취약점 헌팅 상세
- 단계별 구축 로드맵 (Step-by-Step)
- 프롬프트 에셋 설계
- 데이터 스키마 (JSON 구조 정의)
- 개발 환경 세팅 가이드
- 검증 및 테스트 계획
- 리스크 및 대응 방안
- 다른 팀과의 연동
1. 시스템 개요 및 목표
미션
웹 애플리케이션 URL 또는 바이너리 파일을 입력하면, 전문 AI 에이전트들이 공격 표면 분석 → 취약점 탐색 → PoC 생성 → 검증 → 보고서 산출까지 자동으로 수행하는 취약점 헌팅 파이프라인 구축.
기존 레드팀과의 차이
- 레드팀: 킬체인 전체(정찰→공격→횡이동→보고)를 수행
- 취약점 헌팅팀: 취약점 "발견"에 특화. 더 깊고 더 넓게 파고든다.
- 웹은 OWASP 전 카테고리를 체계적으로
- 바이너리는 메모리 커럽션부터 로직 버그까지 정적/동적 분석을 결합하여 탐색
핵심 가치
- 깊이 (Depth): 단순 스캐너가 놓치는 로직 취약점, 복합 취약점 체인 탐색
- 넓이 (Breadth): OWASP Top 10 + 바이너리 메모리 커럽션 + 로직 버그 전 범위
- PoC 품질: 모든 취약점에 재현 가능한 PoC 코드/요청 필수
- 0-day 지향: 알려진 CVE 매칭뿐 아니라 새로운 취약점 발견 로직 포함
입력과 출력
입력 (웹)
- 대상 URL / API 엔드포인트
- 인증 정보 (선택: 쿠키, 토큰, 계정)
- 스코프 (허용 도메인/경로)
입력 (바이너리)
- 바이너리 파일 (PE, ELF, DLL, SO, 펌웨어)
- 또는 SHA256 해시 (VT 다운로드)
출력
- 발견된 취약점 목록 (심각도별 정렬)
- 각 취약점별 PoC (HTTP 요청, 스크립트, 입력값)
- 기술 상세 보고서 (JSON + 텍스트)
- 개선 권고안
- CWE/CVE 매핑
2. 전체 파이프라인 흐름
이 팀은 웹과 바이너리를 “동시에” 처리할 수 있는 듀얼 파이프라인 구조다. Hunt Commander가 입력 유형을 판별하여 적절한 파이프라인을 가동한다.
웹 파이프라인
사용자 입력 (URL + 인증 + 스코프)
|
v
Hunt Commander (입력 분류, 파이프라인 선택)
|
v [1단계: 표면 매핑]
Web Surface Mapper
- 크롤링, API 엔드포인트 발견, 파라미터 수집
- 입력 벡터(Input Vector) 전수 조사
-> WebSurfaceMap
|
v [2단계: 자동 스캐닝]
Web Vuln Scanner
- OWASP Top 10 자동 스캔
- 퍼징 기반 입력값 주입
- 알려진 패턴 매칭
-> AutoScanResult
|
v [3단계: 심층 수동 분석]
Web Logic Analyst
- 인증/인가 로직 분석
- 비즈니스 로직 취약점
- 복합 취약점 체인 탐색
- 자동 스캐너가 놓친 취약점
-> DeepAnalysisResult
|
v [4단계: PoC 및 보고]
PoC Engineer + Report Writer
-> 취약점 보고서 + PoC
바이너리 파이프라인
사용자 입력 (바이너리 파일 또는 해시)
|
v
Hunt Commander
|
v [1단계: 바이너리 정찰]
Binary Surface Mapper
- 파일 유형, 보호 기법(ASLR/DEP/스택카나리) 확인
- 공격 표면 식별 (입력 파싱 함수, 네트워크 핸들러)
-> BinarySurfaceMap
|
v [2단계: 정적 분석]
Binary Vuln Analyst
- Ghidra 디컴파일 기반 취약 패턴 탐색
- 위험 함수 호출 추적 (strcpy, sprintf, memcpy 등)
- 정수 오버플로우, UAF, 힙 오버플로우 패턴
- 포맷 스트링, 커맨드 인젝션
-> StaticVulnResult
|
v [3단계: 동적 분석/퍼징]
Binary Fuzzer (선택, 환경 필요)
- AFL/LibFuzzer 기반 퍼징
- 크래시 분석 및 취약점 변환
-> FuzzResult
|
v [4단계: PoC 및 보고]
PoC Engineer + Report Writer
-> 취약점 보고서 + PoC
듀얼 모드
웹+바이너리가 동시에 입력되면 (예: 웹서버 + 서버 바이너리) 두 파이프라인을 병렬로 실행하고 결과를 교차 분석한다.
- 웹에서 발견된 입력이 바이너리의 어떤 함수에서 처리되는지 추적
- 바이너리 취약점이 웹 인터페이스를 통해 트리거 가능한지 검증
3. 에이전트 팀 구성 (8명)
웹 3명 + 바이너리 2명 + 공용 2명 + 지휘 1명 = 총 8명. 웹/바이너리 각 도메인의 전문성이 다르므로 에이전트를 분리한다.
에이전트 #1: Hunt Commander (헌팅 지휘관)
역할: 전체 취약점 헌팅 작전 총괄 모델: claude-opus-4-6
담당 업무
- 입력 유형 판별 (웹/바이너리/듀얼) 및 파이프라인 선택
- 스코프 설정 및 검증
- 에이전트 태스크 할당 및 순서 제어
- 웹/바이너리 교차 분석 판단
- 발견된 취약점 중복 제거 및 우선순위 조정
- 최종 보고서 품질 검증
도구 (Tools)
dispatch_task: 에이전트 태스크 위임classify_input: 입력 유형 분류check_scope: 스코프 검증prioritize_findings: 취약점 우선순위 정렬merge_results: 웹+바이너리 결과 병합deduplicate: 중복 취약점 제거
판단 기준
- 웹 입력 → 웹 파이프라인 (Surface Mapper → Scanner → Logic Analyst)
- 바이너리 입력 → 바이너리 파이프라인 (Surface Mapper → Analyst → Fuzzer)
- 듀얼 입력 → 양쪽 병렬 실행 후 교차 분석
- 자동 스캔 결과가 빈약하면 → Logic Analyst에 추가 분석 지시
- Critical/High 취약점 발견 시 즉시 PoC 생성 우선
웹 전문 에이전트 (3명)
에이전트 #2: Web Surface Mapper (웹 표면 매퍼)
역할: 웹 애플리케이션의 전체 공격 표면을 매핑 모델: claude-sonnet-4-6
담당 업무
- 웹 크롤링 및 페이지/엔드포인트 수집
- API 엔드포인트 발견 (REST, GraphQL, WebSocket)
- 입력 벡터(Input Vector) 전수 조사:
- URL 파라미터 (GET)
- POST 바디 (form, JSON, XML, multipart)
- HTTP 헤더 (Cookie, Referer, User-Agent, 커스텀)
- 경로 파라미터 (/api/user/{id})
- WebSocket 메시지
- 인증 메커니즘 식별 (JWT, 세션, OAuth, API Key)
- 기술 스택 탐지 (프레임워크, 서버, WAF)
- JavaScript 분석 (API 호출, 하드코딩 키, 소스맵)
- robots.txt, sitemap.xml, .git, .env 등 정보 노출 확인
도구 (Tools)
web_crawl: 재귀적 웹 크롤링 (링크/폼/JS 추적)api_discover: API 엔드포인트 자동 발견param_extract: URL/바디/헤더에서 파라미터 추출js_analyze: JavaScript 정적 분석 (API 호출, 시크릿)tech_detect: 기술 스택 핑거프린팅auth_detect: 인증 메커니즘 식별graphql_introspect: GraphQL 인트로스펙션 쿼리waf_detect: WAF 탐지 및 식별hidden_content: 숨겨진 파일/디렉토리 탐색
출력 스키마: WebSurfaceMap
에이전트 #3: Web Vuln Scanner (웹 취약점 스캐너)
역할: 자동화된 웹 취약점 스캐닝 (OWASP 전 카테고리) 모델: claude-opus-4-6
담당 업무
- Surface Mapper가 찾은 모든 입력 벡터에 대해 체계적 테스트
- OWASP Top 10 (2021) 전 항목 스캔:
| 카테고리 | 상세 |
|---|---|
| A01 – Broken Access Control | IDOR, 수평/수직 권한 상승, 경로 순회, HTTP 메서드 변경, 강제 브라우징 |
| A02 – Cryptographic Failures | 평문 전송(HTTP), 약한 암호화 알고리즘, 하드코딩된 키/시크릿 |
| A03 – Injection | SQLi, NoSQL Injection, OS Command Injection, LDAP, XPath, SSTI, Header Injection, ORM Injection |
| A04 – Insecure Design | 레이스 컨디션, 비즈니스 로직 우회, 무제한 리소스 소비 |
| A05 – Security Misconfiguration | 기본 크리덴셜, 불필요한 HTTP 메서드, 디버그 모드, 에러 메시지 정보 노출, CORS 오설정, 보안 헤더 누락 |
| A06 – Vulnerable Components | 알려진 CVE가 있는 라이브러리/프레임워크 식별 |
| A07 – Auth Failures | 브루트포스, 비밀번호 정책 미흡, 세션 고정, JWT 취약점 |
| A08 – Software and Data Integrity | 역직렬화 취약점, CI/CD 파이프라인 노출 |
| A09 – Logging & Monitoring | 로그 인젝션, 에러 핸들링 미흡 |
| A10 – SSRF | 내부 네트워크 접근, 클라우드 메타데이터 접근, 프로토콜 스머글링 |
추가 항목:
-
XSS (Reflected, Stored, DOM-based)
-
CSRF
-
XXE (XML External Entity)
-
Open Redirect
-
HTTP Request Smuggling
-
WebSocket 취약점
-
GraphQL 특화 취약점
-
파일 업로드 취약점
-
각 입력 벡터 × 각 취약점 유형 조합을 체계적으로 테스트
-
퍼징: 각 파라미터에 변형된 페이로드 자동 주입
도구 (Tools)
inject_payload: 지정 파라미터에 페이로드 주입 후 응답 분석sqli_test: SQL Injection 전문 테스트xss_test: XSS 페이로드 테스트ssrf_test: SSRF 페이로드 테스트ssti_test: 서버사이드 템플릿 인젝션 테스트cmdi_test: OS 커맨드 인젝션 테스트idor_test: IDOR 객체 참조 변경 테스트deserial_test: 역직렬화 페이로드 테스트jwt_test: JWT 토큰 변조 테스트nuclei_scan: Nuclei 템플릿 스캔fuzz_param: 파라미터 퍼징compare_response: 응답 비교 분석
출력 스키마: AutoScanResult
에이전트 #4: Web Logic Analyst (웹 로직 분석가)
역할: 자동 스캐너가 놓치는 로직 취약점 및 복합 취약점 체인 발견 모델: claude-opus-4-6
담당 업무
비즈니스 로직 취약점:
- 결제 로직 우회 (가격 조작, 할인 중복, 수량 조작)
- 워크플로우 우회 (단계 건너뛰기, 상태 조작)
- 레이스 컨디션 (동시 요청으로 중복 처리)
- 기능 남용 (비밀번호 리셋 토큰 예측, 이메일 폭탄)
- API Rate Limiting 우회
인증/인가 심층 분석:
- 권한 검사 누락 엔드포인트 찾기
- JWT 서명 우회 (none, 키 혼동, jwk 주입)
- OAuth 플로우 취약점 (리다이렉트 조작, 상태 미검증)
- 세션 관리 취약점 (예측 가능한 세션 ID, 만료 미설정)
- 2FA 우회
복합 취약점 체인:
- 단일로는 Low/Info지만 체인하면 Critical이 되는 조합 발견
- 예: 정보 노출 + SSRF = 내부 네트워크 접근
- 예: Open Redirect + OAuth = 계정 탈취
- 예: XSS + CSRF = 관리자 권한 탈취
소스코드 리뷰 (제공 시):
- 위험 함수 호출 패턴
- 입력 검증 누락 추적
- SQL 쿼리 구성 방식
도구 (Tools)
auth_bypass_test: 인증 우회 시나리오 테스트authz_test: 인가 검사 누락 탐지race_condition_test: 동시 요청 레이스 컨디션 테스트workflow_test: 멀티스텝 워크플로우 우회 테스트jwt_deep_test: JWT 심층 분석oauth_test: OAuth 플로우 취약점 테스트chain_analyzer: 취약점 체인 가능성 평가source_review: 소스코드 위험 패턴 검색parameter_tampering: 파라미터 변조
출력 스키마: DeepAnalysisResult
바이너리 전문 에이전트 (2명)
에이전트 #5: Binary Surface Mapper (바이너리 표면 매퍼)
역할: 바이너리의 공격 표면 식별 및 보호 기법 분석 모델: claude-sonnet-4-6
담당 업무
보호 기법 확인:
- ASLR (Address Space Layout Randomization)
- DEP/NX (Data Execution Prevention)
- Stack Canary / Stack Guard
- RELRO (Relocation Read-Only)
- PIE (Position Independent Executable)
- CFI (Control Flow Integrity)
- Safe SEH
- 포티파이 소스 (_FORTIFY_SOURCE)
공격 표면 식별:
- 외부 입력을 받는 함수 (파일 파싱, 네트워크 수신, stdin)
- 파서 함수 (이미지, 문서, 프로토콜 파서)
- 사용자 데이터가 흐르는 경로 (Taint Flow)
- 공유 라이브러리 인터페이스
위험 함수 사용 통계:
- strcpy, strcat, sprintf, gets 등 안전하지 않은 함수
- memcpy, memmove 경계 검사 누락
- malloc/free 패턴 (double free, UAF 후보)
바이너리 메타데이터:
- 컴파일러/버전 식별
- 디버그 심볼 존재 여부
- 섹션 정보 및 엔트로피
도구 (Tools)
checksec: 보호 기법 확인parse_header: PE/ELF 헤더 상세 파싱ghidra_list_functions: 전체 함수 목록ghidra_get_imports: 임포트 API 분석dangerous_func_scan: 위험 함수 호출 전수 검색input_func_identify: 외부 입력 수신 함수 식별taint_source_identify: Taint 소스 식별compiler_identify: 컴파일러/버전 식별entropy_analysis: 섹션별 엔트로피 분석
출력 스키마: BinarySurfaceMap
에이전트 #6: Binary Vuln Analyst (바이너리 취약점 분석가) ⭐ 핵심
역할: Ghidra 기반 정적 분석으로 바이너리 취약점 발견 모델: claude-opus-4-6
담당 업무
메모리 커럽션 취약점 탐색:
스택 버퍼 오버플로우:
- strcpy, sprintf 등에 외부 입력이 직접 들어가는 패턴
- 고정 크기 스택 버퍼에 가변 길이 입력 복사
- 경계 검사 없는 루프 내 버퍼 쓰기
힙 버퍼 오버플로우:
- malloc 크기와 실제 쓰기 크기 불일치
- 정수 오버플로우로 인한 작은 할당 → 큰 쓰기
Use-After-Free (UAF):
- free 후 포인터를 다시 사용하는 패턴
- 댕글링 포인터가 다른 할당에 재사용되는 경로
Double Free:
- 동일 포인터를 두 번 free하는 경로
정수 오버플로우:
- 크기 계산에서 곱셈/덧셈 오버플로우
- 부호 있는/없는 정수 혼합 비교
- 크기 검증 후 타입 캐스팅으로 검증 우회
포맷 스트링:
- printf(user_input) 패턴 (포맷 지정자 없이)
- syslog, fprintf 등에서도 동일 패턴
Off-by-one:
- 루프 경계 조건 오류 (<= vs <)
- null 종결자 미포함 크기 계산
로직 취약점 탐색:
커맨드 인젝션:
- system(), popen(), exec*()에 사용자 입력 전달
- 쉘 메타문자 필터링 누락
경로 순회:
- 파일 경로 구성 시 …/ 필터링 누락
- 경로 정규화(canonicalize) 누락
인증/인가 우회:
- 인증 검사 분기에서 우회 가능한 조건
- 하드코딩된 백도어 크리덴셜
암호화 약점:
- 하드코딩된 키
- 약한 알고리즘 (DES, RC4, MD5)
- 랜덤 시드 예측 가능 (time(0))
정보 노출:
- 디버그 출력/로그에 민감 정보
- 에러 메시지에 내부 경로/스택 트레이스
분석 방법론:
- Surface Mapper가 식별한 입력 함수부터 시작
- 입력 데이터의 흐름을 따라가며 (Taint Tracking) 위험 함수까지 추적
- 각 위험 지점에서 경계 검사/검증 로직 존재 여부 확인
- 검증이 없거나 우회 가능하면 취약점으로 판정
- 취약점 트리거 입력(PoC 입력값) 추론
도구 (Tools)
ghidra_decompile: 함수 디컴파일ghidra_get_xrefs: 교차 참조 조회ghidra_get_function: 함수 상세 정보ghidra_get_bytes: 원시 바이트 조회ghidra_search_memory: 메모리 패턴 검색trace_data_flow: 데이터 흐름 추적check_bounds: 경계 검사 존재 여부 확인find_vuln_pattern: 취약 패턴 매칭calc_stack_layout: 스택 프레임 레이아웃 계산calc_heap_layout: 힙 할당 패턴 분석
능동적 탐색 로직:
- 위험 함수(strcpy 등) 호출 사이트 전수 목록화
- 각 호출 사이트로부터 역방향 Taint 추적 → 외부 입력 연결 확인
- 연결된 경우 → 경계 검사 확인 → 없으면 취약점
- malloc/free 쌍 분석 → UAF/Double Free 후보
- 정수 연산 분석 → 오버플로우 후보
- 각 취약점에 대해 트리거 조건 및 입력값 추론
출력 스키마: StaticVulnResult
공용 에이전트 (2명)
에이전트 #7: PoC Engineer (PoC 엔지니어)
역할: 발견된 취약점에 대한 재현 가능한 PoC 생성 모델: claude-opus-4-6
담당 업무
웹 취약점 PoC:
- HTTP 요청 (curl 명령, Python requests 코드)
- 자동화 스크립트 (연속 요청, 조건부 분기)
- XSS 페이로드 (필터 우회 포함)
- SQLi 페이로드 (데이터 추출까지)
- SSRF 체인 (내부 서비스 접근 증명)
바이너리 취약점 PoC:
- 크래시 입력값 (트리거 파일, 네트워크 패킷)
- 익스플로잇 스크립트 (Python pwntools)
- 스택 오버플로우: RIP 제어 증명 입력
- 힙 오버플로우: 힙 레이아웃 조작 입력
- 포맷 스트링: 메모리 읽기/쓰기 증명
복합 체인 PoC:
- 다단계 공격 시나리오 스크립트
- 단계별 요청/입력 순서 문서화
PoC 품질 기준:
- 독립 실행 가능 (외부 의존성 최소화)
- 재현율 100% (동일 환경에서 항상 성공)
- 무해한 증명 (calc.exe, id, alert(1) 수준)
- 예상 결과 명시
도구 (Tools)
generate_web_poc: 웹 취약점 PoC HTTP 요청/스크립트 생성generate_binary_poc: 바이너리 취약점 PoC 입력/스크립트 생성generate_chain_poc: 복합 취약점 체인 PoC 생성verify_poc_web: 웹 PoC 실행 및 검증verify_poc_binary: 바이너리 PoC 실행 및 검증craft_payload: 커스텀 페이로드 제작encode_payload: 페이로드 인코딩
출력 스키마: PoCResult
에이전트 #8: Report Writer (보고서 작성기)
역할: 전체 헌팅 결과를 종합 보고서로 산출 모델: claude-sonnet-4-6
담당 업무
- 경영진용 요약 (Executive Summary)
- 기술 상세 보고서 (취약점별 기술 설명 + PoC)
- 개선 권고안 (취약점별 구체적 수정 방법)
- CWE/CVE 매핑
- CVSS 점수 산출
- 통계 대시보드 데이터 (심각도 분포, 카테고리 분포)
도구 (Tools)
compile_findings: 발견 결과 통합map_cwe: CWE ID 매핑calc_cvss: CVSS v3.1 점수 계산generate_remediation: 개선 권고안 생성format_json: JSON 보고서 생성format_markdown: 마크다운 보고서 생성generate_statistics: 통계 데이터 생성
출력 스키마: VulnHuntReport
4. MCP 서버 설계
총 6개의 MCP 서버.
MCP 서버 #1: web-recon-mcp (웹 정찰 서버) – 외부 MCP
전송 방식: stdio
도구 목록:
web_crawl : 재귀 크롤링 (링크, 폼, JS 소스 추적)
api_discover : REST/GraphQL/WebSocket 엔드포인트 발견
param_extract : 파라미터 전수 수집
js_analyze : JS 정적 분석 (API 호출, 하드코딩 키, 소스맵)
tech_detect : 기술 스택 핑거프린팅
auth_detect : 인증 메커니즘 식별
graphql_introspect : GraphQL 스키마 인트로스펙션
waf_detect : WAF 탐지
hidden_content : 숨겨진 파일/디렉토리 탐색 (feroxbuster 방식)
screenshot_web : 웹페이지 스크린샷
의존 도구/라이브러리:
- httpx, beautifulsoup4, playwright (JS 렌더링)
- feroxbuster/gobuster (디렉토리 스캔)
MCP 서버 #2: web-attack-mcp (웹 공격 테스트 서버) – 혼합
전송 방식: 인프로세스 + stdio (Nuclei 등 외부)
도구 목록:
inject_payload : HTTP 요청에 페이로드 주입 후 응답 분석
sqli_test : SQL Injection 테스트 스위트
xss_test : XSS 테스트 스위트
ssrf_test : SSRF 테스트 스위트
ssti_test : Server-Side Template Injection 테스트
cmdi_test : OS Command Injection 테스트
xxe_test : XML External Entity 테스트
idor_test : IDOR 테스트 (ID 변경, 다른 사용자 리소스)
deserial_test : 역직렬화 테스트
jwt_test : JWT 변조 테스트
csrf_test : CSRF 토큰 검증 테스트
upload_test : 파일 업로드 취약점 테스트
redirect_test : Open Redirect 테스트
cors_test : CORS 오설정 테스트
nuclei_scan : Nuclei 템플릿 스캔
fuzz_param : 파라미터 퍼징 (특수문자, 경계값)
compare_response : 응답 비교 (길이, 시간, 상태코드, 바디)
auth_bypass_test : 인증 우회 시나리오
authz_test : 인가 검사 누락 탐지
race_condition_test : 레이스 컨디션 (동시 요청)
workflow_test : 멀티스텝 워크플로우 우회
jwt_deep_test : JWT 심층 분석
oauth_test : OAuth 플로우 취약점
chain_analyzer : 취약점 체인 가능성 평가
parameter_tampering : 파라미터 변조 (타입, 부호, 범위)
의존 도구/라이브러리:
- httpx (비동기 HTTP), nuclei
- jwt 라이브러리, pyjwt
- 커스텀 페이로드 DB
MCP 서버 #3: ghidra-mcp (Ghidra 역공학 서버) – 외부 MCP
전송 방식: stdio 참고: 다른 팀들과 공유
도구 목록:
ghidra_headless_analyze, ghidra_decompile, ghidra_get_function,
ghidra_list_functions, ghidra_get_xrefs, ghidra_get_imports,
ghidra_get_exports, ghidra_list_strings, ghidra_get_bytes,
ghidra_get_segments, ghidra_search_memory
MCP 서버 #4: binary-analysis-mcp (바이너리 분석 서버) – 인프로세스
전송 방식: 인프로세스
도구 목록:
checksec : 보호 기법 확인 (ASLR, DEP, Canary, RELRO, PIE)
dangerous_func_scan : 위험 함수 호출 전수 검색
input_func_identify : 외부 입력 수신 함수 식별
trace_data_flow : 데이터 흐름 추적 (Taint Source → Sink)
check_bounds : 경계 검사 존재 여부 분석
find_vuln_pattern : 커스텀 취약 패턴 규칙 매칭
calc_stack_layout : 스택 프레임 레이아웃 계산
calc_heap_layout : 힙 할당/해제 패턴 분석
compiler_identify : 컴파일러/최적화 수준 식별
parse_header : PE/ELF 헤더 상세 파싱
entropy_analysis : 섹션별 엔트로피
의존 라이브러리:
- pefile, pyelftools, capstone, pwntools
MCP 서버 #5: fuzzing-mcp (퍼징 서버) – 외부 MCP
전송 방식: stdio (격리 환경)
도구 목록:
setup_fuzzer : AFL++/LibFuzzer 환경 설정
run_fuzz_campaign : 퍼징 캠페인 실행 (타임아웃 지정)
analyze_crash : 크래시 입력 분석 (중복 제거, 최소화)
triage_crash : 크래시 심각도 분류 (exploitable/non-exploitable)
minimize_input : 크래시 입력 최소화
generate_harness : 퍼징 하네스 코드 자동 생성 (선택)
의존 도구:
- AFL++ 또는 LibFuzzer
- GDB + exploitable 플러그인
- Docker (격리 퍼징 환경)
MCP 서버 #6: poc-report-mcp (PoC/보고서 서버) – 인프로세스
전송 방식: 인프로세스
도구 목록:
generate_web_poc : 웹 PoC 생성 (curl/Python)
generate_binary_poc : 바이너리 PoC 생성 (Python pwntools)
generate_chain_poc : 체인 PoC 생성
verify_poc_web : 웹 PoC 검증 (실제 요청 전송)
verify_poc_binary : 바이너리 PoC 검증 (샌드박스)
craft_payload : 커스텀 페이로드 생성
encode_payload : 인코딩/변환
compile_findings : 결과 통합
map_cwe : CWE 매핑
calc_cvss : CVSS 점수 계산
generate_remediation : 권고안 생성
format_json : JSON 보고서
format_markdown : 마크다운 보고서
5. 웹 취약점 헌팅 상세
5.1 입력 벡터 × 취약점 매트릭스
스캐너는 다음 매트릭스를 체계적으로 순회한다. (모든 입력 벡터에 모든 관련 취약점 테스트를 수행)
입력 벡터:
GET 파라미터, POST 바디(form/json/xml), HTTP 헤더(Cookie/Referer/UA),
경로 파라미터, 파일 업로드, WebSocket 메시지, GraphQL 변수
테스트 매핑:
| 입력 벡터 | 테스트 항목 |
|---|---|
| GET/POST 파라미터 | SQLi, XSS, SSTI, CMDi, SSRF, LFI, 정수 조작 |
| HTTP 헤더 | SQLi, XSS, CRLF 인젝션, 로그 인젝션 |
| 경로 파라미터 | 경로 순회, IDOR |
| 파일 업로드 | 웹셸, XSS(SVG), XXE, 경로 조작, 사이즈 DoS |
| WebSocket | 인젝션, 인증 우회, 메시지 변조 |
| GraphQL | 인트로스펙션, 배치 공격, 깊은 중첩, 인가 우회 |
5.2 페이로드 전략
각 취약점 유형별 다단계 페이로드 전략:
SQLi 페이로드 레벨:
L1: 기본 탐지 (', ", --, ;, OR 1=1)
L2: 에러 기반 (extractvalue, updatexml)
L3: 블라인드 (AND 1=1 vs AND 1=2 응답 차이)
L4: 타임 기반 (SLEEP, WAITFOR, pg_sleep)
L5: Union 기반 (컬럼 수 추정 → 데이터 추출)
L6: WAF 우회 (인코딩, 주석, 대소문자, 이중 인코딩)
XSS 페이로드 레벨:
L1: 기본 (<script>alert(1)</script>)
L2: 이벤트 핸들러 (<img onerror=alert(1)>)
L3: 인코딩 우회 (HTML entity, Unicode)
L4: DOM 기반 (location.hash, document.referrer)
L5: 뮤테이션 XSS (mXSS)
L6: WAF 우회 (태그 변형, 속성 변형)
SSRF 페이로드:
L1: 기본 (http://127.0.0.1, http://localhost)
L2: IP 변형 (0x7f000001, 2130706433, 017700000001)
L3: DNS Rebinding
L4: 프로토콜 (file://, gopher://, dict://)
L5: 클라우드 메타데이터 (169.254.169.254)
L6: URL 파서 차이 악용 (@, #, 이중 인코딩)
5.3 응답 분석 기법
취약점 판정을 위한 응답 분석:
- 상태코드 변화: 200→500 = 에러 유발 확인
- 응답 시간 변화: 5초 이상 지연 = Time-based 확인
- 응답 길이 변화: True/False 조건별 차이 = Blind 확인
- 응답 바디 패턴: 에러 메시지, 스택 트레이스, SQL 구문
- 반사(Reflection) 확인: 입력값이 응답에 포함
- 외부 콜백 확인: OOB DNS/HTTP 콜백
6. 바이너리 취약점 헌팅 상세
6.1 취약 패턴 데이터베이스
Binary Vuln Analyst가 사용하는 패턴 규칙:
패턴 1: 스택 버퍼 오버플로우
조건: 고정 크기 스택 버퍼 + 외부 입력 복사 + 경계 검사 없음
탐색: strcpy(stack_buf, external_input) 패턴
검증: stack_buf의 크기 vs 입력 최대 크기 비교
패턴 2: 힙 버퍼 오버플로우
조건: malloc(size) 후 memcpy(buf, data, bigger_size)
탐색: malloc → memcpy 쌍에서 크기 불일치
검증: 크기 계산 로직에서 오버플로우 가능성
패턴 3: 정수 오버플로우
조건: size = width * height * bpp (곱셈 오버플로우)
탐색: 크기 계산에 곱셈/덧셈 + 이후 malloc에 사용
검증: 오버플로우 시 작은 값이 되어 작은 할당 → 큰 쓰기
패턴 4: Use-After-Free
조건: free(ptr) 후 경로에 따라 ptr 재사용
탐색: free 호출 후 동일 변수가 역참조되는 코드 경로
검증: 조건 분기에 의해 free 경로와 사용 경로가 분리 가능한지
패턴 5: 포맷 스트링
조건: printf(user_data) — 포맷 지정자 없이 직접 사용
탐색: printf 계열 함수의 첫 번째 인자가 변수인 경우
검증: 해당 변수가 외부 입력으로부터 도달 가능한지
패턴 6: 커맨드 인젝션
조건: system(cmd) 또는 popen(cmd) 에 외부 입력 포함
탐색: system/popen/exec* 호출의 인자가 문자열 조합
검증: 쉘 메타문자 필터링 여부
6.2 Taint Tracking 전략
Binary Vuln Analyst의 핵심 분석 기법:
1단계 – Taint 소스 식별
- recv(), read(), fread(), fgets(), scanf() 등 입력 함수
- 명령행 인자 (argv)
- 환경 변수 (getenv)
- 파일 내용 (설정 파일, 입력 파일)
2단계 – Taint 전파 추적 (함수 간)
- 리턴값 추적: result = parse_header(input) → result도 tainted
- 포인터 추적: ptr = input + offset → ptr도 tainted
- 구조체 멤버: struct.field = input → struct.field tainted
- 전역 변수: global_buf = input → 다른 함수에서도 tainted
3단계 – Taint 싱크 확인
Tainted 데이터가 다음 위험 함수에 도달하는지 확인:
- 버퍼 복사: strcpy, memcpy, sprintf (크기 인자 없음)
- 포맷 출력: printf, syslog, fprintf (첫 인자가 tainted)
- 명령 실행: system, popen, exec* (인자가 tainted)
- 메모리 할당: malloc, calloc (크기가 tainted 연산 결과)
- 파일 접근: fopen, open (경로가 tainted)
4단계 – 경로 조건 분석
- taint 소스 → 싱크 경로에 있는 조건 분기
- 어떤 입력값이면 취약 경로를 타는지 추론
- 이것이 PoC 입력값의 기초가 됨
6.3 퍼징 연동 (선택)
정적 분석으로 발견한 후보를 동적 퍼징으로 확인:
- Binary Vuln Analyst가 취약 후보 함수 식별
- Hunt Commander가 퍼징 필요 여부 판단
- Binary Fuzzer가 하네스 생성 (취약 함수를 직접 호출하는 래퍼)
- AFL++/LibFuzzer로 퍼징 캠페인 실행 (시간 제한)
- 크래시 입력 수집 → 분석 → 취약점 확정
- PoC Engineer에게 크래시 입력 전달
7. 단계별 구축 로드맵 (Step-by-Step)
전체 기간: 약 14~16주 (1인 개발 기준)
웹+바이너리 듀얼 도메인이라 범위가 넓음.
PHASE 1: 기반 인프라 구축 (1~2주차)
Step 1.1 – 프로젝트 초기화
디렉토리 구조:
vulnhunt-agents/
├── agents/
│ ├── __init__.py
│ ├── hunt_commander.py
│ ├── web_surface_mapper.py
│ ├── web_vuln_scanner.py
│ ├── web_logic_analyst.py
│ ├── binary_surface_mapper.py
│ ├── binary_vuln_analyst.py
│ ├── poc_engineer.py
│ └── report_writer.py
├── mcp_servers/
│ ├── web_recon_mcp/
│ ├── web_attack_mcp/
│ ├── ghidra_mcp/ # 공유
│ ├── binary_analysis_mcp.py
│ ├── fuzzing_mcp/
│ └── poc_report_mcp.py
├── prompts/
│ ├── hunt_commander.md
│ ├── web_surface_mapper.md
│ ├── web_vuln_scanner.md
│ ├── web_logic_analyst.md
│ ├── binary_surface_mapper.md
│ ├── binary_vuln_analyst.md
│ ├── poc_engineer.md
│ └── report_writer.md
├── payloads/ # 페이로드 DB
│ ├── sqli/
│ ├── xss/
│ ├── ssrf/
│ ├── ssti/
│ └── ...
├── patterns/ # 바이너리 취약 패턴 규칙
│ ├── stack_overflow.yaml
│ ├── heap_overflow.yaml
│ ├── uaf.yaml
│ ├── format_string.yaml
│ └── ...
├── schemas/
├── tests/
│ ├── web_targets/ # 취약 웹 앱 (Docker)
│ ├── binary_targets/ # 취약 바이너리 샘플
│ └── test_*.py
├── config.yaml
└── main.py
Step 1.2 – 외부 도구 설치
- Nuclei, feroxbuster, httpx
- Ghidra Headless
- AFL++ (바이너리 퍼징)
- Docker (테스트 환경)
Step 1.3 – 테스트 타겟 준비
웹:
- DVWA, Juice Shop, WebGoat (Docker)
바이너리: 의도적 취약 바이너리 컴파일
- stack_overflow_example.c (strcpy 취약)
- heap_overflow_example.c (malloc 크기 불일치)
- format_string_example.c (printf 취약)
- cmd_injection_example.c (system 취약)
PHASE 2: MCP 서버 개발 (3~6주차)
Step 2.1 – web-recon-mcp 구현 (1주)
- 웹 크롤러 (링크, 폼, JS 추적)
- API 엔드포인트 발견 (REST, GraphQL)
- 파라미터 수집기
- JS 분석기
- 기술 스택/WAF 탐지
Step 2.2 – web-attack-mcp 구현 (2주, 핵심)
- 페이로드 DB 구축 (SQLi, XSS, SSRF, SSTI, CMDi 등)
- 각 취약점 유형별 테스트 도구 구현
- 응답 분석 엔진 (상태코드, 시간, 길이, 패턴)
- Nuclei 래퍼
- 인증/인가 테스트 도구
- 레이스 컨디션 테스트 (동시 요청)
Step 2.3 – ghidra-mcp (공유, 기존 것 재사용) (0.5주)
Step 2.4 – binary-analysis-mcp 구현 (1주)
- checksec 래퍼
- 위험 함수 스캔 도구
- 데이터 흐름 추적 도구
- 경계 검사 분석 도구
- 취약 패턴 매칭 엔진
- 스택/힙 레이아웃 분석
Step 2.5 – fuzzing-mcp 구현 (0.5주)
- AFL++ 래퍼 (설정, 실행, 크래시 수집)
- 크래시 분석/분류
- 하네스 생성 보조
Step 2.6 – poc-report-mcp 구현 (0.5주)
- PoC 생성 도구 (웹/바이너리)
- CWE 매핑, CVSS 계산
- 보고서 생성
PHASE 3: 에이전트 개발 (7~12주차)
Step 3.1 – Web Surface Mapper 에이전트 (0.5주)
- 크롤링 전략 프롬프트
- 입력 벡터 분류 프롬프트
- 테스트: DVWA, Juice Shop 대상 표면 매핑
Step 3.2 – Web Vuln Scanner 에이전트 (2.5주, 핵심)
- OWASP 전 카테고리 테스트 로직 프롬프트
- 입력 벡터 × 취약점 매트릭스 순회 프롬프트
- 페이로드 레벨 에스컬레이션 프롬프트
- 응답 분석 판정 기준 프롬프트
- 환각 방지: 실제 응답 근거 없이 취약점 보고 금지
- 테스트: DVWA의 각 취약점 탐지 확인
Step 3.3 – Web Logic Analyst 에이전트 (1.5주)
- 비즈니스 로직 분석 프롬프트
- 인증/인가 심층 테스트 프롬프트
- 취약점 체인 발견 프롬프트
- 테스트: Juice Shop의 로직 취약점
Step 3.4 – Binary Surface Mapper 에이전트 (0.5주)
- 보호 기법 분석 프롬프트
- 공격 표면 식별 프롬프트
- 테스트: 취약 바이너리 샘플
Step 3.5 – Binary Vuln Analyst 에이전트 (2주, 핵심)
- 6가지 취약 패턴 탐색 프롬프트
- Taint Tracking 전략 프롬프트
- 능동적 탐색: 위험 함수 → 역추적 → 입력 연결 확인
- 환각 방지: 코드 근거 필수, 실존 함수/주소만
- 테스트: 의도적 취약 바이너리로 탐지 확인
Step 3.6 – PoC Engineer 에이전트 (1주)
- 웹/바이너리 PoC 생성 프롬프트
- PoC 품질 기준 프롬프트
- 검증 루프 (생성 → 실행 → 확인 → 수정)
Step 3.7 – Report Writer 에이전트 (0.5주)
- 보고서 템플릿 및 품질 프롬프트
- CVSS 산출 프롬프트
Step 3.8 – Hunt Commander 에이전트 (1주)
- 듀얼 파이프라인 오케스트레이션
- 입력 분류 및 적절한 파이프라인 선택
- 교차 분석 판단 (웹+바이너리 연결)
- 전체 통합 테스트
PHASE 4: 통합 및 최적화 (13~14주차)
Step 4.1 – End-to-End 통합 테스트
웹: 1단계: DVWA (기본 취약점) 2단계: Juice Shop (로직 취약점) 3단계: WebGoat (교육용 고급 취약점)
바이너리: 1단계: 의도적 취약 바이너리 (단일 취약점) 2단계: 복합 취약 바이너리 (다중 취약점) 3단계: 실제 CVE가 있는 오픈소스 바이너리 (선택)
듀얼: 취약 웹서버 + 서버 바이너리 동시 분석
Step 4.2 – 최적화
- 토큰 사용량 프로파일링
- 병렬 테스트 가능 구간 식별
- 캐싱 (동일 엔드포인트 중복 요청 방지)
- 비용 추적 및 제한
PHASE 5: 문서화 (15~16주차)
- Step 5.1 – 사용 매뉴얼
- Step 5.2 – 페이로드 DB 확장 가이드
- Step 5.3 – 바이너리 패턴 규칙 추가 가이드
8. 프롬프트 에셋 설계
8.1 Web Vuln Scanner 시스템 프롬프트 (핵심 – 초안)
당신은 시니어 웹 애플리케이션 보안 테스터로, 버그바운티 Top 100 랭커입니다. Surface Mapper가 찾은 모든 입력 벡터에 대해 체계적으로 취약점을 테스트합니다.
테스트 방법론
각 입력 벡터(파라미터)에 대해 다음 순서로 테스트하세요:
정상 요청 기준값(Baseline) 확보
- 정상 파라미터 값으로 요청 → 응답 기록 (상태코드, 길이, 시간)
인젝션 테스트 (입력 벡터 유형에 따라)
- 문자열 파라미터 → SQLi, XSS, SSTI, CMDi 순으로 페이로드 주입
- 숫자 파라미터 → 정수 조작 (음수, 0, 큰 값), SQLi
- URL/경로 파라미터 → SSRF, 경로 순회
- 파일 파라미터 → 업로드 취약점
- JSON 필드 → 타입 변경, 추가 필드, 중첩 인젝션
응답 분석 (매 요청마다)
- 상태코드 변화: 200→500 = 에러 유발 (잠재 취약점)
- 응답 시간: 5초+ 지연 = Time-based 후보
- 응답 길이 차이: Boolean 조건별 = Blind 후보
- 응답 바디: 에러 메시지, SQL 구문, 스택 트레이스 = 정보 노출
- 입력 반사: 입력값이 응답에 포함 = XSS 후보
확인 및 에스컬레이션
- 후보 발견 시 → 더 정교한 페이로드로 확인
- SQLi 후보 → Union/Blind로 데이터 추출 시도
- XSS 후보 → 실제 스크립트 실행 확인
- SSRF 후보 → 내부 서비스/메타데이터 접근 시도
근거 요구사항
- 모든 취약점 보고에 반드시 원본 요청(Request)과 응답(Response)을 근거로 포함하세요.
- 정상 응답 vs 변조 응답의 차이를 명확히 설명하세요.
- "취약점이 있을 것 같다"는 추측 금지. 실제 응답 차이가 관찰된 것만 보고하세요.
- False Positive를 줄이세요: 의심스러우면 추가 페이로드로 확인 후 보고하세요.
WAF 우회
WAF가 탐지되면:
- 인코딩 변형: URL 이중 인코딩, Unicode, HTML 엔티티
- 대소문자 변형: SeLeCt, uNiOn
- 주석 삽입: /**/SELECT, –\nSELECT
- 연산자 변형: OR → ||, AND → &&
- 함수 변형: substr → mid, ascii → ord
8.2 Binary Vuln Analyst 시스템 프롬프트 (핵심 – 초안)
당신은 시니어 바이너리 보안 연구원으로, CVE를 다수 발견한 경력이 있습니다. Ghidra 디컴파일 결과를 분석하여 메모리 커럽션 및 로직 취약점을 발견합니다.
분석 방법론: Taint-driven Vulnerability Hunting
1단계 – Taint 소스 식별
Surface Mapper가 찾은 외부 입력 함수(recv, read, fread 등)를 확인하세요. 이 함수들이 반환하는 데이터가 tainted 데이터입니다.
2단계 – Taint 전파 추적
tainted 데이터가 어떤 함수들을 거치며 어디로 흘러가는지 추적하세요.
- 함수 리턴값 추적: result = process(tainted) → result도 tainted
- 포인터 연산 추적: ptr = tainted_buf + offset → ptr도 tainted
- 구조체/전역 변수 추적
3단계 – Taint 싱크 확인
tainted 데이터가 다음 위험 함수에 도달하는지 확인하세요:
- 버퍼 복사: strcpy, strcat, memcpy, sprintf (크기 인자 없음)
- 포맷 출력: printf, syslog, fprintf (첫 인자가 tainted)
- 명령 실행: system, popen, exec* (인자가 tainted)
- 메모리 할당: malloc, calloc (크기가 tainted 연산 결과)
- 파일 접근: fopen, open (경로가 tainted)
4단계 – 경계 검사 확인
tainted 데이터 → 싱크 경로 사이에 경계 검사가 있는지 확인하세요:
- strlen(input) < sizeof(buffer) 같은 검사 → 안전
- 검사가 없거나 우회 가능하면 → 취약점
5단계 – PoC 입력 추론
취약점을 트리거하는 입력 조건을 추론하세요:
- 어떤 크기의 입력이면 오버플로우가 발생하는지
- 어떤 값이면 조건 분기를 우회하는지
- 정확한 바이트 수, 패딩, 리턴 주소 오프셋 등
근거 요구사항
- 모든 취약점에 코드 주소, 함수명, 디컴파일 코드 라인을 근거로 제시하세요.
- taint 경로를 함수 호출 체인으로 명시하세요:
recv() at 0x401000 → parse_header() at 0x401200 → strcpy() at 0x401350- 경계 검사 부재를 증명하세요 (검사가 "없다"는 것도 근거 필요).
- 실존하지 않는 함수/주소 만들어내지 마세요.
8.3 PoC Engineer 시스템 프롬프트 (초안)
당신은 익스플로잇 개발자입니다. 발견된 취약점에 대해 재현 가능한 PoC를 만듭니다.
PoC 품질 기준 (필수)
- 재현 가능: 동일 환경에서 누가 실행해도 동일 결과
- 독립 실행: 외부 의존성 최소화 (Python 표준 라이브러리 우선)
- 무해한 증명: 파괴적 페이로드 금지
- 웹: alert(1), document.domain 수준
- 바이너리: 크래시 증명 또는 calc.exe/id 실행 수준
- SQLi: 버전 조회 또는 사용자 테이블 목록 수준
- 예상 결과 명시: 실행 시 어떤 응답/결과가 나오는지 설명
- 재현 단계: 1, 2, 3 순서로 명확한 단계 제시
웹 PoC 형식
- curl 명령 (간단한 경우)
- Python requests 스크립트 (복잡한 경우)
- 인증이 필요하면 인증 절차 포함
바이너리 PoC 형식
- 크래시 입력 파일 (hex dump)
- Python pwntools 스크립트 (익스플로잇)
- 실행 환경 요구사항 명시 (OS, 라이브러리)
9. 데이터 스키마 (JSON 구조 정의)
9.1 WebSurfaceMap
{
"target": {
"base_url": "string",
"scope": ["string (허용 도메인/경로)"]
},
"pages": [
{
"url": "string",
"method": "GET | POST | PUT | DELETE",
"status_code": "number",
"content_type": "string",
"parameters": [
{
"name": "string",
"location": "query | body | header | path | cookie",
"type": "string | number | boolean | file | json | xml",
"sample_value": "string",
"required": "boolean"
}
],
"forms": [
{
"action": "string",
"method": "string",
"fields": ["string"]
}
]
}
],
"api_endpoints": [
{
"url": "string",
"method": "string",
"content_type": "string",
"auth_required": "boolean",
"parameters": ["Parameter 객체"]
}
],
"technologies": [
{
"name": "string",
"version": "string | null",
"category": "string"
}
],
"authentication": {
"type": "session | jwt | oauth | api_key | basic | none",
"details": "string"
},
"waf_detected": {
"present": "boolean",
"name": "string | null"
},
"information_leaks": [
{
"type": "source_map | git | env | debug | backup",
"url": "string",
"details": "string"
}
],
"summary": {
"total_pages": "number",
"total_api_endpoints": "number",
"total_parameters": "number",
"total_forms": "number",
"input_vectors_by_type": {
"query": "number",
"body": "number",
"header": "number",
"path": "number",
"file": "number"
}
}
}
9.2 BinarySurfaceMap
{
"binary_info": {
"filename": "string",
"file_type": "string",
"architecture": "string",
"compiler": "string | null",
"stripped": "boolean"
},
"protections": {
"aslr": "boolean",
"dep_nx": "boolean",
"stack_canary": "boolean",
"relro": "none | partial | full",
"pie": "boolean",
"cfi": "boolean",
"fortify_source": "boolean",
"safe_seh": "boolean | null (Windows only)"
},
"attack_surface": {
"input_functions": [
{
"function_name": "string",
"address": "string (hex)",
"input_type": "network | file | stdin | argv | env",
"called_from": ["string"]
}
],
"dangerous_function_calls": [
{
"function": "string (예: strcpy)",
"category": "buffer_copy | format | exec | memory | file",
"call_address": "string (hex)",
"caller_function": "string",
"risk_level": "high | medium | low"
}
],
"total_functions": "number",
"dangerous_call_count": "number"
}
}
9.3 VulnFinding (개별 취약점, 웹/바이너리 공용)
{
"id": "string (UUID)",
"domain": "web | binary",
"title": "string",
"type": "sqli | xss | ssrf | ssti | cmdi | idor | stack_overflow | heap_overflow | uaf | format_string | integer_overflow | ...",
"severity": "critical | high | medium | low | info",
"cvss_score": "number (0.0-10.0)",
"cvss_vector": "string",
"cwe_id": "string (예: CWE-89)",
"cwe_name": "string",
"cve_id": "string | null",
"location": {
"web": {
"url": "string | null",
"method": "string | null",
"parameter": "string | null",
"parameter_location": "string | null"
},
"binary": {
"function_name": "string | null",
"function_address": "string | null",
"vulnerable_line": "string | null"
}
},
"description": "string",
"evidence": {
"web": {
"request": "string | null (원본 HTTP 요청)",
"response_excerpt": "string | null",
"baseline_comparison": "string | null (정상 vs 변조 차이)",
"payload_used": "string | null"
},
"binary": {
"taint_path": "string | null (함수 호출 체인)",
"vulnerable_code": "string | null (디컴파일 코드)",
"missing_check": "string | null (누락된 검증)",
"trigger_condition": "string | null"
},
"reasoning": "string"
},
"poc": {
"type": "curl | python_script | input_file | pwntools_script",
"code": "string",
"expected_result": "string",
"reproduction_steps": ["string"],
"verified": "boolean"
},
"remediation": {
"recommendation": "string",
"code_fix_example": "string | null",
"references": ["string (URL)"]
},
"chain_potential": {
"can_chain": "boolean",
"chain_with": ["string (다른 취약점 ID)"],
"chain_impact": "string | null"
}
}
9.4 VulnHuntReport (최종 보고서)
{
"report_metadata": {
"report_id": "string (UUID)",
"generated_at": "string (ISO 8601)",
"hunt_duration_seconds": "number",
"total_cost_usd": "number",
"target_type": "web | binary | dual"
},
"executive_summary": {
"overall_risk": "critical | high | medium | low",
"total_findings": "number",
"by_severity": {
"critical": "number",
"high": "number",
"medium": "number",
"low": "number",
"info": "number"
},
"key_findings": ["string (핵심 3~5개)"],
"top_recommendations": ["string"]
},
"web_surface_map": "WebSurfaceMap | null",
"binary_surface_map": "BinarySurfaceMap | null",
"findings": ["VulnFinding 배열"],
"vulnerability_chains": [
{
"chain_id": "string",
"steps": ["string (취약점 ID 순서)"],
"combined_impact": "string",
"combined_severity": "string"
}
],
"coverage": {
"web_owasp_coverage": {
"A01_broken_access_control": "tested | not_applicable",
"A02_cryptographic_failures": "tested | not_applicable",
"A03_injection": "tested | not_applicable",
"A04_insecure_design": "tested | not_applicable",
"A05_misconfiguration": "tested | not_applicable",
"A06_vulnerable_components": "tested | not_applicable",
"A07_auth_failures": "tested | not_applicable",
"A08_integrity_failures": "tested | not_applicable",
"A09_logging_monitoring": "tested | not_applicable",
"A10_ssrf": "tested | not_applicable"
},
"binary_pattern_coverage": {
"stack_overflow": "tested | not_applicable",
"heap_overflow": "tested | not_applicable",
"use_after_free": "tested | not_applicable",
"double_free": "tested | not_applicable",
"integer_overflow": "tested | not_applicable",
"format_string": "tested | not_applicable",
"command_injection": "tested | not_applicable",
"path_traversal": "tested | not_applicable"
}
},
"remediation_plan": [
{
"priority": "number (1=최우선)",
"finding_id": "string",
"finding_title": "string",
"recommendation": "string",
"effort": "low | medium | high"
}
]
}
10. 개발 환경 세팅 가이드
필수 소프트웨어
- Python 3.10+
- Ghidra 11.x + Java 17+
- Nuclei (최신)
- feroxbuster 또는 gobuster
- AFL++ (바이너리 퍼징, 선택)
- Docker / Docker Compose (테스트 환경)
Python 패키지 (requirements.txt)
claude-agent-sdk
httpx[http2] # 비동기 HTTP (HTTP/2 지원)
beautifulsoup4
playwright # JS 렌더링 크롤링
pefile
pyelftools
capstone # 디스어셈블러
pwntools # 바이너리 PoC
jsonschema
pyyaml
jinja2
nuclei # Nuclei Python 래퍼
pyjwt # JWT 분석
환경 변수
ANTHROPIC_API_KEY=sk-ant-...
GHIDRA_INSTALL_DIR=/path/to/ghidra
NUCLEI_PATH=/usr/local/bin/nuclei
NUCLEI_TEMPLATES_DIR=/path/to/nuclei-templates
AFL_PATH=/usr/local/bin/afl-fuzz (선택)
config.yaml
anthropic:
api_key: ${ANTHROPIC_API_KEY}
max_budget_usd: 15.0
agents:
hunt_commander:
model: claude-opus-4-6
web_surface_mapper:
model: claude-sonnet-4-6
web_vuln_scanner:
model: claude-opus-4-6
max_payloads_per_param: 50
timeout_per_request_ms: 10000
web_logic_analyst:
model: claude-opus-4-6
binary_surface_mapper:
model: claude-sonnet-4-6
binary_vuln_analyst:
model: claude-opus-4-6
max_taint_depth: 10
max_functions_to_analyze: 100
poc_engineer:
model: claude-opus-4-6
report_writer:
model: claude-sonnet-4-6
web:
crawl_depth: 3
max_pages: 500
request_delay_ms: 100
concurrent_requests: 10
user_agent: "VulnHuntAgent/1.0"
binary:
ghidra_timeout: 600
fuzz_duration_seconds: 3600
max_crash_inputs: 100
11. 검증 및 테스트 계획
11.1 웹 테스트
DVWA (Damn Vulnerable Web Application)
기대 탐지 목록:
- SQL Injection (에러/블라인드/타임)
- XSS (반사/저장)
- Command Injection
- File Inclusion (LFI/RFI)
- File Upload
- CSRF
- Brute Force
평가: 탐지율 90% 이상 (각 난이도별)
Juice Shop (OWASP)
기대 탐지 목록:
- 다양한 XSS
- SQLi/NoSQLi
- Broken Access Control (IDOR, 관리자 접근)
- 로직 취약점 (0원 결제, 쿠폰 남용)
- JWT 취약점
- XXE
- SSRF
평가: Challenge 해결률 70% 이상
11.2 바이너리 테스트
의도적 취약 바이너리
- stack_overflow.c: strcpy 스택 오버플로우 → 탐지 + 오프셋 계산
- heap_overflow.c: malloc 크기 불일치 → 탐지 + 조건 추론
- format_string.c: printf(argv[1]) → 탐지 + 읽기/쓰기 PoC
- cmd_inject.c: system(user_input) → 탐지 + 페이로드
- integer_overflow.c: 크기 계산 오버플로우 → 탐지
- uaf.c: free 후 사용 → 탐지 + 조건 추론
평가: 6/6 탐지 목표
실제 CVE 바이너리 (선택)
- 알려진 CVE가 있는 오픈소스 바이너리 구버전
- 해당 CVE 재발견 여부 확인
11.3 핵심 품질 지표
웹
- True Positive Rate: 알려진 취약점 탐지율 (목표 85%+)
- False Positive Rate: 오탐률 (목표 15% 미만)
- PoC 재현율: PoC 실행 시 실제 성공률 (목표 95%+)
바이너리
- 취약 패턴 탐지율: (목표 80%+)
- Taint 경로 정확도: (목표 90%+)
- 크래시 입력 유효성: (목표 80%+)
12. 리스크 및 대응 방안
리스크 1: False Positive 과다
원인: LLM이 응답 차이를 과대 해석하여 취약점으로 오판
대응:
- 근거 요구사항 강화: 실제 요청/응답 차이 필수
- 확인 테스트 필수: 후보 발견 → 추가 페이로드로 확인 → 보고
- PoC 검증 게이트: PoC 재현 실패 시 보고에서 제외
리스크 2: 토큰 한도 초과
원인: 대규모 웹 (수백 개 엔드포인트), 대규모 바이너리 (수천 개 함수)
대응:
- 웹: 페이지 수 제한, 파라미터 우선순위 필터링
- 바이너리: 위험 함수 호출 사이트만 우선 분석
- 청킹: 일정 단위로 나누어 분석
리스크 3: WAF/보호 기법에 의한 탐지 방해
원인: WAF가 페이로드 차단, ASLR/Canary가 익스플로잇 방해
대응:
- 웹: WAF 우회 페이로드 레벨 에스컬레이션
- 바이너리: 보호 기법 존재 여부를 보고서에 명시, 우회 방안 제안
리스크 4: 인증 필요 영역 미탐색
원인: 인증 토큰 만료, 세션 유지 실패
대응:
- 인증 자동 갱신 로직
- 세션 상태 모니터링
- 인증 실패 시 재로그인
리스크 5: 타겟 서비스 가용성 영향
원인: 대량 요청으로 서비스 부하
대응:
- 요청 간 딜레이 설정 (config.yaml)
- 동시 요청 수 제한
- 에러율 모니터링 → 임계값 초과 시 자동 감속
리스크 6: 바이너리 Taint Tracking 정확도
원인: LLM 기반 추적은 정적 분석 도구 대비 정확도 낮을 수 있음
대응:
- 보수적 판정: 확실한 경로만 취약점 보고, 불확실하면 "후보"로 분류
- 퍼징 교차 검증: 정적 분석 후보를 동적 퍼징으로 확인
- 경로별 신뢰도 점수 부여
13. 다른 팀과의 연동
레드팀 연동
취약점 헌팅팀이 발견한 취약점 목록 + PoC를 레드팀의 Exploit Operator에게 직접 전달하여 공격 실행.
- 입력: VulnHuntReport.findings
- 출력: 레드팀 ExploitResult
악성코드 분석 팀 연동
바이너리 취약점 분석 시 ghidra-mcp 공유. 악성코드 내부의 취약점(백도어 내 버그 등) 발견 시나리오도 가능.
공격무기 빌더 연동
취약점 헌팅팀이 바이너리에서 발견한 취약점을 활용하는 익스플로잇 코드를 공격무기 빌더가 빌드.
4팀 통합 워크플로우
[취약점 헌팅팀] 웹/바이너리 취약점 발견
|
v
[레드팀] 취약점 기반 공격 시뮬레이션
|
v
[악성코드 분석팀] 공격 중 발견한 악성코드 분석
|
v
[공격무기 빌더] APT 도구 재빌드 → 레드팀 재사용
|
v
종합 보고서 → 블루팀 방어 훈련
부록: 핵심 코드 스켈레톤 (main.py)
# main.py - 취약점 헌팅 에이전트 진입점
import asyncio
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions, AgentDefinition
async def hunt_vulnerabilities(
target: str, # URL 또는 바이너리 경로
target_type: str = "auto", # "web" | "binary" | "dual" | "auto"
auth_config: dict = None, # 웹 인증 정보
scope: list = None, # 허용 범위
):
# MCP 서버 생성 (생략)
# ...
options = ClaudeAgentOptions(
agents={
"hunt-commander": AgentDefinition(
description="취약점 헌팅 작전 총괄",
prompt=load_prompt("prompts/hunt_commander.md"),
tools=["dispatch_task", "classify_input", "check_scope",
"prioritize_findings", "merge_results"],
model="opus",
),
# 웹 에이전트 3명
"web-surface-mapper": AgentDefinition(
description="웹 공격 표면 매핑",
prompt=load_prompt("prompts/web_surface_mapper.md"),
tools=[web_recon_srv.tools],
model="sonnet",
),
"web-vuln-scanner": AgentDefinition(
description="OWASP 전 카테고리 자동 스캐닝",
prompt=load_prompt("prompts/web_vuln_scanner.md"),
tools=[web_attack_srv.tools],
model="opus",
),
"web-logic-analyst": AgentDefinition(
description="로직 취약점 및 체인 분석",
prompt=load_prompt("prompts/web_logic_analyst.md"),
tools=[web_attack_srv.tools],
model="opus",
),
# 바이너리 에이전트 2명
"binary-surface-mapper": AgentDefinition(
description="바이너리 공격 표면 분석",
prompt=load_prompt("prompts/binary_surface_mapper.md"),
tools=[ghidra_srv.tools, binary_srv.tools],
model="sonnet",
),
"binary-vuln-analyst": AgentDefinition(
description="바이너리 취약점 정적 분석",
prompt=load_prompt("prompts/binary_vuln_analyst.md"),
tools=[ghidra_srv.tools, binary_srv.tools],
model="opus",
),
# 공용 에이전트 2명
"poc-engineer": AgentDefinition(
description="PoC 생성 및 검증",
prompt=load_prompt("prompts/poc_engineer.md"),
tools=[poc_report_srv.tools],
model="opus",
),
"report-writer": AgentDefinition(
description="종합 보고서 생성",
prompt=load_prompt("prompts/report_writer.md"),
tools=[poc_report_srv.tools],
model="sonnet",
),
},
max_budget_usd=15.0,
)
async with ClaudeSDKClient(options=options) as client:
query = f"타겟: {target}\n타입: {target_type}\n"
if auth_config:
query += f"인증: {json.dumps(auth_config)}\n"
if scope:
query += f"스코프: {json.dumps(scope)}\n"
query += "취약점을 찾아주세요."
await client.query(query)
result = []
async for msg in client.receive_response():
result.append(msg)
return result
if __name__ == "__main__":
import sys
target = sys.argv[1]
result = asyncio.run(hunt_vulnerabilities(target))
print(result)
끝
댓글 남기기