open-sploit 1.2.0

package/template/skills/hackerone/SKILL.md

@@ -0,0 +1,137 @@
+---
+name: hackerone
+description: HackerOne bug bounty automation - parses scope CSVs, deploys parallel pentesting agents per asset, validates PoCs, and generates platform-ready submission reports.
+---
+
+# HackerOne Bug Bounty
+
+Automates: scope parsing → parallel testing per asset → **authoritative finding validation** → submission reports.
+
+## Quick start
+
+1. Input: HackerOne program URL or scope CSV.
+2. Parse scope and program guidelines.
+3. Spawn one coordinator per eligible asset (parallel).
+4. Each coordinator runs the standard engagement flow (see `skills/coordination/SKILL.md`).
+5. Run the **`validate-findings` workflow per asset** (authoritative submission gate). Generate HackerOne reports from the validated set ONLY — never submit a finding that is not `VALID`/`REPAIRED`.
+
+## Scope CSV format
+
+Expected columns:
+- `identifier` — asset URL/domain.
+- `asset_type` — URL, WILDCARD, API, CIDR.
+- `eligible_for_submission` — must be `true`.
+- `max_severity` — critical / high / medium / low.
+- `instruction` — asset-specific notes.
+
+Parse with `skills/hackerone/tools/csv_parser.py`. Filter for `eligible_for_submission=true`.
+
+## Agent deployment
+
+One coordinator per asset, spawned in parallel:
+
+```python
+coordinator_role = Read("skills/coordination/SKILL.md")
+Agent(prompt=f"{coordinator_role}\n\nTARGET: {asset_url}\nSCOPE: {program_guidelines}\nOUTPUT_DIR: ...",
+      run_in_background=True)
+```
+
+10 assets → 10 parallel coordinators (~2-4 h vs 20-40 h sequential). Each coordinator follows `skills/coordination/SKILL.md` and `reference/role-matrix.md`.
+
+## Finding validation (authoritative submission gate)
+
+Every finding requires `poc.py` (executable exploit), `poc_output.txt` (timestamped execution proof), manual repro steps, and evidence (screenshots / HTTP captures / video). This is the input the validator consumes.
+
+**After each asset's coordinator returns, the orchestrator runs the `validate-findings` workflow for that asset and submits ONLY findings it marks `VALID` or `REPAIRED`:**
+
+```python
+v = Workflow(name="validate-findings", args={
+    "output_dir": asset_output_dir,   # the coordinator's OUTPUT_DIR
+    "target": asset_url,
+    "business_tier": "revenue",       # production/external bug-bounty scope; else "unknown"
+    "votes": 3,                       # adversarial refuters per finding (bounty = stricter)
+    "repair": True,                   # regenerate broken/absent PoCs so each finding has a runnable evidence script
+    "strict": True,                   # one failed gate => REJECTED
+})
+# v.counts -> {total, valid, repaired, rejected}; v.validated[] / v.rejected[]
+# Verdicts at {asset_output_dir}/artifacts/validated/{id}.json (+ false-positives/).
+# Asset report at {asset_output_dir}/reports/validation-report.md.
+```
+
+`validate-findings` is the authoritative gate because it directly preempts the most common HackerOne rejections: it verifies each CVE against **NVD + a recomputed CVSS base score (from the vector) + CISA KEV + the vendor advisory**, **runs (and repairs) every PoC** until it emits the evidence that proves the issue, **recomputes the risk/severity**, corroborates every claim against raw evidence, and kills false positives via **adversarial refutation**.
+
+The orchestrator is the only layer that runs this workflow (it is top-level; the workflow is one level below — legal nesting). To avoid double work, coordinators may treat their **interleaved per-finding validators** (run the instant each candidate is materialized) as a provisional self-check; the standalone `validate-findings` verdict is authoritative for submission. A `REJECTED` finding is a false positive — it never enters a submission, an appendix, or a count; its `artifacts/false-positives/{id}.json` is the sole record. Likewise a coordinator-dropped candidate (uncured DEMOTED, in `artifacts/dropped/`) is never submitted.
+
+The HackerOne PoC contract is a superset of the standard finding contract (`skills/coordination/reference/validator-role.md`).
+
+## Submission report format
+
+Build each report from a validated finding only. Required sections per HackerOne standard:
+1. Summary (2-3 sentences).
+2. Severity (CVSS + business impact; v4.0 primary, v3.1 → v3.0 → v2.0 fallback) — use the score `validate-findings` recomputed from the vector and the risk bucket it assigned, not a hand-typed number.
+3. Steps to Reproduce (numbered, clear) — mirror the validated `verification-script.py`.
+4. Visual Evidence (from `evidence/validation/`).
+5. Impact (realistic attack scenario).
+6. Remediation (actionable fixes).
+
+Validate report *format* with `skills/hackerone/tools/report_validator.py` (complements the finding validation).
+
+## Output structure
+
+Standard `OUTPUT_DIR` (`skills/coordination/reference/output-discipline.md`) plus a per-asset `reports/submissions/` containing the platform-ready markdown. `validate-findings` writes the verdicts under `artifacts/validated|false-positives/` and the asset `reports/validation-report.md`.
+
+```
+{OUTPUT_DIR}/
+├── findings/
+│   └── finding-NNN/evidence/validation/   # validate-findings proof packages
+├── reports/
+│   ├── submissions/                        # built ONLY from artifacts/validated/
+│   │   ├── H1_CRITICAL_001.md
+│   │   └── H1_HIGH_001.md
+│   ├── validation-report.md                # validate-findings asset report
+│   └── SUBMISSION_GUIDE.md
+├── recon/
+├── logs/
+└── artifacts/
+    ├── validated/          # {id}.json — submit these
+    └── false-positives/    # {id}.json — never submit these
+```
+
+## Program selection
+
+**High-value:** new programs (< 30 days), fast response (< 24 h), high bounties, large attack surface. **Avoid:** slow response (> 1 week), low bounties, restrictive scope.
+
+## Submission checklist
+
+- [ ] **`validate-findings` verdict = `VALID` or `REPAIRED`** (`artifacts/validated/{id}.json` exists). Never submit a `REJECTED` finding.
+- [ ] CVSS **recomputed from the vector** (v4.0 primary; v3.1 → v3.0 → v2.0 fallback) and matching NVD when a CVE applies (`evidence/validation/cve-verification.md`).
+- [ ] Working PoC with `poc_output.txt` (the validator re-ran/repaired it and confirmed the evidence token).
+- [ ] Step-by-step reproduction.
+- [ ] Visual evidence.
+- [ ] Realistic impact (risk score/bucket from `evidence/validation/risk-assessment.md`).
+- [ ] Remediation guidance.
+- [ ] Sensitive data sanitized.
+- [ ] Asset is `eligible_for_submission=true`.
+
+## Common rejections (preempt)
+
+| Rejection | Prevention |
+|-----------|------------|
+| Out of Scope | Verify `eligible_for_submission=true` and asset-type match |
+| Cannot Reproduce | `validate-findings` re-runs (and repairs) the PoC 3× and requires a vuln-class evidence token — only reproducible findings pass the gate |
+| Duplicate | Search disclosed reports before submission; submit quickly |
+| Insufficient Impact | Document realistic attack scenario; `validate-findings` recomputes risk/severity so the rating is defensible |
+| Incorrect severity / CVSS | `validate-findings` recomputes the base score from the vector and cross-checks NVD + KEV; any mismatch is flagged before you submit |
+
+## Tools
+
+- `skills/hackerone/tools/csv_parser.py` — parse HackerOne scope CSVs.
+- **`validate-findings` workflow** — authoritative per-asset finding validation (NVD/CVSS-math/KEV/exploit-run/repair/risk/adversarial). The submission gate; run once per asset.
+- `skills/hackerone/tools/report_validator.py` — validate report *format* completeness (the 6 submission sections). Complements `validate-findings` (which validates the *finding*); run it on each report built from a validated finding.
+- `skills/coordination/SKILL.md` — coordinator scaffold.
+
+## Usage
+
+```bash
+/hackerone <program_url_or_csv_path>
+```

