codejury 1.2.0__tar.gz → 1.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codejury
-Version: 1.2.0
+Version: 1.3.0
 Summary: AI-assisted security review for code diffs and whole repositories.
 Author: AISecLabs
 License-Expression: MIT
@@ -115,10 +115,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

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

@@ -73,10 +73,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

{codejury-1.2.0 → codejury-1.3.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.3.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")

codejury-1.3.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.3.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.3.0}/codejury/domains/evm/knowledge/index.md

@@ -20,10 +20,15 @@ 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
 - `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.3.0/codejury/domains/evm/knowledge/vulnerabilities/bad-randomness.md

@@ -0,0 +1,34 @@
+---
+id: bad-randomness
+title: Insecure 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.
+
+### 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.3.0/codejury/domains/evm/knowledge/vulnerabilities/unsafe-math.md

@@ -0,0 +1,31 @@
+---
+id: unsafe-math
+title: Unchecked Math and Unsafe Cast
+impact: HIGH
+tags: [swc-101, overflow, downcast, fund-loss]
+aliases: [unchecked-math, unsafe-cast, downcast-truncation]
+triggers: ["unchecked", "uint128", "uint96", "uint64", "uint32", "int128", "SafeCast", "toUint", "downcast", "overflow"]
+---
+
+## Unchecked Math and Unsafe Cast
+
+Solidity 0.8 reverts on overflow by default, but arithmetic inside an `unchecked` block,
+or any code on a pre-0.8 pragma, wraps silently. Separately, a narrowing cast such as
+`uint256` to `uint128` truncates the high bits with no revert, so a large value becomes a
+small one. Either corrupts accounting, a balance, a share count, or a fee, and the
+contract acts on the wrong number. Keep value math checked, and use a checked cast such as
+OpenZeppelin SafeCast when narrowing a width.
+
+### Vulnerable
+```solidity
+function record(uint256 amount) external {
+    totalShares += uint128(amount);   // a value above 2**128-1 truncates, supply under-counts
+}
+```
+
+### Secure
+```solidity
+function record(uint256 amount) external {
+    totalShares += SafeCast.toUint128(amount);   // reverts instead of truncating
+}
+```

codejury-1.3.0/codejury/domains/evm/knowledge/vulnerabilities/weird-erc20.md

@@ -0,0 +1,42 @@
+---
+id: weird-erc20
+title: Weird ERC20 Behavior
+impact: HIGH
+tags: [fee-on-transfer, rebasing, erc777, accounting, fund-loss]
+aliases: [fee-on-transfer, deflationary-token, rebasing-token, erc777-hook]
+triggers: ["transferFrom", "transfer(", "balanceOf", "amount", "ERC777", "tokensReceived", "tokensToSend", "rebas", "fee", "safeTransferFrom", "received"]
+---
+
+## Weird ERC20 Behavior
+
+A contract that integrates an arbitrary token often assumes the token moves exactly the
+requested `amount`, returns true, and never hands back control. Many real tokens break
+those assumptions. A fee-on-transfer or deflationary token delivers less than `amount`,
+so crediting the caller the requested amount over-credits a deposit and inflates shares,
+balances, or accounting against the pool. A rebasing token changes balances out from
+under a stored amount, so a figure recorded at deposit no longer matches the real
+balance. An ERC777 token runs a `tokensReceived` or `tokensToSend` hook inside a plain
+`transfer` or `transferFrom`, handing control to a party the caller chooses, which is a
+reentrancy vector covered in reentrancy. The boundary with unchecked-low-level-call is
+that the return value here is honored, the bug is that the amount moved is not the amount
+assumed. For value that must be exact, measure the real balance delta across the transfer
+rather than trusting the requested amount, and treat a token address that is not one
+fixed constant as possibly any of these.
+
+### Vulnerable
+```solidity
+function deposit(uint256 amount) external {
+    token.transferFrom(msg.sender, address(this), amount);
+    shares[msg.sender] += amount;        // credits the requested amount, a fee token delivered less
+}
+```
+
+### Secure
+```solidity
+function deposit(uint256 amount) external {
+    uint256 balanceBefore = token.balanceOf(address(this));
+    token.transferFrom(msg.sender, address(this), amount);
+    uint256 received = token.balanceOf(address(this)) - balanceBefore;
+    shares[msg.sender] += received;       // credit only what actually arrived
+}
+```

{codejury-1.2.0 → codejury-1.3.0}/codejury/domains/evm/playbook/methodology.md

@@ -48,7 +48,7 @@ by contract: every `external` and `public` function, plus `fallback` and `receiv
 each record the contract, the function, the access control on it, owner-only or
 role-gated or open, and a review status.
 
