codejury 0.12.0__tar.gz → 0.13.2__tar.gz

{codejury-0.12.0 → codejury-0.13.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codejury
-Version: 0.12.0
+Version: 0.13.2
 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
@@ -17,6 +17,7 @@ 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

{codejury-0.12.0 → codejury-0.13.2}/codejury/cli.py

@@ -17,15 +17,25 @@ 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,
@@ -36,6 +46,31 @@ _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,
     *,
@@ -44,12 +79,30 @@ def audit_diff(
     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))."""
-    if mode == "adversarial":
-        findings = AdversarialAuditRunner(provider=provider, model=model).run(diff, max_rounds=max_rounds).findings
+    """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 = AuditRunner(provider=provider, model=model).run(diff)
+        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, []
@@ -85,9 +138,12 @@ def main(argv: list[str] | None = None) -> int:
     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=0)
+    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")
@@ -110,6 +166,7 @@ def _dispatch(args, parser) -> int:
         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

codejury-0.13.2/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.2/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.2/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
+```

{codejury-0.12.0 → codejury-0.13.2}/codejury/data/rules/command-injection.md

@@ -1,8 +1,9 @@
 ---
+id: command-injection
 title: Command Injection
 impact: CRITICAL
-tags: [injection, command, cwe-78, owasp-a03]
-triggers: ["os.system", "os.popen", "subprocess", "shell=True", "exec(", "Runtime.getRuntime", "child_process", "popen"]
+tags: [cwe-78, owasp-a03, injection]
+triggers: ["os.system", "os.popen", "subprocess", "shell=True", "Runtime.getRuntime", "child_process", "popen", "exec("]
 ---
 
 ## Command Injection

codejury-0.13.2/codejury/data/rules/cross-site-request-forgery.md

@@ -0,0 +1,21 @@
+---
+id: cross-site-request-forgery
+title: Cross-Site Request Forgery
+impact: HIGH
+tags: [cwe-352, owasp-a01]
+triggers: ["@app.route", "methods=[\"POST\"", "csrf", "SameSite", "csrf_exempt", "@csrf", "form"]
+---
+
+## Cross-Site Request Forgery
+
+A state-changing request is accepted using only ambient credentials (a session cookie) with no anti-CSRF token or SameSite protection, so a malicious site can make the victim's browser perform the action. Require a CSRF token (or SameSite=strict/lax cookies + origin check) on every state-changing endpoint.
+
+### Python
+Vulnerable:
+```python
+@app.route("/account/email", methods=["POST"])
+@csrf.exempt            # disables CSRF protection on a state-changing route
+def change_email():
+    current_user.email = request.form["email"]; db.commit()
+```
+Secure: keep CSRF protection on; validate the token, or set the session cookie `SameSite="Lax"` and check the Origin header.

codejury-0.12.0/codejury/data/rules/xss.md → codejury-0.13.2/codejury/data/rules/cross-site-scripting.md

@@ -1,13 +1,14 @@
 ---
-title: Cross-Site Scripting (XSS)
+id: cross-site-scripting
+title: Cross-Site Scripting
 impact: HIGH
-tags: [xss, output-encoding, cwe-79, owasp-a03]
+tags: [cwe-79, owasp-a03, injection]
 triggers: ["innerHTML", "dangerouslySetInnerHTML", "|safe", "mark_safe", "render_template_string", "v-html", "document.write", "Markup("]
 ---
 
-## Cross-Site Scripting (XSS)
+## Cross-Site Scripting
 
-Untrusted data rendered into HTML without encoding executes as script in the victim's browser. Render data as text (textContent), rely on framework auto-escaping, and never disable it for user data.
+Untrusted data rendered into HTML without context-aware encoding executes as script in the victim's browser. Render data as text, rely on framework auto-escaping, and never disable it for user data.
 
 ### JavaScript
 Vulnerable:
@@ -21,4 +22,4 @@ el.textContent = "Hello " + username;
 
 ### Python (templates)
 Vulnerable: `return render_template_string("<div>" + user_input + "</div>")`
-Secure: rely on Jinja auto-escaping; never pass `| safe` to user data.
+Secure: rely on Jinja auto-escaping; never apply `| safe` to user data.

codejury-0.13.2/codejury/data/rules/hardcoded-secrets.md

@@ -0,0 +1,21 @@
+---
+id: hardcoded-secrets
+title: Hardcoded Secrets
+impact: HIGH
+tags: [cwe-798, cwe-259, owasp-a02]
+triggers: ["api_key =", "API_KEY =", "password =", "secret =", "token =", "sk_live", "ghp_", "aws_secret"]
+---
+
+## Hardcoded Secrets
+
+A literal credential, key, or token in source leaks with the code and cannot be rotated easily. Load secrets from environment variables or a secret manager. A variable that reads from the environment or is passed in as a parameter is fine; only an actual literal value is a finding.
+
+### Python
+Vulnerable:
+```python
+API_KEY = "sk_live_51HxQ...actual-secret"
+```
+Secure:
+```python
+api_key = os.environ["API_KEY"]
+```

codejury-0.13.2/codejury/data/rules/http-response-splitting.md

@@ -0,0 +1,24 @@
+---
+id: http-response-splitting
+title: HTTP Response Splitting
+impact: MEDIUM
+tags: [cwe-113, cwe-93, owasp-a03]
+triggers: ["set_header", "add_header", "Location", "Set-Cookie", "response.headers", "resp.headers", "make_response", "setHeader"]
+---
+
+## HTTP Response Splitting / Header Injection
+
+Putting untrusted input into a response header (or redirect Location, Set-Cookie) without stripping CR/LF lets an attacker inject headers or split the response. Strip or reject newline characters in any header value built from input; frameworks often do this, but manual header construction may not.
+
+### Python
+Vulnerable:
+```python
+resp.headers["X-Echo"] = request.args["v"]   # v may contain \r\n
+```
+Secure:
+```python
+v = request.args["v"]
+if "\n" in v or "\r" in v:
+    abort(400)
+resp.headers["X-Echo"] = v
+```

codejury-0.13.2/codejury/data/rules/improper-authentication.md

@@ -0,0 +1,26 @@
+---
+id: improper-authentication
+title: Improper Authentication
+impact: HIGH
+tags: [cwe-287, cwe-306, owasp-a07]
+triggers: ["login", "authenticate", "password ==", "== token", "auth", "bypass", "if not user", "verify_password"]
+---
+
+## Improper Authentication
+
+Authentication is missing on a protected path, can be bypassed by a logic flaw, or compares credentials unsafely (a hardcoded bypass token, a non-constant-time compare, trusting a client-asserted identity). Verify identity server-side against a trusted store before granting access; compare secrets in constant time.
+
+### Python
+Vulnerable:
+```python
+if request.headers.get("X-Auth") == "debug-bypass":   # hardcoded bypass
+    return admin_dashboard()
+if user.token == request.args["token"]:               # non-constant-time, and client-asserted
+    login(user)
+```
+Secure:
+```python
+import hmac
+if user and hmac.compare_digest(user.token, request.args["token"]):
+    login(user)
+```

codejury-0.13.2/codejury/data/rules/information-exposure.md

@@ -0,0 +1,34 @@
+---
+id: information-exposure
+title: Information Exposure
+impact: MEDIUM
+tags: [cwe-200, cwe-532, cwe-209, owasp-a02]
+triggers: ["traceback.format_exc", "str(e)", "log.info(token", "logger.debug(secret", "print(password", "DEBUG = True", "jsonify(error="]
+---
+
+## Information Exposure
+
+Sensitive data (secrets, tokens, PII) written to logs, or internal detail (stack traces, exception messages, debug output) returned to the client, helps an attacker and widens breach impact. Log only non-secret data, return a generic error to the caller, and keep detail server-side.
+
+### Python
+Vulnerable:
+```python
+logger.info("auth token: %s", token)
+return jsonify(error=traceback.format_exc()), 500
+```
+Secure:
+```python
+logger.info("auth attempt for user %s", user_id)
+app.logger.exception("auth failed"); return jsonify(error="internal error"), 500
+```
+
+### Not a finding (do not flag)
+
+This is about leaking secrets/PII or internal detail. It is not a finding to:
+- read or serve a file, make a request, or return ordinary application data,
+- log non-sensitive identifiers (a user id, a request path, a status).
+
+Reaching a file or returning a record is only information exposure when the data
+returned is itself sensitive (a secret, another user's PII) or internal (a stack
+trace, a query). A plain `open(...)` or response is not this weakness.
+

codejury-0.13.2/codejury/data/rules/insecure-cryptography.md

@@ -0,0 +1,23 @@
+---
+id: insecure-cryptography
+title: Insecure Cryptography
+impact: HIGH
+tags: [cwe-327, cwe-916, owasp-a02]
+triggers: ["hashlib.md5", "hashlib.sha1", "DES", "ECB", "MODE_ECB", "random.random", "random.randint", "md5(", "sha1("]
+---
+
+## Insecure Cryptography
+
+Weak algorithms (MD5, SHA-1, DES, RC4), ECB mode, fast hashes for passwords, static or reused IVs, and non-cryptographic randomness for security values are exploitable. Use AES-GCM or ChaCha20-Poly1305, bcrypt/scrypt/argon2 for passwords, a fresh random nonce per message, and a CSPRNG (secrets / os.urandom).
+
+### Python
+Vulnerable:
+```python
+hashlib.md5(password.encode()).hexdigest()
+token = str(random.randint(0, 999999))
+```
+Secure:
+```python
+bcrypt.hashpw(password.encode(), bcrypt.gensalt())
+token = secrets.token_urlsafe(32)
+```

{codejury-0.12.0 → codejury-0.13.2}/codejury/data/rules/insecure-deserialization.md

@@ -1,7 +1,8 @@
 ---
+id: insecure-deserialization
 title: Insecure Deserialization
 impact: CRITICAL
-tags: [deserialization, rce, cwe-502, owasp-a08]
+tags: [cwe-502, owasp-a08, rce]
 triggers: ["pickle.loads", "pickle.load", "yaml.load", "marshal.loads", "jsonpickle", "ObjectInputStream", "torch.load"]
 ---
 

codejury-0.13.2/codejury/data/rules/insecure-direct-object-reference.md

@@ -0,0 +1,25 @@
+---
+id: insecure-direct-object-reference
+title: Insecure Direct Object Reference
+impact: HIGH
+tags: [cwe-639, owasp-a01, access-control]
+triggers: ["objects.get(", "findById", "get_object_or_404", "/<id>", "/:id", "request.args", "params[", "pk=", "where id ="]
+---
+
+## Insecure Direct Object Reference
+
+A record is fetched or mutated by a user-supplied id without checking the caller owns or may access it, so an authenticated user reaches another user's, tenant's, or service's data by changing the id. Scope every object lookup to the caller's identity or tenant.
+
+### Python (Django)
+Vulnerable:
+```python
+account = Account.objects.get(id=request.GET["account_id"])
+```
+Secure:
+```python
+account = get_object_or_404(Account, id=request.GET["account_id"], owner=request.user)
+```
+
+### Node.js (Express)
+Vulnerable: `const doc = await Document.findById(req.params.id)`
+Secure: `const doc = await Document.findOne({ _id: req.params.id, userId: req.user.id })`

codejury-0.13.2/codejury/data/rules/insecure-transport.md

@@ -0,0 +1,22 @@
+---
+id: insecure-transport
+title: Insecure Transport
+impact: HIGH
+tags: [cwe-319, cwe-295, owasp-a02]
+triggers: ["http://", "verify=False", "CERT_NONE", "check_hostname", "_create_unverified", "rejectUnauthorized", "InsecureSkipVerify"]
+---
+
+## Insecure Transport
+
+Sending sensitive data over cleartext HTTP, or disabling TLS certificate/hostname verification, exposes it to interception and man-in-the-middle. Use HTTPS and leave certificate verification on (the secure default).
+
+### Python
+Vulnerable:
+```python
+requests.get("https://api.example.com/data", verify=False)
+requests.post("http://api.example.com/login", data=creds)
+```
+Secure:
+```python
+requests.get("https://api.example.com/data")   # verify defaults to True
+```

codejury-0.13.2/codejury/data/rules/jwt-validation.md

@@ -0,0 +1,22 @@
+---
+id: jwt-validation
+title: JWT Validation Flaw
+impact: HIGH
+tags: [cwe-347, cwe-345, owasp-a07]
+triggers: ["jwt.decode", "verify=False", "verify_signature", "algorithms", "none", "decode("]
+---
+
+## JWT Validation Flaw
+
+Accepting a JWT without verifying its signature, allowing the "none" algorithm, or reading claims before verification lets an attacker forge identity. Verify the signature with a fixed algorithm and validate iss/aud/exp before using any claim.
+
+### Python
+Vulnerable:
+```python
+claims = jwt.decode(token, options={"verify_signature": False})
+jwt.decode(token, key, algorithms=["none"])
+```
+Secure:
+```python
+claims = jwt.decode(token, key, algorithms=["RS256"], audience=AUD, issuer=ISS)
+```

{codejury-0.12.0 → codejury-0.13.2}/codejury/data/rules/mass-assignment.md

@@ -1,8 +1,9 @@
 ---
+id: mass-assignment
 title: Mass Assignment
 impact: HIGH
-tags: [mass-assignment, overposting, cwe-915, owasp-a08]
-triggers: ["(**request", "update(**", "setattr(", "Object.assign", ".save()", "create(**", "request.get_json"]
+tags: [cwe-915, owasp-a04, owasp-a08]
+triggers: ["(**request", "update(**", "setattr(", "Object.assign", "create(**", "request.get_json", ".save()"]
 ---
 
 ## Mass Assignment

codejury-0.13.2/codejury/data/rules/missing-authorization.md

@@ -0,0 +1,28 @@
+---
+id: missing-authorization
+title: Missing Authorization
+impact: HIGH
+tags: [cwe-862, owasp-a01, access-control]
+triggers: ["@app.route", "@router", "@login_required", "requires_", "permission", "is_admin", "role", "def delete", "def admin"]
+---
+
+## Missing Authorization
+
+A privileged or state-changing endpoint performs its action without verifying the caller is allowed to, or derives the role/permission from a client-controlled value. Enforce authorization server-side, per request, from a trusted store; a route that mutates or exposes privileged data must check the caller's rights the same way its peers do.
+
+### Python
+Vulnerable:
+```python
+@app.route("/admin/users/<uid>", methods=["DELETE"])
+def delete_user(uid):          # no authorization check
+    User.objects.get(id=uid).delete()
+
+is_admin = request.json["is_admin"]   # privilege from the client
+```
+Secure:
+```python
+@app.route("/admin/users/<uid>", methods=["DELETE"])
+@requires_admin
+def delete_user(uid):
+    User.objects.get(id=uid).delete()
+```

codejury-0.13.2/codejury/data/rules/open-redirect.md

@@ -0,0 +1,24 @@
+---
+id: open-redirect
+title: Open Redirect
+impact: MEDIUM
+tags: [cwe-601, owasp-a01]
+triggers: ["redirect(", "Location", "next=", "return_url", "redirect_uri", "sendRedirect", "res.redirect"]
+---
+
+## Open Redirect
+
+A redirect target taken from untrusted input without validation lets an attacker send victims to an attacker-controlled site (phishing, OAuth token theft). Validate the target against an allowlist of paths/hosts, or only allow relative paths.
+
+### Python
+Vulnerable:
+```python
+return redirect(request.args["next"])
+```
+Secure:
+```python
+target = request.args["next"]
+if not target.startswith("/") or target.startswith("//"):
+    target = "/"
+return redirect(target)
+```

codejury-0.13.2/codejury/data/rules/path-traversal.md

@@ -0,0 +1,34 @@
+---
+id: path-traversal
+title: Path Traversal
+impact: HIGH
+tags: [cwe-22, owasp-a01]
+triggers: ["open(", "os.path.join", "send_file", "sendfile", "readFile", "filename", "../", "upload"]
+---
+
+## Path Traversal
+
+A filesystem path built from untrusted input without containment lets `../` escape the intended directory. Resolve the path and confirm it stays within an allowed base, or use only the basename.
+
+### Python
+Vulnerable:
+```python
+open(os.path.join(UPLOAD_DIR, request.args["filename"]))
+```
+Secure:
+```python
+target = (UPLOAD_DIR / filename).resolve()
+if not target.is_relative_to(UPLOAD_DIR):
+    raise ValueError("path escapes base dir")
+```
+
+### Not a finding (do not flag)
+
+If the input is neutralized before the file operation there is no traversal:
+- `os.path.basename(name)` is applied (strips `../` and any directory parts),
+- the resolved path is confirmed within a base (`is_relative_to`, `realpath` under base),
+- the value is from an allowlist, or is a constant / trusted-config path.
+
+`open(os.path.join(BASE, os.path.basename(name)))` is safe: basename removes the
+traversal. Do not report it.
+

codejury-0.13.2/codejury/data/rules/race-condition.md

@@ -0,0 +1,26 @@
+---
+id: race-condition
+title: Race Condition (TOCTOU)
+impact: HIGH
+tags: [cwe-362, cwe-367, owasp-a04]
+triggers: ["if balance", "balance -=", "select_for_update", "get(...).save", "check", "transaction", "lock", "atomic"]
+---
+
+## Race Condition / TOCTOU
+
+A check and the action it guards run on shared state without a lock or atomic update, so two concurrent requests both pass the check (double-spend, double-redeem, limit bypass). Use a row lock, an atomic conditional update, or a transaction.
+
+### Python (Django)
+Vulnerable:
+```python
+acct = Account.objects.get(pk=pk)
+if acct.balance >= amount:
+    acct.balance -= amount; acct.save()   # concurrent requests both pass
+```
+Secure:
+```python
+with transaction.atomic():
+    acct = Account.objects.select_for_update().get(pk=pk)
+    if acct.balance >= amount:
+        acct.balance -= amount; acct.save()
+```