Skip to content

fix(security): hold a streamed AWS key-value pair past the 512 floor - #21573

Merged
chenmingwei23 merged 1 commit into
mainfrom
fix/stream-aws-keyed-holdback-17115
Oct 21, 2026
Merged

chenmingwei23 merged 1 commit into
mainfrom
fix/stream-aws-keyed-holdback-17115

Conversation

@bolichen97

@bolichen97 bolichen97 commented Oct 17, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

Goal: A streamed AWS secret after its key (aws_secret_access_key=, "SessionToken": ", ...) never reaches the chat stream raw, however long it is.

The batch pass redacts an AWS key-value pair only when the key and the value sit in the same redact() call. The stream redactor holds back at most 512 characters for a value with no known anchor. A longer value was cut at 512, cut away from its key, and streamed raw.

Measured on origin/main 8c4a3d9bce with a value that has no 40-character base64 run (so only the key-value branch can catch it): at chunk sizes 1, 7, 64 and 600, a 600 to 5,000 character value streamed with every 10-character piece of it visible, for all four AWS key shapes (key=v, key = "v", JSON "Key": "v", Key: v). 73 of the 125 tested cases leaked. The batch pass redacted every one of them whole.

Why it matters

An AWS session token is often longer than 512 characters, and it is a working credential until it expires. The live stream goes to every open dashboard tab and to channel adapters, so a model that echoes a credentials file or a SessionToken field shows the token to anyone watching the stream.

Not a goal

  • Key-anchored names other than the three AWS key-value branches the batch pass already has (api_key=, password: and so on). Those have no batch key-value rule today.
  • Keeping the key label in the redacted text. The batch pass replaces the whole pair on main, and the stream matches it.
  • A whitespace between a closing key quote and its colon ("SessionToken" : "v"). That split exists for short values too.
  • A label padded past the floor: a key name with no separator yet is held only inside the 512 floor, then released as on main, so Key + long padding + : v split in that padding can still stream v, exactly as main does.

What changed (motivation → approach → change)

Symptom: a long AWS value streams raw after the first 512 held characters. Root cause: the stream redactor only raises its holdback for STRONG anchors (a JWT, a Bearer header, a ?token= parameter). An AWS key label was not one, so the 512 floor cut the value away from its key.

Approach, as the issue's recorded decision says: hold past the floor up to the existing 4,096 ceiling, and fail closed beyond it. StreamRedactor.feed in src/kiro_crew/security/text_redaction.py gets an AWS key-value anchor beside the Bearer one. The label grammar and its linear finder live in a new module, src/kiro_crew/security/stream_aws_anchor.py, built from redaction._AWS_LABEL_RULES so the key lists cannot drift.

Case What the stream does
label with its separator, value under 4,096 held with its key; output equals batch redact()
value past 4,096 one tag; the drop ends at the value's terminator [\s"',}] or closing quote, or where the last nested carrier (?token=) ends
where the cut lands only at whitespace or the start of the held buffer, never inside a batch match
a whitespace-free run that carries the label past 4,096 accepted cost: dropped from the start of the held run behind one tag
a bare key name, no separator yet WEAK: held inside the 512 floor, released as on main past it
a label glued to a dropped AWS value (.../Authorization: , ...SecretAccessKey = ) when AWS is the only carrier, the drop ends at that label once its separator shows, so its own value is held with it; Bearer, JWT and ?token= drops end as on main
a key name inside another credential (aws_session_token=...AccessKeyId , a bare 40-character run) that credential is kept whole; the key anchors nothing
a PEM word (begin) near the key the drop starts at the AWS cut, not at 0, and the 512 floor never splits a finished pair it holds

The anchor is found by a linear scan with a few anchored matches, so a long run of repeated labels cannot stall the event loop. A stream that names no AWS key skips it after a substring check. docs/system-specs/modules/security.md names the anchor, the cut rule and its cost. The security package line budget in test/test_security_gate_liveness.py rises by the 356 lines this adds (217 of them the new module), from main's 31,509 to 31,865.

Backwards compatibility

Compatible: the stream only holds more text back around an AWS label and drops a value that the batch pass would have redacted anyway; ordinary text and every other anchor stream as before (3,000 seeded no-AWS streams at random chunk sizes are byte-identical to main). The one benign-text cost is the fail-closed drop of a whitespace-free run over 4,096 characters that ends in an AWS pair.

Removes nothing: no key, API, record or text that main emits is taken away beyond that documented drop.

Tests

test/test_stream_redactor_aws_keyed.py:

Test Locks in
test_aws_keyed_value_past_the_floor_never_streams_raw 5 key shapes × 600/3,000/5,000 chars × chunk 1/7/64/600: no piece of the value in the output
test_aws_keyed_value_under_the_ceiling_streams_as_the_batch_pass_writes_it under the ceiling, stream output equals redact()
test_oversized_aws_keyed_continuation_is_discarded, test_aws_keyed_discard_stops_at_the_value_terminator, test_a_closed_value_past_the_ceiling_keeps_its_suffix past the ceiling: one tag, no continuation byte, the drop ends at the terminator
test_a_bare_secret_ending_in_a_key_name_before_a_long_value_never_streams a 40-character run ending in AccessKeyId, = and a 4,602-char value, chunks 1/7/64/600: no prefix of the run streams
test_a_long_whitespace_free_run_before_an_aws_pair_fails_closed the accepted cost: a 5,000-char run before a short pair is one tag, never split
test_minified_json_past_the_ceiling_fails_closed_from_the_held_run released fields stay, no value byte streams, one tag
test_a_pem_word_before_an_aws_label_does_not_widen_the_drop prose before begin aws_secret_access_key=, open or closed by its quote, streams unchanged
test_a_finished_aws_pair_held_by_a_pem_word_is_not_split_by_the_floor no piece of a finished long value streams when a PEM word follows it
test_a_label_glued_to_a_dropped_value_keeps_its_own_value_hidden, test_a_label_at_the_end_of_a_buffer_that_fails_closed_keeps_its_value_hidden a Bearer or AWS label glued to an over-ceiling dropped value, whole or split at 1/3 chars: its value never streams
test_a_label_name_inside_a_dropped_value_does_not_end_the_drop a key or header name inside a dropped Bearer, JWT, ?token= or AWS value, with no separator, never ends the drop
test_a_value_glued_to_an_authorization_separator_stays_in_the_drop /Authorization:SECRET glued inside a dropped ?token= or AWS value stays dropped
test_a_bare_run_glued_before_a_batch_match_is_not_split a 36-char run glued before Authorization: Bearer ...&AccessKeyId= stays whole
test_a_label_after_a_long_run_is_held_once_its_separator_arrives key = after a 1,500-char run holds the value that follows
the key-name-inside-another-credential, URL, Bearer, nested ?token=, linear-finder and shape tests carried over unchanged

