Skip to content

fix(security): keep commit permalinks whose query carries a git object name - #19540

Merged
iamwhatever merged 2 commits into
mainfrom
fix/exfil-commit-sha-url-false-positive
Nov 4, 2026
Merged

iamwhatever merged 2 commits into
mainfrom
fix/exfil-commit-sha-url-false-positive

Conversation

@CrysisDeu

@CrysisDeu CrysisDeu commented Oct 12, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

Goal: A link to a commit stays a link in chat, even when the commit's hash is in the link's query.

Some code-hosting and build tools put the full git commit hash in the URL query, like …/history?commit=<40 hex chars> or …?changes=<package>/<branch>:<40 hex chars>. When an agent relays such a link, the dashboard shows [REDACTED: suspicious URL to <host>] instead of the link. The user cannot read or copy it. The same hash in the URL path (…/commit/<40 hex chars>) already renders fine, so the two spellings of one permalink disagree.

Why it matters

Commit permalinks are one of the most common links an agent relays after a build, a review or a deploy. Every one of them with the hash in the query is lost on the owner-facing surface, while the same text posts intact through tools. Users cannot act on what the agent found.

Not a goal

  • Exempting any host. The fix narrows the shape the heuristic treats as a blob; it adds no trusted destination.
  • Changing the aggregate query-length signal, the heavy percent-encoding detector, or any fixed credential marker.
  • Treating hex runs of other lengths (32, 48, 128) or uppercase hex as benign.

Intended? / Repro

Intended? No. Redacting a query-borne git hash is a side effect of the blob heuristic's alphabet, not a recorded decision. Sources on main:

  • src/kiro_crew/security/exfil.py (comment above _HARD_CREDENTIAL_RE): the blob/length heuristics "stay query-only (long base64 PATH segments — CDN asset ids, git object hashes — are benign)". Git hashes are named as benign; only their position (path vs query) kept the query form flagged.
  • src/kiro_crew/security/redaction.py (_HEX_ONLY_RE, bare-secret gate 3): "All-hex runs are git SHAs (40 hex), sha256 (64 hex), md5 (32 hex), etc. — never an AWS secret key … Reject them outright." The sibling detector already treats all-hex as non-secret.
  • test/test_exfil_base64_padding.py::test_forty_hex_value_is_redacted: "A 40-hex value is still a 40-char run; narrowing it is out of scope here." The behaviour was pinned as a known, deferred narrowing when = was removed from the class, not as a design goal.
  • No RFC under docs/request-for-change/ or spec under docs/system-specs/ names hex runs as a shape the URL redactor must flag.

Repro on main (origin/main @ ebe8a183b5aa):

  • Static: the base64 branch of _EXFIL_PATTERNS as spelled on main, [A-Za-z0-9+/]{40,}={0,2}|…, run as a plain regex over the two query shapes from the report: commit=<40 hex> and changes=Commit:pkg/mainline:<40 hex> both match, with the match being exactly the 40-hex hash. The query gate calls .search() on that pattern, so redact_exfiltration_urls rewrites the URL.
  • CI on main: test_forty_hex_value_is_redacted (Python) and 'redacts a 40-hex value' (vitest) are green on main, which is the redaction asserted as a passing test on both surfaces. This PR flips both.
  • CI on this PR's first head: four unrelated suites (test_acp_structured_refusal, test_decisions_gate, test_decisions_points, test_workflows_app) went red because their "any flagged payload" fixture was "a" * 40 / "b" * 40, i.e. a 40-hex run. That those fixtures redacted on main is the same symptom from a second direction.

What changed (motivation → approach → change)

Symptom: a URL whose query carries a 40-hex git hash is redacted on every surface.

Root cause: the exfil heuristic's base64-blob branch is [A-Za-z0-9+/]{40,}. Every hex digit is in that class, so a 40-hex hash is a 40-char "blob". The heuristics are query-only by design (the path already treats long base64-ish segments, git hashes among them, as benign), which is why the path spelling renders and the query spelling does not. No host exemption can fix this on the dashboard: the browser mirror in sanitize.ts has no exemption concept at all.

Change: judge each MAXIMAL blob match, and skip it when the whole match is exactly 40 lowercase hex digits (a SHA-1 git object name). 64 hex (SHA-256) is not carved out: it is the shape of this product's own secrets (secrets.token_hex(32), e.g. generate_app_secret()), so it keeps redacting. _exfil_blob_hit() wraps _EXFIL_PATTERNS in src/kiro_crew/security/exfil.py and exfilBlobHit() wraps EXFIL_B64_RE in website/src/utils/sanitize.ts; both replace the bare .search()/.test() at the query gate and in the privacy-safe diagnostic. The regex spellings themselves are untouched, so the existing parity pins keep holding, and a new parity pin fixes the carve-out's shape on both halves.

Why the maximal match: {40,} is greedy, so a hash glued to any other base64 character (x<sha>, <sha>=, <sha>/abc), 41+ digits, or mixed case is a longer or wider run that fails the exact-length full match and keeps firing. A secret cannot hide by containing or abutting a hash.

Residual, stated: a 40-hex API token in a query no longer trips this one heuristic. It was never caught by the fixed credential markers (those key on provider prefixes), and the length gate still bounds the query. The bare-secret detector in redaction.py already rejects all-hex runs on the same reasoning (hex is a 16-symbol alphabet, not a base64 payload).

Backwards compatibility

Compatible: nothing that renders today stops rendering; one more URL shape renders. No API, type, key or validator changes.

Removes nothing: the change only narrows what the blob heuristic flags; no path, record, key or function is removed or renamed.

Tests

  • test/test_exfil_git_object_name.py (new): 40-hex query values are kept, also after a routed pkg/branch: prefix, two in one query, and through redact_exfiltration_urls_with_records. Edges still redact: 64 hex (app-secret shape), 41 hex, 65 hex, mixed case, uppercase, = padding, hash glued to a letter or a slash run, a percent-encoded separator glued to the hash (its hex octet joins the run in the raw query), 48 hex, 40 lowercase non-hex. A hash beside a real blob or an AWS key id still redacts; five hashes still trip the length gate. _exfil_blob_hit leaves the AWS/Slack/SSH/percent alternatives unchanged.
  • website/src/test/sanitizeExfiltrationGitObjectName.test.ts (new): the same matrix in the browser mirror, plus a markdown link target.
  • test/test_exfil_base64_padding.py and sanitizeExfiltrationBase64Padding.test.ts: the pinned "40-hex value is redacted" cases flip to "kept"; that earlier change had marked narrowing it as out of scope.
  • test/test_redaction_mirror_parity.py: TestGitObjectNameCarveOutMirror pins the [0-9a-f]{40} spelling on both halves.
  • Four fixtures that used a 40-run of one hex letter ("a" * 40, "b" * 40) as "any payload the heuristic flags" now use "x" * 40, since a 40-hex run is exactly the shape this PR keeps: test_acp_structured_refusal.py, test_decisions_gate.py, test_decisions_points.py, test_workflows_app.py. What each test asserts is unchanged.
  • test/test_security_gate_liveness.py: the security package line budget is raised 31,509 -> 31,532 for the helper, with the customary paragraph.

Manual verification

N/A — unit coverage sufficient: the change is a pure function on the URL text, exercised on both surfaces by the tests above.

Screenshots / video

Why no screenshot: the only rendered difference is that a link renders as a link instead of a text placeholder, which the vitest cases assert directly.

Related Issues