package/template/skills/hackerone/reference/INTEGRATION_GUIDE.md

@@ -0,0 +1,199 @@
+# Sensitive Data Metadata Integration Guide
+
+How to track sensitive data discovery in HackerOne workflows using `SensitiveDataTracker`.
+
+## Quick Start
+
+```python
+from tools.sensitive_data_tracker import SensitiveDataTracker
+
+tracker = SensitiveDataTracker(
+    program_name="ACME Corp Bug Bounty",
+    asset_identifier="https://api.example.com",
+    output_dir="{OUTPUT_DIR}",
+)
+```
+
+## Logging Discoveries
+
+```python
+# Credentials
+tracker.add_credentials(
+    username="admin", password_hash="$2y$10$abc...", account_type="admin",
+    location="SQLi in /search", finding_id="finding-001",
+    hash_algorithm="bcrypt",
+    evidence={"poc_script": "findings/finding-001/poc.py",
+              "screenshot": "evidence/screenshots/finding-001-admin.png"},
+)
+
+# API keys
+tracker.add_api_key(
+    key_id="sk_live_abc123xyz", key_preview="sk_live_****...xyz",
+    scope=["read:users", "write:data", "admin"],
+    location="Hardcoded in React app.js",
+    finding_id="finding-003", token_type="Stripe API Key",
+)
+
+# Private keys
+tracker.add_private_key(
+    key_type="RSA", key_length=2048,
+    purpose="AWS EC2 prod key pair",
+    location=".git/config in repo",
+    finding_id="finding-005",
+    systems_accessible=["prod-api", "prod-db", "prod-cache"],
+)
+
+# Database credentials
+tracker.add_database_credentials(
+    database_type="PostgreSQL", host="db.internal.company.com", port=5432,
+    database_name="production_users",
+    location="Config file via path traversal",
+    finding_id="finding-002", records_affected=2547,
+    evidence={"poc_script": "findings/finding-002/poc.py",
+              "data_sample": "evidence/http-captures/finding-002-db-dump.txt"},
+)
+
+# PII access
+tracker.add_user_pii(
+    pii_types=["email", "phone", "home_address", "dob"],
+    records_affected=2547,
+    location="DB via SQLi", finding_id="finding-001",
+    affected_jurisdictions=["EU", "California"],
+    evidence={"sample_record": "evidence/screenshots/finding-001-pii-sample.png",
+              "count_proof": "evidence/http-captures/finding-001-record-count.txt"},
+)
+```
+
+## Finalize and Export
+
+```python
+tracker.finalize()
+report_path = tracker.export_summary()  # markdown
+# JSON saved to {OUTPUT_DIR}/artifacts/sensitive_data_metadata.json
+```
+
+## Integration Points
+
+### Hunter agent
+
+Initialize at testing start, process each returned finding through a dispatch helper that maps `credentials_found`, `api_keys_found`, `private_keys_found`, etc. into the corresponding `tracker.add_*` calls. Call `tracker.finalize()` and `tracker.export_summary()` at the end.
+
+```python
+def process_finding(finding_data, tracker):
+    for cred in finding_data.get("credentials_found", []):
+        tracker.add_credentials(
+            username=cred["username"], password_hash=cred["password_hash"],
+            account_type=cred["type"], location=cred["location"],
+            finding_id=finding_data["finding_id"],
+        )
+    for key in finding_data.get("api_keys_found", []):
+        tracker.add_api_key(
+            key_id=key["key_id"], key_preview=key["preview"],
+            scope=key["scope"], location=key["location"],
+            finding_id=finding_data["finding_id"], token_type=key["type"],
+        )
+    # ... handle other categories
+```
+
+### Pentester agent — extracting indicators from PoC output
+
+Inspect `poc_output.txt` and tag indicators by regex match before passing to the tracker.
+
+```python
+def collect_indicators(finding):
+    indicators = {k: [] for k in
+        ("credentials_found","api_keys_found","private_keys_found",
+         "database_credentials","user_pii_accessed","config_data_exposed")}
+    poc_output = open(finding["poc_output.txt"]).read()
+    if re.search(r"username[:\s]+\w+", poc_output):
+        indicators["credentials_found"].append({"detected_in": "poc_output", "type": "username"})
+    if re.search(r"(sk_live|pk_test|Bearer|Authorization)", poc_output):
+        indicators["api_keys_found"].append({"detected_in": "poc_output", "type": "api_key"})
+    if re.search(r"-----BEGIN.*PRIVATE KEY-----", poc_output):
+        indicators["private_keys_found"].append({"detected_in": "poc_output", "type": "private_key"})
+    return indicators
+```
+
+## Detection Patterns
+
+```python
+CREDENTIAL_PATTERNS = [
+    r"username[:\s]+(['\"]?)(\w+)\1",
+    r"password[:\s]+(['\"]?)(.+?)\1",
+    r"user[:\s]+(['\"]?)(\w+)\1",
+    r"pass[:\s]+(['\"]?)(.+?)\1",
+    r"admin[:\s]+(['\"]?)(\w+)\1",
+]
+API_KEY_PATTERNS = [
+    r"(sk_live|sk_test)_[A-Za-z0-9]{20,}",
+    r"(pk_live|pk_test)_[A-Za-z0-9]{20,}",
+    r"Bearer\s+[A-Za-z0-9._\-]+",
+    r"Authorization[:\s]+Bearer\s+\S+",
+    r"api[_-]?key[:\s]+(['\"]?)([A-Za-z0-9_\-]+)\1",
+]
+PRIVATE_KEY_PATTERNS = [
+    r"-----BEGIN\s+(?:RSA\s+)?PRIVATE KEY-----",
+    r"-----BEGIN\s+EC\s+PRIVATE KEY-----",
+    r"-----BEGIN\s+OPENSSH PRIVATE KEY-----",
+    r"-----BEGIN\s+PGP PRIVATE KEY BLOCK-----",
+]
+DB_CREDENTIAL_PATTERNS = [
+    r"(mongodb|postgres|mysql|mssql)://([^:]+):([^@]+)@",
+    r"db[_-]?(user|pass)[:\s]+(['\"]?)(.+?)\2",
+    r"database[_-]?(url|connection)[:\s]+(['\"]?)(.+?)\3",
+    r"jdbc:.*://(.*):(.*)@",
+]
+PII_PATTERNS = {
+    "email": r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}",
+    "phone": r"\+?1?\s*\(?(\d{3})\)?[\s.-]?(\d{3})[\s.-]?(\d{4})",
+    "ssn": r"\d{3}-\d{2}-\d{4}",
+    "credit_card": r"\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}",
+}
+```
+
+## Output
+
+- `{OUTPUT_DIR}/artifacts/sensitive_data_metadata.json` — per-finding records with `program`, `asset_identifier`, dates, `sensitive_data_categories` (credentials / api_keys_and_tokens / private_data / configuration_data / user_pii / other_sensitive), and `summary` block.
+- `{OUTPUT_DIR}/reports/sensitive_data_report.md` — summary grouped by severity, immediate actions, remediation timeline (0-1h / 1-24h / 1-7d / 30d+).
+
+## Privacy and Redaction
+
+```python
+REDACTION_RULES = {
+    "passwords": "[REDACTED]",
+    "api_keys": "****...last_4_chars",
+    "tokens": "[REDACTED]",
+    "private_keys": "[REDACTED]",
+    "credit_cards": "****-****-****-last_4",
+    "ssn": "***-**-last_4",
+    "phone": "[REDACTED]",
+    "email": "[REDACTED]",
+    "ip_address": "redacted",
+    "database_host": "[REDACTED]",
+}
+```
+
+**GDPR**: document personal-data accessed; notify supervisory authority within 72h on high risk; notify individuals if breached. **CCPA**: document Californian residents' data; respect access/delete rights; file breach notice if PII involved. **General**: minimize PII in reports, secure data in transit/storage, follow responsible-disclosure timeline.
+
+## Validation Checklist
+
+- [ ] `sensitive_data_metadata.json` generated; each item has `discovered_date`
+- [ ] Evidence references resolve to PoC / screenshots
+- [ ] Severity assigned correctly; impact assessed; remediation guidance present
+- [ ] Markdown report properly redacted; GDPR/CCPA implications noted on PII
+- [ ] Highest-risk finding identified; `sensitive_data_report.md` generated
+
+## Troubleshooting
+
+- Not tracked → tracker not initialized at start, or discovery not logged.
+- Incomplete JSON → `tracker.finalize()` not called before export.
+- Report missing → call `tracker.export_summary()` after `finalize()`; ensure output dir exists.
+- Unsure what to track → see `formats/sensitive-data-metadata.md` for the 6 categories.
+
+## References
+
+- `formats/sensitive-data-metadata.md`
+- `.claude/skills/hackerone/tools/sensitive_data_tracker.py`
+- GDPR: https://gdpr-info.eu/
+- CCPA: https://oag.ca.gov/privacy/ccpa
+- HackerOne: https://www.hackerone.com/