-Then record two cross-cutting artifacts in `inventory/`:
+Then record three cross-cutting artifacts in `inventory/`:
 
 - **The role and ownership model**: every privileged role, owner, admin, governance, the
   minter and upgrader, which functions each can call, and how a role is granted or
@@ -57,6 +57,13 @@ Then record two cross-cutting artifacts in `inventory/`:
   balances, the share and accounting math, the price and oracle sources, and every path
   that mints, burns, or moves value, since a value-leak has no obvious entrypoint and an
   entrypoint-anchored read misses it.
+- **The intent invariants**: the operator-seeded `inventory/_invariants.md`, the core
+  assets, who may legitimately move each, and the properties that must always hold,
+  conservation of value, single-use of a nonce or voucher, monotonic supply and balances,
+  ownership of a position, ordering across a multi-call flow, with the blast radius if one
+  breaks. A static read sees the modifiers but not the protocol's intended accounting, so
+  this names the intent a unit checks against. When the operator left it blank, it seeds
+  nothing and a unit reviews exactly as before.
 
 ---
 

{codejury-1.2.0 → codejury-1.3.0}/codejury/domains/evm/playbook/slash-command.md

@@ -30,13 +30,16 @@ happens inside each sub-review, never in this main context.
    - `units/`, one unit per candidate contract carrying its deep-review mandate and `- Status: open`
    - `inventory/_surface.md`, the coverage denominator
    - `inventory/_auth_model.md`, for the role and ownership model
+   - `inventory/_invariants.md`, the operator-seeded intent invariants, optional
    - `inventory/_severity.md`, the fund-loss grading rubric
 
    Read `METHODOLOGY.md` once for the full process.
 
 2. MAP. Make the worklist complete. Enumerate every external and public function, plus
    `fallback` and `receive`, into `inventory/_surface.md`, and fill `inventory/_auth_model.md`
-   with the role and ownership model and the value map. For anything the seeded units miss,
+   with the role and ownership model and the value map. If the operator seeded
+   `inventory/_invariants.md` with intent invariants, leave it for the units to check, and
+   if it is blank do not invent rows, an unseeded invariants file changes nothing. For anything the seeded units miss,
    add a unit file by copying the mandate from a seeded one: contracts no glob flagged, and
    sequence units for a multi-step or multi-contract flow whose invariant spans several
    calls. Every entrypoint in the surface must be owned by some unit.
@@ -44,8 +47,8 @@ happens inside each sub-review, never in this main context.
 3. FAN OUT. This step is mechanical, not a matter of judgment. For every unit in `units/`
    with `- Status: open`, launch one sub-review per unit as a separate subagent, in
    parallel. One per unit, no unit skipped. Give each only its unit file plus the shared
-   `_stack.md`, `inventory/_auth_model.md`, `inventory/_severity.md`, and
-   `_vulnerabilities.md`. Each sub-review reads its files, traces into inherited base
+   `_stack.md`, `inventory/_auth_model.md`, `inventory/_invariants.md`,
+   `inventory/_severity.md`, and `_vulnerabilities.md`. Each sub-review reads its files, traces into inherited base
    contracts, libraries, and called contracts, hunts the high-impact classes, reentrancy,
    access control, oracle manipulation, accounting, proxy and initializer flaws, signature
    replay, unchecked calls, DoS, verifies each control on the code it reads, refutes its own