Red on 57b13481f3, 65a6afee87 or ceb4d5f9ae (earlier heads), green here: the bare-secret, glued-run, glued-label, label-name-inside, glued-Authorization, PEM-word, PEM-held-pair and long-run tests. Three tests of the previous head are flipped or removed by the cut-rule ruling: the padded-label test is removed (that state machine is gone; the case is now a Not-a-goal), and the minified-JSON and short-pair tests now assert the fail-closed drop. A seeded differential fuzz of 4,000 mixed AWS / Bearer / ?token= / bare-run / glued-run / glued-label / PEM-word / padded-label streams at random chunk sizes: main leaks a secret piece the batch pass hides in 2,453, this branch in 295, and 28 cases leaked here but not on main before the glued-run and glued-label fixes (0 of those remain). One case still leaks here and not on main at that one chunking: a key name inside an earlier AWS value (a batch quirk), which leaks on main in 169 of 300 chunkings and here in 28. The other 294 are main-shared classes: padded labels, a key name inside an earlier AWS value, Bearer, bare runs. Feeding a 4 KB AWS value one byte at a time takes 1.20 CPU s, against 1.08 s for a 4 KB Bearer value.

Determinism: seeded inputs, no clock. The file passed 218/218 in a parallel run.

Manual verification

N/A — unit coverage sufficient: the change is a pure function of the streamed text, and the tests drive it at every chunk size that matters.

Related Issues

Closes #17115

Pattern harvest

Rule candidate: review-prompt
Pattern: a batch redaction rule whose match spans a key and its value needs a matching stream anchor, or the stream floor splits them.

Checklist

  • At most two commits (one is the norm), with a Conventional Commits title
  • Existing tests pass and new tests added for new functionality
  • Self-review completed; code follows project style guidelines
  • Documentation updated (if applicable)
  • No secrets, credentials, or internal references in the diff

Contribution License Agreement

Contributions are accepted under the project's Apache-2.0 license.

@github-actions

github-actions Bot commented Oct 17, 2026 •

Copy link
Copy Markdown
Contributor

Sensitive Change Review

Sensitive files changed:

  • src/kiro_crew/security/__init__.py

  • src/kiro_crew/security/stream_aws_anchor.py

  • src/kiro_crew/security/text_redaction.py

  • @bolichen97 posted a complete reasoning template for ffb262b.

@github-actions

github-actions Bot commented Oct 17, 2026 •

Copy link
Copy Markdown
Contributor

UX Review (Opus 5.5) — ⏭️ skipped

Revision ffb262b8c4b354568957d6183c7bfa068de6cd84 touches no user-facing surface (no changes under website/ or committed screenshots), so the UX review was skipped. Advisory — does not block merge.

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

github-actions Bot commented Oct 17, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Opus 5.5) — 🟡 CONCERNS

Design-level review of ffb262b8c4b354568957d6183c7bfa068de6cd84 — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

Design-Verdict: CONCERNS

The stream redactor keeps growing its own carrier state machine; the description's own fuzz says it still leaks in 295 of 4,000 cases where batch redacts.

Watch

  • Each new case adds another rule. The fix adds a tuple of discard kinds, a carried tail (LABEL_CARRY), label_backoff, label_awaiting_separator, a PEM-hold carve-out and a floor-split repair. The description reports "main leaks … in 2,453, this branch in 295". So the cause: one rule per glued, nested or PEM case. The effect: each review round adds another rule, and the stream and batch passes drift apart further. The truncated sentence "and 28 cases …" may describe streams that leak on this branch but not on main. If so, that is a regression the author has not explained.
    Clears when: the description states what the 295 remaining leaks and the 28 cases are, and that none of them leaks on this branch but not on main.

Suggestions

  • Once a label shows its separator, drop its value straight away behind one tag, up to the value's terminator, instead of holding up to 4,096 to match batch output. The batch pass already replaces the whole pair. That makes most of the hold-and-backoff logic unnecessary.

[DESIGN-REVIEWED] ffb262b

Description read

[DESCRIPTION-READ] ea3e1a28fe1367be722cc37e2dc83abfb10a8a44a65e6ef52a4c8cd15416602f

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 17, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Opus 5.5) — ✅ PASS

Premise-level review of ffb262b8c4b354568957d6183c7bfa068de6cd84 — 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/CONCERNS are advisory.

First-Principles-Verdict: PASS

Check that the 295 fuzz cases the description says still leak on this branch all fall under the listed Not-a-goal shapes, not a new one.

What this change ships

Inventory (10 items) — 10 justified

Intent: stop a streamed AWS secret longer than 512 characters, sent after its key, from reaching dashboard and channel viewers unredacted. This is a FIX.

  1. A long AWS value after its key is held with that key and redacted whole, up to 4,096 characters — justified
  2. Past 4,096 characters the stream fails closed: one tag, and the rest is dropped up to the value's terminator — justified
  3. A whitespace-free run (minified JSON) that carries an AWS label past 4,096 is dropped whole, benign fields included — justified
  4. A credential label glued to a dropped AWS value ends the drop, so its own value stays hidden — justified
  5. A ?token= nested inside an AWS value keeps the drop going until the outer value ends — justified
  6. A PEM word ("begin") before an AWS key no longer widens the drop back to the start of the buffer — justified
  7. While a key name is buffered, the 512 floor no longer splits a finished AWS pair — justified
  8. A bare AWS key name with no separator yet is held briefly inside the 512 floor — justified
  9. The redactor's held text reads empty while it is discarding, even with a carried tail buffered — justified
  10. The security package's line budget goes up from 31,509 to 31,865 — justified

