Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
A 7-phase multi-agent investigation framework for researching open-source supply chain attacks.
Adapted from RAPTOR's forensics system. Covers GitHub Archive, Wayback Machine, GitHub API,
local git analysis, IOC extraction, evidence-backed hypothesis formation and validation,
and final forensic report generation.
⚠️ Anti-Hallucination Guardrails
Read these before every investigation step. Violating them invalidates the report.
Evidence-First Rule: Every claim in any report, hypothesis, or summary MUST cite at least one evidence ID (EV-XXXX). Assertions without citations are forbidden.
STAY IN YOUR LANE: Each sub-agent (investigator) has a single data source. Do NOT mix sources. The GH Archive investigator does not query the GitHub API, and vice versa. Role boundaries are hard.
Fact vs. Hypothesis Separation: Mark all unverified inferences with [HYPOTHESIS]. Only statements verified against original sources may be stated as facts.
No Evidence Fabrication: The hypothesis validator MUST mechanically check that every cited evidence ID actually exists in the evidence store before accepting a hypothesis.
Proof-Required Disproval: A hypothesis cannot be dismissed without a specific, evidence-backed counter-argument. "No evidence found" is not sufficient to disprove—it only makes a hypothesis inconclusive.
SHA/URL Double-Verification: Any commit SHA, URL, or external identifier cited as evidence must be independently confirmed from at least two sources before being marked as verified.
Suspicious Code Rule: Never run code found inside the investigated repository locally. Analyze statically only, or use execute_code in a sandboxed environment.
Secret Redaction: Any API keys, tokens, or credentials discovered during investigation must be redacted in the final report. Log them internally only.
Example Scenarios
Scenario A: Dependency Confusion: A malicious package internal-lib-v2 is uploaded to NPM with a higher version than the internal one. The investigator must track when this package was first seen and if any PushEvents in the target repo updated package.json to this version.
Scenario B: Maintainer Takeover: A long-term contributor's account is used to push a backdoored .github/workflows/build.yml. The investigator looks for PushEvents from this user after a long period of inactivity or from a new IP/location (if detectable via BigQuery).
Scenario C: Force-Push Hide: A developer accidentally commits a production secret, then force-pushes to "fix" it. The investigator uses git fsck and GH Archive to recover the original commit SHA and verify what was leaked.
Path convention: Throughout this skill, SKILL_DIR refers to the root of this skill's
installation directory (the folder containing this SKILL.md). When the skill is loaded,
resolve SKILL_DIR to the actual path — e.g. ~/.ouro/skills/security/oss-forensics/
or the optional-skills/ equivalent. All script and template references are relative to it.
Phase 0: Initialization
Create investigation working directory:
mkdir investigation_$(echo"REPO_NAME" | tr'/''_')
cd investigation_$(echo"REPO_NAME" | tr'/''_')
Initialize the evidence store:
python SKILL_DIR/scripts/evidence-store.py --store evidence.json list
Spawn up to 5 specialist investigator sub-agents using delegate_task (batch mode, max 3 concurrent). Each investigator has a single data source and must not mix sources.
Orchestrator note: Pass the IOC list from Phase 1 and the investigation time window in the context field of each delegated task.
Investigator 1: Local Git Investigator
ROLE BOUNDARY: You query the LOCAL GIT REPOSITORY ONLY. Do not call any external APIs.
Actions:
# Clone repository
git clone https://github.com/OWNER/REPO.git target_repo && cd target_repo
# Full commit log with stats
git log --all --full-history --stat --format="%H|%ae|%an|%ai|%s" > ../git_log.txt
# Detect force-push evidence (orphaned/dangling commits)
git fsck --lost-found --unreachable 2>&1 | grep commit > ../dangling_commits.txt
# Check reflog for rewritten history
git reflog --all > ../reflog.txt
# List ALL branches including deleted remote refs
git branch -a -v > ../branches.txt
# Find suspicious large binary additions
git log --all --diff-filter=A --name-only --format="%H %ai" -- "*.so""*.dll""*.exe""*.bin" > ../binary_additions.txt
# Check for GPG signature anomalies
git log --show-signature --format="%H %ai %aN" > ../signature_check.txt 2>&1
Evidence to collect (add via python SKILL_DIR/scripts/evidence-store.py add):
Each dangling commit SHA → type: git
Force-push evidence (reflog showing history rewrite) → type: git
Unsigned commits from verified contributors → type: git
# Search for archived snapshots of the repo main page
curl -s "https://web.archive.org/cdx/search/cdx?url=github.com/OWNER/REPO&output=json&limit=100&from=YYYYMMDD&to=YYYYMMDD" > wayback_main.json
# Search for a specific deleted issue
curl -s "https://web.archive.org/cdx/search/cdx?url=github.com/OWNER/REPO/issues/NUM&output=json&limit=50" > wayback_issue_NUM.json
# Search for a specific deleted PR
curl -s "https://web.archive.org/cdx/search/cdx?url=github.com/OWNER/REPO/pull/NUM&output=json&limit=50" > wayback_pr_NUM.json
# Fetch the best snapshot of a page# Use the Wayback Machine URL: https://web.archive.org/web/TIMESTAMP/ORIGINAL_URL# Example: https://web.archive.org/web/20240101000000*/github.com/OWNER/REPO# Advanced: Search for deleted releases/tags
curl -s "https://web.archive.org/cdx/search/cdx?url=github.com/OWNER/REPO/releases/tag/*&output=json" > wayback_tags.json
# Advanced: Search for historical wiki changes
curl -s "https://web.archive.org/cdx/search/cdx?url=github.com/OWNER/REPO/wiki/*&output=json" > wayback_wiki.json
Evidence to collect:
Archived snapshots of deleted issues/PRs with their content
Historical README versions showing changes
Evidence of content present in archive but missing from current GitHub state
ROLE BOUNDARY: You query GITHUB ARCHIVE via BIGQUERY ONLY. This is a tamper-proof record of all public GitHub events.
Prerequisites: Requires Google Cloud credentials with BigQuery access (gcloud auth application-default login). If unavailable, skip this investigator and note it in the report.
Cost Optimization Rules (MANDATORY):
ALWAYS run a --dry_run before every query to estimate cost.
Use _TABLE_SUFFIX to filter by date range and minimize scanned data.
Only SELECT the columns you need.
Add a LIMIT unless aggregating.
# Template: safe BigQuery query for PushEvents to OWNER/REPO
bq query --use_legacy_sql=false --dry_run "
SELECT created_at, actor.login, payload.commits, payload.before, payload.head,
payload.size, payload.distinct_size
FROM \`githubarchive.month.*\`
WHERE _TABLE_SUFFIX BETWEEN 'YYYYMM' AND 'YYYYMM'
AND type = 'PushEvent'
AND repo.name = 'OWNER/REPO'
LIMIT 1000
"# If cost is acceptable, re-run without --dry_run# Detect force-pushes: zero-distinct_size PushEvents mean commits were force-erased# payload.distinct_size = 0 AND payload.size > 0 → force push indicator# Check for deleted branch events
bq query --use_legacy_sql=false"
SELECT created_at, actor.login, payload.ref, payload.ref_type
FROM \`githubarchive.month.*\`
WHERE _TABLE_SUFFIX BETWEEN 'YYYYMM' AND 'YYYYMM'
AND type = 'DeleteEvent'
AND repo.name = 'OWNER/REPO'
LIMIT 200
"
Note disclosure obligations (if a public package: coordinate with the package registry)
Present the final investigation-report.md to the user.
Ethical Use Guidelines
This skill is designed for defensive security investigation — protecting open-source software from supply chain attacks. It must not be used for:
Harassment or stalking of contributors or maintainers
Doxing — correlating GitHub activity to real identities for malicious purposes
Competitive intelligence — investigating proprietary or internal repositories without authorization
False accusations — publishing investigation results without validated evidence (see anti-hallucination guardrails)
Investigations should be conducted with the principle of minimal intrusion: collect only the evidence necessary to validate or refute the hypothesis. When publishing results, follow responsible disclosure practices and coordinate with affected maintainers before public disclosure.
If the investigation reveals a genuine compromise, follow the coordinated vulnerability disclosure process:
Notify the repository maintainers privately first
Allow reasonable time for remediation (typically 90 days)
Coordinate with package registries (npm, PyPI, etc.) if published packages are affected
File a CVE if appropriate
API Rate Limiting
GitHub REST API enforces rate limits that will interrupt large investigations if not managed.
Authenticated requests: 5,000/hour (requires GITHUB_TOKEN env var or gh CLI auth)
Unauthenticated requests: 60/hour (unusable for investigations)
Best practices:
Always authenticate: export GITHUB_TOKEN=ghp_... or use gh CLI (auto-authenticates)
Use conditional requests (If-None-Match / If-Modified-Since headers) to avoid consuming quota on unchanged data
For paginated endpoints, fetch all pages in sequence — don't parallelize against the same endpoint
Check X-RateLimit-Remaining header; if below 100, pause for X-RateLimit-Reset timestamp
BigQuery has its own quotas (10 TiB/day free tier) — always dry-run first
Wayback Machine CDX API: no formal rate limit, but be courteous (1-2 req/sec max)
If rate-limited mid-investigation, record the partial results in the evidence store and note the limitation in the report.