codejury 0.11.0__tar.gz → 0.13.1__tar.gz

codejury-0.13.1/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: codejury
+Version: 0.13.1
+Summary: AI code security review: an adversarial diff-audit engine and an agent-driven whole-repo review methodology, with security knowledge as rich rules
+Author: AISecLabs
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/aiseclabs/codejury
+Project-URL: Repository, https://github.com/aiseclabs/codejury
+Keywords: security,appsec,static analysis,llm,owasp,asvs,code review
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: json-repair>=0.30
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.40; extra == "anthropic"
+Provides-Extra: openai
+Requires-Dist: openai>=1.0; extra == "openai"
+Provides-Extra: litellm
+Requires-Dist: litellm>=1.0; extra == "litellm"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: jsonschema>=4.0; extra == "dev"
+Dynamic: license-file
+
+# codejury
+
+AI code security review, in two paths matched to their nature:
+
+- **Diff review** (coded): audit a pull request's diff for newly introduced,
+  exploitable risks. A single balanced LLM call, or an adversarial
+  Finder/Challenger/Judge pass for higher coverage and fewer false positives.
+- **Whole-repo review** (agent-driven): a methodology an interactive agent
+  (Claude Code, Codex) runs to traverse a codebase from its API entrypoints,
+  verify issues with a real PoC, and iterate over rounds with a persistent
+  memory. Too large for a single LLM call, so codejury ships the methodology and
+  scaffolds the workspace rather than running a pipeline.
+
+Security knowledge lives in **rich rules** (`codejury/data/rules/*.md`, with
+per-language vulnerable/secure examples), injected into the audit prompt, not
+buried in code.
+
+## Install
+
+```bash
+pip install codejury                 # core
+pip install "codejury[anthropic]"    # or [openai] / [litellm] for a backend
+```
+
+## Diff review
+
+```bash
+# audit a diff file
+codejury audit --diff-file changes.diff
+
+# audit a git range in a repo
+codejury audit --repo /path/to/app --git-range origin/main...HEAD
+
+# from stdin
+git diff HEAD~1 | codejury audit
+
+# adversarial mode: Finder + Challenger + Judge (higher coverage, lower FP, ~3x cost)
+codejury audit --diff-file changes.diff --mode adversarial
+
+# CI gate + SARIF
+codejury audit --diff-file changes.diff --format sarif --fail-on high
+```
+
+Configure a backend with `--provider`/`--model`/`--api-key`/`--api-base` or the
+`CODEJURY_API_KEY` / `CODEJURY_MODEL` / `CODEJURY_API_BASE` environment variables.
+`codejury dry-run` exercises the engine with a mock provider and no key.
+
+## Whole-repo review
+
+```bash
+codejury full-review /path/to/your/repo
+```
+
+This scaffolds a review workspace (`api/`, `issues/`, `analysis/`, and a
+`security-review-memory.md`), seeds the API inventory from a deterministic scan,
+and prints the methodology. Run it with an interactive agent: it reads the
+methodology and the rules, traverses the code from its API entrypoints, records
+high-confidence issues with a PoC, and asks you to confirm credentials or false
+positives along the way. Nothing runs against production.
+
+## Findings
+
+Each finding carries a file and line, a severity and category, a concrete
+exploit scenario, a recommendation, and a confidence. A false-positive filter
+drops test/mock-path and low-confidence noise; the model is also told not to
+report dependency CVEs, style notes, speculation, or config-leak-only risks.
+
+## Extending
+
+Add a vulnerability class by dropping a new `codejury/data/rules/<class>.md` with
+the standard frontmatter (title, impact, tags, triggers) and vulnerable/secure
+examples. It is data; no code change needed.

codejury-0.13.1/README.md