[FIRST-PRINCIPLES-REVIEWED] ffb262b

Description read

[DESCRIPTION-READ] 1612f1e8a6dc17df43e9bc7a0b7c2c72213448eef9f4b53367e0e762915bf9a6

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 17, 2026 •

Copy link
Copy Markdown
Contributor

Opus 5.5 Review — ✅ no blocking findings

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

Review details

No findings.

[OPUS-REVIEWED] ffb262b

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

False positive or not applicable? A repository writer can comment:
/ai-review override fable ffb262b8c4b354568957d6183c7bfa068de6cd84: <one-sentence reason>

@github-actions

github-actions Bot commented Oct 17, 2026 •

Copy link
Copy Markdown
Contributor

GPT 6.1 Review — ✅ no blocking findings

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

This comment is updated in place on each push.

Review details

No findings.
[GPT-REVIEWED] ffb262b

False positive or not applicable? A repository writer can comment:
/ai-review override gpt ffb262b8c4b354568957d6183c7bfa068de6cd84: <one-sentence reason>

@github-actions

github-actions Bot commented Oct 17, 2026 •

Copy link
Copy Markdown
Contributor

Security Scope Review -- 🟡 CONCERNS

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

Verdict basis: the reviewer's own judgement; no confirmed regression.

Security scope review -- adjudicated candidates

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

No candidate flipped from allowed to refused.

Scope-Verdict: CONCERNS

TIGHTENING: StreamRedactor.feed output redaction, which now treats a trailing AWS key label as a STRONG anchor, holds the label and value up to _STREAM_HOLDBACK_JWT_MAX, and fails closed past it with an aws-keyed discard -- the threat is an AWS key value longer than the 512 floor being split from its label and streamed raw: "AWS key-value labels are STRONG for the same reason: the label's separator whitespace is outside _CRED_CLASS, and the value is only redacted while its label reaches the same batch call." (src/kiro_crew/security/text_redaction.py, the +aws_keyed_anchor = (stream_aws_anchor.find(self._buf, _CRED_CLASS, natural_cut) ... hunk).

ADJUDICATED: 15 candidates, verdicts pending from the harness. The diff does not touch the tool-call deny composite. _CREDENTIAL_PATTERNS, _contains_fixed_credential and all three tiers (sensitive-bash, exfil, deny-rules) are unchanged. The only new link to them is importing stream_aws_anchor at package load. The shell rows are a control that should not flip; they are not evidence about the guard that changed.

PLATFORM COVERAGE: posix rows: the test runs, grep/rg label searches, export AWS_PROFILE, and a git log on the changed file. windows rows: py with \ paths, findstr, cmd set ... && aws.exe, and PowerShell $env:AWS_PROFILE. any rows: aws sts/aws configure commands with no paths. The diff itself makes no path, separator, interpreter or environment-variable assumption. The new grammar works on text, with \s, [:=] and quote classes that do not depend on the host. So no platform spelling is left unprobed for the shell half.

UNADJUDICATED: The guard is StreamRedactor.feed / stream_aws_anchor.find / label_backoff / discard_run. The call path is streamed agent output going to StreamRedactor.feed(chunk) (the chat wire, transcript and channel renderers that use the stream redactor), then Phase A safety cuts, then the Phase B fail-closed drop with _discard_kind = ("aws-keyed", ...). The classifier cannot judge it, because it checks only shell command lines. These are the legitimate outputs I would have submitted, written as prose:

  • Minified JSON from aws sts get-session-token or aws sts assume-role. The output is longer than 4096 bytes with no whitespace before the "SessionToken":"..." field, as when an agent prints a compact policy document. By the PR's own stated cost, the whole held run is dropped behind one tag, including benign fields before the label (test_minified_json_past_the_ceiling_fails_closed_from_the_held_run, test_a_long_whitespace_free_run_before_an_aws_pair_fails_closed).
  • A long whitespace-free CloudFormation, Terraform or IAM JSON blob in which AccessKeyId= or SessionToken: appears only as a schema field name (for example "SessionToken":{"Type":"String"}) past the ceiling. The structural }/, ends the value class, but the drop starts from the start of the held run.
  • Prose or code that quotes the label with a separator and a long non-secret value. Examples are aws_session_token=[REDACTED]"AWS_SESSION_TOKEN"] inside a single-line minified bundle, or a log line SessionToken: <redacted-by-provider> followed by more than 4 KB with no whitespace.
  • The held property now returns "" while discarding. Any caller that reads held to show pending text changes behaviour. I have no adjudication for that either.

