@iamnishankhan/opencode-kit-grok 1.0.0

package/kit/.opencode/skills/vulnerability-scanner/SKILL.md

@@ -0,0 +1,278 @@
+---
+name: vulnerability-scanner
+description: Advanced vulnerability analysis principles. OWASP 2025, Supply Chain Security, attack surface mapping, risk prioritization.
+compatibility: opencode
+metadata:
+  when_to_use: "\"When scanning for security vulnerabilities, checking OWASP 2025 compliance, or analyzing supply chain security.\""
+  version: "1.0.0"
+---
+# Vulnerability Scanner
+
+> Think like an attacker, defend like an expert. 2025 threat landscape awareness.
+
+## 🔧 Runtime Scripts
+
+**Execute for automated validation:**
+
+| Script | Purpose | Usage |
+|--------|---------|-------|
+| `.opencode/scripts/security_scan.py` | Validate security principles applied | `python .opencode/scripts/security_scan.py <project_path>` |
+
+## 📋 Reference Files
+
+| File | Purpose |
+|------|---------|
+| [checklists.md](checklists.md) | OWASP Top 10, Auth, API, Data protection checklists |
+
+---
+
+## 1. Security Expert Mindset
+
+### Core Principles
+
+| Principle | Application |
+|-----------|-------------|
+| **Assume Breach** | Design as if attacker already inside |
+| **Zero Trust** | Never trust, always verify |
+| **Defense in Depth** | Multiple layers, no single point |
+| **Least Privilege** | Minimum required access only |
+| **Fail Secure** | On error, deny access |
+
+### Threat Modeling Questions
+
+Before scanning, ask:
+1. What are we protecting? (Assets)
+2. Who would attack? (Threat actors)
+3. How would they attack? (Attack vectors)
+4. What's the impact? (Business risk)
+
+---
+
+## 2. OWASP Top 10:2025
+
+### Risk Categories
+
+| Rank | Category | Think About |
+|------|----------|-------------|
+| **A01** | Broken Access Control | Who can access what? IDOR, SSRF |
+| **A02** | Security Misconfiguration | Defaults, headers, exposed services |
+| **A03** | Software Supply Chain 🆕 | Dependencies, CI/CD, build integrity |
+| **A04** | Cryptographic Failures | Weak crypto, exposed secrets |
+| **A05** | Injection | User input → system commands |
+| **A06** | Insecure Design | Flawed architecture |
+| **A07** | Authentication Failures | Session, credential management |
+| **A08** | Integrity Failures | Unsigned updates, tampered data |
+| **A09** | Logging & Alerting | Blind spots, no monitoring |
+| **A10** | Exceptional Conditions 🆕 | Error handling, fail-open states |
+
+### 2025 Key Changes
+
+```
+2021 → 2025 Shifts:
+├── SSRF merged into A01 (Access Control)
+├── A02 elevated (Cloud/Container configs)
+├── A03 NEW: Supply Chain (major focus)
+├── A10 NEW: Exceptional Conditions
+└── Focus shift: Root causes > Symptoms
+```
+
+---
+
+## 3. Supply Chain Security (A03)
+
+### Attack Surface
+
+| Vector | Risk | Question to Ask |
+|--------|------|-----------------|
+| **Dependencies** | Malicious packages | Do we audit new deps? |
+| **Lock files** | Integrity attacks | Are they committed? |
+| **Build pipeline** | CI/CD compromise | Who can modify? |
+| **Registry** | Typosquatting | Verified sources? |
+
+### Defense Principles
+
+- Verify package integrity (checksums)
+- Pin versions, audit updates
+- Use private registries for critical deps
+- Sign and verify artifacts
+
+---
+
+## 4. Attack Surface Mapping
+
+### What to Map
+
+| Category | Elements |
+|----------|----------|
+| **Entry Points** | APIs, forms, file uploads |
+| **Data Flows** | Input → Process → Output |
+| **Trust Boundaries** | Where auth/authz checked |
+| **Assets** | Secrets, PII, business data |
+
+### Prioritization Matrix
+
+```
+Risk = Likelihood × Impact
+
+High Impact + High Likelihood → CRITICAL
+High Impact + Low Likelihood  → HIGH
+Low Impact + High Likelihood  → MEDIUM
+Low Impact + Low Likelihood   → LOW
+```
+
+---
+
+## 5. Risk Prioritization
+
+### CVSS + Context
+
+| Factor | Weight | Question |
+|--------|--------|----------|
+| **CVSS Score** | Base severity | How severe is the vuln? |
+| **EPSS Score** | Exploit likelihood | Is it being exploited? |
+| **Asset Value** | Business context | What's at risk? |
+| **Exposure** | Attack surface | Internet-facing? |
+
+### Prioritization Decision Tree
+
+```
+Is it actively exploited (EPSS >0.5)?
+├── YES → CRITICAL: Immediate action
+└── NO → Check CVSS
+         ├── CVSS ≥9.0 → HIGH
+         ├── CVSS 7.0-8.9 → Consider asset value
+         └── CVSS <7.0 → Schedule for later
+```
+
+---
+
+## 6. Exceptional Conditions (A10 - New)
+
+### Fail-Open vs Fail-Closed
+
+| Scenario | Fail-Open (BAD) | Fail-Closed (GOOD) |
+|----------|-----------------|---------------------|
+| Auth error | Allow access | Deny access |
+| Parsing fails | Accept input | Reject input |
+| Timeout | Retry forever | Limit + abort |
+
+### What to Check
+
+- Exception handlers that catch-all and ignore
+- Missing error handling on security operations
+- Race conditions in auth/authz
+- Resource exhaustion scenarios
+
+---
+
+## 7. Scanning Methodology
+
+### Phase-Based Approach
+
+```
+1. RECONNAISSANCE
+   └── Understand the target
+       ├── Technology stack
+       ├── Entry points
+       └── Data flows
+
+2. DISCOVERY
+   └── Identify potential issues
+       ├── Configuration review
+       ├── Dependency analysis
+       └── Code pattern search
+
+3. ANALYSIS
+   └── Validate and prioritize
+       ├── False positive elimination
+       ├── Risk scoring
+       └── Attack chain mapping
+
+4. REPORTING
+   └── Actionable findings
+       ├── Clear reproduction steps
+       ├── Business impact
+       └── Remediation guidance
+```
+
+---
+
+## 8. Code Pattern Analysis
+
+### High-Risk Patterns
+
+| Pattern | Risk | Look For |
+|---------|------|----------|
+| **String concat in queries** | Injection | `"SELECT * FROM " + user_input` |
+| **Dynamic code execution** | RCE | `eval()`, `exec()`, `Function()` |
+| **Unsafe deserialization** | RCE | `pickle.loads()`, `unserialize()` |
+| **Path manipulation** | Traversal | User input in file paths |
+| **Disabled security** | Various | `verify=False`, `--insecure` |
+
+### Secret Patterns
+
+| Type | Indicators |
+|------|-----------|
+| API Keys | `api_key`, `apikey`, high entropy |
+| Tokens | `token`, `bearer`, `jwt` |
+| Credentials | `password`, `secret`, `key` |
+| Cloud | `AWS_`, `AZURE_`, `GCP_` prefixes |
+
+---
+
+## 9. Cloud Security Considerations
+
+### Shared Responsibility
+
+| Layer | You Own | Provider Owns |
+|-------|---------|---------------|
+| Data | ✅ | ❌ |
+| Application | ✅ | ❌ |
+| OS/Runtime | Depends | Depends |
+| Infrastructure | ❌ | ✅ |
+
+### Cloud-Specific Checks
+
+- IAM: Least privilege applied?
+- Storage: Public buckets?
+- Network: Security groups tightened?
+- Secrets: Using secrets manager?
+
+---
+
+## 10. Anti-Patterns
+
+| ❌ Don't | ✅ Do |
+|----------|-------|
+| Scan without understanding | Map attack surface first |
+| Alert on every CVE | Prioritize by exploitability + asset |
+| Ignore false positives | Maintain verified baseline |
+| Fix symptoms only | Address root causes |
+| Scan once before deploy | Continuous scanning |
+| Trust third-party deps blindly | Verify integrity, audit code |
+
+---
+
+## 11. Reporting Principles
+
+### Finding Structure
+
+Each finding should answer:
+1. **What?** - Clear vulnerability description
+2. **Where?** - Exact location (file, line, endpoint)
+3. **Why?** - Root cause explanation
+4. **Impact?** - Business consequence
+5. **How to fix?** - Specific remediation
+
+### Severity Classification
+
+| Severity | Criteria |
+|----------|----------|
+| **Critical** | RCE, auth bypass, mass data exposure |
+| **High** | Data exposure, privilege escalation |
+| **Medium** | Limited scope, requires conditions |
+| **Low** | Informational, best practice |
+
+---
+
+> **Remember:** Vulnerability scanning finds issues. Expert thinking prioritizes what matters. Always ask: "What would an attacker do with this?"