@@ -0,0 +1,72 @@
+# codejury
+
+AI code security review, in two paths matched to their nature:
+
+- **Diff review** (coded): audit a pull request's diff for newly introduced,
+  exploitable risks. A single balanced LLM call, or an adversarial
+  Finder/Challenger/Judge pass for higher coverage and fewer false positives.
+- **Whole-repo review** (agent-driven): a methodology an interactive agent
+  (Claude Code, Codex) runs to traverse a codebase from its API entrypoints,
+  verify issues with a real PoC, and iterate over rounds with a persistent
+  memory. Too large for a single LLM call, so codejury ships the methodology and
+  scaffolds the workspace rather than running a pipeline.
+
+Security knowledge lives in **rich rules** (`codejury/data/rules/*.md`, with
+per-language vulnerable/secure examples), injected into the audit prompt, not
+buried in code.
+
+## Install
+
+```bash
+pip install codejury                 # core
+pip install "codejury[anthropic]"    # or [openai] / [litellm] for a backend
+```
+
+## Diff review
+
+```bash
+# audit a diff file
+codejury audit --diff-file changes.diff
+
+# audit a git range in a repo
+codejury audit --repo /path/to/app --git-range origin/main...HEAD
+
+# from stdin
+git diff HEAD~1 | codejury audit
+
+# adversarial mode: Finder + Challenger + Judge (higher coverage, lower FP, ~3x cost)
+codejury audit --diff-file changes.diff --mode adversarial
+
+# CI gate + SARIF
+codejury audit --diff-file changes.diff --format sarif --fail-on high
+```
+
+Configure a backend with `--provider`/`--model`/`--api-key`/`--api-base` or the
+`CODEJURY_API_KEY` / `CODEJURY_MODEL` / `CODEJURY_API_BASE` environment variables.
+`codejury dry-run` exercises the engine with a mock provider and no key.
+
+## Whole-repo review
+
+```bash
+codejury full-review /path/to/your/repo
+```
+
+This scaffolds a review workspace (`api/`, `issues/`, `analysis/`, and a
+`security-review-memory.md`), seeds the API inventory from a deterministic scan,
+and prints the methodology. Run it with an interactive agent: it reads the
+methodology and the rules, traverses the code from its API entrypoints, records
+high-confidence issues with a PoC, and asks you to confirm credentials or false
+positives along the way. Nothing runs against production.
+
+## Findings
+
+Each finding carries a file and line, a severity and category, a concrete
+exploit scenario, a recommendation, and a confidence. A false-positive filter
+drops test/mock-path and low-confidence noise; the model is also told not to
+report dependency CVEs, style notes, speculation, or config-leak-only risks.
+
+## Extending
+
+Add a vulnerability class by dropping a new `codejury/data/rules/<class>.md` with
+the standard frontmatter (title, impact, tags, triggers) and vulnerable/secure
+examples. It is data; no code change needed.

codejury-0.13.1/codejury/__init__.py

@@ -0,0 +1,14 @@
+"""codejury: an AI code security review tool.
+
+Two paths matched to their nature: a coded diff-audit engine (standard single
+call or adversarial Finder/Challenger/Judge), and a whole-repo review run as a
+methodology by an interactive agent. Security knowledge lives in rich markdown
+rules (data/rules) injected into the audit prompt, not in a rendered schema.
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("codejury")
+except PackageNotFoundError:  # running from a source tree without an install
+    __version__ = "0.0.0"

{codejury-0.11.0 → codejury-0.13.1}/codejury/analysis/repo_model.py

@@ -51,12 +51,30 @@ def load_entrypoint_signatures(path: str | Path = ENTRYPOINTS_FILE) -> _Signatur
     return _Signatures(decorators=tuple(data.get("decorators", [])), calls=tuple(data.get("calls", [])))
 
 
-def build_repo_model_from_dir(root: str | Path, *, signatures: _Signatures | None = None) -> RepoModel:
-    """Build a RepoModel by reading a directory. Reuses RepoSource's safe walk."""
-    from codejury.sources.repo import RepoSource
+_SKIP_DIRS = frozenset({".git", ".venv", "venv", "node_modules", "__pycache__", ".mypy_cache", ".pytest_cache"})
+
+
+def _read_python_files(root: Path) -> dict[str, str]:
+    """{relative path: content} for .py files under root, skipping noise dirs and
+    symlinks that escape the tree."""
+    root = root.resolve()
+    files: dict[str, str] = {}
+    for path in root.rglob("*.py"):
+        rel = path.relative_to(root)
+        if any(part in _SKIP_DIRS for part in rel.parts):
+            continue
+        try:
+            if not path.resolve().is_relative_to(root):
+                continue  # symlink escaping the tree
+            files[str(rel)] = path.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError, ValueError):
+            continue
+    return files
 
-    files = RepoSource(root, extensions=(".py",)).read_files()
-    return build_repo_model(root, files, signatures=signatures)
+
+def build_repo_model_from_dir(root: str | Path, *, signatures: _Signatures | None = None) -> RepoModel:
+    """Build a RepoModel by reading the .py files under a directory."""
+    return build_repo_model(root, _read_python_files(Path(root)), signatures=signatures)
 
 
 def build_repo_model(root: str | Path, files: dict[str, str], *, signatures: _Signatures | None = None) -> RepoModel:

codejury-0.13.1/codejury/cli.py

@@ -0,0 +1,199 @@
+"""codejury CLI.
+
+Two entry points matched to their nature:
+
+- ``audit`` runs the coded diff engine over a unified diff: a single balanced
+  call (standard) or the adversarial Finder/Challenger/Judge pass.
+- ``full-review`` scaffolds a workspace and prints the methodology for an
+  interactive agent to run a whole-repo review (it does not run an LLM pipeline,
+  which a single call cannot do for a whole codebase).
+
+``dry-run`` exercises the diff engine with a mock provider and no API key.
+"""
+
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+
+import dataclasses
+
+from codejury.diff.debate import AdversarialAuditRunner
+from codejury.diff.engine import AuditRunner
+from codejury.diff.findings_filter import FindingsFilter
+from codejury.diff.report import gate, render
+from codejury.diff.rules import allowed_categories, normalize_category
+from codejury.domain.finding import Finding
+
+# A diff larger than this is audited file-by-file so a big PR does not overflow
+# the model's context and silently truncate the reply.
+_MAX_DIFF_CHARS = 60_000
+from codejury.fullreview.scaffold import scaffold
+from codejury.providers.factory import (
+    DEFAULT_API_BASE,
+    DEFAULT_API_KEY,
+    DEFAULT_CHALLENGER_MODEL,
+    DEFAULT_FINDER_MODEL,
+    DEFAULT_JUDGE_MODEL,
+    DEFAULT_MODEL,
+    PROVIDERS,
+    make_provider,
+)
+from codejury.providers.mock import MockProvider
+
+_FORMATS = ("text", "markdown", "json", "sarif")
+_FAIL_ON = ("critical", "high", "medium", "low")
+
+
+def _split_diff_by_file(diff: str) -> list[str]:
+    """Split a unified diff into one diff per file (`diff --git ...` boundaries)."""
+    chunks: list[str] = []
+    cur: list[str] = []
+    for line in diff.splitlines(keepends=True):
+        if line.startswith("diff --git ") and cur:
+            chunks.append("".join(cur))
+            cur = []
+        cur.append(line)
+    if cur:
+        chunks.append("".join(cur))
+    return chunks or ([diff] if diff.strip() else [])
+
+
+def _dedup_findings(findings: list[Finding]) -> list[Finding]:
+    seen: set = set()
+    out: list[Finding] = []
+    for f in findings:
+        k = (f.file, f.line, f.category, f.description)
+        if k not in seen:
+            seen.add(k)
+            out.append(f)
+    return out
+
+
+def audit_diff(
+    diff: str,
+    *,
+    provider,
+    model: str,
+    mode: str = "standard",
+    max_rounds: int = 3,
+    filter_findings: bool = True,
+    finder_model: str | None = None,
+    challenger_model: str | None = None,
+    judge_model: str | None = None,
+) -> tuple[list[Finding], list[tuple[Finding, str]]]:
+    """Audit a diff and return (kept findings, dropped (finding, reason)).
+
+    A diff over the size budget is audited one file at a time so it does not
+    overflow the context. Finding categories are normalized to the rule-id set."""
+    def _run_one(d: str) -> list[Finding]:
+        if mode == "adversarial":
+            return AdversarialAuditRunner(
+                provider=provider, model=model,
+                finder_model=finder_model, challenger_model=challenger_model, judge_model=judge_model,
+            ).run(d, max_rounds=max_rounds).findings
+        return AuditRunner(provider=provider, model=model).run(d)
+
+    if len(diff) > _MAX_DIFF_CHARS:
+        chunks = _split_diff_by_file(diff)
+        findings = _dedup_findings([f for c in chunks for f in _run_one(c)])
+    else:
+        findings = _run_one(diff)
+
+    allowed = set(allowed_categories())
+    findings = [dataclasses.replace(f, category=normalize_category(f.category, allowed)) for f in findings]
+    if filter_findings:
+        return FindingsFilter().filter(findings)
+    return findings, []
+
+
+def _read_diff(args) -> str:
+    if args.diff_file:
+        with open(args.diff_file, encoding="utf-8") as f:
+            return f.read()
+    if args.git_range:
+        return subprocess.run(
+            ["git", "-C", args.repo or ".", "diff", args.git_range],
+            capture_output=True, text=True, check=True,
+        ).stdout
+    return sys.stdin.read()
+
+
+def _dry_run_diff() -> str:
+    return "+++ b/app.py\n@@ -0,0 +1 @@\n+cursor.execute('SELECT * FROM u WHERE n=' + name)\n"
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="codejury")
+    sub = parser.add_subparsers(dest="command")
+
+    sub.add_parser("dry-run", help="run the diff engine with a mock provider, no key")
+
+    a = sub.add_parser("audit", help="audit a unified diff for security findings")
+    a.add_argument("--diff-file", default=None, help="unified diff file (default: read stdin)")
+    a.add_argument("--repo", default=None, help="repo path for --git-range")
+    a.add_argument("--git-range", default=None, help="git range to diff, e.g. origin/main...HEAD")
+    a.add_argument("--mode", choices=("standard", "adversarial"), default="standard")
+    a.add_argument("--rounds", type=int, default=3, help="adversarial debate rounds")
+    a.add_argument("--provider", choices=PROVIDERS, default="anthropic")
+    a.add_argument("--model", default=DEFAULT_MODEL)
+    a.add_argument("--finder-model", default=DEFAULT_FINDER_MODEL, help="adversarial: finder role model (default: --model)")
+    a.add_argument("--challenger-model", default=DEFAULT_CHALLENGER_MODEL, help="adversarial: challenger role model")
+    a.add_argument("--judge-model", default=DEFAULT_JUDGE_MODEL, help="adversarial: judge role model")
+    a.add_argument("--api-base", default=DEFAULT_API_BASE)
+    a.add_argument("--api-key", default=DEFAULT_API_KEY)
+    a.add_argument("--retries", type=int, default=2, help="provider retry attempts on transient failure")
+    a.add_argument("--format", choices=_FORMATS, default="text", dest="fmt")
+    a.add_argument("--no-filter", action="store_true", help="skip the false-positive filter")
+    a.add_argument("--fail-on", choices=_FAIL_ON, default=None, dest="fail_on")
+
+    fr = sub.add_parser("full-review", help="scaffold a whole-repo review for an interactive agent")
+    fr.add_argument("directory", help="target repository to review")
+    fr.add_argument("--workspace", default="codejury-review", help="where to create the review workspace")
+
+    args = parser.parse_args(argv)
+    try:
+        return _dispatch(args, parser)
+    except Exception as exc:
+        print(f"{args.command or 'codejury'} failed: {exc}", file=sys.stderr)
+        return 1
+
+
+def _dispatch(args, parser) -> int:
+    if args.command == "audit":
+        provider = make_provider(args.provider, api_key=args.api_key, api_base=args.api_base, retries=args.retries)
+        kept, _ = audit_diff(
+            _read_diff(args), provider=provider, model=args.model,
+            mode=args.mode, max_rounds=args.rounds, filter_findings=not args.no_filter,
+            finder_model=args.finder_model, challenger_model=args.challenger_model, judge_model=args.judge_model,
+        )
+        print(render(args.fmt, kept))
+        return 1 if gate(kept, args.fail_on) else 0
+
+    if args.command == "full-review":
+        res = scaffold(args.directory, args.workspace)
+        print(f"Workspace: {res.workspace}", file=sys.stderr)
+        print(f"Seeded {res.entrypoints} entrypoints into {res.workspace}/api/_entrypoints.md", file=sys.stderr)
+        print(f"Memory: {res.memory_path}", file=sys.stderr)
+        print("\nRun this review with an interactive agent (Claude Code / Codex) using the methodology below.\n")
+        print(res.methodology)
+        return 0
+
+    if args.command in (None, "dry-run"):
+        kept, _ = audit_diff(
+            _dry_run_diff(),
+            provider=MockProvider(default='{"findings": [{"file": "app.py", "line": 1, "severity": "HIGH", '
+                                          '"category": "sql_injection", "description": "[mock] no backend called", '
+                                          '"confidence": 0.9}]}'),
+            model="mock",
+        )
+        print(render("text", kept))
+        return 0
+
+    parser.print_help()
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