package/template/skills/hackerone/reference/sensitive-data-tracking.md

@@ -0,0 +1,134 @@
+# Sensitive Data Tracking Reference
+
+Track and document all credentials, tokens, API keys, and sensitive data discovered during HackerOne testing.
+
+## Data Categories
+
+| Category | Types | Default Severity |
+|----------|-------|-----------------|
+| Credentials | Usernames, passwords, hashes, service accounts | CRITICAL |
+| API Keys & Tokens | Bearer tokens, API keys, OAuth tokens, JWTs | HIGH |
+| Private Data | Private keys (RSA/EC/SSH), certificates | CRITICAL |
+| Configuration Data | Database connection strings, config files, env vars | CRITICAL |
+| User PII | Email, phone, address, SSN, DOB | CRITICAL |
+| Other Sensitive | Internal IPs, architecture info, service discovery | MEDIUM |
+
+## Metadata Schema
+
+Each engagement produces a `sensitive_data_metadata.json`:
+
+```json
+{
+  "program": "Program Name",
+  "program_handle": "handle",
+  "asset_identifier": "https://example.com",
+  "asset_type": "URL",
+  "testing_date_start": "2025-01-16T10:00:00Z",
+  "testing_date_end": "2025-01-16T14:30:00Z",
+  "tester": "Pentester Agent",
+  "sensitive_data_categories": {
+    "credentials": [],
+    "api_keys_and_tokens": [],
+    "private_data": [],
+    "configuration_data": [],
+    "user_pii": [],
+    "other_sensitive": []
+  },
+  "summary": {
+    "total_items_discovered": 0,
+    "by_category": {},
+    "by_severity": {},
+    "highest_risk_finding": null
+  }
+}
+```
+
+Each item in a category array contains: `type`, `location`, `finding_id`, `discovered_date`, `data` (redacted), `evidence` (file refs), `impact_assessment` (severity, scope), `remediation`, `status`.
+
+## Detection Patterns
+
+### Credentials
+```python
+CREDENTIAL_PATTERNS = [
+    r"username[:\s]+(['\"]?)(\w+)\1",
+    r"password[:\s]+(['\"]?)(.+?)\1",
+    r"admin[:\s]+(['\"]?)(\w+)\1"
+]
+```
+
+### API Keys
+```python
+API_KEY_PATTERNS = [
+    r"(sk_live|sk_test)_[A-Za-z0-9]{20,}",
+    r"(pk_live|pk_test)_[A-Za-z0-9]{20,}",
+    r"Bearer\s+[A-Za-z0-9._\-]+",
+    r"api[_-]?key[:\s]+(['\"]?)([A-Za-z0-9_\-]+)\1"
+]
+```
+
+### Private Keys
+```python
+PRIVATE_KEY_PATTERNS = [
+    r"-----BEGIN\s+(?:RSA\s+)?PRIVATE KEY-----",
+    r"-----BEGIN\s+EC\s+PRIVATE KEY-----",
+    r"-----BEGIN\s+OPENSSH PRIVATE KEY-----"
+]
+```
+
+### Database Credentials
+```python
+DB_CREDENTIAL_PATTERNS = [
+    r"(mongodb|postgres|mysql|mssql)://([^:]+):([^@]+)@",
+    r"jdbc:.*://(.*):(.*)@"
+]
+```
+
+### PII
+```python
+PII_PATTERNS = {
+    "email": r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}",
+    "phone": r"\+?1?\s*\(?(\d{3})\)?[\s.-]?(\d{3})[\s.-]?(\d{4})",
+    "ssn": r"\d{3}-\d{2}-\d{4}",
+    "credit_card": r"\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}"
+}
+```
+
+## Redaction Rules
+
+| Data Type | Redaction Format |
+|-----------|-----------------|
+| Passwords | `[REDACTED]` |
+| API keys | `****...last_4_chars` |
+| Tokens | `[REDACTED]` |
+| Private keys | `[REDACTED]` |
+| Credit cards | `****-****-****-last_4` |
+| SSN | `***-**-last_4` |
+| Phone/Email | `[REDACTED]` |
+| Database hosts | `[REDACTED]` |
+
+**Safe to show**: Key ID/fingerprint, last 4 chars, key type/algorithm, scope/permissions, account type.
+
+## Tracker API
+
+```python
+from tools.sensitive_data_tracker import SensitiveDataTracker
+
+tracker = SensitiveDataTracker(program_name, asset_identifier, output_dir)
+
+tracker.add_credentials(username, password_hash, account_type, location, finding_id, ...)
+tracker.add_api_key(key_id, key_preview, scope, location, finding_id, ...)
+tracker.add_private_key(key_type, key_length, purpose, location, finding_id, ...)
+tracker.add_database_credentials(database_type, host, port, database_name, location, finding_id, ...)
+tracker.add_user_pii(pii_types, records_affected, location, finding_id, ...)
+tracker.add_configuration_data(...)
+tracker.add_other_sensitive_data(...)
+
+tracker.finalize()
+tracker.export_summary()  # -> sensitive_data_report.md + sensitive_data_metadata.json
+```
+
+## Compliance Notes
+
+- **GDPR**: Document all personal data accessed. Notify supervisory authority within 72 hours if high risk. Notify affected individuals.
+- **CCPA**: Document California resident data accessed. Provide right to access/delete. File breach notification if applicable.
+- **General**: Minimize PII in reports. Secure all data during testing. Follow responsible disclosure practices.