{codejury-1.2.0 → codejury-1.3.0}/codejury/domains/evm/playbook/unit-review.md

@@ -8,13 +8,15 @@ trace each one into the internal functions, libraries, base contracts it inherit
 external contracts it calls, down to where value moves or state changes. The flaw often
 lives in an inherited modifier, a library, or a called protocol, not the entrypoint. Read
 the shared `_stack.md` and `inventory/_auth_model.md` for the role and ownership model,
-`_vulnerabilities.md` for the class definitions with vulnerable and secure examples, and
-`_false_positive_traps.md` for the recurring ways a static read misjudges them.
+`inventory/_invariants.md` for the operator-seeded intent invariants, `_vulnerabilities.md`
+for the class definitions with vulnerable and secure examples, and `_false_positive_traps.md`
+for the recurring ways a static read misjudges them.
 
 Hunt the high-impact classes: reentrancy, missing or broken access control, oracle and
 price manipulation, accounting and precision errors, proxy, delegatecall, and initializer
-flaws, signature replay, unchecked low-level calls, and denial of service. Money is the
-asset, grade every finding by funds moved, locked, or stolen.
+flaws, signature replay, unchecked low-level calls, weird ERC20 behavior such as
+fee-on-transfer and rebasing tokens, and denial of service. Money is the asset, grade
+every finding by funds moved, locked, or stolen.
 
 For every control on the path, decide on the code you actually read, never on the presence
 of a named guard:
@@ -64,6 +66,19 @@ of a named guard:
   separator, the signer checked nonzero? A signature alone is replayable.
 - **Trusted-source**: a value is not safe because a caller you treat as trusted set it, if
   that caller is an arbitrary external account or contract.
+- **Seeded invariant**: `inventory/_invariants.md` may name a property the operator asserts
+  must always hold, conservation of value, single-use of a nonce or voucher, monotonic
+  supply or balances, ownership of a position, ordering across a flow. Apply it only to the
+  invariants whose assets or functions this unit's code actually touches, and skip every
+  other row. For each one that applies, trace whether a reachable path can break the
+  property, an unconserved mint, a reused signature, a balance moved the wrong way, a
+  position mutated by a non-owner, a step run out of order, and treat a breakable invariant
+  as a finding, the same as any guard you read. Decide on the code you read, not on the row:
+  a seeded property is a hypothesis to test against this path, never a finding on its own.
+  When the file is blank, or no seeded row touches this unit's code, there is nothing to
+  check here and you report nothing for it. A confirmed break is graded by funds moved,
+  locked, or stolen per the rubric, the seeded blast radius is its floor, and a property the
+  code preserves is a cleared control you record, not a finding.
 
 Refute in place: name the one controlling fact that would make the code safe, read that
 exact code, including inherited modifiers and the called contract, and settle it. Confirmed

{codejury-1.2.0 → codejury-1.3.0}/codejury/domains/web/knowledge/index.md

@@ -30,12 +30,17 @@ of these ids.
 - `xml-external-entity` CWE-611
 - `server-side-template-injection` CWE-1336
 - `http-response-splitting` CWE-113
+- `nosql-injection` CWE-943
 
 ### A04 Insecure Design / Business Logic
 - `business-logic` CWE-840
 - `replay-attack` CWE-294
 - `race-condition` CWE-362
 - `mass-assignment` CWE-915
+- `unrestricted-file-upload` CWE-434
+
+### A05 Security Misconfiguration
+- `cors-misconfiguration` CWE-942
 
 ### A07 Identification and Authentication
 - `improper-authentication` CWE-287
@@ -44,6 +49,7 @@ of these ids.
 
 ### A08 Software and Data Integrity
 - `insecure-deserialization` CWE-502
+- `prototype-pollution` CWE-1321
 
 ### A10 Server-Side Request Forgery
 - `server-side-request-forgery` CWE-918