codejury-0.13.1/codejury/data/agent/full-review.md

@@ -0,0 +1,102 @@
+# Full Security Review — Agent Methodology
+
+A whole-repository security audit, run by an interactive coding agent (Claude
+Code, Codex, etc.), not a one-shot LLM call. It traverses the codebase from its
+API entrypoints, reasons across files, verifies issues with a real PoC, and
+iterates over multiple rounds with a persistent memory. One round is roughly
+30 minutes; run as many rounds as needed.
+
+Target repository: the directory you were given.
+Workspace: `<workspace>/<project>/` (created for you), holding `api/`,
+`issues/`, `analysis/`, and `security-review-memory.md`.
+
+---
+
+## On start (do this first)
+
+1. Read `security-review-memory.md` in the workspace if it exists:
+   - skip every pattern under "Confirmed false positives";
+   - do not re-report anything under "Fixed";
+   - weight the files under "High-risk areas" more heavily.
+2. Read `api/_entrypoints.md` (seeded for you from a deterministic scan) as the
+   starting map of HTTP routes and CLI commands.
+3. Read the relevant rule files under the shipped `rules/` for the target's stack
+   (sql-injection, idor, ssrf, authentication-jwt, insecure-deserialization, ...).
+
+## Analysis
+
+Start from the API entrypoints and read the implementation of each one. For every
+endpoint ask:
+
+- What inputs can the attacker control?
+- Is authentication, authorization, signature verification, tenant isolation, or
+  a business-state check bypassed or missing?
+- IDOR: can a user reach another user's, tenant's, or service's resource by a
+  supplied id?
+- Do privileged operations (payment, signing, approval, state change) allow state
+  bypass or replay (no nonce / time window)?
+- Mass assignment: is a user-controlled body bound wholesale into a model?
+- Signature: is a caller-supplied key trusted as the trust anchor?
+
+Record the API inventory in `api/` (one file per module: route + auth method +
+review status ✅/⚠️/❌). Record architecture understanding and high-risk paths in
+`analysis/`.
+
+## Scope
+
+Report only HIGH / CRITICAL, exploitable, high-confidence issues. **Do not report**
+(regardless of severity): dependency CVEs, style or best-practice notes,
+speculative issues you cannot tie to a concrete exploit, and risks that only
+matter if production config is leaked.
+
+## Recording an issue
+
+Write one `issues/<name>.md` per confirmed issue. Do not write an issue you cannot
+confirm with high confidence. Each must have:
+
+```markdown
+# <title>
+
+- Risk: HIGH | CRITICAL
+- Type: IDOR | auth bypass | signature flaw | business logic | ...
+- Endpoint: `<METHOD> <path>`
+
+## Analysis
+(cite exact file paths and line numbers)
+
+## Attack path
+(end-to-end, actionable steps)
+
+## PoC
+(a curl command or script that actually triggers it)
+
+## Verification
+(result of actually running the PoC in a sandbox / dev environment)
+
+## Fix
+```
+
+## PoC verification (human in the loop)
+
+Confirm each issue by running the PoC against a sandbox / dev environment. When
+you need something only the operator has, stop and ask:
+
+- an auth cookie or token,
+- an MFA step,
+- specific test data or an account.
+
+Never run a PoC against production, and never use real credentials or perform a
+destructive action without the operator's explicit go-ahead.
+
+## Iteration
+
+Each round, read the workspace history first and do not repeat finished work.
+Process leftover TODOs; otherwise pick an unreviewed (❌) or to-deepen (⚠️)
+endpoint from the API inventory. When every endpoint is ✅ and there are no TODOs,
+report the review complete.
+
+## On finish
+
+Append a row to the audit history in `security-review-memory.md`, and ask the
+operator which findings were false positives. Record those under "Confirmed false
+positives" so future rounds skip them.