package/kit/.opencode/skills/vulnerability-scanner/checklists.md

@@ -0,0 +1,124 @@
+# Security Checklists
+
+> Quick reference checklists for security audits. Use alongside vulnerability-scanner principles.
+
+---
+
+## OWASP Top 10 Audit Checklist
+
+> Aligned to OWASP Top 10:2025.
+
+### A01: Broken Access Control
+- [ ] Authorization on all protected routes
+- [ ] Deny by default
+- [ ] Rate limiting implemented
+- [ ] CORS properly configured
+
+### A02: Security Misconfiguration
+- [ ] Unnecessary features disabled
+- [ ] Error messages sanitized
+- [ ] Security headers configured
+- [ ] Default credentials changed
+
+### A03: Software Supply Chain Failures
+- [ ] Dependencies up to date, no known vulnerabilities
+- [ ] Dependency integrity verified (lockfiles, checksums)
+- [ ] Unused dependencies removed
+- [ ] Build/CI pipeline and third-party scripts vetted
+
+### A04: Cryptographic Failures
+- [ ] Passwords hashed (bcrypt/argon2, cost 12+)
+- [ ] Sensitive data encrypted at rest
+- [ ] TLS 1.2+ for all connections
+- [ ] No secrets in code/logs
+
+### A05: Injection
+- [ ] Parameterized queries
+- [ ] Input validation on all user data
+- [ ] Output encoding for XSS
+- [ ] No eval() or dynamic code execution
+
+### A06: Insecure Design
+- [ ] Threat modeling done
+- [ ] Security requirements defined
+- [ ] Business logic validated
+
+### A07: Authentication Failures
+- [ ] MFA available
+- [ ] Session invalidation on logout
+- [ ] Session timeout implemented
+- [ ] Brute force protection
+
+### A08: Software or Data Integrity Failures
+- [ ] Dependency integrity verified
+- [ ] CI/CD pipeline secured
+- [ ] Update mechanism secured
+
+### A09: Security Logging and Alerting Failures
+- [ ] Security events logged
+- [ ] Logs protected
+- [ ] No sensitive data in logs
+- [ ] Alerting configured
+
+### A10: Mishandling of Exceptional Conditions
+- [ ] Errors handled explicitly (no silent catch/empty handlers)
+- [ ] Fail closed, not open, on unexpected state
+- [ ] No sensitive detail leaked in error responses
+
+---
+
+## Authentication Checklist
+
+- [ ] Strong password policy
+- [ ] Account lockout
+- [ ] Secure password reset
+- [ ] Session management
+- [ ] Token expiration
+- [ ] Logout invalidation
+
+---
+
+## API Security Checklist
+
+- [ ] Authentication required
+- [ ] Authorization per endpoint
+- [ ] Input validation
+- [ ] Rate limiting
+- [ ] Output sanitization
+- [ ] Error handling
+
+---
+
+## Data Protection Checklist
+
+- [ ] Encryption at rest
+- [ ] Encryption in transit
+- [ ] Key management
+- [ ] Data minimization
+- [ ] Secure deletion
+
+---
+
+## Security Headers
+
+| Header | Purpose |
+|--------|---------|
+| **Content-Security-Policy** | XSS prevention |
+| **X-Content-Type-Options** | MIME sniffing |
+| **X-Frame-Options** | Clickjacking |
+| **Strict-Transport-Security** | Force HTTPS |
+| **Referrer-Policy** | Referrer control |
+
+---
+
+## Quick Audit Commands
+
+| Check | What to Look For |
+|-------|------------------|
+| Secrets in code | password, api_key, secret |
+| Dangerous patterns | eval, innerHTML, SQL concat |
+| Dependency issues | npm audit, snyk |
+
+---
+
+> **Usage:** Copy relevant checklists into your PLAN.md or security report.