package/template/skills/hackerone/tools/csv_parser.py

@@ -0,0 +1,185 @@
+"""
+HackerOne Scope CSV Parser
+
+Parses HackerOne scope CSV files and extracts eligible assets for testing.
+"""
+
+import csv
+from pathlib import Path
+from typing import List, Dict, Optional
+
+
+def parse_scope_csv(csv_path: str) -> List[Dict[str, str]]:
+    """
+    Parse HackerOne scope CSV file and extract eligible assets.
+
+    Args:
+        csv_path: Path to the CSV scope file
+
+    Returns:
+        List of asset dictionaries with parsed fields
+
+    Example:
+        >>> assets = parse_scope_csv("scopes_for_program.csv")
+        >>> print(assets[0])
+        {
+            'identifier': 'example.com',
+            'asset_type': 'URL',
+            'max_severity': 'critical',
+            'instruction': '',
+            'eligible_for_bounty': True,
+            'eligible_for_submission': True
+        }
+    """
+    assets = []
+    csv_file = Path(csv_path)
+
+    if not csv_file.exists():
+        raise FileNotFoundError(f"CSV file not found: {csv_path}")
+
+    with open(csv_file, 'r', encoding='utf-8') as f:
+        reader = csv.DictReader(f)
+
+        # Validate required columns
+        required_columns = ['identifier', 'asset_type', 'eligible_for_submission']
+        if not all(col in reader.fieldnames for col in required_columns):
+            raise ValueError(f"CSV missing required columns: {required_columns}")
+
+        for row_num, row in enumerate(reader, start=2):  # Start at 2 (header is 1)
+            # Only include assets eligible for submission
+            if row.get('eligible_for_submission', '').lower() != 'true':
+                continue
+
+            asset = {
+                'identifier': row['identifier'].strip(),
+                'asset_type': row['asset_type'].strip(),
+                'max_severity': row.get('max_severity', 'critical').strip(),
+                'instruction': row.get('instruction', '').strip(),
+                'eligible_for_bounty': row.get('eligible_for_bounty', 'true').lower() == 'true',
+                'eligible_for_submission': True,
+                'csv_row': row_num
+            }
+
+            # Validate identifier is not empty
+            if not asset['identifier']:
+                print(f"Warning: Skipping row {row_num} - empty identifier")
+                continue
+
+            assets.append(asset)
+
+    return assets
+
+
+def categorize_assets(assets: List[Dict[str, str]]) -> Dict[str, List[Dict[str, str]]]:
+    """
+    Categorize assets by type for organized testing.
+
+    Args:
+        assets: List of parsed assets
+
+    Returns:
+        Dictionary mapping asset types to asset lists
+
+    Example:
+        >>> categorized = categorize_assets(assets)
+        >>> print(categorized.keys())
+        dict_keys(['URL', 'WILDCARD', 'API', 'CIDR'])
+    """
+    categorized = {}
+
+    for asset in assets:
+        asset_type = asset['asset_type']
+        if asset_type not in categorized:
+            categorized[asset_type] = []
+        categorized[asset_type].append(asset)
+
+    return categorized
+
+
+def filter_by_severity(assets: List[Dict[str, str]], min_severity: str = 'low') -> List[Dict[str, str]]:
+    """
+    Filter assets by minimum severity level.
+
+    Args:
+        assets: List of parsed assets
+        min_severity: Minimum severity ('critical', 'high', 'medium', 'low')
+
+    Returns:
+        Filtered list of assets
+    """
+    severity_levels = {'low': 0, 'medium': 1, 'high': 2, 'critical': 3}
+    min_level = severity_levels.get(min_severity.lower(), 0)
+
+    filtered = []
+    for asset in assets:
+        asset_level = severity_levels.get(asset['max_severity'].lower(), 0)
+        if asset_level >= min_level:
+            filtered.append(asset)
+
+    return filtered
+
+
+def get_bounty_eligible_assets(assets: List[Dict[str, str]]) -> List[Dict[str, str]]:
+    """
+    Filter to only bounty-eligible assets.
+
+    Args:
+        assets: List of parsed assets
+
+    Returns:
+        List of bounty-eligible assets
+    """
+    return [asset for asset in assets if asset.get('eligible_for_bounty', False)]
+
+
+def generate_summary(assets: List[Dict[str, str]]) -> str:
+    """
+    Generate a summary of parsed assets.
+
+    Args:
+        assets: List of parsed assets
+
+    Returns:
+        Formatted summary string
+    """
+    total = len(assets)
+    bounty_eligible = len(get_bounty_eligible_assets(assets))
+    categorized = categorize_assets(assets)
+
+    summary = f"Total assets: {total}\n"
+    summary += f"Bounty eligible: {bounty_eligible}\n\n"
+    summary += "By type:\n"
+
+    for asset_type, type_assets in sorted(categorized.items()):
+        summary += f"  {asset_type}: {len(type_assets)}\n"
+
+    summary += "\nBy severity:\n"
+    severity_counts = {}
+    for asset in assets:
+        sev = asset['max_severity']
+        severity_counts[sev] = severity_counts.get(sev, 0) + 1
+
+    for sev in ['critical', 'high', 'medium', 'low']:
+        if sev in severity_counts:
+            summary += f"  {sev.capitalize()}: {severity_counts[sev]}\n"
+
+    return summary
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) < 2:
+        print("Usage: python csv_parser.py <csv_file>")
+        sys.exit(1)
+
+    csv_path = sys.argv[1]
+
+    try:
+        assets = parse_scope_csv(csv_path)
+        print(generate_summary(assets))
+        print(f"\nParsed {len(assets)} eligible assets from {csv_path}")
+
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)