codejury 1.2.0__tar.gz → 1.4.0__tar.gz

{codejury-1.2.0 → codejury-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codejury
-Version: 1.2.0
+Version: 1.4.0
 Summary: AI-assisted security review for code diffs and whole repositories.
 Author: AISecLabs
 License-Expression: MIT
@@ -84,8 +84,10 @@ codejury install-slash-command                  # Claude Code
 codejury install-slash-command --agent codex    # Codex
 ```
 
-`install-slash-command` copies `/codejury-review-repo` into the selected agent's command
-directory. Pass `--dir` to install it somewhere else.
+`install-slash-command` copies `/codejury-review` into the selected agent's command
+directory. The one command dispatches by argument: a directory runs the Repo Review
+fan-out, a diff file or git range runs the coded Diff Review. Pass `--dir` to install it
+somewhere else.
 
 ## Configure a Model Backend
 
@@ -115,10 +117,10 @@ example a Claude base finder challenged by GPT and confirmed by Claude:
 
 ```bash
 export CODEJURY_CHALLENGER_PROVIDER=openai
-export CODEJURY_CHALLENGER_MODEL=...         # a GPT model, the skeptic
+export CODEJURY_CHALLENGER_MODEL=...             # a GPT model, the skeptic
 export CODEJURY_CHALLENGER_API_KEY=...
-export CODEJURY_CHALLENGER_WIRE_API=responses   # the gpt-5 reasoning models speak Responses
-export CODEJURY_JUDGE_MODEL=...              # a Claude model, the confirmer, distinct from the challenger
+export CODEJURY_CHALLENGER_WIRE_API=responses    # the gpt-5 reasoning models speak Responses
+export CODEJURY_JUDGE_MODEL=...                  # a Claude model, the confirmer, distinct from the challenger
 ```
 
 The same `CODEJURY_FINDER_*` / `CODEJURY_CHALLENGER_*` / `CODEJURY_JUDGE_*` and the matching
@@ -232,7 +234,7 @@ _pocs.md        PoC reconciliation, planned versus delivered
 Then run the interactive slash command in Claude Code or Codex:
 
 ```text
-/codejury-review-repo /path/to/repo
+/codejury-review /path/to/repo
 ```
 
 The agent maps the attack surface, fills the authorization model, runs one focused

{codejury-1.2.0 → codejury-1.4.0}/README.md

@@ -42,8 +42,10 @@ codejury install-slash-command                  # Claude Code
 codejury install-slash-command --agent codex    # Codex
 ```
 
-`install-slash-command` copies `/codejury-review-repo` into the selected agent's command
-directory. Pass `--dir` to install it somewhere else.
+`install-slash-command` copies `/codejury-review` into the selected agent's command
+directory. The one command dispatches by argument: a directory runs the Repo Review
+fan-out, a diff file or git range runs the coded Diff Review. Pass `--dir` to install it
+somewhere else.
 
 ## Configure a Model Backend
 
@@ -73,10 +75,10 @@ example a Claude base finder challenged by GPT and confirmed by Claude:
 
 ```bash
 export CODEJURY_CHALLENGER_PROVIDER=openai
-export CODEJURY_CHALLENGER_MODEL=...         # a GPT model, the skeptic
+export CODEJURY_CHALLENGER_MODEL=...             # a GPT model, the skeptic
 export CODEJURY_CHALLENGER_API_KEY=...
-export CODEJURY_CHALLENGER_WIRE_API=responses   # the gpt-5 reasoning models speak Responses
-export CODEJURY_JUDGE_MODEL=...              # a Claude model, the confirmer, distinct from the challenger
+export CODEJURY_CHALLENGER_WIRE_API=responses    # the gpt-5 reasoning models speak Responses
+export CODEJURY_JUDGE_MODEL=...                  # a Claude model, the confirmer, distinct from the challenger
 ```
 
 The same `CODEJURY_FINDER_*` / `CODEJURY_CHALLENGER_*` / `CODEJURY_JUDGE_*` and the matching
@@ -190,7 +192,7 @@ _pocs.md        PoC reconciliation, planned versus delivered
 Then run the interactive slash command in Claude Code or Codex:
 
 ```text
-/codejury-review-repo /path/to/repo
+/codejury-review /path/to/repo
 ```
 
 The agent maps the attack surface, fills the authorization model, runs one focused

{codejury-1.2.0 → codejury-1.4.0}/codejury/__init__.py

@@ -1,6 +1,6 @@
 """AI code security review tool.
 
-Two paths matched to their nature: a coded diff-audit engine, a standard single
+Two paths matched to their nature: a coded diff audit engine, a standard single
 call or an adversarial Finder/Challenger/Judge pass, and a whole-repo review run
 as a methodology by an interactive agent. Security knowledge lives in rich
 markdown vulnerability classes under knowledge/vulnerabilities, injected into the

{codejury-1.2.0 → codejury-1.4.0}/codejury/cli.py

@@ -291,7 +291,7 @@ def _add_executor_arg(target) -> None:
 
 
 def _add_audit_args(p) -> None:
-    """The diff-audit flags for `review diff`."""
+    """The diff audit flags for `review diff`."""
     p.add_argument("--file", default=None, help="unified diff file (default: read stdin)")
     p.add_argument("--repo", default=None, help="repo path for --git-range")
     p.add_argument("--git-range", default=None, help="git range to diff, e.g. origin/main...HEAD")
@@ -366,8 +366,10 @@ def main(argv: list[str] | None = None) -> int:
         _add_role_backend_args(roles, role)
 
     tuning = repo.add_argument_group("run tuning (advanced)", "only affect --run, sane defaults otherwise")
-    tuning.add_argument("--max-passes", type=int, default=24, dest="max_passes",
-                        help="cap on diverse passes before stopping")
+    tuning.add_argument("--max-passes", type=int, default=None, dest="max_passes",
+                        help="cap on diverse passes before stopping, default scales to the domain: "
+                             "(min-lens-shots + 1) * number of lenses, so every lens meets its shot "
+                             "floor with a cycle of headroom for convergence")
     tuning.add_argument("--converge-after", type=int, default=2, dest="converge_after",
                         help="stop once this many consecutive passes add no new finding")
     tuning.add_argument("--min-lens-shots", type=int, default=2, dest="min_lens_shots",
@@ -382,12 +384,12 @@ def main(argv: list[str] | None = None) -> int:
     _add_domain_arg(repo)
 
     inst = sub.add_parser("install-slash-command",
-                          help="install the /codejury-review-repo slash command for an agent")
+                          help="install the /codejury-review slash command for an agent")
     inst.add_argument("--agent", choices=("claude", "codex"), default="claude",
                       help="which agent's command directory to install into")
     inst.add_argument("--dir", default=None, help="explicit target directory, overrides --agent")
     inst.add_argument("--force", action="store_true",
-                      help="overwrite an existing codejury-review-repo.md at the destination")
+                      help="overwrite an existing codejury-review.md at the destination")
     inst.add_argument("--domain", default="web", metavar="DOMAIN",
                       help="which domain's slash command to install, one of: " + ", ".join(available_domains()))
 
@@ -411,6 +413,49 @@ def _diff_provider(args, spec, kind: str):
     return _role_provider(args, spec)
 
 
+def build_diff_providers(args):
+    """Resolve the diff seats into providers exactly as `review diff` does, so a non-CLI caller
+    such as the eval runs a case through the same wiring a user gets. Returns the base provider
+    and model the audit needs plus the per-role finder, challenger, and judge providers and
+    models, the role fields None in standard mode. The single source the CLI and the eval share,
+    so the probe cannot drift from the product on which model or seat reviews a diff."""
+    base = _base_spec(args)
+    if args.mode == "adversarial":
+        roles = {r: _role_spec(args, r, base) for r in ("finder", "challenger", "judge")}
+        kinds = {r: _seat_backend(s, args.executor) for r, s in roles.items()}
+        agent_roles = [r for r, k in kinds.items() if k == "agent"]
+        _warn_roles_under_agent(args, agent_roles)
+        if args.executor == "auto":
+            _note_subscription_fallback(agent_roles)
+        fp = _diff_provider(args, roles["finder"], kinds["finder"])
+        cp = _diff_provider(args, roles["challenger"], kinds["challenger"])
+        jp = _diff_provider(args, roles["judge"], kinds["judge"])
+        return (fp, roles["finder"]["model"], fp, roles["finder"]["model"],
+                cp, roles["challenger"]["model"], jp, roles["judge"]["model"])
+    base_kind = _seat_backend(base, args.executor)
+    if args.executor == "auto" and base_kind == "agent":
+        _note_subscription_fallback(("audit",))
+    return (_diff_provider(args, base, base_kind), base["model"], None, None, None, None, None, None)
+
+
+def diff_args_from_env(mode: str, *, executor: str = "auto", rounds: int = 3):
+    """A diff args namespace from the environment defaults, the same values `review diff` reads
+    when no flag is passed, so `build_diff_providers` builds the user's real wiring. Lets the eval
+    drive the audit through the product path rather than a hardcoded provider."""
+    from types import SimpleNamespace
+    ns = dict(provider=DEFAULT_PROVIDER, model=DEFAULT_MODEL, api_key=DEFAULT_API_KEY,
+              api_base=DEFAULT_API_BASE, retries=DEFAULT_RETRIES, timeout=DEFAULT_TIMEOUT,
+              executor=executor, mode=mode, rounds=rounds)
+    for role in ROLES:
+        d = DEFAULT_ROLE_BACKENDS[role]
+        ns[f"{role}_provider"] = d["provider"]
+        ns[f"{role}_model"] = d["model"]
+        ns[f"{role}_api_key"] = d["api_key"]
+        ns[f"{role}_api_base"] = d["api_base"]
+        ns[f"{role}_wire_api"] = d["wire_api"]
+    return SimpleNamespace(**ns)
+
+
 def _dispatch(args, parser) -> int:
     scope = getattr(args, "scope", None)
     if args.command == "review" and scope == "diff":
@@ -424,29 +469,8 @@ def _dispatch(args, parser) -> int:
         else:
             diff = _read_diff(args)
             domain = resolve_domain(args.domain, _diff_paths(diff))
-            base = _base_spec(args)
-            if args.mode == "adversarial":
-                # each seat resolves on its own key, so a keyless Claude finder and judge ride the
-                # subscription while an OpenAI challenger uses its own key. The finder backs the base
-                # default audit_diff needs, the per-role providers below override it field by field
-                roles = {r: _role_spec(args, r, base) for r in ("finder", "challenger", "judge")}
-                kinds = {r: _seat_backend(s, args.executor) for r, s in roles.items()}
-                agent_roles = [r for r, k in kinds.items() if k == "agent"]
-                _warn_roles_under_agent(args, agent_roles)
-                if args.executor == "auto":
-                    _note_subscription_fallback(agent_roles)
-                finder_provider = _diff_provider(args, roles["finder"], kinds["finder"])
-                challenger_provider = _diff_provider(args, roles["challenger"], kinds["challenger"])
-                judge_provider = _diff_provider(args, roles["judge"], kinds["judge"])
-                finder_model = roles["finder"]["model"]
-                challenger_model = roles["challenger"]["model"]
-                judge_model = roles["judge"]["model"]
-                provider, model = finder_provider, roles["finder"]["model"]
-            else:
-                base_kind = _seat_backend(base, args.executor)
-                if args.executor == "auto" and base_kind == "agent":
-                    _note_subscription_fallback(("audit",))
-                provider, model = _diff_provider(args, base, base_kind), base["model"]
+            (provider, model, finder_provider, finder_model,
+             challenger_provider, challenger_model, judge_provider, judge_model) = build_diff_providers(args)
         kept, _, degraded = audit_diff(
             diff, provider=provider, model=model,
             mode=args.mode, max_rounds=args.rounds, filter_findings=not args.no_filter,
@@ -457,7 +481,7 @@ def _dispatch(args, parser) -> int:
         print(render(args.fmt, kept))
         if degraded:
             # the adversarial judge was unusable and the result fell back to the
-            # unjudged set, so this is a failed audit, not a clean pass, invariant 3
+            # unjudged set, so this is a failed audit, not a clean pass, invariant 4
             print("error: the adversarial audit degraded on an unusable judge reply, "
                   "the result is incomplete and not a clean pass", file=sys.stderr)
         return 1 if degraded or gate(kept, args.fail_on) else 0
@@ -518,13 +542,17 @@ def _dispatch(args, parser) -> int:
               f"PoC reconciliation in {fr.workspace}/_pocs.md")
         if fr.verify and fr.verify.errors:
             print(f"WARNING: {fr.verify.errors} verification calls failed. Re-run to resume.", file=sys.stderr)
-            return 1   # fail loud: an incomplete verification is not a clean finalize, invariant 3
+            return 1   # fail loud: an incomplete verification is not a clean finalize, invariant 4
         return 0
 
     if args.command == "review" and scope == "repo" and args.run:
         from codejury.review.repo.engine import run_repo_review
         from codejury.review.repo.verifier import ModelVerifier
         domain = resolve_domain(args.domain, _repo_file_names(args.directory))
+        # scale the pass cap to the domain, so the min-lens-shots floor is always meetable and the
+        # convergence early-stop can fire, with one lens cycle of headroom above the floor
+        if args.max_passes is None:
+            args.max_passes = (args.min_lens_shots + 1) * len(domain.lenses)
         _warn_secondary_env()
         base = _base_spec(args)
         finder = _role_spec(args, "finder", base)
@@ -600,7 +628,7 @@ def _dispatch(args, parser) -> int:
                   file=sys.stderr)
         print(f"Findings written to {res.scaffold.workspace}/findings/ and {res.scaffold.workspace}/findings.json")
         # fail loud: a partial run or a run still finding issues at the cap must not exit clean,
-        # invariant 3 and the stability red line, so a non-converged run is not reported as done
+        # invariant 4 and the stability red line, so a non-converged run is not reported as done
         return 1 if failures or not acc.converged else 0
 
     if args.command == "review" and scope == "repo":
@@ -633,7 +661,7 @@ def _dispatch(args, parser) -> int:
         print(
             "This command sets up the review, it does not find anything itself. Next, have an "
             f"interactive agent follow {res.workspace}/METHODOLOGY.md to run the review, or use the "
-            "/codejury-review-repo command in Claude Code or Codex. The agent proposes findings in "
+            "/codejury-review command in Claude Code or Codex. The agent proposes findings in "
             f"{res.workspace}/candidates/, finalize confirms them into {res.workspace}/findings/."
         )
         return 0
@@ -645,14 +673,14 @@ def _dispatch(args, parser) -> int:
             "codex": Path.home() / ".codex" / "prompts",
         }
         target_dir = Path(args.dir) if args.dir else agent_dirs[args.agent]
-        dst = target_dir / "codejury-review-repo.md"
+        dst = target_dir / "codejury-review.md"
         if dst.exists() and not args.force:
             print(f"{dst} already exists. Re-run with --force to overwrite it.", file=sys.stderr)
             return 1
         target_dir.mkdir(parents=True, exist_ok=True)
         dst.write_text(slash_command_file.read_text(encoding="utf-8"), encoding="utf-8")
         print(f"Installed slash command to {dst}")
-        print("Run it in the agent with: /codejury-review-repo <repository>")
+        print("Run it in the agent with: /codejury-review <repository or diff>")
         return 0
 
     if args.command == "review":

{codejury-1.2.0 → codejury-1.4.0}/codejury/domains/base.py

@@ -97,7 +97,7 @@ class Domain:
 class BackendUnavailable(RuntimeError):
     """A tool-backed seam was asked to work but its external tool is not installed. Raised,
     never swallowed into an empty result, so a missing toolchain is a loud failure and not a
-    silently clean review, invariant 3."""
+    silently clean review, invariant 4."""
 
 
 @dataclass(frozen=True, kw_only=True)

{codejury-1.2.0 → codejury-1.4.0}/codejury/domains/evm/__init__.py

@@ -13,15 +13,22 @@ from pathlib import Path
 from codejury.domains.base import Domain
 from codejury.domains.evm.facts.slither import SlitherFacts
 
-# the repo-review pass lenses for contracts: each pass leads with one, the empty lens
-# reviews every class
+# the repo-review pass lenses for contracts: each pass leads with one class, the empty lens
+# reviews every class. A named lens is a reliable focused pass and the empty catch-all is not,
+# so every shipped contract class gets its own lens rather than relying on the catch-all.
 EVM_LENSES = (
     "access-control",
     "reentrancy",
-    "oracle-manipulation",
+    "oracle-price-manipulation",
     "accounting-precision",
     "signature-replay",
     "denial-of-service",
+    "bad-randomness",
+    "front-running",
+    "proxy-delegatecall",
+    "unchecked-low-level-call",
+    "unsafe-math",
+    "weird-erc20",
     "",
 )
 

{codejury-1.2.0 → codejury-1.4.0}/codejury/domains/evm/facts/slither.py

@@ -4,7 +4,7 @@ Solidity compiler, availability is lazy-checked so importing the domain never ne
 heavy dependency, and slither itself is imported only inside extract.
 
 A backend that cannot run fails loud rather than returning empty facts that would read as a
-clean review, invariant 3. A missing toolchain raises BackendUnavailable, a compile error
+clean review, invariant 4. A missing toolchain raises BackendUnavailable, a compile error
 in the target propagates as the native slither error.
 """
 

codejury-1.4.0/codejury/domains/evm/knowledge/guides/protocols/defi-primitives.md

@@ -0,0 +1,41 @@
+---
+id: defi-primitives
+title: DeFi Primitives
+kind: protocol
+detect:
+  content: ["getReserves", "getAmountOut", "addLiquidity", "removeLiquidity", "borrow", "repay", "liquidate", "collateral", "healthFactor", "rewardPerToken", "getVotes", "propose", "quorum", "flashLoan"]
+---
+# DeFi Primitive Review Notes
+
+Protocol-level invariants for the common money legos, the AMM, the lending market, the
+staking vault, and governance. Read the `languages/solidity` guide for the idioms. The
+high-value bugs here are cross-function and cross-contract invariants, price manipulation,
+and transaction ordering, so confirm each property against the real multi-step flow rather
+than a single function.
+
+## AMM and Pricing
+- A price read from spot reserves, `getReserves`, `slot0`, or `balanceOf`, moves in one
+  transaction under a flash loan. Use a manipulation-resistant source with a staleness and
+  a bounds check, see the oracle-price-manipulation class.
+- A swap, deposit, or redeem that enforces no minimum output and no deadline lets a
+  sandwich or a stale transaction execute at an attacker-chosen price. Confirm a `minOut`
+  and a deadline bind the trade.
+
+## Lending
+- Collateral value and the health factor are read at action time from a sound oracle, a
+  borrow cannot exceed the collateral after rounding, and a liquidation cannot be blocked
+  or front-run for free.
+- Closing or liquidating a position updates debt and collateral accounting before any
+  external transfer or token callback, see the reentrancy class.
+
+## Staking and Rewards
+- Reward accounting, the `rewardPerToken` accumulator and the per-user checkpoints, updates
+  before a stake, withdraw, or claim changes the balance it is computed from, or rewards are
+  over or under paid, see the accounting-precision class.
+
+## Governance
+- Voting power is read from a snapshot taken before the proposal, not the live balance, or
+  a flash loan borrows votes for one block to pass a proposal. Confirm a checkpoint or
+  snapshot and a timelock on execution.
+- A privileged governance or parameter action is gated to the executor and timelocked, see
+  the access-control class.

codejury-1.4.0/codejury/domains/evm/knowledge/guides/protocols/erc-standards.md

@@ -0,0 +1,39 @@
+---
+id: erc-standards
+title: ERC Token Standards
+kind: protocol
+detect:
+  content: ["ERC20", "ERC721", "ERC1155", "ERC4626", "IERC20", "transferFrom", "safeTransferFrom", "onERC721Received", "onERC1155Received", "convertToShares", "totalAssets", "decimals"]
+---
+# ERC Token Standards Review Notes
+
+These are token-standard invariants, independent of the surrounding protocol. The way each
+shows up in code differs by stack, so read the `languages/solidity` guide for the concrete
+idioms and confirm each invariant against the real flow. The high-value bugs are accounting
+divergence, share-price manipulation, and callback reentrancy rather than syntax.
+
+## ERC20
+- A `transfer` or `transferFrom` return value must be honored or wrapped with SafeERC20,
+  a token that returns false or nothing on failure makes the call look successful, see the
+  unchecked-low-level-call class.
+- A token address that is not one fixed constant may be fee-on-transfer, deflationary,
+  rebasing, or ERC777. Measure the real balance delta across the transfer for any value
+  that must be exact, do not credit the requested amount, see the weird-erc20 class.
+- Allowance has the approve then `transferFrom` race, and for a fee token the approval must
+  cover the amount plus the fee, not the amount alone.
+
+## ERC721 and ERC1155
+- `safeTransferFrom` invokes `onERC721Received` or `onERC1155Received` on the recipient, a
+  hook that hands control to a party the caller chooses, a reentrancy vector. Write state
+  before the safe transfer, see the reentrancy class.
+- `setApprovalForAll` grants blanket control of every token of an owner. Confirm it is
+  scoped to a trusted operator and revocable, and that a transfer checks owner or approval.
+
+## ERC4626 Vaults
+- Conversion rounds against the user, shares down on deposit and assets down on withdraw,
+  or value leaks to the other side, see the accounting-precision class.
+- First-depositor share-price inflation: an empty vault lets the first depositor donate
+  assets to inflate the share price and steal later deposits. Confirm a seed deposit, a
+  dead-shares mint, or a virtual-offset defense.
+- `totalAssets` must reflect real holdings, not a spot read an attacker can move in one
+  transaction, see the oracle-price-manipulation class.

{codejury-1.2.0 → codejury-1.4.0}/codejury/domains/evm/knowledge/index.md

@@ -19,11 +19,17 @@ the target. A finding's `category` is one of these ids.
 
 ### Economic and Accounting
 - `oracle-price-manipulation` spot price or balance as price, flash-loan assisted
+- `front-running` no minOut or deadline, sandwich, profitable action front-run
 - `accounting-precision` rounding, division before multiplication, ERC-4626 first-depositor inflation
+- `weird-erc20` fee-on-transfer, rebasing, ERC777 callback, received below the requested amount
+- `unsafe-math` unchecked-block overflow, narrowing downcast truncation
 
 ### Signatures
 - `signature-replay` missing nonce, chainid, or domain separator, ecrecover malleability
 
+### Randomness
+- `bad-randomness` block.timestamp, blockhash, or prevrandao as a randomness source
+
 Report only real, exploitable, high-confidence issues with a concrete exploit path and a
 fund or control impact. Do not report gas-optimization or style notes, floating-pragma or
 compiler advisories, dependency CVEs, or 0.8 checked-arithmetic overflow outside an

{codejury-1.2.0 → codejury-1.4.0}/codejury/domains/evm/knowledge/vulnerabilities/access-control.md

@@ -1,10 +1,11 @@
 ---
 id: access-control
 title: Missing or Broken Access Control
+lens: access-control
 impact: CRITICAL
 tags: [swc-105, swc-115, access-control, fund-loss]
 aliases: [missing-access-control, broken-access-control]
-triggers: ["onlyOwner", "function mint", "function burn", "function withdraw", "selfdestruct", "tx.origin", "require(msg.sender", "_mint", "setOwner", "transferOwnership", "external", "public"]
+triggers: ["onlyOwner", "function mint", "function burn", "function withdraw", "selfdestruct", "tx.origin", "require(msg.sender", "_mint", "setOwner", "transferOwnership", "function approve", "blacklist", "isBlacklisted", "whenNotPaused", "external", "public"]
 ---
 
 ## Missing or Broken Access Control
@@ -16,6 +17,14 @@ The cause is a missing modifier, a modifier on the wrong function, an authorizat
 but not the right one. Gate every state-changing privileged function to the exact role,
 and use `msg.sender`.
 
+A security gate that some entrypoints enforce and a sibling omits is a broken invariant,
+report the gap even when the omitted path does not itself move value. A token with a
+blacklist, pause, or sanctions check that runs on `transfer` and `transferFrom` but not on
+`approve`, `permit`, or `increaseAllowance` lets a barred account still take part in the
+flow, so the control is not the invariant it claims. Enumerate the sibling entrypoints a
+stated invariant should cover and name the one missing the check, do not clear it because a
+later step looks gated.
+
 ### Vulnerable
 ```solidity
 function mint(address to, uint256 amount) external {   // no access control

{codejury-1.2.0 → codejury-1.4.0}/codejury/domains/evm/knowledge/vulnerabilities/accounting-precision.md

@@ -1,6 +1,7 @@
 ---
 id: accounting-precision
 title: Accounting and Precision Error
+lens: accounting-precision
 impact: HIGH
 tags: [accounting, rounding, precision, erc4626, fund-loss]
 aliases: [accounting, precision]

codejury-1.4.0/codejury/domains/evm/knowledge/vulnerabilities/bad-randomness.md

@@ -0,0 +1,41 @@
+---
+id: bad-randomness
+title: Insecure Randomness
+lens: bad-randomness
+impact: HIGH
+tags: [swc-120, randomness, fund-loss]
+aliases: [weak-randomness, predictable-random]
+triggers: ["block.timestamp", "blockhash", "block.difficulty", "block.prevrandao", "block.number", "keccak256(abi.encodePacked(block", "random", "% "]
+---
+
+## Insecure Randomness
+
+Deriving an outcome that controls value, a lottery winner, an NFT trait, a mint order, or
+a selection, from on-chain data such as `block.timestamp`, `blockhash`, `block.number`, or
+`block.prevrandao` is predictable. A caller computes the same value in the same block, and
+a validator can influence or withhold it, so the result is gamed and the payout is stolen.
+Use a verifiable randomness source such as a VRF, or a commit-reveal scheme where the seed
+is fixed before it can be known.
+
+The timestamp-dependence variant is the same root cause applied to time, not selection: a
+proposer can nudge `block.timestamp` by a few seconds, so logic that gates an auction close,
+a vesting unlock, a deadline, or a reward rate on an exact `block.timestamp` comparison is
+manipulable at the margin. Use a tolerance band, a block-number gate, or an oracle time
+rather than trusting `block.timestamp` to the second.
+
+### Vulnerable
+```solidity
+function drawWinner(address[] calldata players) external {
+    uint256 i = uint256(keccak256(abi.encodePacked(block.timestamp, block.prevrandao))) % players.length;
+    _payout(players[i]);   // any player predicts i in the same block
+}
+```
+
+### Secure
+```solidity
+function drawWinner(uint256 requestId) external {
+    uint256 random = vrf.randomness(requestId);   // unpredictable until the VRF fulfills
+    uint256 i = random % playerCount;
+    _payout(players[i]);
+}
+```

{codejury-1.2.0 → codejury-1.4.0}/codejury/domains/evm/knowledge/vulnerabilities/denial-of-service.md

@@ -1,8 +1,9 @@
 ---
 id: denial-of-service
 title: Denial of Service
+lens: denial-of-service
 impact: HIGH
-tags: [swc-113, swc-128, dos, griefing, gas]
+tags: [swc-113, swc-128, dos, griefing, gas, fund-loss]
 aliases: [dos]
 triggers: ["for (", "while (", ".length", "push(", "transfer(", "revert", "external call", "unbounded", "for(uint", "selfdestruct"]
 ---

codejury-1.4.0/codejury/domains/evm/knowledge/vulnerabilities/front-running.md

@@ -0,0 +1,50 @@
+---
+id: front-running
+title: Front-Running and Slippage
+lens: front-running
+impact: HIGH
+tags: [swc-114, front-running, mev, sandwich, slippage, fund-loss]
+aliases: [mev, sandwich, slippage, frontrunning, front-run]
+triggers: ["swap", "minOut", "amountOutMin", "minAmountOut", "amountOutMinimum", "deadline", "getAmountOut", "addLiquidity", "removeLiquidity", "swapExactTokensForTokens", "0, path", "claim", "harvest"]
+---
+
+## Front-Running and Slippage
+
+A state-changing action is ordered against the victim in the mempool. A swap, deposit,
+or redeem that enforces no minimum output and no deadline executes at an attacker-chosen
+price, or a profitable action is observed and front-run. The classic shape is a sandwich,
+the attacker buys ahead of the victim, lets the victim's trade move the price, then sells
+into it. Bind every trade with a caller-supplied `minOut` and a `deadline`, and treat any
+value the transaction derives from a movable on-chain source as untrusted, see the
+oracle-price-manipulation class.
+
+### Vulnerable
+```solidity
+function zapIn(uint256 amountIn) external {
+    // minOut hardcoded to 0 and block.timestamp as the deadline, so a sandwich sets the price
+    uint256[] memory out = router.swapExactTokensForTokens(
+        amountIn, 0, path, address(this), block.timestamp
+    );
+    deposit(out[out.length - 1]);
+}
+```
+
+### Secure
+```solidity
+function zapIn(uint256 amountIn, uint256 minOut, uint256 deadline) external {
+    uint256[] memory out = router.swapExactTokensForTokens(
+        amountIn, minOut, path, address(this), deadline
+    );
+    deposit(out[out.length - 1]);
+}
+```
+
+### Not a Finding
+
+A trade that passes the caller's `minOut` and `deadline` straight through to the router
+is the expected control and is not reportable. Report it only when the slippage bound is
+hardcoded to 0, the deadline is replaced with `block.timestamp` so it can never expire,
+`minOut` is computed from a spot price read in the same call, or a privileged action's
+ordering grants a concrete and quantifiable fund advantage. A pure view function, an
+action with no economic ordering advantage, or generic mempool-visibility commentary is
+not a finding.

{codejury-1.2.0 → codejury-1.4.0}/codejury/domains/evm/knowledge/vulnerabilities/oracle-price-manipulation.md

@@ -1,6 +1,7 @@
 ---
 id: oracle-price-manipulation
 title: Oracle and Price Manipulation
+lens: oracle-price-manipulation
 impact: CRITICAL
 tags: [oracle, price-manipulation, flash-loan, fund-loss]
 aliases: [oracle, oracle-manipulation, oracle-validation, price-manipulation]

{codejury-1.2.0 → codejury-1.4.0}/codejury/domains/evm/knowledge/vulnerabilities/proxy-delegatecall.md

@@ -1,6 +1,7 @@
 ---
 id: proxy-delegatecall
 title: Proxy, Delegatecall, and Initializer Flaws
+lens: proxy-delegatecall
 impact: CRITICAL
 tags: [swc-112, delegatecall, proxy, initializer, upgrade, fund-loss]
 aliases: [delegatecall, unprotected-upgrade]

codejury-1.4.0/codejury/domains/evm/knowledge/vulnerabilities/reentrancy.md

@@ -0,0 +1,61 @@
+---
+id: reentrancy
+title: Reentrancy
+lens: reentrancy
+impact: CRITICAL
+tags: [swc-107, reentrancy, fund-loss]
+aliases: [read-only-reentrancy]
+triggers: [".call{value", ".call(", "transfer(", "send(", "external call", "balances[", "withdraw", "nonReentrant", "safeTransfer", "onERC721Received", "tokensToSend", "tokensReceived", "ERC777", "buyout", "before state", "get_virtual_price", "getReserves", "getRate", "sharePrice", "view returns", "balanceOf(address(this))"]
+---
+
+## Reentrancy
+
+An external call hands control to the callee before the contract finishes updating its
+own state, so the callee can call back in and act on the stale pre-update state. The
+classic form drains a balance by re-entering a withdraw before the balance is zeroed.
+Cross-function reentrancy re-enters a different function that shares the same state, and
+read-only reentrancy reads a view mid-update from another protocol. The read-only form
+needs no state write in the reentered call: a price or share view such as a Curve
+`get_virtual_price`, a Balancer `getRate`, or a `getReserves` or `balanceOf(address(this))`
+spot read returns a stale value while a withdraw or exit has sent value but not yet synced
+its reserves, and a consumer that prices collateral off that view is fooled. Write state
+before the external call, or guard with `nonReentrant`, and remember a guard on the mutating
+function does not stop the cross-contract read-only form, the view must be consistent at the
+moment of the external call.
+
+A token transfer is an external call too. An ERC777 token runs a `tokensToSend` hook on
+the sender and a `tokensReceived` hook on the recipient, and other tokens add their own
+transfer callback, so a plain `transfer` or `safeTransfer` of an ERC20 can hand control to
+an attacker exactly like a raw `call`. Treat any token whose address is not a fixed trusted
+constant as possibly hook bearing and check every token-move path for reentrancy, not only
+the `call{value}` paths. Clearing a path because the token is assumed to be a normal ERC20
+with no hook is an assumed off-file control unless the token set is pinned to a known
+allowlist, so keep the finding, see the recall red line.
+
+Ordering effects before interactions in the one function under review is not enough on its
+own. A transfer hook can reenter a different function that reads or writes the same position,
+loan, or reserve while this flow is only half finished, the cross-function form, so trace
+where control can go during every transfer and check the whole flow's invariants, not just
+the local ones. In a lending, auction, or buyout flow that pays the current holder before it
+finalizes the position's terms, that payout is the callback window, so audit the order of
+the payout against the state writes.
+
+### Vulnerable
+```solidity
+function withdraw() external {
+    uint256 bal = balances[msg.sender];
+    (bool ok, ) = msg.sender.call{value: bal}("");   // call before the state update
+    require(ok);
+    balances[msg.sender] = 0;                          // too late, attacker reentered
+}
+```
+
+### Secure
+```solidity
+function withdraw() external nonReentrant {
+    uint256 bal = balances[msg.sender];
+    balances[msg.sender] = 0;                          // effects before interaction
+    (bool ok, ) = msg.sender.call{value: bal}("");
+    require(ok);
+}
+```