codejury-1.3.0/codejury/domains/web/knowledge/vulnerabilities/cors-misconfiguration.md

@@ -0,0 +1,45 @@
+---
+id: cors-misconfiguration
+title: CORS Misconfiguration
+impact: MEDIUM
+tags: [cwe-942, owasp-a05]
+triggers: ["Access-Control-Allow-Origin", "Access-Control-Allow-Credentials", "cors(", "origin", "req.headers.origin", "ACAO"]
+---
+
+## CORS Misconfiguration
+
+A server that reflects the request `Origin` back into `Access-Control-Allow-Origin` while
+also sending `Access-Control-Allow-Credentials: true` lets any website read the
+authenticated responses of a logged-in victim, so a malicious page steals the victim's
+data or tokens cross-origin. Reflecting the origin, or trusting it by a substring or
+suffix match, is the exploitable form. Validate the origin against an exact allowlist and
+send credentials only to those origins.
+
+### Vulnerable
+```javascript
+app.use((req, res, next) => {
+  res.setHeader("Access-Control-Allow-Origin", req.headers.origin)   // reflects any origin
+  res.setHeader("Access-Control-Allow-Credentials", "true")
+  next()
+})
+```
+
+### Secure
+```javascript
+const ALLOWED = new Set(["https://app.example.com"])
+app.use((req, res, next) => {
+  if (ALLOWED.has(req.headers.origin)) {
+    res.setHeader("Access-Control-Allow-Origin", req.headers.origin)
+    res.setHeader("Access-Control-Allow-Credentials", "true")
+  }
+  next()
+})
+```
+
+### Not a Finding
+
+A wildcard `Access-Control-Allow-Origin: *` without `Allow-Credentials` on data that is
+already public is not a finding, the browser blocks the credentialed case. An exact-match
+allowlist is the expected control. Report it only when the origin is reflected, matched by
+substring, suffix, or `startsWith`, or read from attacker-controlled config, together with
+credentials or access to non-public data.

codejury-1.3.0/codejury/domains/web/knowledge/vulnerabilities/nosql-injection.md

@@ -0,0 +1,40 @@
+---
+id: nosql-injection
+title: NoSQL Injection
+impact: HIGH
+tags: [cwe-943, owasp-a03]
+triggers: ["find(", "findOne(", "$where", "$ne", "$gt", "req.body", "req.query", "collection.", "mongo"]
+---
+
+## NoSQL Injection
+
+Passing untrusted input straight into a NoSQL query object lets an attacker inject query
+operators rather than values. A login that builds `{ user, pass }` from the request body
+is bypassed when `pass` arrives as `{"$ne": null}`, and `$where`, `$gt`, or `$regex`
+extract or enumerate data. The sql-injection class does not cover this, the payload is a
+structured operator, not a string break. Coerce inputs to the expected scalar type or
+validate against a schema before querying.
+
+### Vulnerable
+```javascript
+app.post("/login", (req, res) => {
+  db.users.findOne({ user: req.body.user, pass: req.body.pass })   // pass can be {$ne: null}
+    .then(u => res.json({ ok: !!u }))
+})
+```
+
+### Secure
+```javascript
+app.post("/login", (req, res) => {
+  const user = String(req.body.user)
+  const pass = String(req.body.pass)   // operators cannot survive the cast to string
+  db.users.findOne({ user, pass }).then(u => res.json({ ok: !!u }))
+})
+```
+
+### Not a Finding
+
+A query whose untrusted fields are cast to a scalar or validated against a schema before
+the call is the expected control. Report it only when a request value reaches the query
+object as a raw object or array, so an operator like `$ne`, `$gt`, `$regex`, or `$where`
+can be injected.

codejury-1.3.0/codejury/domains/web/knowledge/vulnerabilities/prototype-pollution.md