package/kit/.opencode/skills/vulnerability-scanner/scripts/dependency_analyzer.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""Offline dependency hygiene analyzer for common package ecosystems."""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+SKIP_DIRS = {"node_modules", ".git", ".agents", ".agent", ".venv", "venv", "dist", "build", ".next", "vendor"}
+SEVERITY = {"none": 99, "low": 1, "medium": 2, "high": 3, "critical": 4}
+
+
+def iter_named_files(root: Path, names: set[str]):
+    for path in root.rglob("*"):
+        if any(part in SKIP_DIRS for part in path.parts):
+            continue
+        if path.is_file() and path.name in names:
+            yield path
+
+
+def add(findings: list[dict[str, Any]], severity: str, issue: str, path: Path, detail: str) -> None:
+    findings.append({"severity": severity, "issue": issue, "file": path.as_posix(), "detail": detail})
+
+
+def analyze_package_json(path: Path, root: Path, findings: list[dict[str, Any]]) -> dict[str, Any]:
+    try:
+        data = json.loads(path.read_text("utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        add(findings, "high", "Invalid package.json", path.relative_to(root), str(exc))
+        return {"file": path.relative_to(root).as_posix(), "dependencies": 0}
+
+    deps: dict[str, str] = {}
+    for section in ("dependencies", "devDependencies", "peerDependencies", "optionalDependencies"):
+        values = data.get(section, {})
+        if isinstance(values, dict):
+            deps.update({str(k): str(v) for k, v in values.items()})
+
+    for name, spec in deps.items():
+        normalized = spec.strip().lower()
+        if normalized in {"*", "latest", "next"}:
+            add(findings, "high", "Unbounded dependency version", path.relative_to(root), f"{name}: {spec}")
+        elif normalized.startswith(("http://", "https://", "git://", "git+http://")):
+            add(findings, "high", "Dependency fetched from mutable remote", path.relative_to(root), f"{name}: {spec}")
+        elif normalized.startswith("github:") and "#" not in normalized:
+            add(findings, "medium", "GitHub dependency is not pinned to a ref", path.relative_to(root), f"{name}: {spec}")
+
+    package_dir = path.parent
+    locks = [name for name in ("package-lock.json", "npm-shrinkwrap.json", "yarn.lock", "pnpm-lock.yaml", "bun.lock", "bun.lockb") if (package_dir / name).exists()]
+    if not locks:
+        add(findings, "high", "Missing JavaScript lock file", path.relative_to(root), "Add and commit one package-manager lock file.")
+    elif len(locks) > 1:
+        add(findings, "medium", "Multiple JavaScript lock files", path.relative_to(root), ", ".join(locks))
+    return {"file": path.relative_to(root).as_posix(), "dependencies": len(deps), "lock_files": locks}
+
+
+def analyze_requirements(path: Path, root: Path, findings: list[dict[str, Any]]) -> dict[str, Any]:
+    unpinned = []
+    total = 0
+    try:
+        lines = path.read_text("utf-8").splitlines()
+    except OSError as exc:
+        add(findings, "high", "Unreadable requirements file", path.relative_to(root), str(exc))
+        return {"file": path.relative_to(root).as_posix(), "dependencies": 0}
+    for raw in lines:
+        line = raw.strip()
+        if not line or line.startswith(("#", "-r", "--", "-e")):
+            continue
+        total += 1
+        if " @ " in line or re.search(r"===|==", line):
+            continue
+        if re.match(r"^[A-Za-z0-9_.-]+(?:\[[^]]+\])?\s*(?:$|[<>!~]=?)", line):
+            unpinned.append(line)
+    for spec in unpinned[:25]:
+        add(findings, "medium", "Python dependency is not exactly pinned", path.relative_to(root), spec)
+    return {"file": path.relative_to(root).as_posix(), "dependencies": total, "unpinned": len(unpinned)}
+
+
+def analyze(root: Path) -> dict[str, Any]:
+    findings: list[dict[str, Any]] = []
+    manifests: list[dict[str, Any]] = []
+    for path in iter_named_files(root, {"package.json"}):
+        manifests.append(analyze_package_json(path, root, findings))
+    for path in iter_named_files(root, {"requirements.txt", "requirements-dev.txt", "requirements-prod.txt"}):
+        manifests.append(analyze_requirements(path, root, findings))
+
+    # Lightweight presence checks for other ecosystems.
+    for manifest, locks, ecosystem in (
+        ("Cargo.toml", ("Cargo.lock",), "Rust"),
+        ("Gemfile", ("Gemfile.lock",), "Ruby"),
+        ("go.mod", ("go.sum",), "Go"),
+        ("Pipfile", ("Pipfile.lock",), "Python/Pipenv"),
+        ("pyproject.toml", ("poetry.lock", "uv.lock", "requirements.txt"), "Python"),
+    ):
+        for path in iter_named_files(root, {manifest}):
+            present = [name for name in locks if (path.parent / name).exists()]
+            if not present:
+                add(findings, "medium", f"No recognized {ecosystem} lock/resolution file", path.relative_to(root), f"Expected one of: {', '.join(locks)}")
+
+    counts = {severity: sum(f["severity"] == severity for f in findings) for severity in ("critical", "high", "medium", "low")}
+    return {
+        "project": str(root),
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "manifests": manifests,
+        "findings": findings,
+        "summary": {"total": len(findings), **counts},
+    }
+
+
+def should_fail(report: dict[str, Any], threshold: str) -> bool:
+    if threshold == "none":
+        return False
+    rank = SEVERITY[threshold]
+    return any(report["summary"].get(level, 0) and value >= rank for level, value in SEVERITY.items() if level != "none")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Analyze dependency pinning and lock-file hygiene without network access")
+    parser.add_argument("project", nargs="?", default=".")
+    parser.add_argument("--output", choices=["json", "summary"], default="summary")
+    parser.add_argument("--fail-on", choices=list(SEVERITY), default="high")
+    args = parser.parse_args()
+    root = Path(args.project).resolve()
+    if not root.is_dir():
+        parser.error(f"Project directory does not exist: {root}")
+    report = analyze(root)
+    if args.output == "json":
+        print(json.dumps(report, indent=2, ensure_ascii=False))
+    else:
+        s = report["summary"]
+        print(f"Dependency Analysis: {root}")
+        print(f"Findings: {s['total']} (critical={s['critical']}, high={s['high']}, medium={s['medium']}, low={s['low']})")
+        for finding in report["findings"][:20]:
+            print(f"[{finding['severity'].upper()}] {finding['file']}: {finding['issue']} - {finding['detail']}")
+        if not report["findings"]:
+            print("[PASS] No dependency hygiene issues detected.")
+    return 1 if should_fail(report, args.fail_on) else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())