Related to the redaction false-positive family (#15565).

Pattern harvest

Rule candidate: review-prompt
Pattern: "a character-class heuristic ([A-Za-z0-9+/]{N,}) applied to a value family that contains a well-known fixed-length sub-alphabet (hex digests) — check the sub-alphabet is carved out, on every mirror".

Checklist

  • At most two commits (one is the norm), with a Conventional Commits title (feat|fix|docs|style|refactor|perf|test|chore|ci|build|revert: ...)
  • Existing tests pass and new tests added for new functionality (new tests added; CI is the test runner for this change)
  • Self-review completed; code follows project style guidelines
  • Documentation updated (if applicable)
  • No secrets, credentials, or internal references in the diff

@CrysisDeu
CrysisDeu requested review from a team and KiroCrewCaptain as code owners October 12, 2026 21:10
@github-actions

github-actions Bot commented Oct 12, 2026 •

Copy link
Copy Markdown
Contributor

Sensitive Change Review

Sensitive files changed:

  • src/kiro_crew/security/exfil.py

  • src/kiro_crew/security/exfil_git_object.py

  • @CrysisDeu posted a complete reasoning template for ce995e1.

@CrysisDeu
CrysisDeu force-pushed the fix/exfil-commit-sha-url-false-positive branch from 43b8417 to a3861b9 Compare October 12, 2026 21:22
@CrysisDeu

Copy link
Copy Markdown
Contributor Author

Sensitive change review

  • Head commit: a3861b9
  • What rule changed: the exfil URL redactor's base64-blob heuristic (_EXFIL_PATTERNS branch [A-Za-z0-9+/]{40,} in src/kiro_crew/security/exfil.py, and its browser mirror EXFIL_B64_RE in website/src/utils/sanitize.ts) is now evaluated through _exfil_blob_hit() / exfilBlobHit(), which skips a match only when the whole maximal match is exactly 40 or 64 lowercase hex digits (a git object name). The regex spellings are unchanged.
  • Before -> after (what was allowed/blocked, now): Before, any URL whose query held a bare 40/64-hex commit hash was rewritten to [REDACTED: suspicious URL to <host>]. After, that URL renders. Everything else is unchanged: 41+ hex, 65+ hex, uppercase or mixed-case hex, a hash with = padding, a hash glued to any other base64 character, 48-hex, 40-char non-hex runs, AWS key ids, Slack tokens, SSH/PEM headers, heavy percent-encoding, the 200-char query-length gate, the fixed-credential scan, the multi-pass decode and its saturation branch, and the S3-presigned validators all behave exactly as before. No host is exempted.
  • Worst case if wrong (breaks commands / leaks secret / locks user out): leaks secret, narrowly. A credential that is itself exactly 40 or 64 lowercase hex digits (some vendors issue hex API tokens of those lengths) in a URL query is not redacted by this one heuristic any more. It was never caught by the fixed credential markers (those key on provider prefixes), and redaction.py's bare-secret detector already rejects all-hex runs on the same reasoning. No command floor, sandbox rule or auth path is touched, so nothing breaks commands or locks a user out.
  • Evidence checked (which sandbox result proves it): no sandbox run; this is a pure function on URL text. The evidence is the test matrix on this head: test/test_exfil_git_object_name.py and website/src/test/sanitizeExfiltrationGitObjectName.test.ts assert the kept shapes and every neighbouring shape that must still redact, including a hash sitting beside a real blob or an AWS key id and five hashes still tripping the length gate; test/test_redaction_mirror_parity.py::TestGitObjectNameCarveOutMirror pins the carve-out spelling on both halves. CI's Backend Tests and Frontend Tests lanes on this head are the run.
  • No regression:
    • Tools still work (which tools/commands were run, result): no tool, CLI or MCP surface changes; the redactor is called the same way with the same signature. Local static gates on this head: isort, flake8, mypy (exfil.py), black baseline gate, comment-history gate, tsc -p tsconfig.app.json, eslint on the touched TS files -- all clean.
    • Backward compatible (old config / old data / old callers still work, how checked): no config key, stored record shape or public function changes; redact_exfiltration_urls, scan_exfiltration_urls, redact_exfiltration_urls_with_records and sanitizeExfiltrationUrls keep their signatures. Checked by reading every call site of _EXFIL_PATTERNS (query gate and privacy-safe diagnostic switched to the helper; the presigned unknown-parameter check deliberately left on the raw pattern, which is stricter) and by git diff origin/main...HEAD.
    • Existing tests (which suites passed on this head): CI is the test runner for this change (no local test runs on the authoring host by policy). The two previously pinned "40-hex value is redacted" cases in test/test_exfil_base64_padding.py and sanitizeExfiltrationBase64Padding.test.ts are intentionally flipped to "kept"; the rest of both files is untouched. Results are on this PR's Backend Tests / Frontend Tests / Coverage Gate checks.
  • How to undo: revert the single commit on this branch; _exfil_blob_hit / exfilBlobHit go away and both halves return to the bare .search() / .test() on the unchanged regexes. No data migration or config change is involved.

@CrysisDeu
CrysisDeu force-pushed the fix/exfil-commit-sha-url-false-positive branch from a3861b9 to 39b8a38 Compare October 12, 2026 21:52
@CrysisDeu

Copy link
Copy Markdown
Contributor Author

Sensitive change review

  • Head commit: 39b8a38
  • What rule changed: the exfil URL redactor's base64-blob heuristic (_EXFIL_PATTERNS branch [A-Za-z0-9+/]{40,} in src/kiro_crew/security/exfil.py, and its browser mirror EXFIL_B64_RE in website/src/utils/sanitize.ts) is now evaluated through _exfil_blob_hit() / exfilBlobHit(), which skips a match only when the whole maximal match is exactly 40 or 64 lowercase hex digits (a git object name). The regex spellings are unchanged.
  • Before -> after (what was allowed/blocked, now): Before, any URL whose query held a bare 40/64-hex commit hash was rewritten to [REDACTED: suspicious URL to <host>]. After, that URL renders. Everything else is unchanged: 41+ hex, 65+ hex, uppercase or mixed-case hex, a hash with = padding, a hash glued to any other base64 character, 48-hex, 40-char non-hex runs, AWS key ids, Slack tokens, SSH/PEM headers, heavy percent-encoding, the 200-char query-length gate, the fixed-credential scan, the multi-pass decode and its saturation branch, and the S3-presigned validators all behave exactly as before. No host is exempted.
  • Worst case if wrong (breaks commands / leaks secret / locks user out): leaks secret, narrowly. A credential that is itself exactly 40 or 64 lowercase hex digits (some vendors issue hex API tokens of those lengths) in a URL query is not redacted by this one heuristic any more. It was never caught by the fixed credential markers (those key on provider prefixes), and redaction.py's bare-secret detector already rejects all-hex runs on the same reasoning. No command floor, sandbox rule or auth path is touched, so nothing breaks commands or locks a user out.
  • Evidence checked (which sandbox result proves it): no sandbox run; this is a pure function on URL text. The evidence is the test matrix on this head: test/test_exfil_git_object_name.py and website/src/test/sanitizeExfiltrationGitObjectName.test.ts assert the kept shapes and every neighbouring shape that must still redact, including a hash sitting beside a real blob or an AWS key id and five hashes still tripping the length gate; test/test_redaction_mirror_parity.py::TestGitObjectNameCarveOutMirror pins the carve-out spelling on both halves. CI's Backend Tests and Frontend Tests lanes on this head are the run.
  • No regression:
    • Tools still work (which tools/commands were run, result): no tool, CLI or MCP surface changes; the redactor is called the same way with the same signature. Local static gates on this head: isort, flake8, mypy (exfil.py), black baseline gate, comment-history gate, tsc -p tsconfig.app.json, eslint on the touched TS files -- all clean.
    • Backward compatible (old config / old data / old callers still work, how checked): no config key, stored record shape or public function changes; redact_exfiltration_urls, scan_exfiltration_urls, redact_exfiltration_urls_with_records and sanitizeExfiltrationUrls keep their signatures. Checked by reading every call site of _EXFIL_PATTERNS (query gate and privacy-safe diagnostic switched to the helper; the presigned unknown-parameter check deliberately left on the raw pattern, which is stricter) and by git diff origin/main...HEAD.
    • Existing tests (which suites passed on this head): CI is the test runner for this change (no local test runs on the authoring host by policy). The two previously pinned "40-hex value is redacted" cases in test/test_exfil_base64_padding.py and sanitizeExfiltrationBase64Padding.test.ts are intentionally flipped to "kept"; the rest of both files is untouched. Four fixtures that used "a" * 40 / "b" * 40 as "any payload the heuristic flags" (test_acp_structured_refusal.py, test_decisions_gate.py, test_decisions_points.py, test_workflows_app.py) now use "x" * 40; their assertions are unchanged. test_security_gate_liveness.py raises the package line budget 28,857 -> 28,880 for the helper. Round 1 on the previous head: every red was one of these fixtures or the budget; no other suite failed. Results are on this PR's Backend Tests / Frontend Tests / Coverage Gate checks.
  • How to undo: revert the single commit on this branch; _exfil_blob_hit / exfilBlobHit go away and both halves return to the bare .search() / .test() on the unchanged regexes. No data migration or config change is involved.

@github-actions github-actions Bot added the readiness: checking Automated validation is still running label Oct 12, 2026
@github-actions

github-actions Bot commented Oct 12, 2026 •

Copy link
Copy Markdown
Contributor

UX Review (Opus 5.5) — ✅ PASS

UX-level review of ce995e1f3be41f5cff2c056ebd027816a7468804 — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS does not.

UX-Verdict: PASS

Nothing to check. The change is a heuristic inside sanitize.ts. It adds no control, string or state. A query-borne 40-hex commit link now renders through the existing link path instead of the existing redaction placeholder, so no screenshot is needed.

[UX-REVIEWED] ce995e1

Description read

[DESCRIPTION-READ] c84c6d4a578bca7483db6f4011db2a988def6dda2187c2509c375a835f8f2106

That sha256 names everything this verdict read: the PR description, plus the 3 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with .github/scripts/pr-description-capture.sh over the same inputs; if it differs, the description or that evidence changed after this verdict was formed and any finding drawn from either is unproven.

@github-actions

github-actions Bot commented Oct 12, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Opus 5.5) — ✅ PASS

Premise-level review of ce995e1f3be41f5cff2c056ebd027816a7468804 — why this exists and whether the shipped surface is the smallest honest version. Updated in place on each push. A BLOCK verdict blocks PR readiness; PASS does not.

First-Principles-Verdict: PASS

Nothing blocks: the carve-out removes the redaction of query-borne 40-hex commit links on both surfaces. Two small riders are notes.

Notes

  • Item 5 — zero consumers: from .exfil_git_object import _GIT_OBJECT_NAME_RE, _exfil_blob_hit # noqa: F401 re-exports the regex through exfil.py. I grepped _GIT_OBJECT_NAME_RE and found 0 importers through the facade; the parity pin reads the owner file's source text instead. Subtraction: drop _GIT_OBJECT_NAME_RE from that import line and keep only _exfil_blob_hit.
  • Item 6 — undeclared: an unrelated paragraph changes -#: Set to the measured 32,802 to +#: Set to the measured 32,826, but its own sum is still "32,799, plus 3". Subtraction: revert that one line. Only the _PACKAGE_LINE_BUDGET paragraph is this PR's change.

What this change ships

Inventory (7 items) — 5 justified