These are narrowings I can argue but not confirm. The narrow fix to consider is letting the AWS cut also land at a JSON structural delimiter (, or {) that comes before the key label, not only at whitespace or buffer start. That keeps the value with its label in one batch call and stops dropping benign fields in front of it.

[SCOPE-REVIEWED] ffb262b

@bolichen97
bolichen97 enabled auto-merge (squash) October 17, 2026 09:35
@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Oct 17, 2026
@bolichen97
bolichen97 force-pushed the fix/stream-aws-keyed-holdback-17115 branch from 32eb180 to e62eec0 Compare October 17, 2026 12:07
@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Oct 17, 2026
@bolichen97

bolichen97 commented Oct 17, 2026 •

Copy link
Copy Markdown
Contributor Author

span=9d6bc76fed0d
issue (blocking): both security-class findings at 32eb180 -- fixed in e62eec0, no override

F1 (padded label, opening quote ends the drop): the discard now walks the rest of the label grammar first (aws-key -> aws-sep -> aws-keyed), so padding plus a quote cannot end it before the value. A separator-free key is not dropped: it is released unchanged and a late separator tags and drops the value after it.
F2 (nested ?token= picks the inner carrier): every carrier whose material reaches the buffer end stays armed, and the drop ends where the last of them ends.
A value closed by its quote is dropped only through the quote; the suffix is kept.
Pinned: test_a_label_padded_past_the_ceiling_still_hides_its_quoted_value, test_a_nested_token_parameter_does_not_end_the_outer_aws_value, test_a_closed_value_past_the_ceiling_keeps_its_suffix (red on 32eb180, green on e62eec0).
The local GPT pass on the interim head found a quadratic anchor search and a bare-key data loss; both fixed (linear scan, release of separator-free keys), pinned by the equivalence and release tests.
self-added: yes
mechanism: AWS key-value stream anchor with a label-grammar discard

@bolichen97

Copy link
Copy Markdown
Contributor Author

note: Security Scope CONCERNS at 32eb180 (0 confirmed newly refused) -- answered per candidate

Separator-free label escalating like a STRONG anchor: changed in e62eec0. A key with no separator is released unchanged past the ceiling (test_a_padded_key_with_no_separator_is_released_unchanged); only a separator that then arrives makes the value after it a credential.
No left word boundary (AWSAccessKeyId, X...SessionToken): kept on purpose. It is the batch rule's own spelling (redaction._AWS_LABEL_RULES, no boundary), and the stream must hide what the batch pass hides. Under the 4,096 ceiling the output equals redact().
Presigned URL over 4,096 with AWSAccessKeyId=: past the ceiling it is tagged and dropped, the same fail-closed outcome Bearer and ?token= already have. Main streamed that tail raw.
Minified aws sts get-session-token JSON: released at ",; pinned by test_aws_keyed_value_under_the_ceiling_streams_as_the_batch_pass_writes_it.
CloudFormation AccessKeyId: with a long unquoted value: same as a real key value, held to 4,096 then dropped; no tool call is refused.

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Oct 17, 2026
@bolichen97
bolichen97 force-pushed the fix/stream-aws-keyed-holdback-17115 branch from e62eec0 to d21134a Compare October 17, 2026 15:28
@bolichen97

bolichen97 commented Oct 17, 2026 •

Copy link
Copy Markdown
Contributor Author

span=9c8352609526
fixed in d21134a: the AWS anchor moved into its own module

The label grammar, the linear finder and the label-grammar discard states now live in src/kiro_crew/security/stream_aws_anchor.py (194 lines). security/__init__.py keeps only the feed call sites the item excluded.
Those call sites are +42 lines over the 3,698 baseline row: the pending-label check, the anchor call and the multi-carrier arming that replaces the old one-kind branch. They read StreamRedactor's own state, so moving them means moving feed itself, which is a refactor of the whole class and outside this PR's goal. check_file_line_cap.py reports the growth (report-only, 0 failures).
self-added: yes
mechanism: AWS key-value stream anchor

@bolichen97

bolichen97 commented Oct 17, 2026 •

Copy link
Copy Markdown
Contributor Author

span=fc6840566455
rebutted: keep the label-grammar states as code, not a table

There are three states (aws-key, aws-sep, aws-keyed) and one anchor that uses them. Each transition does something different (consume an optional quote and whitespace, require a separator byte, step over one opening quote), so a table would need a small interpreter of its own to express them.
A table pays off when a second key-value anchor arrives. Until then it adds an indirection that only one caller uses. The states are now isolated in stream_aws_anchor.py, so that change stays local when it is needed.

@bolichen97

bolichen97 commented Oct 17, 2026 •

Copy link
Copy Markdown
Contributor Author

span=d9b8507e79b5
rebutted: the padded-label states close a security finding this PR's own CI raised

The GPT lane raised it at 32eb180 as a fenced security-class BLOCK: feed("SessionToken:" + " "*4200) then feed('"' + value + '" done') armed the value discard early, the opening quote ended it, and the value after the quote went out to chat_chunk raw. That is a reachable leak in code this PR adds, so it is in scope and must be fixed. A security finding cannot be cleared by deferral, and this account does not override one.
Removing the states reopens that leak. The smaller alternative, treating a separator-free key as WEAK, was tried: a padded key with no separator then leaks its value the same way once the separator arrives. The pending-label state is the version that releases benign text unchanged (test_a_padded_key_with_no_separator_is_released_unchanged) and still hides the value.
Pinned: test_a_label_padded_past_the_ceiling_still_hides_its_quoted_value, red on 32eb180.
self-added: yes
mechanism: label-grammar discard states for an AWS label padded past the ceiling

@bolichen97

bolichen97 commented Oct 17, 2026 •

Copy link
Copy Markdown
Contributor Author

span=2ebd0260e8b7
rebutted: the multi-kind discard does not change any nesting main already had

For nesting that already existed, the outer carrier's value class contains the inner one: the ?token= class contains every JWT byte, and the Bearer class contains every JWT byte plus .. So the longest run among the armed kinds is always the outer carrier's run, which is the one main's "prefer the enclosing carrier" rule picked. Token and Bearer cannot both reach the buffer end, since the Bearer anchor needs whitespace the token class excludes.
Measured: 3,000 seeded streams of ?token=/&token=/Bearer with JWT-shaped and plain values of 10, 600 and 4,146 characters, continuations from every class, chunk sizes 1 to 5,000. The output on c8515d500b (the same security/ tree as d21134a, which only rebased) is byte-identical to main 8b709b4 in all 3,000.
The tuple only matters when an AWS value encloses another carrier, which is the GPT F2 leak (?token= inside a SessionToken value, ended by &).
self-added: yes
mechanism: every carrier reaching the buffer end stays armed

@github-actions github-actions Bot added the merge conflict Branch has merge conflicts with its base — author must resolve before merge label Oct 17, 2026
@bolichen97
bolichen97 force-pushed the fix/stream-aws-keyed-holdback-17115 branch from d21134a to 9eb30f6 Compare October 19, 2026 03:57
@bolichen97

Copy link
Copy Markdown
Contributor Author

[operator: bolichen97] Rebased onto main d32ab41 (d21134a -> 9eb30f6), still one commit. Main moved StreamRedactor out of security/__init__.py into security/text_redaction.py; this PR's feed/flush/reset delta is re-applied there unchanged, and the line budget moves 31,038 -> 31,272 (the same +234). No rule or design change. Local: targeted security tests pass, black/isort/flake8/mypy/semgrep clean, local GPT + Opus review PASS. CI re-running.

@bolichen97

Copy link
Copy Markdown
Contributor Author

[operator: bolichen97] Maintainer ruling: redesign the AWS stream cut rule. The cut lands only at whitespace or at the start of the held buffer, and never inside a batch credential match. The URL walk-back, the ceiling clamp (the "cut raise" toward main's 512 floor) and the padded-label states (aws-key, aws-key-pad, aws-sep, the pending-label carry) are removed. The Opus "begin" guard is added. Accepted cost, documented in the PR body and docs/system-specs/modules/security.md: a whitespace-free run longer than 4,096 characters that carries an AWS label fails closed from the start of the held run.

57b1348 -> 65a6afe, still one commit, rebased onto main 8f828d6 (main did not touch this PR's files).

Tests flipped or removed by this ruling, each with its reason:

  • test_a_label_padded_past_the_ceiling_still_hides_its_quoted_value: removed. The padded-label state machine is gone; a key name padded past the floor is now released as on main, and the PR body lists that under Not a goal.
  • test_minified_json_past_the_ceiling_keeps_the_fields_before_the_key -> test_minified_json_past_the_ceiling_fails_closed_from_the_held_run: now asserts the fail-closed drop (no value byte, one tag, already-released fields kept).
  • test_a_short_aws_pair_after_a_long_run_splits_the_run_where_main_does -> test_a_long_whitespace_free_run_before_an_aws_pair_fails_closed: now asserts the accepted cost (one tag, never split).

Local GPT and Opus reviews of the intermediate commit each found one real leak vs main, both fixed in this head with tests: a batch match that starts mid-token now walks the cut back to whitespace (a bare run glued before Authorization: stays whole), and a credential label glued to a dropped AWS value (.../Authorization:, ...SecretAccessKey = ) ends the drop so its own value is held with it. A seeded differential fuzz of 4,000 streams finds 1 case that leaks here and not on main at that one chunking (a key name inside an earlier AWS value; main leaks the same text in 169 of 300 chunkings, this head in 28).

@bolichen97

Copy link
Copy Markdown
Contributor Author

span=8c954628938f
fixed in 65a6afe: the AWS cut has no ceiling clamp any more, so it cannot split a bare-secret run

Reproduced: a 40-char run ending in AccessKeyId, = and "v0-" * 1534 at 600-char chunks streamed the run's first 29 characters on 57b1348.
Per the maintainer ruling the clamp is removed: the cut lands only at whitespace or the start of the held buffer, never inside a batch match, so the whole run before the key is held and fails closed with the value.
Pinned by test_a_bare_secret_ending_in_a_key_name_before_a_long_value_never_streams (chunks 1/7/64/600): red on 57b1348, green here; output is one tag.

@bolichen97

Copy link
Copy Markdown
Contributor Author

span=29afcaa962ab
fixed in 65a6afe: a PEM word before the key no longer widens the fail-closed drop

Reproduced: "prose " * 900 + "Let us begin aws_secret_access_key=..." in one feed dropped all ~5.4 KB of prose behind one tag on 57b1348.
The PEM hold only defers a commit; when an AWS value is the only carrier failing closed, the drop now starts at the lowest non-PEM safety cut (token crossing and partial-tag cuts still apply), as the finding proposed.
Pinned by test_a_pem_word_before_an_aws_label_does_not_widen_the_drop: red on 57b1348, green here; the prose streams unchanged.

@bolichen97

Copy link
Copy Markdown
Contributor Author

span=e788b93c0032
fixed in 65a6afe: the padded-label state machine is removed, as the subtraction asked

_aws_pending, PENDING_LABEL_RES, pending_state and the aws-key / aws-key-pad / aws-sep discard kinds are deleted. A key name with no separator is WEAK: held only inside the 512 floor, released as on main past it.
The PR body's Not a goal now names that case: Key + long padding + : v split in the padding can still stream v, exactly as main does.

@bolichen97

Copy link
Copy Markdown
Contributor Author

checked: per-chunk cost while an AWS label is held

The URL scan is gone with the URL walk-back; _credential_matches(buf) still runs once per feed while a label is held, over at most the 4,096-char held buffer.
Measured on 65a6afe: a 4 KB AWS value fed one byte at a time takes 1.20 CPU s, against 1.08 s for a 4 KB Bearer value on the same tree. A stream that names no AWS key skips the anchor after a substring check.

@bolichen97

Copy link
Copy Markdown
Contributor Author

Sensitive change review

  • Head commit: 65a6afe
  • What rule changed: StreamRedactor.feed (src/kiro_crew/security/text_redaction.py) treats a trailing AWS key label (the keys of redaction._AWS_LABEL_RULES, grammar in the new src/kiro_crew/security/stream_aws_anchor.py) as a STRONG anchor, like Bearer, once its separator has arrived; a bare key name is WEAK (held only inside the 512 floor). The AWS cut lands only at whitespace or at the start of the held buffer, never inside a batch credential match (a match that starts mid-token moves the cut back to that token's whitespace); a key name inside a batch match is not a label. A credential label glued to the dropped AWS value (an AWS key name or Authorization, followed by its separator or ending the dropped run) ends the drop and stays buffered; a fully consumed discard chunk keeps its last label-length bytes, never emitted, so a label split across chunks is seen whole. A PEM hold does not widen an AWS-only fail-closed drop past the AWS cut. While an AWS key name is buffered, the 512 floor never splits a complete batch match.
  • Before -> after (what was allowed/blocked, now): Before, an AWS key-value value longer than the 512-character stream floor was cut from its label and streamed raw (73 of 125 measured cases leaked). Now the label and value are held together up to the 4,096 ceiling and redacted whole; past it the stream emits one credential tag and drops the value up to [\s"',}]. Accepted cost (maintainer ruling): a whitespace-free run longer than 4,096 characters that carries an AWS label is dropped from the start of the held run. A key name padded past the floor is released as on main. No shell, tool-call or deny rule changed.
  • Worst case if wrong (breaks commands / leaks secret / locks user out): Leak: an AWS value streams raw (the case this fixes). Over-redaction: benign whitespace-free text glued to an AWS label past 4,096 chars is dropped behind a tag on the live stream only; the stored transcript and batch redact() are unchanged. No command is blocked and no user is locked out.
  • Evidence checked (which sandbox result proves it): Pure text function, no sandbox involved. test/test_stream_redactor_aws_keyed.py, with the new bare-secret, glued-run, glued-label, PEM-word, PEM-held-pair and long-run tests red on 57b1348 and green here. A seeded differential fuzz of 4,000 mixed AWS / Bearer / ?token= / bare-run / glued-run / glued-label / PEM-word / padded-label streams: main leaks a secret piece the batch pass hides in 2,453, this head in 293; one case leaks here and not on main at that one chunking (a key name inside an earlier AWS value, a batch quirk: main leaks that text in 169 of 300 chunkings, this head in 28). Security Scope Review on the previous head: 0 newly refused tool calls on macOS, Ubuntu and Windows.
  • No regression:
    • Tools still work (which tools/commands were run, result): no tool or shell path touched.
    • Backward compatible (old config / old data / old callers still work, how checked): same feed/flush/reset/held/discarding API (held stays "" while discarding), no config or data format. Every test file that references StreamRedactor, text_redaction or stream_aws_anchor passes (23 files, 3,272 passed).
    • Existing tests (which suites passed on this head): test/test_stream_redactor_aws_keyed.py + test/test_security_gate_liveness.py (208 passed, after the rebase onto 8f828d6); black/isort/flake8/mypy and the backend gate floor clean. The repo related set on the pre-rebase commit: 26,060 passed, 18 failed; the same 18 (test/test_acp_spawn_offload.py, test/test_auto_improvement_members.py) fail on clean main on this host. CI on this head: see the PR checks.
  • How to undo: revert the single commit. Nothing persistent changes.

@bolichen97

Copy link
Copy Markdown
Contributor Author

span=8c954628938f
fixed in ceb4d5f: a label back-off can no longer end an enclosing Bearer or token-parameter drop

Reproduced both deltas on 65a6afe: the v1- continuation streamed raw after a Bearer drop met AccessKeyId, and after a nested ?token= drop met SecretAccessKey=abc.
Back-off, the carried tail and the in-buffer glued-label stop now run only when the AWS value is the sole carrier (("aws-keyed",)); with no AWS carrier only one kind is armed, as on main. A name ends a drop only once its separator is in the buffer.
Pinned by test_a_label_name_inside_a_dropped_value_does_not_end_the_drop (Bearer, JWT, token-param, nested-token, AWS): red on 65a6afe, green here. 3,000 seeded no-AWS streams are byte-identical to main.

@bolichen97

Copy link
Copy Markdown
Contributor Author

span=87dae0dc8f33
fixed in ceb4d5f: label back-off is limited to an AWS-only discard and needs the label's separator

Reproduced on 65a6afe: a key or authorization spelling at a chunk end inside a dropped Bearer, JWT or ?token= value ended the drop and the rest streamed.
As the finding proposed: label_backoff runs only while the discard kind is exactly ("aws-keyed",), a name counts only with its separator (Authorization needs separator plus whitespace), and a name at a chunk end stays in the carried tail for the next pass.
Pinned by test_a_label_name_inside_a_dropped_value_does_not_end_the_drop and test_a_value_glued_to_an_authorization_separator_stays_in_the_drop: red on 65a6afe, green here.

@bolichen97

Copy link
Copy Markdown
Contributor Author

span=b1b72a437697
fixed in ceb4d5f: the drop-ending change is scoped to the AWS-armed path

label_backoff, the carried tail and the glued-label stop run only for an AWS-only discard. With no AWS carrier exactly one kind is armed again (token-parameter, then Bearer, then JWT), and the spec says so: "With no AWS carrier, every armed discard has exactly one kind, the enclosing carrier's".
Evidence: 3,000 seeded no-AWS streams (Bearer, JWT, ?token=, PEM words, long runs) at random chunk sizes produce byte-identical output on this head and on main.

@bolichen97

Copy link
Copy Markdown
Contributor Author

span=14b187533989
needs-a-decision: the one remaining here-not-main fuzz case is a key name inside an earlier AWS value

The case: AccessKeyId=<4,200 chars>/SessionToken: <600 chars> after a PEM word. The batch pass reads /SessionToken: as part of the first value, so key_inside makes the second key anchor nothing, by design.
Measured on the same text over 300 random chunkings: main's stream leaks the second secret in 169, this head in 28. The 4,000-stream differential fuzz shows it as here-only at that one chunking.
Asked of the maintainer: accept this case as the batch quirk it is, or ask for a follow-up that anchors a key name inside an AWS value.

@bolichen97

Copy link
Copy Markdown
Contributor Author

span=34346eb20bd5
rebutted: one check against batch matches cannot replace the remaining rules, because they answer different questions

The cut rule already is that one check: whitespace or buffer start, never inside a batch match. The other rules decide where a drop ENDS, which no batch match says while the value is still streaming: the PEM guard (a non-credential hold must not move the drop start), the glued-label stop (a label inside the dropped run owns the value after its whitespace), and the floor guard (a finished pair must not be split once its label is gone).
Each is scoped to the AWS-only carrier and pinned by its own red-on-previous-head test; no-AWS streams are byte-identical to main.

@bolichen97

Copy link
Copy Markdown
Contributor Author

Sensitive change review

  • Head commit: ceb4d5f
  • What rule changed: StreamRedactor.feed (src/kiro_crew/security/text_redaction.py) treats a trailing AWS key label (the keys of redaction._AWS_LABEL_RULES, grammar in the new src/kiro_crew/security/stream_aws_anchor.py) as a STRONG anchor, like Bearer, once its separator has arrived; a bare key name is WEAK (held only inside the 512 floor). The AWS cut lands only at whitespace or at the start of the held buffer, never inside a batch credential match (a match that starts mid-token moves the cut back to that token's whitespace); a key name inside a batch match is not a label. When the AWS value is the only carrier being dropped, a credential label glued to it (an AWS key name followed by its separator, or Authorization followed by its separator and whitespace) ends the drop and stays buffered; that AWS-only discard keeps its last label-length bytes (and a key name followed by up to 8 whitespace bytes), never emitted, so a label split across chunks is judged whole. A Bearer, JWT or token-parameter drop is never ended this way, and with no AWS carrier exactly one discard kind is armed, as on main. A PEM hold does not widen an AWS-only fail-closed drop past the AWS cut. While an AWS key name is buffered, the 512 floor never splits a complete batch match.
  • Before -> after (what was allowed/blocked, now): Before, an AWS key-value value longer than the 512-character stream floor was cut from its label and streamed raw (73 of 125 measured cases leaked). Now the label and value are held together up to the 4,096 ceiling and redacted whole; past it the stream emits one credential tag and drops the value up to [\s"',}]. Accepted cost (maintainer ruling): a whitespace-free run longer than 4,096 characters that carries an AWS label is dropped from the start of the held run. A key name padded past the floor is released as on main. No shell, tool-call or deny rule changed.
  • Worst case if wrong (breaks commands / leaks secret / locks user out): Leak: an AWS value streams raw (the case this fixes). Over-redaction: benign whitespace-free text glued to an AWS label past 4,096 chars is dropped behind a tag on the live stream only; the stored transcript and batch redact() are unchanged. No command is blocked and no user is locked out.
  • Evidence checked (which sandbox result proves it): Pure text function, no sandbox involved. test/test_stream_redactor_aws_keyed.py, with the new bare-secret, glued-run, glued-label, label-name-inside, glued-Authorization, PEM-word, PEM-held-pair and long-run tests red on 57b1348 or 65a6afe and green here. A seeded differential fuzz of 4,000 mixed AWS / Bearer / ?token= / bare-run / glued-run / glued-label / PEM-word / padded-label streams: main leaks a secret piece the batch pass hides in 2,453, this head in 295; 3,000 seeded no-AWS streams are byte-identical to main; one case leaks here and not on main at that one chunking (a key name inside an earlier AWS value, a batch quirk: main leaks that text in 169 of 300 chunkings, this head in 28). Security Scope Review on the previous head: 0 newly refused tool calls on macOS, Ubuntu and Windows.
  • No regression:
    • Tools still work (which tools/commands were run, result): no tool or shell path touched.
    • Backward compatible (old config / old data / old callers still work, how checked): same feed/flush/reset/held/discarding API (held stays "" while discarding), no config or data format. Every test file that references StreamRedactor, text_redaction or stream_aws_anchor passes (23 files, 3,293 passed).
    • Existing tests (which suites passed on this head): test/test_stream_redactor_aws_keyed.py + test/test_security_gate_liveness.py (227 passed, after the rebase onto 2501be6); black/isort/flake8/mypy and the backend gate floor clean. The repo related set on the pre-rebase commit: 26,060 passed, 18 failed; the same 18 (test/test_acp_spawn_offload.py, test/test_auto_improvement_members.py) fail on clean main on this host. CI on this head: see the PR checks.
  • How to undo: revert the single commit. Nothing persistent changes.

@bolichen97

Copy link
Copy Markdown
Contributor Author

[operator: bolichen97] 65a6afe -> ceb4d5f, still one commit, rebased onto main 2501be6 (main did not touch this PR's files). Fixes the GPT and Opus blocks on 65a6afe: label back-off, the carried tail and the glued-label stop run only for an AWS-only discard, a name needs its separator, and with no AWS carrier one discard kind is armed as on main (3,000 seeded no-AWS streams byte-identical to main). Dispositions posted per lane; Sensitive Change template reposted for ceb4d5f.

A value after a recognised AWS key label (aws_secret_access_key=, "SessionToken": ", ...) is only redacted while its label reaches the same batch call. Past the 512-character stream floor the stream redactor cut such a value from its label and streamed it raw. A label that has reached its separator is now a strong anchor, like Bearer: the value is held up to the JWT ceiling and fails closed beyond it. The cut lands only at whitespace, at the start of the held buffer or at the start of a batch match, so a whitespace-free run that carries the label past the ceiling is dropped whole.

Closes #17115
@bolichen97

Copy link
Copy Markdown
Contributor Author

span=8c954628938f
fixed in ffb262b: the PEM guard covers a closed AWS pair too

Reproduced on ceb4d5f: "prose " * 900 + 'Let us begin aws_session_token="..."' in one feed returned only the tag; the closed pair armed nothing, so the PEM hold's cut at 0 stood.
The guard now applies whenever an AWS anchor is the only carrier, open (["aws-keyed"]) or closed by its quote ([]): the drop starts at the lowest non-PEM safety cut, token-crossing and partial-tag cuts still applied.
Pinned by test_a_pem_word_before_an_aws_label_does_not_widen_the_drop[closed]: red on ceb4d5f, green here; the prose streams unchanged.

@bolichen97

Copy link
Copy Markdown
Contributor Author

checked: the fuzz note on what still leaks here and not on main

On ffb262b the 4,000-stream differential fuzz finds 1 case that leaks here and not on main at its one chunking: a key name inside an earlier AWS value, which main's stream leaks in 169 of 300 chunkings of the same text and this head in 28. The 28 here-only cases seen before the glued-run and glued-label fixes are all gone. That one case is put to the maintainer in the needs-a-decision disposition on 65a6afe.

@bolichen97

Copy link
Copy Markdown
Contributor Author

checked: the recorded decision is the linked issue's

"The issue's recorded decision" is the hold-to-4,096-then-fail-closed decision on #17115, the issue this PR closes (Closes #17115 under Related Issues). The cut-rule change on top of it is the maintainer ruling in this thread.

@bolichen97

Copy link
Copy Markdown
Contributor Author

[operator: bolichen97] ceb4d5f -> ffb262b, still one commit, rebased onto main 5c17469 (main did not touch this PR's files). Fixes the GPT block on ceb4d5f: the PEM guard covers a closed AWS pair as well as an open one. Sensitive Change template reposted for ffb262b.

Security scope candidate validation was red on ceb4d5f at "Probe the candidate set for credential shapes": the scope lane's own generated candidate set carried a credential shape. No file in this diff is part of that set; it reruns on this head.

@bolichen97

Copy link
Copy Markdown
Contributor Author

Sensitive change review

  • Head commit: ffb262b
  • What rule changed: StreamRedactor.feed (src/kiro_crew/security/text_redaction.py) treats a trailing AWS key label (the keys of redaction._AWS_LABEL_RULES, grammar in the new src/kiro_crew/security/stream_aws_anchor.py) as a STRONG anchor, like Bearer, once its separator has arrived; a bare key name is WEAK (held only inside the 512 floor). The AWS cut lands only at whitespace or at the start of the held buffer, never inside a batch credential match (a match that starts mid-token moves the cut back to that token's whitespace); a key name inside a batch match is not a label. When the AWS value is the only carrier being dropped, a credential label glued to it (an AWS key name followed by its separator, or Authorization followed by its separator and whitespace) ends the drop and stays buffered; that AWS-only discard keeps its last label-length bytes (and a key name followed by up to 8 whitespace bytes), never emitted, so a label split across chunks is judged whole. A Bearer, JWT or token-parameter drop is never ended this way, and with no AWS carrier exactly one discard kind is armed, as on main. A PEM hold does not widen an AWS-only fail-closed drop (open or closed AWS value) past the AWS cut. While an AWS key name is buffered, the 512 floor never splits a complete batch match.
  • Before -> after (what was allowed/blocked, now): Before, an AWS key-value value longer than the 512-character stream floor was cut from its label and streamed raw (73 of 125 measured cases leaked). Now the label and value are held together up to the 4,096 ceiling and redacted whole; past it the stream emits one credential tag and drops the value up to [\s"',}]. Accepted cost (maintainer ruling): a whitespace-free run longer than 4,096 characters that carries an AWS label is dropped from the start of the held run. A key name padded past the floor is released as on main. No shell, tool-call or deny rule changed.
  • Worst case if wrong (breaks commands / leaks secret / locks user out): Leak: an AWS value streams raw (the case this fixes). Over-redaction: benign whitespace-free text glued to an AWS label past 4,096 chars is dropped behind a tag on the live stream only; the stored transcript and batch redact() are unchanged. No command is blocked and no user is locked out.
  • Evidence checked (which sandbox result proves it): Pure text function, no sandbox involved. test/test_stream_redactor_aws_keyed.py, with the new bare-secret, glued-run, glued-label, label-name-inside, glued-Authorization, PEM-word, PEM-held-pair and long-run tests red on 57b1348, 65a6afe or ceb4d5f and green here. A seeded differential fuzz of 4,000 mixed AWS / Bearer / ?token= / bare-run / glued-run / glued-label / PEM-word / padded-label streams: main leaks a secret piece the batch pass hides in 2,453, this head in 295; 3,000 seeded no-AWS streams are byte-identical to main; one case leaks here and not on main at that one chunking (a key name inside an earlier AWS value, a batch quirk: main leaks that text in 169 of 300 chunkings, this head in 28). Security Scope Review on the previous head: 0 newly refused tool calls on macOS, Ubuntu and Windows.
  • No regression:
    • Tools still work (which tools/commands were run, result): no tool or shell path touched.
    • Backward compatible (old config / old data / old callers still work, how checked): same feed/flush/reset/held/discarding API (held stays "" while discarding), no config or data format. Every test file that references StreamRedactor, text_redaction or stream_aws_anchor passes (23 files, 3,294 passed).
    • Existing tests (which suites passed on this head): test/test_stream_redactor_aws_keyed.py + test/test_security_gate_liveness.py (228 passed, after the rebase onto 5c17469); black/isort/flake8/mypy and the backend gate floor clean. The repo related set on the pre-rebase commit: 26,060 passed, 18 failed; the same 18 (test/test_acp_spawn_offload.py, test/test_auto_improvement_members.py) fail on clean main on this host. CI on this head: see the PR checks.
  • How to undo: revert the single commit. Nothing persistent changes.

@bolichen97

Copy link
Copy Markdown
Contributor Author

span=e5907619c682
checked: what the 295 remaining fuzz leaks are

Of the 295 streams that leak a piece the batch pass hides on this head, 294 also leak on main. By context they are padded labels (key and value split by long whitespace, the listed Not-a-goal), a key name inside an earlier AWS value (the batch pass reads it as value), Bearer values and bare 40-character runs; none is a new shape.
One stream leaks here and not on main at its one chunking: a key name inside an earlier AWS value. Over 300 chunkings of that text main leaks in 169 and this head in 28. It is put to the maintainer in the needs-a-decision disposition on 65a6afe. The 28 here-only cases seen before the glued-run and glued-label fixes are gone.

@bolichen97

Copy link
Copy Markdown
Contributor Author

span=80bc8a57e4a2
rebutted: dropping the value as soon as the separator shows would change every short AWS pair, and the issue decided against it

The recorded decision on #17115 is hold up to 4,096, then fail closed: under the ceiling the stream output equals batch redact() (pinned by test_aws_keyed_value_under_the_ceiling_streams_as_the_batch_pass_writes_it). Dropping at the separator would end the value at the stream's guess of its terminator, not the batch rule's, and turn every short pair into a sticky discard.
The hold is also what makes the key-inside-another-credential and glued-run cases come out equal to batch. The back-off rules only decide where an over-ceiling drop ends, which a drop-at-separator design would still need.

@bolichen97

Copy link
Copy Markdown
Contributor Author

checked: the 295 remaining fuzz leaks fall in known, main-shared shapes

294 of them also leak on main: padded labels (the listed Not-a-goal), a key name inside an earlier AWS value, Bearer values and bare 40-character runs. The one here-only stream is a key name inside an earlier AWS value at one chunking (main leaks that text in 169 of 300 chunkings, this head in 28), put to the maintainer as a needs-a-decision.

@chenmingwei23 chenmingwei23 left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Approved: lanes green on this head, no outstanding reviewer blockers.

@KiroCrewCaptain KiroCrewCaptain left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Review lanes on the head carry CONCERNS (advisory) and no BLOCK; the watch holder read them and approved explicitly.

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.

Streaming redaction: a key-anchored value longer than the stream holdback cap is only partially redacted

4 participants