@@ -0,0 +1,45 @@
+---
+id: prototype-pollution
+title: Prototype Pollution
+impact: HIGH
+tags: [cwe-1321]
+triggers: ["__proto__", "constructor", "prototype", "merge", "Object.assign", "deepMerge", "[key]", "extend("]
+---
+
+## Prototype Pollution
+
+A recursive merge, clone, or `set`-by-path that copies attacker-controlled keys into a
+JavaScript object without rejecting `__proto__`, `constructor`, or `prototype` writes onto
+`Object.prototype`. Every object then inherits the injected property, which lets an
+attacker tamper with application logic, cause denial of service, or in some sinks reach
+remote code execution. Reject those keys, use a null-prototype object or a `Map`, or
+validate against a schema before merging.
+
+### Vulnerable
+```javascript
+function merge(target, source) {
+  for (const key in source) {
+    if (typeof source[key] === "object") {
+      merge(target[key] = target[key] || {}, source[key])   // walks __proto__ from user JSON
+    } else {
+      target[key] = source[key]
+    }
+  }
+}
+merge({}, JSON.parse(req.body))
+```
+
+### Secure
+```javascript
+const BLOCKED = new Set(["__proto__", "constructor", "prototype"])
+function merge(target, source) {
+  for (const key in source) {
+    if (BLOCKED.has(key)) continue
+    if (typeof source[key] === "object") {
+      merge(target[key] = target[key] || {}, source[key])
+    } else {
+      target[key] = source[key]
+    }
+  }
+}
+```

{codejury-1.2.0 → codejury-1.3.0}/codejury/domains/web/knowledge/vulnerabilities/race-condition.md

@@ -14,8 +14,8 @@ A check and the action it guards run on shared state without a lock or atomic up
 Vulnerable:
 ```python
 acct = Account.objects.get(pk=pk)
-if acct.balance >= amount:
-    acct.balance -= amount   # concurrent requests both pass
+if acct.balance >= amount:   # concurrent requests both pass this check
+    acct.balance -= amount
     acct.save()
 ```
 Secure:

codejury-1.3.0/codejury/domains/web/knowledge/vulnerabilities/unrestricted-file-upload.md

@@ -0,0 +1,46 @@
+---
+id: unrestricted-file-upload
+title: Unrestricted File Upload
+impact: HIGH
+tags: [cwe-434, owasp-a04]
+triggers: ["upload", "filename", ".save(", "multipart", "content-type", "secure_filename", "os.path.join", "MimeType"]
+---
+
+## Unrestricted File Upload
+
+A handler that stores an uploaded file under an attacker-controlled name, extension, or
+content type, into a web-served or executable directory, lets an attacker upload a
+webshell such as a `.php` or `.jsp` file and execute it, or overwrite an existing file.
+The boundary with path-traversal is the file type and execution, not the path: here the
+danger is what the stored file is and where it can run. Force a safe generated name, an
+allowlisted extension validated against the real content, and store outside the web root.
+
+### Vulnerable
+```python
+@app.post("/upload")
+def upload():
+    f = request.files["file"]
+    f.save(os.path.join(UPLOAD_DIR, f.filename))   # attacker sets name and extension
+    return "ok"
+```
+
+### Secure
+```python
+ALLOWED = {"png", "jpg", "pdf"}
+@app.post("/upload")
+def upload():
+    f = request.files["file"]
+    ext = f.filename.rsplit(".", 1)[-1].lower()
+    if ext not in ALLOWED:
+        abort(400)
+    name = f"{uuid4()}.{ext}"
+    f.save(os.path.join(UPLOAD_DIR, name))   # generated name, allowlisted type, outside web root
+    return "ok"
+```
+
+### Not a Finding
+
+An upload validated against an extension and content-type allowlist, stored under a
+generated name outside the web root, is the expected control. Report it only when the
+name, extension, or type is attacker-controlled into a served or executable location, or
+the validation is bypassable such as a check on the client-supplied content type alone.

{codejury-1.2.0 → codejury-1.3.0}/codejury/domains/web/playbook/methodology.md

@@ -64,7 +64,7 @@ Use the seeded entrypoint candidates as a starting subset, not the whole surface
 Open the route modules and read the actual registrations. For each entrypoint
 record the module, the route, the auth method, and a review status.
 
-Then record two cross-cutting artifacts in `inventory/`:
+Then record three cross-cutting artifacts in `inventory/`:
 
 - **The authorization model**: how this codebase enforces access control, by a
   decorator, middleware, permission class, signature, or guard, the actors, tenants, and services,
@@ -73,6 +73,12 @@ Then record two cross-cutting artifacts in `inventory/`:
 - **The sensitive-data map**: where tokens, secrets, PII, keys, and other tenants'
   data live, since the data-exposure class has no attacker entrypoint and an
   entrypoint-anchored read misses it.
+- **The intent invariants**: the operator-seeded `inventory/_invariants.md`, the core
+  assets, who may legitimately move each, and the properties that must always hold,
+  conservation, single-use, monotonic, ownership, ordering, with the blast radius if
+  one breaks. A static read sees the controls but not the business intent behind them,
+  so this names the intent a unit checks against. When the operator left it blank, it
+  seeds nothing and a unit reviews exactly as before.
 
 ---
 
@@ -118,8 +124,8 @@ A unit looked at in passing by the orchestrator is the shallow whole-repo pass t
 method exists to replace, and it is the single thing that drops recall.
 
 Give each sub-review only its slice plus the shared artifacts: `_stack.md`, the
-inventory's auth model, and `_vulnerabilities.md`. Each sub-review follows the full
-mandate below:
+inventory's auth model, the seeded `inventory/_invariants.md`, and `_vulnerabilities.md`.
+Each sub-review follows the full mandate below:
 
 1. **Traces** every entrypoint in its unit out of the view into the managers,
    controllers, DAO, and libraries it calls, to the real sink. The flaw usually

{codejury-1.2.0 → codejury-1.3.0}/codejury/domains/web/playbook/slash-command.md

@@ -37,13 +37,16 @@ review in passing here is the shallow whole-repo pass this method exists to repl
    - `units/`, one unit per candidate entrypoint carrying its deep-review mandate and `- Status: open`
    - `inventory/_surface.md`, the coverage denominator
    - `inventory/_auth_model.md`
+   - `inventory/_invariants.md`, the operator-seeded intent invariants, optional
    - `inventory/_severity.md`, the grading rubric
 
    Read `METHODOLOGY.md` once for the full process.
 
 2. MAP. Make the worklist complete. Enumerate every attacker-influenced entrypoint
    into `inventory/_surface.md` and fill `inventory/_auth_model.md` with the access
-   model and trust boundaries. For anything the seeded units miss, add a unit file by
+   model and trust boundaries. If the operator seeded `inventory/_invariants.md` with
+   intent invariants, leave it for the units to check, and if it is blank do not invent
+   rows, an unseeded invariants file changes nothing. For anything the seeded units miss, add a unit file by
    copying the mandate from a seeded one: non-HTTP sources such as deserializers,
    queues, file parsers, or webhooks, entrypoint modules no guide flagged, and sequence units
    for a multi-step flow whose invariant spans several endpoints. Every entrypoint in
@@ -53,8 +56,8 @@ review in passing here is the shallow whole-repo pass this method exists to repl
    `units/` with `- Status: open`, launch one sub-review per unit as a separate
    subagent or task, in parallel. One per unit, no unit skipped, no two merged to save calls.
    Give each only its unit file, which carries the mandate and the files to own, plus
-   the shared `_stack.md`, `inventory/_auth_model.md`, `inventory/_severity.md`, and
-   `_vulnerabilities.md`. Each
+   the shared `_stack.md`, `inventory/_auth_model.md`, `inventory/_invariants.md`,
+   `inventory/_severity.md`, and `_vulnerabilities.md`. Each
    sub-review reads its files, traces into the managers, DAO, controllers, and
    libraries they call, hunts the high-impact classes, verifies each control on the
    code it actually reads, refutes its own candidates, grades every real finding by