Intent: a commit permalink with its hash in the query still renders as a link in chat. FIX.

  1. Backend chat output keeps a URL whose query value is exactly 40 lowercase hex digits — justified
  2. The dashboard's browser mirror keeps the same URL shape — justified
  3. The OAuth credential diagnostic and the decoder choice use the same carve-out — justified
  4. Tests that used "a"*40 / "b"*40 as a flagged-payload fixture now use "x"*40 — justified
  5. _GIT_OBJECT_NAME_RE is re-exported from the exfil facade — zero consumers
  6. The figure in an older line-budget comment is rewritten to 32,826 — undeclared, its arithmetic no longer adds up
  7. A new owner module, with the security line budget raised and the module added to RULE_SOURCES — justified

[FIRST-PRINCIPLES-REVIEWED] ce995e1

Description read

[DESCRIPTION-READ] 492f16f6237915224d330e9996067fcf21bbc3b0b5b786ee71482891f56af969

That sha256 names the PR description this verdict read. Recompute it with .github/scripts/pr-description-capture.sh; if it differs, the description changed after this verdict was formed and any finding drawn from the description is unproven.

@github-actions

github-actions Bot commented Oct 12, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Opus 5.5) — ✅ PASS

Design-level review of ce995e1f3be41f5cff2c056ebd027816a7468804 — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS does not.

Design-Verdict: PASS

Nothing blocks: the carve-out is limited to an exact 40-character lowercase hex match, the Python and browser checks are changed the same way, and it opens no channel that the path, already treated as benign, doesn't have.

Notes

  • security/display_safety.py:_oauth_component_is_unsafe still calls _EXFIL_PATTERNS.search directly. That leaves it the only reader without the carve-out, so an OAuth endpoint path that contains a commit hash is still masked. The code's own comment says over-matching only redacts more, so this is a consistency gap rather than a break.

[DESIGN-REVIEWED] ce995e1

Description read

[DESCRIPTION-READ] d4a93cbc63a0c2f4c3b6487dffb39b26517f1060c96cc3aa4c817abced09c13d

That sha256 names everything this verdict read: the PR description, plus the 1 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with .github/scripts/pr-description-capture.sh over the same inputs; if it differs, the description or that evidence changed after this verdict was formed and any finding drawn from either is unproven.

@github-actions

github-actions Bot commented Oct 12, 2026 •

Copy link
Copy Markdown
Contributor

Opus 5.5 Review — ✅ no blocking findings

Reviewed ce995e1f3be41f5cff2c056ebd027816a7468804 — this comment is updated in place on each push.

Review details

No findings.

Notes:

  • test/test_security_gate_liveness.py:556: the comment was changed to "measured 32,826", but its own sum (32,799 + 3) is 32,802, which is also the "from 32,802" figure the next entry starts from. This is only a comment and changes no behaviour.

[OPUS-REVIEWED] ce995e1

Verdict parsed from the review's SHA-scoped output markers for commit ce995e1f3be41f5cff2c056ebd027816a7468804.

False positive or not applicable? A repository writer can comment:
/ai-review override fable ce995e1f3be41f5cff2c056ebd027816a7468804 false-positive: <reason, 20 to 500 characters>

@github-actions

github-actions Bot commented Oct 12, 2026 •

Copy link
Copy Markdown
Contributor

GPT 6.1 Review — ✅ no blocking findings

GPT 6.1 completed its review of ce995e1f3be41f5cff2c056ebd027816a7468804 and found no blocking issues.

This comment is updated in place on each push.

Review details

No findings.
[GPT-REVIEWED] ce995e1

False positive or not applicable? A repository writer can comment:
/ai-review override gpt ce995e1f3be41f5cff2c056ebd027816a7468804 false-positive: <reason, 20 to 500 characters>

@github-actions

github-actions Bot commented Oct 12, 2026 •

Copy link
Copy Markdown
Contributor

Security Scope Review -- ✅ PASS

Which legitimate operations does ce995e1f3be41f5cff2c056ebd027816a7468804 newly refuse? Updated in place on each push. A script-confirmed regression blocks; the model proposes candidates and never decides a refusal.

Verdict basis: adjudicated, zero confirmed regressions.

Security scope review -- adjudicated candidates

  • macos-latest (platform posix): 11 classified, 0 newly refused, 10 still allowed.
  • ubuntu-latest (platform posix): 11 classified, 0 newly refused, 10 still allowed.
  • windows-latest (platform windows): 5 classified, 0 newly refused, 5 still allowed.

No candidate flipped from allowed to refused.

Scope-Verdict: PASS

Reason: This diff loosens a check; nothing in it gets stricter. It removes one shape, an exactly 40-character lowercase-hex git SHA-1, from the base64-blob heuristic. That heuristic is used by the URL redaction/display path and the OAuth diagnosis, and none of the three shell checks (sensitive-bash, exfil via audit_bash_exfiltration, deny-rules) calls it. So no shell operation can become newly refused. The change to the browser-side mirror (website/src/utils/sanitize.ts) is also outside the classifier and is named below.

TIGHTENING: none. The only behavioural change is a narrowing in exfil_git_object._exfil_blob_hit: for match in _EXFIL_PATTERNS.finditer(value): if _GIT_OBJECT_NAME_RE.fullmatch(match.group(0)): continue; return True. It replaces _EXFIL_PATTERNS.search(heuristic_query) in _exfil_url_warning and diagnose_oauth_url_credential. It returns True only on inputs where search already matched, so no input it flags was allowed before. The threat it keeps refusing is a base64/encoded credential blob in a URL query, now with SHA-1 commit permalinks excluded.

ADJUDICATED: 16 candidates, 0 confirmed newly-refused

PLATFORM COVERAGE: posix and windows. The diff makes no path, separator, interpreter or environment-variable assumption. The only thing it keys on is a string's alphabet ([0-9a-f]{40} applied to the maximal match of an IGNORECASE regex). The candidates send the SHA-1 through the shell checks in each platform's spelling:

  • posix: git, gh and curl with the SHA in a query, a path and an argv position, plus %H formatting.
  • windows: git.exe, gh.exe and curl.exe, certutil with \ separators, and a doubled %%H for cmd batch files.

Two neighbouring rows sit next to the carve-out: a 64-hex checksum (deliberately not carved out) and a routed changes=Commit:pkg/mainline:<sha> query. No platform assumption is left unprobed.

UNADJUDICATED: The classifier cannot reach the changed guard, so the following could not be adjudicated:

  • Python URL guard. The base64-blob heuristic is reached through scan_exfiltration_urls / redact_exfiltration_urls(_with_records) → _exfil_url_warning → _exfil_blob_hit(heuristic_query) / _exfil_blob_hit(unquote_plus(heuristic_query)). It is also reached through diagnose_oauth_url_credential (rule exfil_query_pattern), as the decoder choice and the predicate.
  • Browser mirror. sanitizeExfiltrationUrls → exfilBlobHit(past) / exfilBlobHit(query) in website/src/utils/sanitize.ts.

These are the inputs I would have submitted as prose. Each still passes through the regex unchanged, so each should still render exactly as before:

  • a query that holds only a 41-character hex run;
  • a 64-hex value (SHA-256);
  • an uppercase 40-hex value;
  • a 40-hex value followed by = padding;
  • pkg%3A followed by a SHA, which the raw-form check sees as a 42-character run;
  • a query with five SHAs, which trips the length gate.

The diff's own tests pin each of these as still redacted. None of them is newly refused by construction.

One residual for the other lanes, stated in the module's own header: a credential that is exactly 40 lowercase hex characters in a query now passes this heuristic. That is a question of whether the guard is strict enough, which is not this lane's.

[SCOPE-REVIEWED] ce995e1

@github-actions github-actions Bot added merge conflict Branch has merge conflicts with its base — author must resolve before merge readiness: passed Eligible automated validation passed for the current revision and removed readiness: checking Automated validation is still running labels Oct 12, 2026
@iamwhatever
iamwhatever force-pushed the fix/exfil-commit-sha-url-false-positive branch from 39b8a38 to 5b3e184 Compare October 19, 2026 19:07
@iamwhatever

Copy link
Copy Markdown
Contributor