codejury-0.13.1/codejury/data/agent/security-review-memory.md

@@ -0,0 +1,30 @@
+# Security Review Memory — <project>
+
+> Maintained by the security-review agent. Read at the start of every round,
+> updated at the end. It skips confirmed false positives, avoids re-reporting
+> fixed issues, and focuses on historically risky areas.
+
+## Confirmed false positives (skip, do not report)
+
+<!-- FP-001 <short description>
+- Date: YYYY-MM-DD
+- Path/pattern: `tests/` or `apps/payment/mock_*.py`
+- Type: sql_injection / auth_bypass / ...
+- Why not a real issue: <reason>
+-->
+
+## Fixed (do not report again)
+
+<!-- FIXED-001 <issue title>
+- Date / commit: YYYY-MM-DD / abc1234
+- Original issue: <summary>
+-->
+
+## High-risk areas (weight every round)
+
+<!-- - `<path>` — <reason, e.g. past auth bypass> -->
+
+## Audit history
+
+| Date | Mode | HIGH | MEDIUM | Notes |
+|------|------|------|--------|-------|

codejury-0.13.1/codejury/data/rules/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: code-security-review
+description: "Application security rules for reviewing code for exploitable vulnerabilities. Use when reviewing a diff or a codebase for security issues, or when writing code that handles untrusted input, authentication, authorization, file paths, database queries, network requests, deserialization, or cryptography. Read the matching rule before judging whether code is vulnerable."
+---
+
+# Code Security Review Rules
+
+Application-security rules, one file per weakness class under `rules/`, named by
+the specific weakness (CWE-style). Each rule states impact, the markers to hunt
+(`triggers`), and vulnerable-vs-secure examples. The diff-audit engine injects the
+rules relevant to a change into the prompt; the full-review agent reads them for
+the target's stack. A finding's `category` is one of these ids.
+
+## Rules by OWASP category
+
+### A01 Broken Access Control
+- `missing-authorization` (CWE-862)
+- `insecure-direct-object-reference` (CWE-639)
+- `cross-site-request-forgery` (CWE-352)
+- `path-traversal` (CWE-22)
+- `open-redirect` (CWE-601)
+
+### A02 Cryptographic Failures
+- `insecure-cryptography` (CWE-327)
+- `insecure-transport` (CWE-319)
+- `hardcoded-secrets` (CWE-798)
+- `information-exposure` (CWE-200/532)
+
+### A03 Injection
+- `sql-injection` (CWE-89)
+- `command-injection` (CWE-78)
+- `code-injection` (CWE-94)
+- `cross-site-scripting` (CWE-79)
+- `xml-external-entity` (CWE-611)
+- `server-side-template-injection` (CWE-1336)
+- `http-response-splitting` (CWE-113)
+
+### A04 Insecure Design / Business Logic
+- `business-logic` (CWE-840)
+- `replay-attack` (CWE-294)
+- `race-condition` (CWE-362)
+- `mass-assignment` (CWE-915)
+
+### A07 Identification and Authentication
+- `improper-authentication` (CWE-287)
+- `jwt-validation` (CWE-347)
+- `session-fixation` (CWE-384)
+
+### A08 Software and Data Integrity
+- `insecure-deserialization` (CWE-502)
+
+### A10 Server-Side Request Forgery
+- `server-side-request-forgery` (CWE-918)
+
+Report only real, exploitable, high-confidence issues with a concrete exploit
+path. Do not report dependency CVEs, style, speculation, or config-leak-only
+risks. The set is data: add a class by dropping a new `rules/<id>.md` with the
+same frontmatter (id, title, impact, tags, triggers) and examples.

codejury-0.13.1/codejury/data/rules/business-logic.md

@@ -0,0 +1,23 @@
+---
+id: business-logic
+title: Business Logic Flaw
+impact: HIGH
+tags: [cwe-840, cwe-841, owasp-a04]
+triggers: ["price", "amount", "quantity", "balance", "status", "approve", "discount", "total =", "request.json[\"price\"", "if status =="]
+---
+
+## Business Logic Flaw
+
+A stateful workflow trusts client-supplied values or does not enforce its own rules: a client-set price/amount/quantity, a state-machine step reached without its prerequisites, an approval or limit bypassed. Validate amounts and state transitions server-side from trusted data, and enforce the workflow's invariants.
+
+### Python
+Vulnerable:
+```python
+total = request.json["price"] * request.json["qty"]   # client sets the price
+order.charge(total)
+```
+Secure:
+```python
+price = Product.objects.get(id=pid).price             # price from the server
+total = price * validate_qty(request.json["qty"])
+```

codejury-0.13.1/codejury/data/rules/code-injection.md

@@ -0,0 +1,23 @@
+---
+id: code-injection
+title: Code Injection
+impact: CRITICAL
+tags: [cwe-94, owasp-a03, injection, rce]
+triggers: ["eval(", "exec(", "compile(", "pickle.loads", "new Function", "setTimeout(\"", "vm.runInContext"]
+---
+
+## Code Injection
+
+Passing untrusted input to a language evaluation primitive (eval, exec, compile, dynamic import, JS Function) lets an attacker execute arbitrary code. Never evaluate untrusted input; parse it with a data-only parser or dispatch through an allowlist.
+
+### Python
+Vulnerable:
+```python
+result = eval(request.args["expr"])
+exec(user_supplied_code)
+```
+Secure:
+```python
+import ast
+result = ast.literal_eval(request.args["expr"])   # data only, no code
+```