Merge pull request 'feat(redteam): 두 템플릿을 공격하는 red team 플러그인을 더한다' (#2) from claude/great-wu-55f9c7 into main

This commit was merged in pull request #2.
This commit is contained in:
2026-11-11 15:15:34 +00:00
16 changed files with 844 additions and 2 deletions
+7 -1
View File
@@ -1,6 +1,6 @@
{
"name": "claude-harness",
"description": "새 프로젝트용 Claude Code 하네스 마켓. 지금은 공통 플러그인 harness 하나다.",
"description": "새 프로젝트용 Claude Code 하네스 마켓. 공통 플러그인 harness와 보안 red team 플러그인 redteam.",
"owner": {
"name": "donghyeon.kang"
},
@@ -10,6 +10,12 @@
"source": "./plugins/harness",
"description": "되돌릴 수 없는 명령 차단, 비밀 값 알림, 예측·실측 장부와 estimate·retro·techdebt 스킬",
"category": "workflow"
},
{
"name": "redteam",
"source": "./plugins/redteam",
"description": "두 템플릿을 공격하는 red team 장치: 역할별 서브에이전트·스킬과 핀 고정 오픈소스 도구 실행 래퍼, 발견 수집 도구",
"category": "security"
}
]
}
@@ -0,0 +1,13 @@
{
"name": "redteam",
"displayName": "Red Team",
"version": "0.1.0",
"description": "두 템플릿을 공격하는 red team 장치: 역할별 서브에이전트(정찰·인증/인가·입력·의존성·설정·프론트), 발동 스킬, 핀 고정 오픈소스 도구 실행 래퍼와 발견 수집 도구. 훅은 두지 않는다(요청할 때만 돈다).",
"author": {
"name": "donghyeon.kang"
},
"homepage": "https://git.learn.hyeonworks.com/donghyeon.kang/claude-harness",
"repository": "https://git.learn.hyeonworks.com/donghyeon.kang/claude-harness",
"license": "MIT",
"keywords": ["security", "red-team", "sast", "dast", "owasp"]
}
+37
View File
@@ -0,0 +1,37 @@
# red team 캠페인 절차 — 체계적으로 빈틈을 반복해서 판다
한 번의 즉흥 공격이 아니라, **빈칸 없는 기준표**를 두 회차 연속 새 발견 0까지 반복한다. 소유자가 "체계적으로 파고들었나"를 물을 때 이 표가 답이다.
```text
범위 확인 ─> 1 공격 표면 목록 ─> 2 기준표(ASVS L2 × API Top 10 × 진입점) ─> 3 공격(정적·수동·동적) ─> 4 발견→근본원인→전 코드 같은 모양→막는 시험 ─> 5 재실행(2회 연속 0까지)
```
## 1. 공격 표면 목록 (capability 전부 켠 조합)
모든 진입점을 표로. 한 칸도 빼지 않는다:
- HTTP endpoint(경로·메서드·인증), WebSocket/STOMP(destination·handshake·origin), GraphQL(query/mutation/subscription·introspection), gRPC(service·method·bind·reflection), 메시지 consumer(topic·역직렬화), 관리/actuator(endpoint·port·bind·auth), 파일 업로드/다운로드, 설정·환경 변수(SSOT registry), 스케줄러/콜백/웹훅.
- 프론트: 라우트(auth-gated?)·API client(endpoint·auth)·저장소(key·분류)·service worker·web worker·postMessage/BroadcastChannel(origin 검증?)·인증/세션·설정(VITE_·runtime)·동적 HTML sink·업로드.
- 서브에이전트(Explore)로 템플릿마다 하나씩, 취약점 분석이 아니라 **열거**만. 결과는 공유 노트.
## 2. 기준표 (빈칸 0이 끝)
행렬: **OWASP API Security Top 10(2023)** + **OWASP Top 10(2021)** + **ASVS L2 핵심 장(V1~V14)** × 1의 진입점 그룹.
칸마다: **시험함(방법) / 근거 / 결과**. 방법은 코드추적(C)·정적도구(S)·동적(D)·아키텍처시험(A). 결과는 PASS·FINDING·N/A·동적대기.
- 빈칸이 있으면 아직 안 끝난 것이다. 동적이 필요한 칸은 "동적 대기"로 두고 3에서 채운다.
## 3. 공격 (세 축 모두)
- 정적: `redteam-scan.sh sast|secrets|deps|config`(semgrep·gitleaks·trivy·checkov·hadolint). 도달 가능·신뢰하지 않는 입력만 발견으로(오탐 거르기).
- 수동: 역할 서브에이전트(authz·input·config·frontend)로 inbound→sink 추적. "checked, not a finding"까지 적어 커버리지를 남긴다.
- 동적: 대상을 띄우고(`bootRunH2`나 전 capability compose) `redteam-scan.sh dast-baseline|dast-api|nuclei` + schemathesis(/v3/api-docs 등 OpenAPI 표면) + **역할별 인가 행렬**(권한 없는 역할·타 tenant 토큰으로 전 endpoint 호출 — keycloak로 다중 역할 토큰 발급).
- 범위: 내가 띄운 인스턴스·의존 컨테이너만. DoS 없음.
## 4. 발견 처리 (한 건도 겉만 고치지 않는다)
`finding.py` 형식(심각도·재현·영향·고치는 법). 발견마다:
1. **근본 원인**을 적는다.
2. **전 코드에서 같은 모양**을 찾는다(한 곳의 버그는 보통 한 부류다).
3. **막는 시험**: 재현(RED) → 고침 → 통과(GREEN). 재분류(오탐·by-design)면 근거를 적고 의도를 시험/주석으로 고정한다.
4. 보고서는 각 템플릿 `docs/reviews/<날짜>-redteam-*.md`에.
## 5. 재실행 — 두 회차 연속 0
회차마다 **무엇을 새로 봤는지** 적는다(새 capability·새 벡터·수정 뒤 재공격). red team 장치를 다시 돌려 고친 발견이 다시 안 나옴을 보이고, **두 회차 연속 새 발견이 0일 때** 끝.
## AI 침투시험 에이전트 (조사 결과, 2026-11)
Strix(Apache-2.0)·PentAGI(MIT)·CAI·PentestGPT·hackingBuddyGPT는 대부분 **LLM이 같은 하위 도구(ZAP·nuclei·sqlmap 등)를 오케스트레이션**하는 구조다. 이 플러그인이 같은 패턴을 **범위 제한·감사 가능·재현 가능**하게 구현한다. 제3자 자율 에이전트를 대상에 자동 투입하는 것은 (a) 범위 이탈·DoS 위험, (b) 외부 에이전트에 넓은 도구 권한을 주는 신뢰/공급망 위험, (c) 프롬프트 인젝션, (d) 비용 때문에 **기본으로 하지 않는다**. 차용한 방법: 모든 발견을 PoC/동적으로 재검증, 두 회차 0까지 반복. 격리 랩에서 외부 시각으로 1회 돌리는 것은 소유자 별도 승인 사항.
+38
View File
@@ -0,0 +1,38 @@
# redteam 플러그인 — 두 템플릿을 공격하는 red team 장치
승인된 보안 시험으로 내가 통제하는 템플릿·서비스를 공격해 취약점을 찾아 고친다. 역할별 서브에이전트와 발동 스킬, 핀 고정 오픈소스 도구 실행 래퍼, 하나의 발견 수집 도구로 이뤄진다.
## 왜 훅이 없나
이 플러그인은 **훅을 두지 않는다.** 보안 공격은 모든 세션에서 자동으로 돌 일이 아니고(출력·컨텍스트 오염), 교전할 때 스킬·서브에이전트로 **요청해서** 돌린다. `harness` 플러그인(위험 명령 차단·장부)과 역할이 다르다.
## 구성
- `agents/` — 역할 서브에이전트 6: `redteam-recon` `redteam-authz` `redteam-input` `redteam-deps` `redteam-config` `redteam-frontend`.
- `skills/redteam/` — 교전 오케스트레이션 스킬(범위 확인 → 정찰 → 공격 → 수집 → 보고 → 고침 → 재실행).
- `scripts/redteam-scan.sh` — 핀 고정 도구 실행 래퍼(desktop에서). 모드: `secrets sast deps config dast-baseline dast-api nuclei pin`.
- `scripts/tools.lock` — 도구 이미지 버전+digest 핀.
- `scripts/finding.py` — 발견 정규화·검사·정렬·보고(JSON Lines). `validate` `report` `summary` `merge`.
- `tests/` — finding.py 로직과 tools.lock·스크립트 형식 시험(표준 라이브러리만).
## 쓰는 법
`/redteam` 스킬을 부르거나, 역할 서브에이전트를 Agent로 띄운다. 자세한 흐름·명령은 `skills/redteam/SKILL.md`.
## 도구와 라이선스
| 도구 | 라이선스 | 비고 |
|---|---|---|
| gitleaks | MIT | 비밀 값 |
| semgrep CE | 엔진 LGPL-2.1 | SAST(공식 이미지, 룰은 런타임·`--metrics=off`로 코드 안 보냄) |
| trivy | Apache-2.0 | 의존성/이미지 — 기존 게이트와 공유 |
| osv-scanner | Apache-2.0 | lockfile 교차검증 |
| checkov | Apache-2.0 | IaC·compose·Dockerfile |
| hadolint | GPL-3.0 | Dockerfile(실행만) |
| OWASP ZAP | Apache-2.0 | DAST baseline·api |
| nuclei | MIT | 노출 템플릿(로컬 대상만) |
| schemathesis | MIT | OpenAPI 퍼징 |
| trufflehog | AGPL-3.0 | 심층 비밀 값(실행만, 배포 안 함) |
| claude-code-security-review(참고) | MIT | AI diff 리뷰. 신뢰 코드에만 |
**공개 repo 규칙:** 룰셋·CVE 데이터를 vendoring하지 않는다. 도구는 런타임에 받고 룰도 그때 받는다. SAST는 semgrep CE(엔진 LGPL): 레지스트리 룰은 Semgrep Rules License(내부 실행은 허용, 재배포 금지)라 커밋하지 않고 런타임에만 받으며, `--metrics=off`로 프로젝트 코드를 밖에 보내지 않는다. opengrep은 공식 컨테이너 이미지가 없어 뺐다. CodeQL은 라이선스(OSS 전용 조건)로 기본 제외.
## 범위·안전
- 공격은 **내가 띄운 인스턴스와 의존 컨테이너뿐.** 운영·남의 서비스·외부는 제외. DoS 금지.
- 무거운 실행은 desktop에서 `flock`·setsid로, 끝나면 이미지·산출물을 지운다.
+24
View File
@@ -0,0 +1,24 @@
---
name: redteam-authz
description: 인증·인가를 공격하는 역할. 인증 우회, 권한 상승, JWT·세션·토큰 약점, 관리 엔드포인트 노출을 찾는다. recon 지도를 받아 보호돼야 할 엔드포인트에 인증 없이·낮은 권한으로 실제 요청을 보내 본다(내가 띄운 인스턴스에만).
tools: Bash, Read, Grep, Glob, WebFetch
---
# redteam-authz — 인증·인가 공격
목표: 인증·인가 경계가 실제로 막는지 요청으로 확인한다. 대상은 내가 띄운 인스턴스뿐. DoS 금지.
## 노리는 것
1. **인증 우회**: 보호 경로에 토큰 없이·만료 토큰·잘못된 서명·`alg:none` JWT로 접근. 200이 나오면 발견.
2. **권한 상승**: 낮은 권한 토큰으로 관리·타인 리소스 접근. IDOR(남의 id로 조회·수정).
3. **관리 표면**: actuator/health/env/heapdump·metrics·prometheus가 인증 없이, 그리고 어떤 인터페이스에 열렸나. loopback-only인지 published인지.
4. **JWT/세션**: 서명 검증 여부, issuer·audience·만료 검사, 키 혼동(HS/RS), 세션 고정·쿠키 속성(HttpOnly/Secure/SameSite).
5. **CORS와 인증**: credential 허용 + origin 반사면 인증 쿠키 탈취 통로.
6. **gRPC/WebSocket/메시징 인증**: web 외 inbound 어댑터도 같은 인증을 거치는지.
## 방법
- SecurityFilterChain·`permitAll()`·`@PreAuthorize`를 먼저 읽어 **설계상 공개/보호**를 적고, 그 뒤 실제 요청으로 **설계와 동작이 같은지** 확인한다. 차이가 발견이다.
- 증거: 요청·응답(상태코드·민감 본문 일부)을 로그로 남긴다.
## 내는 것
finding.py 형식 한 건씩(심각도·재현 절차·영향·고치는 법), `source`는 "manual" 또는 도구명. id는 `BE-AUTHZ-NNN`/`FE-AUTHZ-NNN`.
+26
View File
@@ -0,0 +1,26 @@
---
name: redteam-config
description: 설정·배포를 공격하는 역할. 보안 헤더·CORS·CSP·쿠키 속성, compose·Dockerfile·IaC 오구성, 비밀 값 노출(gitleaks), 기본 자격증명, 과도한 권한(루트·capabilities), TLS 설정을 본다. checkov·hadolint·gitleaks를 돌리고 응답 헤더를 직접 확인한다.
tools: Bash, Read, Grep, Glob, WebFetch
---
# redteam-config — 설정·배포 오구성
목표: 코드가 아니라 설정에서 새는 곳을 본다. 대상은 내가 띄운 인스턴스·그 설정 파일.
## 노리는 것
1. **보안 헤더**: 응답의 CSP, X-Content-Type-Options, X-Frame-Options/frame-ancestors, HSTS, Referrer-Policy, Permissions-Policy. 빠졌거나 약한가.
2. **CORS**: 허용 origin이 반사·와일드카드 + credentials인가. preflight·노출 헤더.
3. **쿠키**: HttpOnly·Secure·SameSite, 세션/토큰 쿠키 범위.
4. **compose/Dockerfile**: 루트로 실행, read-only rootfs 여부, capabilities·privileged, published 바인딩(0.0.0.0 vs 127.0.0.1), 불필요 포트, healthcheck, 시크릿을 build arg/ENV로 굽기.
5. **비밀 값**: gitleaks로 소스·히스토리. 기본 자격증명(`ca_skeleton` 등)이 샘플 밖으로 샜나, 예제 파일이 실제 비밀을 담았나.
6. **TLS**: 평문 허용, 약한 cipher, 인증서 검증 끔.
7. **에러·정보 노출**: 스택트레이스·버전·내부 경로가 응답에 나오나. actuator env/beans 노출.
## 방법
- `redteam-scan.sh config`(checkov+hadolint), `redteam-scan.sh secrets`(gitleaks).
- 띄운 앱에 `curl -i`로 실제 응답 헤더를 받아 본다(ZAP baseline가 대부분 잡지만 수동 확인).
- compose의 하드닝(read-only·loopback·tmpfs)은 이미 양호 — **빠진 헤더·CORS·정보 노출**에 집중.
## 내는 것
finding.py 형식. id는 `BE-CONFIG-NNN`/`FE-CONFIG-NNN`. 샘플 전용 기본값은 노출이 아니면 info로.
+23
View File
@@ -0,0 +1,23 @@
---
name: redteam-deps
description: 의존성·공급망을 공격하는 역할. 알려진 CVE(trivy·osv), 서명 안 된/핀 안 된 의존성, lockfile 표류, 빌드 플러그인·base 이미지, 전이 의존성을 본다. 이미 쓰는 trivy 게이트와 겹치는 부분은 재사용하고 틈만 본다.
tools: Bash, Read, Grep, Glob, WebFetch
---
# redteam-deps — 의존성·공급망
목표: 의존성과 빌드 공급망의 약점을 본다. **이미 trivy 게이트(scripts/ci/trivy-scan.sh)와 V1 수정이 있으니** 그것을 재사용하고 **틈**을 노린다.
## 노리는 것
1. **알려진 CVE**: trivy fs + osv-scanner 교차. 게이트가 막는 건 HIGH/CRIT. MEDIUM·전이·테스트 scope·build-logic까지 본다.
2. **핀·서명**: 의존성·base 이미지·Gitea Packages(dev.cakit.*) 버전·digest 고정, PGP 서명 검증 여부. 떠다니는 태그(`latest`), digest 없는 이미지.
3. **lockfile 무결성**: lockfile이 실제 해석과 맞나, 없어진 source set의 유령 줄(V1 교훈), `--write-locks` 표류.
4. **빌드 공급망**: 플러그인·convention·wrapper(gradle-wrapper.jar) 검증, 저장소(mavenCentral vs 내부) 혼용, 네트워크에서 받는 스크립트.
5. **base 이미지**: Dockerfile FROM의 digest 고정·갱신 정책, 불필요한 패키지.
## 방법
- `redteam-scan.sh deps`(trivy)로 현재 상태를 재고, osv-scanner로 교차 검증.
- V1 노트(`v1-vuln-fix.md`)의 남은 MEDIUM(opentelemetry·ognl)과 정책을 확인 — 이미 아는 것은 중복 보고하지 않는다.
## 내는 것
finding.py 형식. id는 `BE-DEPS-NNN`/`FE-DEPS-NNN`. 이미 게이트가 막거나 V1이 처리·수용한 것은 올리지 않고, **게이트의 틈**(scope·정책·핀 누락)만 올린다.
+26
View File
@@ -0,0 +1,26 @@
---
name: redteam-frontend
description: 프론트 클라이언트를 공격하는 역할. XSS(dangerouslySetInnerHTML·innerHTML), 토큰 저장(localStorage vs httpOnly 쿠키), CSRF, CSP, 오픈 리다이렉트, postMessage·service worker, 의존성, 빌드 산출물의 시크릿을 본다. React/Vite 템플릿 대상. Playwright로 동적 확인.
tools: Bash, Read, Grep, Glob, WebFetch
---
# redteam-frontend — 프론트 클라이언트 공격
목표: React/Vite 프론트 템플릿의 클라이언트 측 약점을 본다. 대상은 내가 빌드·preview한 인스턴스.
## 노리는 것
1. **XSS**: `dangerouslySetInnerHTML`, `innerHTML`, `document.write`, 템플릿에 들어가는 비정제 입력, URL 파라미터 반사. sink마다 소스(사용자 입력)가 닿는지.
2. **토큰·세션 저장**: 액세스/리프레시 토큰을 localStorage/sessionStorage에 두나(XSS로 탈취) 아니면 httpOnly 쿠키인가. 메모리 vs 저장소.
3. **CSRF**: 상태 변경 요청에 토큰·SameSite 방어가 있나. API 클라이언트가 쿠키 인증이면.
4. **CSP·헤더**: index.html meta와 서버/preview 응답의 CSP, `connect-src`·`script-src`·`unsafe-inline`·`unsafe-eval`.
5. **오픈 리다이렉트·네비게이션**: 사용자 입력으로 `window.location`·라우터 이동.
6. **postMessage / service worker / web worker**: origin 검증, SW 캐시·fetch 가로채기, 민감 데이터 캐시.
7. **빌드 산출물**: `dist/`·소스맵에 시크릿·내부 URL·API 키. `.env`가 번들에 구워졌나(VITE_ 접두사 노출 범위).
8. **의존성**: pnpm audit·trivy로 알려진 CVE.
## 방법
- 소스에서 sink grep → 소스 추적. `redteam-scan.sh secrets`로 dist·히스토리.
- Playwright(이미 프론트에 있음)로 반사 XSS·CSP·토큰 저장을 동적으로 확인하는 짧은 스크립트.
## 내는 것
finding.py 형식. id는 `FE-FRONTEND-NNN`(또는 분야별 `FE-INPUT`/`FE-CONFIG`). `target`은 frontend.
+26
View File
@@ -0,0 +1,26 @@
---
name: redteam-input
description: 입력 처리를 공격하는 역할. 주입(SQL·NoSQL·명령·GraphQL), 역직렬화, 경로 traversal(파일 서버), SSRF, 과도한 입력(nested GraphQL·대형 body)을 찾는다. semgrep SAST와 schemathesis 퍼징을 돌리고 수동으로 payload를 보낸다(내가 띄운 인스턴스에만).
tools: Bash, Read, Grep, Glob, WebFetch
---
# redteam-input — 입력 처리 공격
목표: 신뢰하지 않는 입력이 안전하게 다뤄지는지 본다. 대상은 내가 띄운 인스턴스뿐. 파괴·DoS 금지(퍼징은 가벼운 범위로).
## 노리는 것
1. **주입**: SQL/JPQL(파라미터 바인딩 우회), NoSQL(Mongo 연산자 주입), 명령 주입, GraphQL 주입, 로그 주입, 헤더 주입.
2. **역직렬화**: Java 역직렬화, Jackson 다형성(@JsonTypeInfo), 메시징/캐시 payload. gadget 가능 지점.
3. **경로 traversal**: web-fileserver — `../`, 절대경로, 심볼릭 링크, URL 인코딩으로 의도 밖 파일 읽기/쓰기.
4. **SSRF**: 외부 URL을 받아 요청하는 곳(httpclient·웹훅·이미지 fetch). 내부 주소(169.254.169.254, localhost, 사설망)로 보낼 수 있나.
5. **GraphQL 남용**: introspection 노출, 깊은 중첩·alias 증폭, 배치.
6. **업로드**: 콘텐츠 타입·크기·확장자 검증, 저장 경로.
## 방법
- semgrep SAST(`redteam-scan.sh sast`)와 FindSecBugs 결과에서 주입·역직렬화 후보를 모은다.
- 후보마다 소스를 읽어 **실제로 도달 가능한 신뢰하지 않는 입력인지** 확인한다(SAST 오탐 거르기).
- schemathesis(`dast-api`)로 스키마 위반·500을 찾고, 도달 가능한 것은 수동 payload로 재현한다.
- 증거: payload와 응답.
## 내는 것
finding.py 형식. id는 `BE-INPUT-NNN`/`FE-INPUT-NNN`. SAST 후보 중 도달 불가·검증됨은 발견에 올리지 않되, 판단 근거를 recon/input 노트에 남긴다.
+27
View File
@@ -0,0 +1,27 @@
---
name: redteam-recon
description: 공격면 지도를 그리는 정찰 역할. red team 교전 시작에 쓴다 — 엔드포인트·포트·의존 서비스·OpenAPI·설정 파일을 모아 뒤 역할들이 공격할 지도를 만든다. 소스를 읽고 띄운 인스턴스를 관찰만 한다(변경·파괴 없음).
tools: Bash, Read, Grep, Glob, WebFetch
---
# redteam-recon — 공격면 정찰
목표: 공격 대상(desktop에 띄운 템플릿과 의존 컨테이너)의 지도를 만든다. **읽기·관찰만.** 공격은 뒤 역할이 한다.
## 범위 확인 (먼저)
- 대상은 이 교전이 desktop에 **띄운** 템플릿 인스턴스와 그 의존 컨테이너뿐. 운영·Gitea·남의 컨테이너·외부는 제외.
- DoS·부하 금지. 관찰은 가벼운 요청만.
## 모을 것
1. **포트·서비스**: compose.yaml·compose/의 published 포트, 어떤 서비스가 어떤 네트워크에 붙나, 관리 포트(actuator 등)와 바인딩(loopback vs 0.0.0.0).
2. **inbound 어댑터**: `src/adapter/inbound/*`(web, graphql, grpc, websocket, messaging, web-fileserver, …). 각 어댑터가 여는 엔드포인트·메서드·경로.
3. **OpenAPI/스키마**: springdoc·openapi 산출물, GraphQL 스키마(introspection), proto. 있으면 경로를 적는다(dast-api가 쓴다).
4. **인증 경계**: SecurityFilterChain·permitAll·인증 방식(JWT/세션/mTLS), 공개 vs 보호 경로.
5. **설정·시크릿 표면**: 환경변수 키(env-keys 레지스트리), 기본값, `.env.example`, 시크릿 파일 경로.
6. **의존 서비스**: db·redis·kafka·mongo·minio·keycloak·mailpit 중 이 조립이 켜는 것.
## 내는 것
- `recon/attack-surface.md`: 위 지도(표). 엔드포인트마다 (경로, 메서드, 인증 필요?, 어댑터, 입력).
- 뒤 역할에 넘길 "노려볼 곳" 목록: 인증 없는 민감 엔드포인트, 파일 경로 입력, 역직렬화 지점, 외부로 나가는 요청(SSRF 후보), GraphQL introspection.
발견이 아니라 지도를 낸다. 확실한 노출(예: 인증 없는 관리 엔드포인트가 0.0.0.0에 published)은 발견으로 넘긴다 — finding.py 형식(심각도·재현·영향·고치는 법).
+185
View File
@@ -0,0 +1,185 @@
#!/usr/bin/env python3
"""red team 발견 수집·정규화 도구. 표준 라이브러리만 쓴다.
발견은 JSON Lines(한 줄 한 건)로 모은다. 한 건의 필드:
id 짧은 안정 식별자 (예: BE-AUTHZ-001). 재실행 때 같은 발견을 같은 id로.
severity critical | high | medium | low | info
target backend | frontend | shared
category recon | authz | input | deps | config | frontend
title 한 줄 요약
location file:line 또는 URL·엔드포인트
repro 재현 절차 (여러 줄 가능)
impact 악용되면 무엇이 깨지나
fix 고치는 법
status open | fixed | accepted | wontfix (기본 open)
source 도구 이름 또는 "manual"
evidence 증거 경로·로그 (선택)
쓰기:
finding.py validate findings.jsonl 필드·중복 검사 (잘못되면 rc=1)
finding.py report findings.jsonl 심각도순 마크다운 표를 stdout에
finding.py summary findings.jsonl 심각도별 건수 한 줄 (게이트용, open만)
finding.py merge a.jsonl b.jsonl ... id로 중복 제거해 stdout에 (뒤가 이김)
보고 형식은 brief의 「심각도·재현 절차·영향·고치는 법」을 그대로 따른다.
"""
import json
import sys
SEVERITIES = ("critical", "high", "medium", "low", "info")
TARGETS = ("backend", "frontend", "shared")
CATEGORIES = ("recon", "authz", "input", "deps", "config", "frontend")
STATUSES = ("open", "fixed", "accepted", "wontfix")
REQUIRED = ("id", "severity", "target", "category", "title", "impact", "fix")
def severity_rank(sev):
"""정렬용. 작을수록 위험. 모르는 값은 맨 뒤."""
try:
return SEVERITIES.index(sev)
except ValueError:
return len(SEVERITIES)
def validate_one(f):
"""한 건을 검사해 오류 메시지 목록을 돌려준다. 빈 목록이면 통과."""
errors = []
if not isinstance(f, dict):
return ["발견이 객체가 아니다: %r" % (f,)]
for key in REQUIRED:
if not f.get(key):
errors.append("필수 필드 없음: %s" % key)
if f.get("severity") and f["severity"] not in SEVERITIES:
errors.append("severity 값이 틀림: %r (%s 중 하나)" % (f["severity"], "/".join(SEVERITIES)))
if f.get("target") and f["target"] not in TARGETS:
errors.append("target 값이 틀림: %r" % (f["target"],))
if f.get("category") and f["category"] not in CATEGORIES:
errors.append("category 값이 틀림: %r" % (f["category"],))
status = f.get("status", "open")
if status not in STATUSES:
errors.append("status 값이 틀림: %r" % (status,))
return errors
def validate_all(findings):
"""(오류 메시지 목록)을 돌려준다. id 중복도 오류."""
errors = []
seen = {}
for i, f in enumerate(findings):
for e in validate_one(f):
errors.append("[%d] %s" % (i, e))
fid = f.get("id") if isinstance(f, dict) else None
if fid is not None:
if fid in seen:
errors.append("[%d] id 중복: %s (먼저 [%d])" % (i, fid, seen[fid]))
else:
seen[fid] = i
return errors
def sort_findings(findings):
"""심각도(위험한 것 먼저) → target → id 순."""
return sorted(
findings,
key=lambda f: (severity_rank(f.get("severity", "")),
f.get("target", ""),
str(f.get("id", ""))),
)
def counts(findings, only_open=False):
"""심각도별 건수."""
out = {s: 0 for s in SEVERITIES}
for f in findings:
if only_open and f.get("status", "open") != "open":
continue
sev = f.get("severity")
if sev in out:
out[sev] += 1
return out
def to_markdown(findings):
rows = sort_findings(findings)
lines = ["# red team 발견", ""]
c = counts(findings)
co = counts(findings, only_open=True)
lines.append("- 전체: " + ", ".join("%s %d" % (s, c[s]) for s in SEVERITIES))
lines.append("- open: " + ", ".join("%s %d" % (s, co[s]) for s in SEVERITIES))
lines.append("")
for f in rows:
status = f.get("status", "open")
lines.append("## [%s] %s — %s" % (f.get("severity", "?").upper(), f.get("id", "?"), f.get("title", "")))
lines.append("")
lines.append("- 대상: %s · 분야: %s · 상태: %s · 출처: %s"
% (f.get("target", "?"), f.get("category", "?"), status, f.get("source", "?")))
if f.get("location"):
lines.append("- 위치: `%s`" % f["location"])
if f.get("evidence"):
lines.append("- 증거: %s" % f["evidence"])
lines.append("")
lines.append("**재현 절차**")
lines.append("")
lines.append((f.get("repro") or "(없음)").rstrip())
lines.append("")
lines.append("**영향:** " + (f.get("impact") or ""))
lines.append("")
lines.append("**고치는 법:** " + (f.get("fix") or ""))
lines.append("")
return "\n".join(lines).rstrip() + "\n"
def load_jsonl(path):
findings = []
with open(path, encoding="utf-8") as fh:
for n, line in enumerate(fh, 1):
line = line.strip()
if not line or line.startswith("#"):
continue
try:
findings.append(json.loads(line))
except json.JSONDecodeError as e:
raise SystemExit("%s:%d JSON 오류: %s" % (path, n, e))
return findings
def main(argv):
if len(argv) < 2:
raise SystemExit(__doc__)
cmd = argv[1]
if cmd == "merge":
by_id = {}
order = []
for path in argv[2:]:
for f in load_jsonl(path):
fid = f.get("id")
if fid not in by_id:
order.append(fid)
by_id[fid] = f
for fid in order:
print(json.dumps(by_id[fid], ensure_ascii=False))
return 0
path = argv[2]
findings = load_jsonl(path)
if cmd == "validate":
errors = validate_all(findings)
if errors:
sys.stderr.write("\n".join(errors) + "\n")
return 1
print("validate: %d건 통과" % len(findings))
return 0
if cmd == "report":
sys.stdout.write(to_markdown(findings))
return 0
if cmd == "summary":
co = counts(findings, only_open=True)
print("open " + " ".join("%s=%d" % (s, co[s]) for s in SEVERITIES))
# 열린 critical·high가 있으면 rc=1 (게이트용)
return 1 if (co["critical"] or co["high"]) else 0
raise SystemExit("모르는 명령: %s" % cmd)
if __name__ == "__main__":
sys.exit(main(sys.argv))
+154
View File
@@ -0,0 +1,154 @@
#!/usr/bin/env bash
# red team 도구 실행 래퍼. desktop에서만 돈다.
#
# bash redteam-scan.sh <mode> --target <소스경로|URL> --out <결과폴더> [옵션]
#
# 모드:
# secrets gitleaks: 소스·git 히스토리의 비밀 값
# sast semgrep CE: 정적 분석(룰은 런타임에 레지스트리에서, --metrics=off로 코드 안 보냄)
# deps trivy fs: 의존성 취약점(HIGH/CRIT 요약)
# config checkov + hadolint: compose·Dockerfile·IaC 오구성
# dast-baseline OWASP ZAP baseline: 띄운 앱에 수동(passive) 스캔(헤더·쿠키·CSP)
# dast-api ZAP api-scan + schemathesis: OpenAPI 기반 능동·퍼징 (--api 필요)
# nuclei nuclei: 알려진 노출·오구성 템플릿 (대상은 내 로컬 URL만)
# pin tools.lock의 모든 도구를 받아 실제 digest를 출력(고정에 붙여 쓴다)
#
# 옵션:
# --target <v> 소스 폴더(secrets/sast/deps/config) 또는 http URL(dast-*/nuclei)
# --out <dir> 결과를 쓸 폴더 (기본 ./redteam-out)
# --api <v> OpenAPI 스펙 URL 또는 파일 (dast-api)
# --net <name> docker 네트워크(대상 컨테이너에 붙을 때)
#
# 실행 규칙: 무거우니 호출자가 `flock /tmp/claude-gates/heavy.lock`과 setsid로 감싼다.
# 끝나면 받은 이미지를 지운다(desktop 디스크 여유 적음). 공격 대상은 내가 띄운 템플릿뿐.
set -euo pipefail
HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
LOCK="${HERE}/tools.lock"
usage() { sed -n '2,33p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'; }
# tools.lock에서 한 도구의 "image digest"를 돌려준다.
lookup() {
local name="$1" line
line="$(awk -v n="$name" '$1==n {print $2, $3; found=1} END{if(!found) exit 3}' "${LOCK}")" \
|| { echo "tools.lock에 '$name' 없음" >&2; return 3; }
echo "${line}"
}
# 실행용 이미지 참조. digest가 있으면 image@digest, 없으면 image:tag(경고).
image_ref() {
local name="$1" image digest
read -r image digest < <(lookup "$name")
if [ "${digest}" = "-" ]; then
echo "경고: ${name} digest 미고정 — 태그로 받는다. pin 모드로 고정하라" >&2
echo "${image}"
else
echo "${image%%:*}@${digest}"
fi
}
ensure_image() {
local ref="$1"
docker image inspect "${ref}" >/dev/null 2>&1 || docker pull "${ref}" >&2
}
# 모든 도구를 받아 실제 digest를 tools.lock 형식으로 출력
do_pin() {
local name image digest ref repo d
while read -r name image digest; do
case "${name}" in ''|\#*) continue;; esac
docker pull "${image}" >&2 || { echo "${name} pull 실패" >&2; continue; }
repo="${image%%:*}"
d="$(docker image inspect --format '{{index .RepoDigests 0}}' "${image}" 2>/dev/null | sed 's/.*@//')"
[ -n "${d}" ] || d="$(docker inspect --format '{{.Id}}' "${image}")"
printf '%-16s %-48s %s\n' "${name}" "${image}" "${d}"
done < "${LOCK}"
}
MODE="${1:-}"; shift || true
TARGET=""; OUT="./redteam-out"; API=""; NET=""
while [ $# -gt 0 ]; do
case "$1" in
--target) TARGET="$2"; shift 2;;
--out) OUT="$2"; shift 2;;
--api) API="$2"; shift 2;;
--net) NET="$2"; shift 2;;
-h|--help) usage; exit 0;;
*) echo "모르는 옵션: $1" >&2; usage; exit 2;;
esac
done
case "${MODE}" in -h|--help|'') usage; exit 0;; esac
command -v docker >/dev/null 2>&1 || { echo "docker 없음 — desktop에서 돌려라" >&2; exit 2; }
mkdir -p "${OUT}"
netarg=(); [ -n "${NET}" ] && netarg=(--network "${NET}")
case "${MODE}" in
pin)
do_pin
;;
secrets)
ref="$(image_ref gitleaks)"; ensure_image "${ref}"
docker run --rm -v "${TARGET}:/repo:ro" "${ref}" \
detect --source=/repo --no-banner --report-format json --report-path /dev/stdout \
> "${OUT}/secrets.json" 2> "${OUT}/secrets.log" || true
echo "→ ${OUT}/secrets.json"
;;
sast)
# semgrep CE(엔진 LGPL). 룰은 레지스트리에서 런타임에 받고(커밋 안 함), --metrics=off로
# 프로젝트 정보를 밖에 보내지 않는다(--config auto는 metrics를 켜야 해 쓰지 않는다).
ref="$(image_ref semgrep)"; ensure_image "${ref}"
docker run --rm -v "${TARGET}:/src:ro" "${ref}" \
semgrep scan --config p/default --config p/secrets --metrics=off --json /src \
> "${OUT}/sast.json" 2> "${OUT}/sast.log" || true
echo "→ ${OUT}/sast.json"
;;
deps)
ref="$(image_ref trivy)"; ensure_image "${ref}"
docker run --rm -v "${TARGET}:/src:ro" "${ref}" \
fs --scanners vuln --severity HIGH,CRITICAL --format json --output /dev/stdout /src \
> "${OUT}/deps.json" 2> "${OUT}/deps.log" || true
echo "→ ${OUT}/deps.json"
;;
config)
ref="$(image_ref checkov)"; ensure_image "${ref}"
docker run --rm -v "${TARGET}:/src:ro" "${ref}" \
-d /src --compact --quiet -o json > "${OUT}/config-checkov.json" 2> "${OUT}/config-checkov.log" || true
hl="$(image_ref hadolint)"; ensure_image "${hl}"
: > "${OUT}/config-hadolint.json"
while IFS= read -r df; do
docker run --rm -i "${hl}" hadolint --format json - < "${df}" >> "${OUT}/config-hadolint.json" 2>> "${OUT}/config-hadolint.log" || true
done < <(find "${TARGET}" -type f -name 'Dockerfile*' 2>/dev/null)
echo "→ ${OUT}/config-checkov.json ${OUT}/config-hadolint.json"
;;
dast-baseline)
[ -n "${TARGET}" ] || { echo "--target <URL> 필요" >&2; exit 2; }
ref="$(image_ref zap)"; ensure_image "${ref}"
docker run --rm "${netarg[@]}" -v "${OUT}:/zap/wrk:rw" "${ref}" \
zap-baseline.py -t "${TARGET}" -J dast-baseline.json -r dast-baseline.html \
> "${OUT}/dast-baseline.log" 2>&1 || true
echo "→ ${OUT}/dast-baseline.json"
;;
dast-api)
[ -n "${API}" ] || { echo "--api <OpenAPI URL|파일> 필요" >&2; exit 2; }
ref="$(image_ref zap)"; ensure_image "${ref}"
docker run --rm "${netarg[@]}" -v "${OUT}:/zap/wrk:rw" "${ref}" \
zap-api-scan.py -t "${API}" -f openapi -J dast-api.json -r dast-api.html \
> "${OUT}/dast-api.log" 2>&1 || true
st="$(image_ref schemathesis)"; ensure_image "${st}"
docker run --rm "${netarg[@]}" "${st}" \
run "${API}" --checks all --report junit --report-junit-path /dev/stdout \
> "${OUT}/dast-schemathesis.xml" 2> "${OUT}/dast-schemathesis.log" || true
echo "→ ${OUT}/dast-api.json ${OUT}/dast-schemathesis.xml"
;;
nuclei)
[ -n "${TARGET}" ] || { echo "--target <URL> 필요" >&2; exit 2; }
ref="$(image_ref nuclei)"; ensure_image "${ref}"
docker run --rm "${netarg[@]}" "${ref}" \
-u "${TARGET}" -jsonl -silent > "${OUT}/nuclei.jsonl" 2> "${OUT}/nuclei.log" || true
echo "→ ${OUT}/nuclei.jsonl"
;;
*)
echo "모르는 모드: ${MODE}" >&2; usage; exit 2;;
esac
+23
View File
@@ -0,0 +1,23 @@
# red team 도구 핀. 한 줄: `name image:tag digest`
#
# - 공개 repo라 룰셋·CVE 데이터는 vendoring 하지 않는다. 도구는 런타임에 이미지로 받고 룰은 그때 받는다.
# - digest가 sha256:…이면 그 digest로 받고 대조한다(오프라인에서 검증 가능한 공급망 주장).
# - digest가 '-'이면 아직 안 고정. 첫 실행 때 redteam-scan.sh가 태그로 받아 실제 digest를 출력하니,
# 그 값을 여기 붙여 고정한다(TOFU, scripts/ci/trivy-scan.sh의 바이너리 SHA-256과 같은 방식).
# - 실행은 desktop에서만. flock /tmp/claude-gates/heavy.lock, setsid로 떼어 돌린다. 끝나면 이미지를 지운다.
#
# SAST는 semgrep CE(엔진 LGPL-2.1, 공식 이미지). opengrep은 공식 컨테이너 이미지가 없어 뺐다.
# 룰은 런타임에 레지스트리에서 받고(커밋하지 않음), --metrics=off로 프로젝트 정보를 밖에 보내지 않는다.
# 레지스트리 룰은 Semgrep Rules License(내부 실행은 허용, 재배포 금지)라 공개 repo에 담지 않는다.
#
# name image:tag digest
gitleaks zricethezav/gitleaks:v8.30.0 sha256:691af3c7c5a48b16f187ce3446d5f194838f91238f27270ed36eef6359a574d9
semgrep semgrep/semgrep:1.184.0 sha256:cc1b68266f267878b39739373ea9985b9a78e5d64497dd875c8de100b22695ed
trivy aquasec/trivy:0.71.2 sha256:f5d0e600ecda7449e2a9b272805aef698631d3bb3f3a739a750de2c6819acdc9
osv-scanner ghcr.io/google/osv-scanner:v2.2.4 -
checkov bridgecrew/checkov:3.2.495 sha256:4c2c3b67f09867ef2843a03d8ba82adf712eb93ea3584c1708c24ed584f6da17
hadolint hadolint/hadolint:2.14.0-debian -
zap ghcr.io/zaproxy/zaproxy:2.16.1 -
nuclei projectdiscovery/nuclei:v3.4.11 -
schemathesis schemathesis/schemathesis:4.4.2 -
trufflehog trufflesecurity/trufflehog:3.90.10 -
+77
View File
@@ -0,0 +1,77 @@
---
name: redteam
description: Use when running an authorized red team engagement against a template or service you control — attacking your own backend/frontend to find and fix vulnerabilities. 승인된 보안 시험으로 내 템플릿·서비스를 공격해 취약점을 찾아 고칠 때 쓴다("red team", "보안 공격", "취약점 찾아"). 정찰·인증/인가·입력·의존성·설정·프론트 역할과 핀 고정 오픈소스 도구(gitleaks·semgrep·trivy·checkov·ZAP·nuclei·schemathesis)를 오케스트레이션한다.
---
# redteam — 승인된 red team 교전
내가 통제하는 대상(내 템플릿·서비스)을 공격해 취약점을 찾고 고친다. **승인·범위를 먼저 확인한다.**
```text
범위 확인 ─> 정찰(지도) ─> 역할별 공격(도구+수동) ─> 발견 수집 ─> 보고(docs/reviews) ─> 고침(막는 시험) ─> 재실행(회귀 0)
```
## 0. 범위·승인 (건너뛰지 않는다)
- 공격 대상은 **내가 띄운 인스턴스와 그 의존 컨테이너뿐.** 운영·남의 서비스·외부는 제외.
- **DoS·부하 공격 금지.** 퍼징은 가벼운 범위.
- 승인 출처(요청·결정 기록)와 대상 목록을 교전 노트 맨 위에 적는다.
## 1. 정찰
`redteam-recon` 서브에이전트로 공격면 지도를 만든다(엔드포인트·포트·의존 서비스·OpenAPI·인증 경계·설정). 지도 없이 공격하지 않는다.
## 2. 역할별 공격
지도를 각 역할 서브에이전트에 넘긴다. 독립적이면 병렬로 띄운다.
| 역할 | 서브에이전트 | 주로 쓰는 것 |
|---|---|---|
| 인증·인가 | `redteam-authz` | 수동 요청(토큰·IDOR·관리 표면), JWT |
| 입력 처리 | `redteam-input` | semgrep SAST, schemathesis, 수동 payload |
| 의존성·공급망 | `redteam-deps` | trivy·osv (기존 게이트 재사용, 틈만) |
| 설정·배포 | `redteam-config` | checkov·hadolint·gitleaks, 응답 헤더 |
| 프론트 | `redteam-frontend` | grep·Playwright, dist 시크릿 |
## 3. 도구 실행 — desktop에서만
무거운 실행은 desktop에서, `flock`과 setsid로 떼어 돌린다. 도구는 `scripts/tools.lock`에 버전+digest로 고정한다.
```bash
# 핀 고정(첫 1회): 실제 digest를 받아 tools.lock에 붙인다
flock /tmp/claude-gates/heavy.lock bash "${CLAUDE_PLUGIN_ROOT}/scripts/redteam-scan.sh" pin
# 정적·비밀값·의존성·설정(소스 폴더 대상)
bash "${CLAUDE_PLUGIN_ROOT}/scripts/redteam-scan.sh" sast --target <소스> --out <결과>
bash "${CLAUDE_PLUGIN_ROOT}/scripts/redteam-scan.sh" secrets --target <소스> --out <결과>
bash "${CLAUDE_PLUGIN_ROOT}/scripts/redteam-scan.sh" deps --target <소스> --out <결과>
bash "${CLAUDE_PLUGIN_ROOT}/scripts/redteam-scan.sh" config --target <소스> --out <결과>
# 동적(띄운 앱 URL 대상) — 내 인스턴스에만
bash "${CLAUDE_PLUGIN_ROOT}/scripts/redteam-scan.sh" dast-baseline --target http://… --out <결과> --net <docker망>
bash "${CLAUDE_PLUGIN_ROOT}/scripts/redteam-scan.sh" dast-api --api <openapi> --out <결과> --net <docker망>
bash "${CLAUDE_PLUGIN_ROOT}/scripts/redteam-scan.sh" nuclei --target http://… --out <결과> --net <docker망>
```
끝나면 받은 이미지와 산출물을 지운다(desktop 디스크 여유 적음).
## 4. 발견 수집 — 하나의 형식
모든 발견은 `finding.py` JSON Lines로 모은다. 한 건은 **심각도·재현 절차·영향·고치는 법**을 반드시 담는다(brief 형식).
```bash
python3 "${CLAUDE_PLUGIN_ROOT}/scripts/finding.py" validate findings.jsonl # 필드·중복 검사
python3 "${CLAUDE_PLUGIN_ROOT}/scripts/finding.py" report findings.jsonl # 심각도순 마크다운
python3 "${CLAUDE_PLUGIN_ROOT}/scripts/finding.py" summary findings.jsonl # open 건수, HIGH 있으면 rc=1
```
- 도구 출력(SAST·DAST)은 **오탐을 거른 뒤** 발견으로 올린다(도달 가능·신뢰하지 않는 입력인지 확인).
- id는 안정적으로(`BE-AUTHZ-001` 등) — 재실행 때 같은 발견이 같은 id여야 회귀를 센다.
## 5. 보고
보고서는 각 템플릿 repo `docs/reviews/<날짜>-redteam-*.md`에 둔다(claude-harness가 아니라). 발견 목록 + 처리 상태 + 재실행 결과.
## 6. 고침과 재실행
- 발견마다 **막는 시험**을 더한다: 재현(RED) → 고침 → 통과(GREEN). 템플릿 게이트 rc=0.
- 고치지 않는 것은 근거를 적고 `status: accepted|wontfix`로 소유자 결정 칸에.
- 끝에 red team 장치를 **다시 돌려** open 발견이 다시 나오지 않음을 보인다(회귀 0).
## 라이선스 주의
- 공개 repo에는 제한 라이선스 룰셋(semgrep 룰)·CVE 데이터를 vendoring하지 않는다. 도구는 런타임에 받고 룰도 그때 받는다.
- claude-code-security-review·trailofbits 스킬은 **신뢰 코드에만**(프롬프트 인젝션 미하드닝). 외부 자동 fetch를 켜지 않는다.
## 체계적 반복 캠페인
한 번의 공격이 아니라 빈칸 없는 기준표를 두 회차 연속 새 발견 0까지 반복하려면 `CAMPAIGN.md`를 따른다: 공격 표면 목록 → ASVS L2 × API Top 10 × 진입점 행렬 → 정적·수동·동적 → 발견마다 근본 원인·전 코드 같은 모양·막는 시험 → 재실행.
+154
View File
@@ -0,0 +1,154 @@
"""redteam 플러그인 시험. 표준 라이브러리만 쓴다.
python3 -m unittest discover -s plugins/redteam/tests
finding.py의 정규화·검사·정렬·보고 로직과, tools.lock·redteam-scan.sh의 형식을 본다.
"""
import json
import os
import subprocess
import sys
import tempfile
import unittest
PLUGIN = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
SCRIPTS = os.path.join(PLUGIN, "scripts")
sys.path.insert(0, SCRIPTS)
import finding # noqa: E402
def good(**over):
f = {"id": "BE-AUTHZ-001", "severity": "high", "target": "backend", "category": "authz",
"title": "관리 엔드포인트 인증 없음", "impact": "누구나 설정을 본다", "fix": "인증을 건다"}
f.update(over)
return f
class ValidateTest(unittest.TestCase):
def test_good_passes(self):
self.assertEqual(finding.validate_one(good()), [])
def test_missing_required(self):
f = good()
del f["impact"]
self.assertTrue(any("impact" in e for e in finding.validate_one(f)))
def test_bad_severity(self):
self.assertTrue(any("severity" in e for e in finding.validate_one(good(severity="urgent"))))
def test_bad_target_category_status(self):
self.assertTrue(finding.validate_one(good(target="server")))
self.assertTrue(finding.validate_one(good(category="xss")))
self.assertTrue(finding.validate_one(good(status="closed")))
def test_default_status_open_ok(self):
f = good()
self.assertNotIn("status", f)
self.assertEqual(finding.validate_one(f), [])
def test_duplicate_id_is_error(self):
errs = finding.validate_all([good(), good(title="다른 것")])
self.assertTrue(any("중복" in e for e in errs))
def test_non_dict(self):
self.assertTrue(finding.validate_one("x"))
class SortTest(unittest.TestCase):
def test_severity_order(self):
items = [good(id="a", severity="low"), good(id="b", severity="critical"),
good(id="c", severity="medium")]
order = [f["id"] for f in finding.sort_findings(items)]
self.assertEqual(order, ["b", "c", "a"])
def test_unknown_severity_last(self):
items = [good(id="x", severity="weird"), good(id="y", severity="info")]
order = [f["id"] for f in finding.sort_findings(items)]
self.assertEqual(order, ["y", "x"])
def test_counts_open_only(self):
items = [good(severity="high"), good(id="2", severity="high", status="fixed")]
self.assertEqual(finding.counts(items)["high"], 2)
self.assertEqual(finding.counts(items, only_open=True)["high"], 1)
class ReportTest(unittest.TestCase):
def test_markdown_has_repro_impact_fix(self):
md = finding.to_markdown([good(repro="1. curl ...\n2. 200 OK")])
self.assertIn("재현 절차", md)
self.assertIn("영향:", md)
self.assertIn("고치는 법:", md)
self.assertIn("curl", md)
def test_markdown_orders_critical_first(self):
md = finding.to_markdown([good(id="low1", severity="low"), good(id="crit1", severity="critical")])
self.assertLess(md.index("crit1"), md.index("low1"))
class CliTest(unittest.TestCase):
def run_cli(self, *args, findings=None):
with tempfile.NamedTemporaryFile("w", suffix=".jsonl", delete=False, encoding="utf-8") as fh:
for f in (findings or []):
fh.write(json.dumps(f, ensure_ascii=False) + "\n")
path = fh.name
try:
return subprocess.run([sys.executable, "-I", os.path.join(SCRIPTS, "finding.py"), args[0], path, *args[1:]],
capture_output=True, text=True, timeout=30)
finally:
os.unlink(path)
def test_validate_rc(self):
self.assertEqual(self.run_cli("validate", findings=[good()]).returncode, 0)
self.assertEqual(self.run_cli("validate", findings=[good(severity="x")]).returncode, 1)
def test_summary_rc_blocks_on_high(self):
self.assertEqual(self.run_cli("summary", findings=[good(severity="high")]).returncode, 1)
self.assertEqual(self.run_cli("summary", findings=[good(severity="low")]).returncode, 0)
# fixed high는 막지 않는다
self.assertEqual(self.run_cli("summary", findings=[good(severity="high", status="fixed")]).returncode, 0)
def test_report_runs(self):
r = self.run_cli("report", findings=[good()])
self.assertEqual(r.returncode, 0)
self.assertIn("BE-AUTHZ-001", r.stdout)
class ToolsLockTest(unittest.TestCase):
"""tools.lock: 주석·빈 줄 빼고 모든 줄이 `name image:tag digest` 3칸. digest는 sha256: 또는 '-'(미고정)."""
def test_lock_well_formed(self):
path = os.path.join(SCRIPTS, "tools.lock")
self.assertTrue(os.path.exists(path), "tools.lock 없음")
with open(path, encoding="utf-8") as fh:
lines = [l.rstrip("\n") for l in fh]
tools = 0
for n, line in enumerate(lines, 1):
s = line.strip()
if not s or s.startswith("#"):
continue
parts = s.split()
self.assertEqual(len(parts), 3, "tools.lock:%d 칸이 3개가 아님: %r" % (n, line))
name, ref, digest = parts
self.assertIn(":", ref, "tools.lock:%d 이미지에 태그가 없음: %r" % (n, ref))
self.assertTrue(digest == "-" or digest.startswith("sha256:"),
"tools.lock:%d digest 형식: %r" % (n, digest))
tools += 1
self.assertGreaterEqual(tools, 5, "도구가 너무 적다")
class ScanScriptTest(unittest.TestCase):
def test_bash_syntax(self):
path = os.path.join(SCRIPTS, "redteam-scan.sh")
self.assertTrue(os.path.exists(path), "redteam-scan.sh 없음")
r = subprocess.run(["bash", "-n", path], capture_output=True, text=True, timeout=30)
self.assertEqual(r.returncode, 0, "bash -n 실패:\n" + r.stderr)
def test_help_lists_modes(self):
path = os.path.join(SCRIPTS, "redteam-scan.sh")
r = subprocess.run(["bash", path, "--help"], capture_output=True, text=True, timeout=30)
for mode in ("secrets", "sast", "deps", "config", "dast-baseline"):
self.assertIn(mode, r.stdout + r.stderr, "help에 모드 없음: %s" % mode)
if __name__ == "__main__":
unittest.main()
+4 -1
View File
@@ -4,14 +4,17 @@
set -euo pipefail
cd "$(dirname "$0")/.."
echo "== 플러그인 시험"
echo "== 플러그인 시험 (harness)"
python3 -m unittest discover -s plugins/harness/tests
echo "== 플러그인 시험 (redteam)"
python3 -m unittest discover -s plugins/redteam/tests
echo "== 템플릿 시험"
python3 -m unittest discover -s tests
if command -v claude >/dev/null 2>&1; then
echo "== 매니페스트 검사"
claude plugin validate --strict .
claude plugin validate --strict plugins/harness
claude plugin validate --strict plugins/redteam
else
echo "== 매니페스트 검사 건너뜀: claude 명령이 없다" >&2
fi