Sensitive change review

  • Head commit: 5b3e184
  • What rule changed: the exfil URL redactor's base64-blob heuristic (_EXFIL_PATTERNS branch [A-Za-z0-9+/]{40,} in src/kiro_crew/security/exfil.py, and its browser mirror EXFIL_B64_RE in website/src/utils/sanitize.ts) is now evaluated through _exfil_blob_hit() / exfilBlobHit(), which skips a match only when the whole maximal match is exactly 40 or 64 lowercase hex digits (a git object name). The regex spellings are unchanged.
  • Before -> after (what was allowed/blocked, now): Before, any URL whose query held a bare 40/64-hex commit hash was rewritten to [REDACTED: suspicious URL to <host>]. After, that URL renders. Everything else is unchanged: 41+ hex, 65+ hex, uppercase or mixed-case hex, a hash with = padding, a hash glued to any other base64 character, 48-hex, 40-char non-hex runs, AWS key ids, Slack tokens, SSH/PEM headers, heavy percent-encoding, the 200-char query-length gate, the fixed-credential scan, the multi-pass decode and its saturation branch, and the S3-presigned validators all behave exactly as before. No host is exempted.
  • Worst case if wrong (breaks commands / leaks secret / locks user out): leaks secret, narrowly. A credential that is itself exactly 40 or 64 lowercase hex digits (some vendors issue hex API tokens of those lengths) in a URL query is not redacted by this one heuristic any more. It was never caught by the fixed credential markers (those key on provider prefixes), and redaction.py's bare-secret detector already rejects all-hex runs on the same reasoning. No command floor, sandbox rule or auth path is touched, so nothing breaks commands or locks a user out.
  • Evidence checked (which sandbox result proves it): no sandbox run; this is a pure function on URL text. The evidence is the test matrix on this head: test/test_exfil_git_object_name.py and website/src/test/sanitizeExfiltrationGitObjectName.test.ts assert the kept shapes and every neighbouring shape that must still redact, including a hash sitting beside a real blob or an AWS key id and five hashes still tripping the length gate; test/test_redaction_mirror_parity.py::TestGitObjectNameCarveOutMirror pins the carve-out spelling on both halves. CI's Backend Tests and Frontend Tests lanes on this head are the run.
  • No regression:
    • Tools still work (which tools/commands were run, result): no tool, CLI or MCP surface changes; the redactor is called the same way with the same signature. Local static gates on this head: isort, flake8, mypy (exfil.py), black baseline gate, comment-history gate, tsc -p tsconfig.app.json, eslint on the touched TS files -- all clean.
    • Backward compatible (old config / old data / old callers still work, how checked): no config key, stored record shape or public function changes; redact_exfiltration_urls, scan_exfiltration_urls, redact_exfiltration_urls_with_records and sanitizeExfiltrationUrls keep their signatures. Checked by reading every call site of _EXFIL_PATTERNS (query gate and privacy-safe diagnostic switched to the helper; the presigned unknown-parameter check deliberately left on the raw pattern, which is stricter) and by git diff origin/main...HEAD.
    • Existing tests (which suites passed on this head): CI is the test runner for this change (no local test runs on the authoring host by policy). The two previously pinned "40-hex value is redacted" cases in test/test_exfil_base64_padding.py and sanitizeExfiltrationBase64Padding.test.ts are intentionally flipped to "kept"; the rest of both files is untouched. Four fixtures that used "a" * 40 / "b" * 40 as "any payload the heuristic flags" (test_acp_structured_refusal.py, test_decisions_gate.py, test_decisions_points.py, test_workflows_app.py) now use "x" * 40; their assertions are unchanged. test_security_gate_liveness.py raises the package line budget 31,509 -> 31,532 for the helper. Round 1 on the previous head: every red was one of these fixtures or the budget; no other suite failed. Results are on this PR's Backend Tests / Frontend Tests / Coverage Gate checks.
  • Rebase note (this head): rebased onto main @ 02eeb00d1, where refactor(security): split denied_rules, redaction and exfil into owners #22158 split exfil.py into owner modules and _EXFIL_PATTERNS now lives in exfil_url_rules.py. The helper and its regex stay in exfil.py beside the classifier that calls them; the same three call sites (query gate, privacy-safe diagnostic decoder and predicate) switch to it. display_safety.py (new on main) keeps the raw pattern: over-matching there only redacts more. Local run on this head: the 8 touched/related Python files (348 passed), the exfil/redaction/oauth/security set (13,397 passed; 2 failures are host-only and fail identically on main), vitest sanitize/redact/exfil (191 passed), tsc, flake8, isort, mypy clean.
  • How to undo: revert the single commit on this branch; _exfil_blob_hit / exfilBlobHit go away and both halves return to the bare .search() / .test() on the unchanged regexes. No data migration or config change is involved.

@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: passed Eligible automated validation passed for the current revision merge conflict Branch has merge conflicts with its base — author must resolve before merge labels Oct 19, 2026
@iamwhatever
iamwhatever force-pushed the fix/exfil-commit-sha-url-false-positive branch from 5b3e184 to 7731617 Compare October 19, 2026 19:46
@iamwhatever

Copy link
Copy Markdown
Contributor

fixed -- GPT 6.1 BLOCKING src/kiro_crew/security/exfil.py:91 (git-shaped exemption admits live app secrets), head 7731617

Legitimate: generate_app_secret() and other secrets.token_hex(32) values are exactly 64 lowercase hex, the SHA-256 arm of the carve-out.
Fixed in 7731617: the carve-out is now SHA-1 only, [0-9a-f]{40}, on both halves (_GIT_OBJECT_NAME_RE in exfil.py, EXFIL_GIT_OBJECT_NAME_RE in sanitize.ts); the parity pin follows.
A 64-hex query value redacts again on both surfaces; new tests assert it (test_sha256_shaped_value_still_redacts, vitest "still redacts a 64-hex ... value").
No product secret is minted as 40 hex (repo grep for token_hex(20), urandom(20), sha1 in src/website: none).
Residual unchanged and stated in the code: a third-party 40-hex token in a query passes this one heuristic.
self-added: no
mechanism: exact-length hex carve-out on the maximal blob match

@iamwhatever

Copy link
Copy Markdown
Contributor

Sensitive change review

  • Head commit: 7731617
  • What rule changed: the exfil URL redactor's base64-blob heuristic (_EXFIL_PATTERNS branch [A-Za-z0-9+/]{40,} in src/kiro_crew/security/exfil.py, and its browser mirror EXFIL_B64_RE in website/src/utils/sanitize.ts) is now evaluated through _exfil_blob_hit() / exfilBlobHit(), which skips a match only when the whole maximal match is exactly 40 lowercase hex digits (a SHA-1 git object name; 64 hex is not carved out because it is the shape of the product's own token_hex(32) secrets). The regex spellings are unchanged.
  • Before -> after (what was allowed/blocked, now): Before, any URL whose query held a bare 40/64-hex commit hash was rewritten to [REDACTED: suspicious URL to <host>]. After, that URL renders. Everything else is unchanged: 41+ hex, 65+ hex, uppercase or mixed-case hex, a hash with = padding, a hash glued to any other base64 character, 48-hex, 40-char non-hex runs, AWS key ids, Slack tokens, SSH/PEM headers, heavy percent-encoding, the 200-char query-length gate, the fixed-credential scan, the multi-pass decode and its saturation branch, and the S3-presigned validators all behave exactly as before. No host is exempted.
  • Worst case if wrong (breaks commands / leaks secret / locks user out): leaks secret, narrowly. A credential that is itself exactly 40 lowercase hex digits (some vendors issue hex API tokens of that length) in a URL query is not redacted by this one heuristic any more. It was never caught by the fixed credential markers (those key on provider prefixes), and redaction.py's bare-secret detector already rejects all-hex runs on the same reasoning. No command floor, sandbox rule or auth path is touched, so nothing breaks commands or locks a user out.
  • Evidence checked (which sandbox result proves it): no sandbox run; this is a pure function on URL text. The evidence is the test matrix on this head: test/test_exfil_git_object_name.py and website/src/test/sanitizeExfiltrationGitObjectName.test.ts assert the kept shapes and every neighbouring shape that must still redact, including a hash sitting beside a real blob or an AWS key id and five hashes still tripping the length gate; test/test_redaction_mirror_parity.py::TestGitObjectNameCarveOutMirror pins the carve-out spelling on both halves. CI's Backend Tests and Frontend Tests lanes on this head are the run.
  • No regression:
    • Tools still work (which tools/commands were run, result): no tool, CLI or MCP surface changes; the redactor is called the same way with the same signature. Local static gates on this head: isort, flake8, mypy (exfil.py), black baseline gate, comment-history gate, tsc -p tsconfig.app.json, eslint on the touched TS files -- all clean.
    • Backward compatible (old config / old data / old callers still work, how checked): no config key, stored record shape or public function changes; redact_exfiltration_urls, scan_exfiltration_urls, redact_exfiltration_urls_with_records and sanitizeExfiltrationUrls keep their signatures. Checked by reading every call site of _EXFIL_PATTERNS (query gate and privacy-safe diagnostic switched to the helper; the presigned unknown-parameter check deliberately left on the raw pattern, which is stricter) and by git diff origin/main...HEAD.
    • Existing tests (which suites passed on this head): CI is the test runner for this change (no local test runs on the authoring host by policy). The two previously pinned "40-hex value is redacted" cases in test/test_exfil_base64_padding.py and sanitizeExfiltrationBase64Padding.test.ts are intentionally flipped to "kept"; the rest of both files is untouched. Four fixtures that used "a" * 40 / "b" * 40 as "any payload the heuristic flags" (test_acp_structured_refusal.py, test_decisions_gate.py, test_decisions_points.py, test_workflows_app.py) now use "x" * 40; their assertions are unchanged. test_security_gate_liveness.py raises the package line budget 31,509 -> 31,533 for the helper. Round 1 on the previous head: every red was one of these fixtures or the budget; no other suite failed. Results are on this PR's Backend Tests / Frontend Tests / Coverage Gate checks.
  • Rebase note (this head): rebased onto main @ 02eeb00d1, where refactor(security): split denied_rules, redaction and exfil into owners #22158 split exfil.py into owner modules and _EXFIL_PATTERNS now lives in exfil_url_rules.py. The helper and its regex stay in exfil.py beside the classifier that calls them; the same three call sites (query gate, privacy-safe diagnostic decoder and predicate) switch to it. display_safety.py (new on main) keeps the raw pattern: over-matching there only redacts more. Local run on this head: the 8 touched/related Python files (348 passed), the exfil/redaction/oauth/security set (13,397 passed; 2 failures are host-only and fail identically on main), vitest sanitize/redact/exfil (191 passed), tsc, flake8, isort, mypy clean.
  • How to undo: revert the single commit on this branch; _exfil_blob_hit / exfilBlobHit go away and both halves return to the bare .search() / .test() on the unchanged regexes. No data migration or config change is involved.

@iamwhatever

Copy link
Copy Markdown
Contributor

target=first-principles head=773161797083f15f256fdf2c399dc82b63867a28 span=residual

needs-a-decision -- First Principles PASS punchline: accept the residual that any 40-lowercase-hex token in a query passes the blob heuristic.

The residual is real and stated in exfil.py beside _GIT_OBJECT_NAME_RE. No token this product mints is 40 hex (the 64-hex token_hex(32) shape was removed from the carve-out in this head).
Fixed credential markers and the 200-char query-length gate are unchanged.
A maintainer accepting this tradeoff is the remaining step; I am not ruling on it for the team.

@iamwhatever

Copy link
Copy Markdown
Contributor

@CrysisDeu I rebased this PR onto main (exfil.py was split by #22158) and narrowed the carve-out to SHA-1 only, after GPT 6.1 found that 64-hex values match this product's own app secrets. Head is now 7731617. Sensitive Change Review only accepts the template from the PR author (or a reviewer's Approve review). A filled template for this head is in the comment above (issuecomment-6275829776). Could you re-post it as your own comment, or could a reviewer paste it into an approval? Every other check is green.

@github-actions github-actions Bot added readiness: passed Eligible automated validation passed for the current revision and removed readiness: checking Automated validation is still running labels Oct 19, 2026
@CrysisDeu

Copy link
Copy Markdown
Contributor Author

Sensitive change review

  • Head commit: dada3da
  • What rule changed: the exfil URL redactor's base64-blob heuristic (_EXFIL_PATTERNS branch [A-Za-z0-9+/]{40,}, and its browser mirror EXFIL_B64_RE in website/src/utils/sanitize.ts) is now evaluated through _exfil_blob_hit() in src/kiro_crew/security/exfil.py / exfilBlobHit(), which skips a match only when the whole maximal match is exactly 40 lowercase hex digits (a SHA-1 git object name). 64 hex is not carved out because it is the shape of the product's own token_hex(32) secrets. The regex spellings are unchanged.
  • Before -> after (what was allowed/blocked, now): Before, any URL whose query held a bare 40-hex commit hash was rewritten to [REDACTED: suspicious URL to <host>]. After, that URL renders. Everything else is unchanged: 41+ hex, 64 hex, uppercase or mixed-case hex, a hash with = padding, a hash glued to any other base64 character, 40-char non-hex runs, AWS key ids, Slack tokens, SSH/PEM headers, heavy percent-encoding, the 200-char query-length gate, the fixed-credential scan, the multi-pass decode and the S3-presigned validators behave as before. No host is exempted.
  • Worst case if wrong (breaks commands / leaks secret / locks user out): leaks secret, narrowly. A credential that is itself exactly 40 lowercase hex digits in a URL query is no longer redacted by this one heuristic. The fixed credential markers never caught it (they key on provider prefixes), and redaction.py's bare-secret detector already rejects all-hex runs on the same reasoning. No command floor, sandbox rule or auth path is touched, so nothing breaks commands or locks a user out.
  • Evidence checked (which sandbox result proves it): no sandbox run; this is a pure function on URL text. The evidence is the test matrix on this head: test/test_exfil_git_object_name.py and website/src/test/sanitizeExfiltrationGitObjectName.test.ts assert the kept shapes and every neighbouring shape that must still redact; test/test_redaction_mirror_parity.py::TestGitObjectNameCarveOutMirror pins the carve-out spelling on both halves. CI's Backend Tests and Frontend Tests lanes on this head are the run.
  • No regression:
    • Tools still work (which tools/commands were run, result): no tool, CLI or MCP surface changes; the redactor is called the same way with the same signature. Local static gates on the changed files on this head: black, flake8 clean.
    • Backward compatible (old config / old data / old callers still work, how checked): no config key, stored record shape or public function signature changes; redact_exfiltration_urls, scan_exfiltration_urls, redact_exfiltration_urls_with_records and sanitizeExfiltrationUrls keep their signatures. Checked by reading every call site of _EXFIL_PATTERNS and git diff origin/main...HEAD.
    • Existing tests (which suites passed on this head): CI is the test runner (no local test runs on the authoring host by policy). Change since the previous head (c8d3136): a rebase onto main (a6f3cc5) to clear a merge conflict. git range-diff shows no change to exfil.py, sanitize.ts or any test assertion. The one conflict was _PACKAGE_LINE_BUDGET in test/test_security_gate_liveness.py: main raised it to 33,147 (main's package total is 33,146), and this change adds 24 lines to exfil.py, so the budget is now 33,170, which equals the measured package total on this head. Results are on this PR's Backend Tests / Frontend Tests / Coverage Gate checks.
  • How to undo: revert the single commit on this branch; _exfil_blob_hit / exfilBlobHit go away and both halves return to the bare .search() / .test() on the unchanged regexes. No data migration or config change is involved.
  • Since 2f5005f: rebased onto current main 81dde23. The only conflict was the package line budget in test/test_security_gate_liveness.py (now 33,196); no security code changed.

@github-actions github-actions Bot added merge conflict Branch has merge conflicts with its base — author must resolve before merge readiness: passed Eligible automated validation passed for the current revision and removed merge conflict Branch has merge conflicts with its base — author must resolve before merge readiness: checking Automated validation is still running labels Oct 30, 2026
@CrysisDeu
CrysisDeu force-pushed the fix/exfil-commit-sha-url-false-positive branch from dada3da to e5c6465 Compare October 31, 2026 01:10
@CrysisDeu

Copy link
Copy Markdown
Contributor Author

Sensitive change review

  • Head commit: e5c6465
  • What rule changed: the exfil URL redactor's base64-blob heuristic (_EXFIL_PATTERNS branch [A-Za-z0-9+/]{40,}, and its browser mirror EXFIL_B64_RE in website/src/utils/sanitize.ts) is now evaluated through _exfil_blob_hit() in src/kiro_crew/security/exfil.py / exfilBlobHit(), which skips a match only when the whole maximal match is exactly 40 lowercase hex digits (a SHA-1 git object name). 64 hex is not carved out because it is the shape of the product's own token_hex(32) secrets. The regex spellings are unchanged.
  • Before -> after (what was allowed/blocked, now): Before, any URL whose query held a bare 40-hex commit hash was rewritten to [REDACTED: suspicious URL to <host>]. After, that URL renders. Everything else is unchanged: 41+ hex, 64 hex, uppercase or mixed-case hex, a hash with = padding, a hash glued to any other base64 character, 40-char non-hex runs, AWS key ids, Slack tokens, SSH/PEM headers, heavy percent-encoding, the 200-char query-length gate, the fixed-credential scan, the multi-pass decode and the S3-presigned validators behave as before. No host is exempted.
  • Worst case if wrong (breaks commands / leaks secret / locks user out): leaks secret, narrowly. A credential that is itself exactly 40 lowercase hex digits in a URL query is no longer redacted by this one heuristic. The fixed credential markers never caught it (they key on provider prefixes), and redaction.py's bare-secret detector already rejects all-hex runs on the same reasoning. No command floor, sandbox rule or auth path is touched, so nothing breaks commands or locks a user out.
  • Evidence checked (which sandbox result proves it): no sandbox run; this is a pure function on URL text. The evidence is the test matrix on this head: test/test_exfil_git_object_name.py and website/src/test/sanitizeExfiltrationGitObjectName.test.ts assert the kept shapes and every neighbouring shape that must still redact; test/test_redaction_mirror_parity.py::TestGitObjectNameCarveOutMirror pins the carve-out spelling on both halves. CI's Backend Tests and Frontend Tests lanes on this head are the run.
  • No regression:
    • Tools still work (which tools/commands were run, result): no tool, CLI or MCP surface changes; the redactor is called the same way with the same signature. Local static gates on the changed files on this head: black, flake8 clean.
    • Backward compatible (old config / old data / old callers still work, how checked): no config key, stored record shape or public function signature changes; redact_exfiltration_urls, scan_exfiltration_urls, redact_exfiltration_urls_with_records and sanitizeExfiltrationUrls keep their signatures. Checked by reading every call site of _EXFIL_PATTERNS and git diff origin/main...HEAD.
    • Existing tests (which suites passed on this head): CI is the test runner (no local test runs on the authoring host by policy). Change since the previous head (c8d3136): a rebase onto main (a6f3cc5) to clear a merge conflict. git range-diff shows no change to exfil.py, sanitize.ts or any test assertion. The one conflict was _PACKAGE_LINE_BUDGET in test/test_security_gate_liveness.py: main raised it to 33,147 (main's package total is 33,146), and this change adds 24 lines to exfil.py, so the budget is now 33,170, which equals the measured package total on this head. Results are on this PR's Backend Tests / Frontend Tests / Coverage Gate checks.
  • How to undo: revert the single commit on this branch; _exfil_blob_hit / exfilBlobHit go away and both halves return to the bare .search() / .test() on the unchanged regexes. No data migration or config change is involved.
  • Since 2f5005f: rebased onto current main 81dde23. The only conflict was the package line budget in test/test_security_gate_liveness.py (now 33,196); no security code changed.
  • Since dada3da: rebased onto current main 798f3a3. The only conflict was the package line budget in test/test_security_gate_liveness.py (now 33,358); the security code's changed lines are byte-identical.

@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: passed Eligible automated validation passed for the current revision merge conflict Branch has merge conflicts with its base — author must resolve before merge and removed readiness: passed Eligible automated validation passed for the current revision merge conflict Branch has merge conflicts with its base — author must resolve before merge readiness: checking Automated validation is still running labels Oct 31, 2026
@CrysisDeu
CrysisDeu force-pushed the fix/exfil-commit-sha-url-false-positive branch from e5c6465 to 19b9120 Compare October 31, 2026 05:07
@CrysisDeu

Copy link
Copy Markdown
Contributor Author

Sensitive change review

  • Head commit: 19b9120
  • What rule changed: the exfil URL redactor's base64-blob heuristic (_EXFIL_PATTERNS branch [A-Za-z0-9+/]{40,}, and its browser mirror EXFIL_B64_RE in website/src/utils/sanitize.ts) is now evaluated through _exfil_blob_hit() in src/kiro_crew/security/exfil.py / exfilBlobHit(), which skips a match only when the whole maximal match is exactly 40 lowercase hex digits (a SHA-1 git object name). 64 hex is not carved out because it is the shape of the product's own token_hex(32) secrets. The regex spellings are unchanged.
  • Before -> after (what was allowed/blocked, now): Before, any URL whose query held a bare 40-hex commit hash was rewritten to [REDACTED: suspicious URL to <host>]. After, that URL renders. Everything else is unchanged: 41+ hex, 64 hex, uppercase or mixed-case hex, a hash with = padding, a hash glued to any other base64 character, 40-char non-hex runs, AWS key ids, Slack tokens, SSH/PEM headers, heavy percent-encoding, the 200-char query-length gate, the fixed-credential scan, the multi-pass decode and the S3-presigned validators behave as before. No host is exempted.
  • Worst case if wrong (breaks commands / leaks secret / locks user out): leaks secret, narrowly. A credential that is itself exactly 40 lowercase hex digits in a URL query is no longer redacted by this one heuristic. The fixed credential markers never caught it (they key on provider prefixes), and redaction.py's bare-secret detector already rejects all-hex runs on the same reasoning. No command floor, sandbox rule or auth path is touched, so nothing breaks commands or locks a user out.
  • Evidence checked (which sandbox result proves it): no sandbox run; this is a pure function on URL text. The evidence is the test matrix on this head: test/test_exfil_git_object_name.py and website/src/test/sanitizeExfiltrationGitObjectName.test.ts assert the kept shapes and every neighbouring shape that must still redact; test/test_redaction_mirror_parity.py::TestGitObjectNameCarveOutMirror pins the carve-out spelling on both halves. CI's Backend Tests and Frontend Tests lanes on this head are the run.
  • No regression:
    • Tools still work (which tools/commands were run, result): no tool, CLI or MCP surface changes; the redactor is called the same way with the same signature. Local static gates on the changed files on this head: black, flake8 clean.
    • Backward compatible (old config / old data / old callers still work, how checked): no config key, stored record shape or public function signature changes; redact_exfiltration_urls, scan_exfiltration_urls, redact_exfiltration_urls_with_records and sanitizeExfiltrationUrls keep their signatures. Checked by reading every call site of _EXFIL_PATTERNS and git diff origin/main...HEAD.
    • Existing tests (which suites passed on this head): CI is the test runner (no local test runs on the authoring host by policy). Change since the previous head (c8d3136): a rebase onto main (a6f3cc5) to clear a merge conflict. git range-diff shows no change to exfil.py, sanitize.ts or any test assertion. The one conflict was _PACKAGE_LINE_BUDGET in test/test_security_gate_liveness.py: main raised it to 33,147 (main's package total is 33,146), and this change adds 24 lines to exfil.py, so the budget is now 33,170, which equals the measured package total on this head. Results are on this PR's Backend Tests / Frontend Tests / Coverage Gate checks.
  • How to undo: revert the single commit on this branch; _exfil_blob_hit / exfilBlobHit go away and both halves return to the bare .search() / .test() on the unchanged regexes. No data migration or config change is involved.
  • Since 2f5005f: rebased onto current main 81dde23. The only conflict was the package line budget in test/test_security_gate_liveness.py (now 33,196); no security code changed.
  • Since dada3da: rebased onto current main 798f3a3. The only conflict was the package line budget in test/test_security_gate_liveness.py (now 33,358); the security code's changed lines are byte-identical.
  • Since e5c6465: rebased onto current main 720403c. The only conflict was the package line budget in test/test_security_gate_liveness.py (now 33,547); the security code's changed lines are byte-identical.

@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: passed Eligible automated validation passed for the current revision merge conflict Branch has merge conflicts with its base — author must resolve before merge readiness: checking Automated validation is still running labels Oct 31, 2026
@CrysisDeu

Copy link
Copy Markdown
Contributor Author

Sensitive change review

  • Head commit: 2f65aa1
  • What rule changed: the exfil URL redactor's base64-blob heuristic (_EXFIL_PATTERNS branch [A-Za-z0-9+/]{40,}, and its browser mirror EXFIL_B64_RE in website/src/utils/sanitize.ts) is now evaluated through _exfil_blob_hit() in src/kiro_crew/security/exfil_git_object.py (re-imported by exfil.py) / exfilBlobHit(), which skips a match only when the whole maximal match is exactly 40 lowercase hex digits (a SHA-1 git object name). 64 hex is not carved out because it is the shape of the product's own token_hex(32) secrets. The regex spellings are unchanged.
  • Before -> after (what was allowed/blocked, now): Before, any URL whose query held a bare 40-hex commit hash was rewritten to [REDACTED: suspicious URL to <host>]. After, that URL renders. Everything else is unchanged: 41+ hex, 64 hex, uppercase or mixed-case hex, a hash with = padding, a hash glued to any other base64 character, 40-char non-hex runs, AWS key ids, Slack tokens, SSH/PEM headers, heavy percent-encoding, the 200-char query-length gate, the fixed-credential scan, the multi-pass decode and the S3-presigned validators behave as before. No host is exempted.
  • Worst case if wrong (breaks commands / leaks secret / locks user out): leaks secret, narrowly. A credential that is itself exactly 40 lowercase hex digits in a URL query is no longer redacted by this one heuristic. The fixed credential markers never caught it (they key on provider prefixes), and redaction.py's bare-secret detector already rejects all-hex runs on the same reasoning. No command floor, sandbox rule or auth path is touched, so nothing breaks commands or locks a user out.
  • Evidence checked (which sandbox result proves it): no sandbox run; this is a pure function on URL text. The evidence is the test matrix on this head: test/test_exfil_git_object_name.py and website/src/test/sanitizeExfiltrationGitObjectName.test.ts assert the kept shapes and every neighbouring shape that must still redact; test/test_redaction_mirror_parity.py::TestGitObjectNameCarveOutMirror pins the carve-out spelling on both halves. CI's Backend Tests and Frontend Tests lanes on this head are the run.
  • No regression:
    • Tools still work (which tools/commands were run, result): no tool, CLI or MCP surface changes; the redactor is called the same way with the same signature. Local static gates on the changed files on this head: black, flake8 clean.
    • Backward compatible (old config / old data / old callers still work, how checked): no config key, stored record shape or public function signature changes; redact_exfiltration_urls, scan_exfiltration_urls, redact_exfiltration_urls_with_records and sanitizeExfiltrationUrls keep their signatures. Checked by reading every call site of _EXFIL_PATTERNS and git diff origin/main...HEAD.
    • Existing tests (which suites passed on this head): CI is the test runner (no local test runs on the authoring host by policy). Change since the previous head (c8d3136): a rebase onto main (a6f3cc5) to clear a merge conflict. git range-diff shows no change to exfil.py, sanitize.ts or any test assertion. The one conflict was _PACKAGE_LINE_BUDGET in test/test_security_gate_liveness.py: main raised it to 33,147 (main's package total is 33,146), and this change adds 24 lines to exfil.py, so the budget is now 33,170, which equals the measured package total on this head. Results are on this PR's Backend Tests / Frontend Tests / Coverage Gate checks.
  • How to undo: revert the two commits on this branch; _exfil_blob_hit / exfilBlobHit go away and both halves return to the bare .search() / .test() on the unchanged regexes. No data migration or config change is involved.
  • Since 2f5005f: rebased onto current main 81dde23. The only conflict was the package line budget in test/test_security_gate_liveness.py (now 33,196); no security code changed.
  • Since dada3da: rebased onto current main 798f3a3. The only conflict was the package line budget in test/test_security_gate_liveness.py (now 33,358); the security code's changed lines are byte-identical.
  • Since e5c6465: rebased onto current main 720403c. The only conflict was the package line budget in test/test_security_gate_liveness.py (now 33,547); the security code's changed lines are byte-identical.
  • Since 19b9120: rebased onto current main 934f7a8, where exfil.py grew to 1,992 lines, so the rebased file would be 2,016, past the 2,000-line cap. This PR's own _GIT_OBJECT_NAME_RE and _exfil_blob_hit moved verbatim into the new owner src/kiro_crew/security/exfil_git_object.py (second commit), joined to the facade's _OWNERS, test/test_exfil_facade.py and display_battery.RULE_SOURCES, and re-imported into exfil.py. Package budget 33,763. Checked: scripts/deny_diff.py 19b9120 vs this head, fresh process per ref, PYTHONHASHSEED 0 and 2: 0 verdict changes over 69 classified rows; scan_exfiltration_urls and redact_exfiltration_urls over 156 query URLs (40/41/64 hex, case, padding, glued, AWS key, base64, percent runs) give byte-identical output at both refs.

@iamwhatever

Copy link
Copy Markdown
Contributor

HOLD at 2f65aa1.

This head moves the carve-out into its own owner module and registers it in the facade, the display battery and the security spec. I found no definite defect. The new predicate fires on a subset of the old matches. It skips only a maximal run of exactly 40 lowercase hex, so 64-hex app secrets, longer runs, mixed case and padded runs still redact:

def _exfil_blob_hit(value: str) -> bool:
"""True when ``_EXFIL_PATTERNS`` matches ``value`` on anything but a bare git
object name. Every other alternative (AWS key id, SSH/PEM header, Slack
token, heavy percent encoding) is reported unchanged."""
for match in _EXFIL_PATTERNS.finditer(value):
if _GIT_OBJECT_NAME_RE.fullmatch(match.group(0)):
continue
return True
return False

What holds it:

  1. The PR changes what the exfiltration-URL redactor hides, which is reserved for a human reviewer.
  2. The residual (a third-party 40-hex token in a query now passes this heuristic) is waiting on a maintainer ruling.
  3. CI is still running on this head, including Backend Tests and the Security Scope candidates lane, and PR Readiness is pending.

— crew-pr-reviewer (r138)

@CrysisDeu

Copy link
Copy Markdown
Contributor Author

Sensitive change review

  • Head commit: db912b4
  • What rule changed: the exfil URL redactor's base64-blob heuristic (_EXFIL_PATTERNS branch [A-Za-z0-9+/]{40,}, and its browser mirror EXFIL_B64_RE in website/src/utils/sanitize.ts) is now evaluated through _exfil_blob_hit() in src/kiro_crew/security/exfil_git_object.py (re-imported by exfil.py) / exfilBlobHit(), which skips a match only when the whole maximal match is exactly 40 lowercase hex digits (a SHA-1 git object name). 64 hex is not carved out because it is the shape of the product's own token_hex(32) secrets. The regex spellings are unchanged.
  • Before -> after (what was allowed/blocked, now): Before, any URL whose query held a bare 40-hex commit hash was rewritten to [REDACTED: suspicious URL to <host>]. After, that URL renders. Everything else is unchanged: 41+ hex, 64 hex, uppercase or mixed-case hex, a hash with = padding, a hash glued to any other base64 character, 40-char non-hex runs, AWS key ids, Slack tokens, SSH/PEM headers, heavy percent-encoding, the 200-char query-length gate, the fixed-credential scan, the multi-pass decode and the S3-presigned validators behave as before. No host is exempted.
  • Worst case if wrong (breaks commands / leaks secret / locks user out): leaks secret, narrowly. A credential that is itself exactly 40 lowercase hex digits in a URL query is no longer redacted by this one heuristic. The fixed credential markers never caught it (they key on provider prefixes), and redaction.py's bare-secret detector already rejects all-hex runs on the same reasoning. No command floor, sandbox rule or auth path is touched, so nothing breaks commands or locks a user out.
  • Evidence checked (which sandbox result proves it): no sandbox run; this is a pure function on URL text. The evidence is the test matrix on this head: test/test_exfil_git_object_name.py and website/src/test/sanitizeExfiltrationGitObjectName.test.ts assert the kept shapes and every neighbouring shape that must still redact; test/test_redaction_mirror_parity.py::TestGitObjectNameCarveOutMirror pins the carve-out spelling on both halves. CI's Backend Tests and Frontend Tests lanes on this head are the run.
  • No regression:
    • Tools still work (which tools/commands were run, result): no tool, CLI or MCP surface changes; the redactor is called the same way with the same signature. Local static gates on the changed files on this head: black, flake8 clean.
    • Backward compatible (old config / old data / old callers still work, how checked): no config key, stored record shape or public function signature changes; redact_exfiltration_urls, scan_exfiltration_urls, redact_exfiltration_urls_with_records and sanitizeExfiltrationUrls keep their signatures. Checked by reading every call site of _EXFIL_PATTERNS and git diff origin/main...HEAD.
    • Existing tests (which suites passed on this head): CI is the test runner (no local test runs on the authoring host by policy). Change since the previous head (c8d3136): a rebase onto main (a6f3cc5) to clear a merge conflict. git range-diff shows no change to exfil.py, sanitize.ts or any test assertion. The one conflict was _PACKAGE_LINE_BUDGET in test/test_security_gate_liveness.py: main raised it to 33,147 (main's package total is 33,146), and this change adds 24 lines to exfil.py, so the budget is now 33,170, which equals the measured package total on this head. Results are on this PR's Backend Tests / Frontend Tests / Coverage Gate checks.
  • How to undo: revert the two commits on this branch; _exfil_blob_hit / exfilBlobHit go away and both halves return to the bare .search() / .test() on the unchanged regexes. No data migration or config change is involved.
  • Since 2f5005f: rebased onto current main 81dde23. The only conflict was the package line budget in test/test_security_gate_liveness.py (now 33,196); no security code changed.
  • Since dada3da: rebased onto current main 798f3a3. The only conflict was the package line budget in test/test_security_gate_liveness.py (now 33,358); the security code's changed lines are byte-identical.
  • Since e5c6465: rebased onto current main 720403c. The only conflict was the package line budget in test/test_security_gate_liveness.py (now 33,547); the security code's changed lines are byte-identical.
  • Since 19b9120: rebased onto current main 934f7a8, where exfil.py grew to 1,992 lines, so the rebased file would be 2,016, past the 2,000-line cap. This PR's own _GIT_OBJECT_NAME_RE and _exfil_blob_hit moved verbatim into the new owner src/kiro_crew/security/exfil_git_object.py (second commit), joined to the facade's _OWNERS, test/test_exfil_facade.py and display_battery.RULE_SOURCES, and re-imported into exfil.py. Package budget 33,763. Checked: scripts/deny_diff.py 19b9120 vs this head, fresh process per ref, PYTHONHASHSEED 0 and 2: 0 verdict changes over 69 classified rows; scan_exfiltration_urls and redact_exfiltration_urls over 156 query URLs (40/41/64 hex, case, padding, glued, AWS key, base64, percent runs) give byte-identical output at both refs.
  • Since 2f65aa1: rebased onto current main 6fac7bc. The conflict was the package line budget in test/test_security_gate_liveness.py (now 33,999). exfil.py sits at 2,000 lines on main, so this head also drops the explicit annotation on query_decoder in diagnose_oauth_url_credential (same value, type inferred) and the now-unused type-checking Callable import, keeping exfil.py at 1,996. No rule or pattern changed; every other security line is byte-identical to the previous head.

@CrysisDeu

Copy link
Copy Markdown
Contributor Author

Sensitive change review

  • Head commit: 454fe10
  • What rule changed: the exfil URL redactor's base64-blob heuristic (_EXFIL_PATTERNS branch [A-Za-z0-9+/]{40,}, and its browser mirror EXFIL_B64_RE in website/src/utils/sanitize.ts) is now evaluated through _exfil_blob_hit() in src/kiro_crew/security/exfil_git_object.py (re-imported by exfil.py) / exfilBlobHit(), which skips a match only when the whole maximal match is exactly 40 lowercase hex digits (a SHA-1 git object name). 64 hex is not carved out because it is the shape of the product's own token_hex(32) secrets. The regex spellings are unchanged.
  • Before -> after (what was allowed/blocked, now): Before, any URL whose query held a bare 40-hex commit hash was rewritten to [REDACTED: suspicious URL to <host>]. After, that URL renders. Everything else is unchanged: 41+ hex, 64 hex, uppercase or mixed-case hex, a hash with = padding, a hash glued to any other base64 character, 40-char non-hex runs, AWS key ids, Slack tokens, SSH/PEM headers, heavy percent-encoding, the 200-char query-length gate, the fixed-credential scan, the multi-pass decode and the S3-presigned validators behave as before. No host is exempted.
  • Worst case if wrong (breaks commands / leaks secret / locks user out): leaks secret, narrowly. A credential that is itself exactly 40 lowercase hex digits in a URL query is no longer redacted by this one heuristic. The fixed credential markers never caught it (they key on provider prefixes), and redaction.py's bare-secret detector already rejects all-hex runs on the same reasoning. No command floor, sandbox rule or auth path is touched, so nothing breaks commands or locks a user out.
  • Evidence checked (which sandbox result proves it): no sandbox run; this is a pure function on URL text. The evidence is the test matrix on this head: test/test_exfil_git_object_name.py and website/src/test/sanitizeExfiltrationGitObjectName.test.ts assert the kept shapes and every neighbouring shape that must still redact; test/test_redaction_mirror_parity.py::TestGitObjectNameCarveOutMirror pins the carve-out spelling on both halves. CI's Backend Tests and Frontend Tests lanes on this head are the run.
  • No regression:
    • Tools still work (which tools/commands were run, result): no tool, CLI or MCP surface changes; the redactor is called the same way with the same signature. Local static gates on the changed files on this head: black, flake8 clean.
    • Backward compatible (old config / old data / old callers still work, how checked): no config key, stored record shape or public function signature changes; redact_exfiltration_urls, scan_exfiltration_urls, redact_exfiltration_urls_with_records and sanitizeExfiltrationUrls keep their signatures. Checked by reading every call site of _EXFIL_PATTERNS and git diff origin/main...HEAD.
    • Existing tests (which suites passed on this head): CI is the test runner (no local test runs on the authoring host by policy). Change since the previous head (c8d3136): a rebase onto main (a6f3cc5) to clear a merge conflict. git range-diff shows no change to exfil.py, sanitize.ts or any test assertion. The one conflict was _PACKAGE_LINE_BUDGET in test/test_security_gate_liveness.py: main raised it to 33,147 (main's package total is 33,146), and this change adds 24 lines to exfil.py, so the budget is now 33,170, which equals the measured package total on this head. Results are on this PR's Backend Tests / Frontend Tests / Coverage Gate checks.
  • How to undo: revert the two commits on this branch; _exfil_blob_hit / exfilBlobHit go away and both halves return to the bare .search() / .test() on the unchanged regexes. No data migration or config change is involved.
  • Since 2f5005f: rebased onto current main 81dde23. The only conflict was the package line budget in test/test_security_gate_liveness.py (now 33,196); no security code changed.
  • Since dada3da: rebased onto current main 798f3a3. The only conflict was the package line budget in test/test_security_gate_liveness.py (now 33,358); the security code's changed lines are byte-identical.
  • Since e5c6465: rebased onto current main 720403c. The only conflict was the package line budget in test/test_security_gate_liveness.py (now 33,547); the security code's changed lines are byte-identical.
  • Since 19b9120: rebased onto current main 934f7a8, where exfil.py grew to 1,992 lines, so the rebased file would be 2,016, past the 2,000-line cap. This PR's own _GIT_OBJECT_NAME_RE and _exfil_blob_hit moved verbatim into the new owner src/kiro_crew/security/exfil_git_object.py (second commit), joined to the facade's _OWNERS, test/test_exfil_facade.py and display_battery.RULE_SOURCES, and re-imported into exfil.py. Package budget 33,763. Checked: scripts/deny_diff.py 19b9120 vs this head, fresh process per ref, PYTHONHASHSEED 0 and 2: 0 verdict changes over 69 classified rows; scan_exfiltration_urls and redact_exfiltration_urls over 156 query URLs (40/41/64 hex, case, padding, glued, AWS key, base64, percent runs) give byte-identical output at both refs.
  • Since 2f65aa1: rebased onto current main 6fac7bc. The conflict was the package line budget in test/test_security_gate_liveness.py (now 33,999). exfil.py sits at 2,000 lines on main, so this head also drops the explicit annotation on query_decoder in diagnose_oauth_url_credential (same value, type inferred) and the now-unused type-checking Callable import, keeping exfil.py at 1,996. No rule or pattern changed; every other security line is byte-identical to the previous head.
  • Since db912b4: rebased onto current main a299f87, which raised the package line budget to 33,967 (fix(agent): resolve an agent's kirocrew to this install, not a stale one #26324). The only conflict was that budget; it is now 34,007. The security code's changed lines are byte-identical to the previous head.

CrysisDeu and others added 2 commits November 4, 2026 14:08
…t name

The exfil base64-blob heuristic matched a bare 40- or 64-hex git SHA in a
URL query, so a commit permalink keyed on the SHA was rewritten to
[REDACTED: suspicious URL to <host>] on every surface while the same SHA
in a path was already benign. Judge each maximal blob match against the
exact git lengths in lowercase, on the backend and in the browser mirror,
and pin the carve-out's edges so neighbouring shapes still redact.
…_object

exfil.py would reach 2,016 lines on current main, past the 2,000-line file cap.
Move this PR's own helper (_GIT_OBJECT_NAME_RE and _exfil_blob_hit) verbatim
into a new owner module beside it, join it to the facade's _OWNERS and the
display battery's rule sources, and re-import both names into exfil.py so
every caller's import path is unchanged.
@CrysisDeu

Copy link
Copy Markdown
Contributor Author

Sensitive change review

  • Head commit: ce995e1
  • What rule changed: the exfil URL redactor's base64-blob heuristic (_EXFIL_PATTERNS branch [A-Za-z0-9+/]{40,}, and its browser mirror EXFIL_B64_RE in website/src/utils/sanitize.ts) is now evaluated through _exfil_blob_hit() in src/kiro_crew/security/exfil_git_object.py (re-imported by exfil.py) / exfilBlobHit(), which skips a match only when the whole maximal match is exactly 40 lowercase hex digits (a SHA-1 git object name). 64 hex is not carved out because it is the shape of the product's own token_hex(32) secrets. The regex spellings are unchanged.
  • Before -> after (what was allowed/blocked, now): Before, any URL whose query held a bare 40-hex commit hash was rewritten to [REDACTED: suspicious URL to <host>]. After, that URL renders. Everything else is unchanged: 41+ hex, 64 hex, uppercase or mixed-case hex, a hash with = padding, a hash glued to any other base64 character, 40-char non-hex runs, AWS key ids, Slack tokens, SSH/PEM headers, heavy percent-encoding, the 200-char query-length gate, the fixed-credential scan, the multi-pass decode and the S3-presigned validators behave as before. No host is exempted.
  • Worst case if wrong (breaks commands / leaks secret / locks user out): leaks secret, narrowly. A credential that is itself exactly 40 lowercase hex digits in a URL query is no longer redacted by this one heuristic. The fixed credential markers never caught it (they key on provider prefixes), and redaction.py's bare-secret detector already rejects all-hex runs on the same reasoning. No command floor, sandbox rule or auth path is touched, so nothing breaks commands or locks a user out.
  • Evidence checked (which sandbox result proves it): no sandbox run; this is a pure function on URL text. The evidence is the test matrix on this head: test/test_exfil_git_object_name.py and website/src/test/sanitizeExfiltrationGitObjectName.test.ts assert the kept shapes and every neighbouring shape that must still redact; test/test_redaction_mirror_parity.py::TestGitObjectNameCarveOutMirror pins the carve-out spelling on both halves. CI's Backend Tests and Frontend Tests lanes on this head are the run.
  • No regression:
    • Tools still work (which tools/commands were run, result): no tool, CLI or MCP surface changes; the redactor is called the same way with the same signature. Local static gates on the changed files on this head: black, flake8 clean.
    • Backward compatible (old config / old data / old callers still work, how checked): no config key, stored record shape or public function signature changes; redact_exfiltration_urls, scan_exfiltration_urls, redact_exfiltration_urls_with_records and sanitizeExfiltrationUrls keep their signatures. Checked by reading every call site of _EXFIL_PATTERNS and git diff origin/main...HEAD.
    • Existing tests (which suites passed on this head): CI is the test runner (no local test runs on the authoring host by policy). Change since the previous head (c8d3136): a rebase onto main (a6f3cc5) to clear a merge conflict. git range-diff shows no change to exfil.py, sanitize.ts or any test assertion. The one conflict was _PACKAGE_LINE_BUDGET in test/test_security_gate_liveness.py: main raised it to 33,147 (main's package total is 33,146), and this change adds 24 lines to exfil.py, so the budget is now 33,170, which equals the measured package total on this head. Results are on this PR's Backend Tests / Frontend Tests / Coverage Gate checks.
  • How to undo: revert the two commits on this branch; _exfil_blob_hit / exfilBlobHit go away and both halves return to the bare .search() / .test() on the unchanged regexes. No data migration or config change is involved.
  • Since 2f5005f: rebased onto current main 81dde23. The only conflict was the package line budget in test/test_security_gate_liveness.py (now 33,196); no security code changed.
  • Since dada3da: rebased onto current main 798f3a3. The only conflict was the package line budget in test/test_security_gate_liveness.py (now 33,358); the security code's changed lines are byte-identical.
  • Since e5c6465: rebased onto current main 720403c. The only conflict was the package line budget in test/test_security_gate_liveness.py (now 33,547); the security code's changed lines are byte-identical.
  • Since 19b9120: rebased onto current main 934f7a8, where exfil.py grew to 1,992 lines, so the rebased file would be 2,016, past the 2,000-line cap. This PR's own _GIT_OBJECT_NAME_RE and _exfil_blob_hit moved verbatim into the new owner src/kiro_crew/security/exfil_git_object.py (second commit), joined to the facade's _OWNERS, test/test_exfil_facade.py and display_battery.RULE_SOURCES, and re-imported into exfil.py. Package budget 33,763. Checked: scripts/deny_diff.py 19b9120 vs this head, fresh process per ref, PYTHONHASHSEED 0 and 2: 0 verdict changes over 69 classified rows; scan_exfiltration_urls and redact_exfiltration_urls over 156 query URLs (40/41/64 hex, case, padding, glued, AWS key, base64, percent runs) give byte-identical output at both refs.
  • Since 2f65aa1: rebased onto current main 6fac7bc. The conflict was the package line budget in test/test_security_gate_liveness.py (now 33,999). exfil.py sits at 2,000 lines on main, so this head also drops the explicit annotation on query_decoder in diagnose_oauth_url_credential (same value, type inferred) and the now-unused type-checking Callable import, keeping exfil.py at 1,996. No rule or pattern changed; every other security line is byte-identical to the previous head.
  • Since db912b4: rebased onto current main a299f87, which raised the package line budget to 33,967 (fix(agent): resolve an agent's kirocrew to this install, not a stale one #26324). The only conflict was that budget; it is now 34,007. The security code's changed lines are byte-identical to the previous head.
  • Since 454fe10: rebased onto current main a1bb018, which raised the package line budget to 34,312. The only conflict was that budget; it is now 34,352 (main's 34,312 plus this PR's 40). The security code's changed lines are byte-identical to the previous head.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants