mirror of
https://github.com/affaan-m/ECC.git
synced 2026-11-17 13:32:18 +00:00
Merge reviewed PR #3858
This commit is contained in:
3 files changed
+249
-19
No files matched your search
@@ -10,7 +10,7 @@
|
||||
"id": "hand-seeded",
|
||||
"source": "manual-curation-pending-regeneration"
|
||||
},
|
||||
"registryDigest": "6f213dc845937b4093bc018d041b25b538d88d78451b9d799ad614989b360ee4",
|
||||
"registryDigest": "65b0e26848994515124a8e256e8f2ec996453b98bd89c461407edf3c2d1e3883",
|
||||
"schemaVersion": 1,
|
||||
"triggers": {
|
||||
"skill:agent-runtime-gateway-smoke-test": [
|
||||
|
||||
@@ -271,25 +271,39 @@ import json, sys, os, re
|
||||
# Linear-time secret matcher. Bounded quantifiers and a fixed set of auth
|
||||
# schemes (instead of a generic [A-Za-z]+\s+ that overlapped the value class)
|
||||
# prevent the catastrophic backtracking that pegged python at 100% CPU (#2278).
|
||||
# The value class is disjoint from the separators, so it runs to the end of the
|
||||
# token: a long labeled key is redacted whole instead of leaving its tail.
|
||||
_SECRET_RE = re.compile(
|
||||
r"(?i)((?:api[_-]?key|token|secret|password|authorization|credentials?|auth)(?:_access_key|_key)?)"
|
||||
r"""(["'"'"'\s:=\\]{1,8})"""
|
||||
r"((?:bearer|basic|token|bot)\s+)?"
|
||||
r"([A-Za-z0-9_\-/.+=]{8,256})"
|
||||
r"([A-Za-z0-9_\-/.+=]{8,})"
|
||||
)
|
||||
# Value-shaped secrets that carry no keyword: PEM private key blocks (to END or
|
||||
# end of the truncated text), GitHub tokens, AWS key IDs, and DSN passwords
|
||||
# (scheme://user:PASSWORD@host keeps scheme and user). Each branch is anchored
|
||||
# on a literal prefix and uses bounded or non-overlapping classes (#2278).
|
||||
# end of the truncated text), GitHub tokens, AWS key IDs, Anthropic and OpenAI
|
||||
# style sk- keys, JWTs (eyJ header, payload, optional signature) and DSN
|
||||
# passwords (scheme://user:PASSWORD@host keeps scheme and user). Each branch is
|
||||
# anchored on a literal prefix and uses bounded or non-overlapping classes (#2278);
|
||||
# the sk- and JWT classes run to the end of the token so a long value is never
|
||||
# half redacted.
|
||||
# Tokens may follow a JSON escape (\n, \t, \uXXXX) since dict I/O is encoded
|
||||
# before scrubbing; a DSN cut by truncation before its "@" ends at \Z,
|
||||
# except a bare trailing host:port after http(s):// such as http://localhost:3000;
|
||||
# any other scheme (postgres://app:1234) is redacted even when the password is numeric (#3568).
|
||||
# PEM blocks run first: a label such as secret= in front of the BEGIN marker
|
||||
# would otherwise let _SECRET_RE eat "-----BEGIN" and hide the block from this match.
|
||||
_PEM_RE = re.compile(r"-----BEGIN[A-Z ]{0,40}PRIVATE KEY-----[\s\S]*?(?:-----END[A-Z ]{0,40}PRIVATE KEY-----|\Z)")
|
||||
_SECRET_VALUE_RE = re.compile(
|
||||
r"-----BEGIN[A-Z ]{0,40}PRIVATE KEY-----[\s\S]*?(?:-----END[A-Z ]{0,40}PRIVATE KEY-----|\Z)"
|
||||
r"|(?:(?<![A-Za-z0-9_])|(?<=\\[bfnrt])|(?<=\\u[0-9a-fA-F]{4}))(?:gh[pousr]_[A-Za-z0-9]{20,255}|github_pat_[A-Za-z0-9_]{20,255}|(?:AKIA|ASIA)[A-Z0-9]{16})\b"
|
||||
r"(?:(?<![A-Za-z0-9_])|(?<=\\[bfnrt])|(?<=\\u[0-9a-fA-F]{4}))(?:gh[pousr]_[A-Za-z0-9]{20,255}|github_pat_[A-Za-z0-9_]{20,255}|(?:AKIA|ASIA)[A-Z0-9]{16})\b"
|
||||
r"|(?:(?<![A-Za-z0-9_-])|(?<=\\[bfnrt])|(?<=\\u[0-9a-fA-F]{4}))(?:sk-(?:ant|proj|svcacct|admin|or)-[A-Za-z0-9_-]{20,}|sk-[A-Za-z0-9]{20,}[A-Za-z0-9_-]*|eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*)"
|
||||
r"""|(?<=://)(?:(?<=https://)|(?<=http://)|(?<!https://)(?<!http://)())([^\s:/@"\\]{1,256}:)(?(1)|(?!\d{1,5}\Z))[^\s@/"\\]{1,256}(?=@|\Z)"""
|
||||
)
|
||||
# A capture cut at its length limit can end inside an sk- key or JWT that the
|
||||
# full patterns no longer match. Only applied when the text was actually cut,
|
||||
# so a short output that happens to end in "sk-learn" stays readable.
|
||||
_CUT_TAIL_RE = re.compile(
|
||||
r"(?:(?<![A-Za-z0-9_-])|(?<=\\[bfnrt])|(?<=\\u[0-9a-fA-F]{4}))(?:sk-[A-Za-z0-9_-]*|eyJ[A-Za-z0-9_-]*(?:\.[A-Za-z0-9_-]*)?)\Z"
|
||||
)
|
||||
|
||||
import signal
|
||||
def _clv2_bail(*_):
|
||||
@@ -301,9 +315,13 @@ try:
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
raw = sys.stdin.read()[:2000]
|
||||
raw_full = sys.stdin.read()
|
||||
raw = raw_full[:2000]
|
||||
raw = _PEM_RE.sub("[REDACTED]", raw)
|
||||
raw = _SECRET_RE.sub(lambda m: m.group(1) + m.group(2) + (m.group(3) or "") + "[REDACTED]", raw)
|
||||
raw = _SECRET_VALUE_RE.sub(lambda m: (m.group(2) or "") + "[REDACTED]", raw)
|
||||
if len(raw_full) > 2000:
|
||||
raw = _CUT_TAIL_RE.sub("[REDACTED]", raw)
|
||||
print(json.dumps({"timestamp": os.environ["TIMESTAMP"], "event": "parse_error", "raw": raw}))
|
||||
' >> "$OBSERVATIONS_FILE"
|
||||
exit 0
|
||||
@@ -356,31 +374,50 @@ observation = {
|
||||
# Linear-time secret matcher. Bounded quantifiers and a fixed set of auth
|
||||
# schemes (instead of a generic [A-Za-z]+\s+ that overlapped the value class)
|
||||
# prevent the catastrophic backtracking that pegged python at 100% CPU (#2278).
|
||||
# The value class is disjoint from the separators, so it runs to the end of the
|
||||
# token: a long labeled key is redacted whole instead of leaving its tail.
|
||||
_SECRET_RE = re.compile(
|
||||
r"(?i)((?:api[_-]?key|token|secret|password|authorization|credentials?|auth)(?:_access_key|_key)?)"
|
||||
r"""(["'"'"'\s:=\\]{1,8})"""
|
||||
r"((?:bearer|basic|token|bot)\s+)?"
|
||||
r"([A-Za-z0-9_\-/.+=]{8,256})"
|
||||
r"([A-Za-z0-9_\-/.+=]{8,})"
|
||||
)
|
||||
# Value-shaped secrets that carry no keyword: PEM private key blocks (to END or
|
||||
# end of the truncated text), GitHub tokens, AWS key IDs, and DSN passwords
|
||||
# (scheme://user:PASSWORD@host keeps scheme and user). Each branch is anchored
|
||||
# on a literal prefix and uses bounded or non-overlapping classes (#2278).
|
||||
# end of the truncated text), GitHub tokens, AWS key IDs, Anthropic and OpenAI
|
||||
# style sk- keys, JWTs (eyJ header, payload, optional signature) and DSN
|
||||
# passwords (scheme://user:PASSWORD@host keeps scheme and user). Each branch is
|
||||
# anchored on a literal prefix and uses bounded or non-overlapping classes (#2278);
|
||||
# the sk- and JWT classes run to the end of the token so a long value is never
|
||||
# half redacted.
|
||||
# Tokens may follow a JSON escape (\n, \t, \uXXXX) since dict I/O is encoded
|
||||
# before scrubbing; a DSN cut by truncation before its "@" ends at \Z,
|
||||
# except a bare trailing host:port after http(s):// such as http://localhost:3000;
|
||||
# any other scheme (postgres://app:1234) is redacted even when the password is numeric (#3568).
|
||||
# PEM blocks run first: a label such as secret= in front of the BEGIN marker
|
||||
# would otherwise let _SECRET_RE eat "-----BEGIN" and hide the block from this match.
|
||||
_PEM_RE = re.compile(r"-----BEGIN[A-Z ]{0,40}PRIVATE KEY-----[\s\S]*?(?:-----END[A-Z ]{0,40}PRIVATE KEY-----|\Z)")
|
||||
_SECRET_VALUE_RE = re.compile(
|
||||
r"-----BEGIN[A-Z ]{0,40}PRIVATE KEY-----[\s\S]*?(?:-----END[A-Z ]{0,40}PRIVATE KEY-----|\Z)"
|
||||
r"|(?:(?<![A-Za-z0-9_])|(?<=\\[bfnrt])|(?<=\\u[0-9a-fA-F]{4}))(?:gh[pousr]_[A-Za-z0-9]{20,255}|github_pat_[A-Za-z0-9_]{20,255}|(?:AKIA|ASIA)[A-Z0-9]{16})\b"
|
||||
r"(?:(?<![A-Za-z0-9_])|(?<=\\[bfnrt])|(?<=\\u[0-9a-fA-F]{4}))(?:gh[pousr]_[A-Za-z0-9]{20,255}|github_pat_[A-Za-z0-9_]{20,255}|(?:AKIA|ASIA)[A-Z0-9]{16})\b"
|
||||
r"|(?:(?<![A-Za-z0-9_-])|(?<=\\[bfnrt])|(?<=\\u[0-9a-fA-F]{4}))(?:sk-(?:ant|proj|svcacct|admin|or)-[A-Za-z0-9_-]{20,}|sk-[A-Za-z0-9]{20,}[A-Za-z0-9_-]*|eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*)"
|
||||
r"""|(?<=://)(?:(?<=https://)|(?<=http://)|(?<!https://)(?<!http://)())([^\s:/@"\\]{1,256}:)(?(1)|(?!\d{1,5}\Z))[^\s@/"\\]{1,256}(?=@|\Z)"""
|
||||
)
|
||||
# A capture cut at its length limit can end inside an sk- key or JWT that the
|
||||
# full patterns no longer match. Only applied when the text was actually cut,
|
||||
# so a short output that happens to end in "sk-learn" stays readable.
|
||||
_CUT_TAIL_RE = re.compile(
|
||||
r"(?:(?<![A-Za-z0-9_-])|(?<=\\[bfnrt])|(?<=\\u[0-9a-fA-F]{4}))(?:sk-[A-Za-z0-9_-]*|eyJ[A-Za-z0-9_-]*(?:\.[A-Za-z0-9_-]*)?)\Z"
|
||||
)
|
||||
|
||||
def scrub(val):
|
||||
if val is None:
|
||||
return None
|
||||
val = _SECRET_RE.sub(lambda m: m.group(1) + m.group(2) + (m.group(3) or "") + "[REDACTED]", str(val))
|
||||
return _SECRET_VALUE_RE.sub(lambda m: (m.group(2) or "") + "[REDACTED]", val)
|
||||
val = str(val)
|
||||
# Tool I/O is cut to 5000 chars before it reaches this process.
|
||||
cut = len(val) >= 5000
|
||||
val = _PEM_RE.sub("[REDACTED]", val)
|
||||
val = _SECRET_RE.sub(lambda m: m.group(1) + m.group(2) + (m.group(3) or "") + "[REDACTED]", val)
|
||||
val = _SECRET_VALUE_RE.sub(lambda m: (m.group(2) or "") + "[REDACTED]", val)
|
||||
return _CUT_TAIL_RE.sub("[REDACTED]", val) if cut else val
|
||||
|
||||
if parsed["input"]:
|
||||
observation["input"] = scrub(parsed["input"])
|
||||
|
||||
@@ -42,6 +42,13 @@ function capture(phase, input, expectedEvent) {
|
||||
}
|
||||
}
|
||||
|
||||
// The persisted input/output is the scrubbed JSON of the tool payload, so one
|
||||
// field can be compared exactly instead of only checking a canary is gone.
|
||||
function capturedField(records, field) {
|
||||
const record = JSON.parse(records);
|
||||
return JSON.parse(record.event === 'tool_start' ? record.input : record.output)[field];
|
||||
}
|
||||
|
||||
console.log('=== Actual registered observation secret redaction ===');
|
||||
if (process.platform === 'win32') {
|
||||
console.log('Skipping shell fixtures: native Windows runner requires platform CI.');
|
||||
@@ -52,6 +59,17 @@ if (process.platform === 'win32') {
|
||||
// Synthetic canary data proves that captured credential-shaped text is masked.
|
||||
const canary = 'CANARY_TOKEN_abcdefghijk';
|
||||
const pemCanary = 'MIIEcanaryPEMbodyAAAA';
|
||||
// Prefixes are split so secret scanners do not flag the synthetic fixtures.
|
||||
const anthropicCanary = 'CANARYanthropic_Key-0123456789abcdefghijklmnop';
|
||||
const anthropicKey = `${'sk-'}ant-api03-${anthropicCanary}`;
|
||||
const openaiCanary = 'CANARYopenaiProject0123456789abcdefghij';
|
||||
const openaiProjectKey = `${'sk-'}proj-${openaiCanary}`;
|
||||
const legacyCanary = 'CANARYlegacy0123456789abcdefghijklmnopqrstu';
|
||||
const legacyKey = `${'sk-'}${legacyCanary}`;
|
||||
const jwtCanary = 'Q0FOQVJZc2lnbmF0dXJl';
|
||||
const jwt = `${'eyJ'}hbGciOiJIUzI1NiJ9.eyJzdWIiOiJjYW5hcnkifQ.${jwtCanary}`;
|
||||
// e30 is base64url for {}, a valid but very short claims segment.
|
||||
const emptyClaimsJwt = `${'eyJ'}hbGciOiJIUzI1NiJ9.e30.${jwtCanary}`;
|
||||
for (const [label, content, secret = canary] of [
|
||||
['double-quoted source', 'const apiKey = "CANARY_TOKEN_abcdefghijk";'],
|
||||
['single-quoted source', "const password = 'CANARY_TOKEN_abcdefghijk';"],
|
||||
@@ -68,13 +86,30 @@ if (process.platform === 'win32') {
|
||||
['truncated PEM private key block', `-----BEGIN OPENSSH ${'PRIVATE'} KEY-----\n${pemCanary}`, pemCanary],
|
||||
['GitHub classic token', `GH_PAT=${'ghp_'}CANARY${'0'.repeat(30)}`, `CANARY${'0'.repeat(30)}`],
|
||||
['GitHub fine-grained token', `use ${'github_pat_'}CANARY_${'1'.repeat(40)}`, `CANARY_${'1'.repeat(40)}`],
|
||||
['AWS access key id', `key id ${'AKIA'}CANARY0EXAMPLE00`, 'CANARY0EXAMPLE00']
|
||||
['AWS access key id', `key id ${'AKIA'}CANARY0EXAMPLE00`, 'CANARY0EXAMPLE00'],
|
||||
// Bare sk- keys and JWTs carry no keyword, so only their shape gives them away (#3846).
|
||||
['bare Anthropic key', `echo ${anthropicKey} > key.txt`, anthropicCanary],
|
||||
['bare OpenAI project key', `client = OpenAI(${openaiProjectKey})`, openaiCanary],
|
||||
['bare legacy sk- key', `KEYS = [${legacyKey}]`, legacyCanary],
|
||||
['bare JWT', `curl -H "X-Session: ${jwt}" https://api.example.com`, jwtCanary],
|
||||
['bare JWT with empty claims', `curl -H "X-Session: ${emptyClaimsJwt}" https://api.example.com`, jwtCanary],
|
||||
// Redacted to the end of the token, not skipped because a hyphen follows.
|
||||
['bare legacy sk- key with a suffix', `KEYS = [${legacyKey}-CANARYsuffix]`, 'CANARYsuffix']
|
||||
]) {
|
||||
test(`redacts ${label} before persisting tool input`, () => {
|
||||
const records = capture('pre', { tool_name: 'Write',
|
||||
tool_input: { file_path: '/tmp/example.js', content } });
|
||||
assert.ok(!records.includes(secret), 'seeded credential persisted');
|
||||
assert.ok(records.includes('[REDACTED]'));
|
||||
if (label === 'bare JWT') {
|
||||
assert.equal(capturedField(records, 'content'), content.replace(jwt, '[REDACTED]'));
|
||||
}
|
||||
if (label === 'bare JWT with empty claims') {
|
||||
assert.equal(capturedField(records, 'content'), content.replace(emptyClaimsJwt, '[REDACTED]'));
|
||||
}
|
||||
if (label === 'bare legacy sk- key with a suffix') {
|
||||
assert.equal(capturedField(records, 'content'), 'KEYS = [[REDACTED]]');
|
||||
}
|
||||
});
|
||||
test(`redacts ${label} before persisting structured tool output`, () => {
|
||||
const records = capture('post', { tool_name: 'Read',
|
||||
@@ -92,7 +127,9 @@ if (process.platform === 'win32') {
|
||||
['GitHub fine-grained token after tab', `col\t${'github_pat_'}CANARY_${'1'.repeat(40)}`,
|
||||
`CANARY_${'1'.repeat(40)}`],
|
||||
['AWS access key id after CRLF', `id:\r\n${'AKIA'}CANARY0EXAMPLE00`, 'CANARY0EXAMPLE00'],
|
||||
['AWS session key id after newline', `id:\n${'ASIA'}CANARY0EXAMPLE00`, 'CANARY0EXAMPLE00']
|
||||
['AWS session key id after newline', `id:\n${'ASIA'}CANARY0EXAMPLE00`, 'CANARY0EXAMPLE00'],
|
||||
['Anthropic key after newline', `key:\n${anthropicKey}`, anthropicCanary],
|
||||
['JWT after tab', `jwt\t${jwt}`, jwtCanary]
|
||||
]) {
|
||||
test(`redacts ${label} in structured tool output`, () => {
|
||||
const records = capture('post', { tool_name: 'Read',
|
||||
@@ -102,6 +139,107 @@ if (process.platform === 'win32') {
|
||||
});
|
||||
}
|
||||
|
||||
// The three commands from #3846. Only the first two have a keyword in front of the key.
|
||||
for (const command of [
|
||||
`ANTHROPIC_API_KEY=${anthropicKey} claude -p hi`,
|
||||
`curl -H "x-api-key: ${anthropicKey}" https://api.example.com`,
|
||||
`echo ${anthropicKey} > key.txt`
|
||||
]) {
|
||||
test(`redacts the Anthropic key in Bash input and output: ${command.split(' ')[0]}`, () => {
|
||||
for (const records of [
|
||||
capture('pre', { tool_name: 'Bash', tool_input: { command } }),
|
||||
capture('post', { tool_name: 'Bash', tool_input: { command: 'cat key.txt' },
|
||||
tool_response: { stdout: command, stderr: '' } })
|
||||
]) {
|
||||
assert.ok(!records.includes(anthropicCanary), 'Anthropic key persisted');
|
||||
const field = JSON.parse(records).event === 'tool_start' ? 'command' : 'stdout';
|
||||
assert.equal(capturedField(records, field), command.replace(anthropicKey, '[REDACTED]'));
|
||||
}
|
||||
});
|
||||
}
|
||||
test('redacts a bare Anthropic key in the parse-error fallback', () => {
|
||||
const records = capture('post', JSON.stringify([`echo ${anthropicKey}`]), 'parse_error');
|
||||
assert.ok(!records.includes(anthropicCanary), 'Anthropic key persisted');
|
||||
assert.ok(records.includes('[REDACTED]'));
|
||||
});
|
||||
|
||||
// Truncation can also cut a bare JWT inside its payload or a key inside its
|
||||
// body. What is left at the end of the capture must still be redacted.
|
||||
const jwtKept = jwt.slice(0, jwt.indexOf('.') + 10);
|
||||
const jwtPayloadStart = jwtKept.slice(jwt.indexOf('.') + 1);
|
||||
const keyKept = anthropicKey.slice(0, 'sk-ant-api03-'.length + 12);
|
||||
const cutAt = (end, value, kept) => `${'a'.repeat(end - kept.length - 1)} ${value}`;
|
||||
for (const [label, value, kept, leak] of [
|
||||
['JWT', jwt, jwtKept, jwtPayloadStart],
|
||||
['Anthropic key', anthropicKey, keyKept, keyKept.slice('sk-ant-api03-'.length)]
|
||||
]) {
|
||||
for (const [where, phase, input, expectedEvent] of [
|
||||
['string tool output', 'post', { tool_name: 'Bash', tool_input: { command: 'env' },
|
||||
tool_response: cutAt(5000, value, kept) }],
|
||||
// json.dumps prefixes '{"content": "' (13 chars) before the value.
|
||||
['structured tool output', 'post', { tool_name: 'Read', tool_input: { file_path: '/tmp/x' },
|
||||
tool_response: { content: cutAt(5000 - 13, value, kept) } }],
|
||||
['parse-error fallback', 'post', JSON.stringify([cutAt(2000 - 2, value, kept)]), 'parse_error']
|
||||
]) {
|
||||
test(`redacts the ${label} cut at the truncation boundary in ${where}`, () => {
|
||||
const records = capture(phase, input, expectedEvent);
|
||||
assert.ok(!records.includes(leak), `cut ${label} persisted`);
|
||||
assert.ok(records.includes('[REDACTED]'));
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// A long key or JWT is redacted whole, never only up to some length cap.
|
||||
const longTail = 'CANARYlongTail';
|
||||
for (const [label, value] of [
|
||||
['an over-long Anthropic key', `${anthropicKey}${'A'.repeat(600)}${longTail}`],
|
||||
['a JWT with a long signature', `${jwt}${'s'.repeat(1500)}${longTail}`]
|
||||
]) {
|
||||
test(`redacts ${label} completely`, () => {
|
||||
const records = capture('post', { tool_name: 'Read', tool_input: { file_path: '/tmp/x' },
|
||||
tool_response: { content: `value ${value} end` } });
|
||||
assert.equal(capturedField(records, 'content'), 'value [REDACTED] end');
|
||||
});
|
||||
}
|
||||
// A keyword-labeled value is redacted whole, however long it is and whatever
|
||||
// shaped token sits at its start.
|
||||
for (const [label, text, expected] of [
|
||||
['long sk-proj key', `OPENAI_API_KEY=${openaiProjectKey}${'B'.repeat(300)}${longTail}`, 'OPENAI_API_KEY=[REDACTED]'],
|
||||
['sk- password with a suffix', `password=${'sk-'}${'A'.repeat(30)}.${longTail}`, 'password=[REDACTED]'],
|
||||
['GitHub token with a suffix', `token=${'ghp_'}${'0'.repeat(30)}/${longTail}`, 'token=[REDACTED]'],
|
||||
['PEM private key block',
|
||||
`secret=-----BEGIN RSA ${'PRIVATE'} KEY-----\n${longTail}\n-----END RSA PRIVATE KEY-----`, 'secret=[REDACTED]']
|
||||
]) {
|
||||
for (const [phase, input, expectedEvent] of [
|
||||
['post', { tool_name: 'Read', tool_input: { file_path: '/tmp/x' }, tool_response: { content: text } }],
|
||||
['post', JSON.stringify([text]), 'parse_error']
|
||||
]) {
|
||||
test(`redacts a keyword-labeled ${label} completely (${expectedEvent || 'tool_complete'})`, () => {
|
||||
const records = capture(phase, input, expectedEvent);
|
||||
assert.ok(!records.includes(longTail), 'value tail persisted');
|
||||
assert.ok(records.includes(expected));
|
||||
});
|
||||
}
|
||||
}
|
||||
// A labeled JWT cut inside a payload longer than 256 chars at the capture limit.
|
||||
test('redacts a keyword-labeled JWT cut inside a long payload', () => {
|
||||
const labeled = `Authorization: Bearer ${'eyJ'}hbGciOiJIUzI1NiJ9.eyJ${'p'.repeat(600)}${longTail}`;
|
||||
const records = capture('post', { tool_name: 'Bash', tool_input: { command: 'env' },
|
||||
tool_response: `${'a'.repeat(5000 - labeled.length + 5)} ${labeled}` });
|
||||
assert.ok(!records.includes('pppp'), 'JWT payload persisted');
|
||||
assert.ok(records.includes('Authorization: Bearer [REDACTED]'));
|
||||
});
|
||||
|
||||
// The end-of-capture match only applies to text that was actually cut.
|
||||
for (const output of ['git checkout sk-learn', 'payload eyJhIjoxLCJiIjoyfQ']) {
|
||||
test(`keeps short string output ending in "${output.split(' ').pop().slice(0, 8)}" unredacted`, () => {
|
||||
const records = capture('post', { tool_name: 'Bash', tool_input: { command: 'echo' },
|
||||
tool_response: output });
|
||||
assert.ok(records.includes(output), 'short output altered');
|
||||
assert.ok(!records.includes('[REDACTED]'));
|
||||
});
|
||||
}
|
||||
|
||||
// Capture truncation (5000 chars, 2000 in the parse-error fallback) can cut a
|
||||
// DSN right before its '@'; the password must still be redacted (#3568).
|
||||
const cutSecret = 'CANARYcutPassw0rd';
|
||||
@@ -148,7 +286,17 @@ if (process.platform === 'win32') {
|
||||
'password_hash = hashlib.sha256(pw)',
|
||||
'fetch(http://localhost:8080/api/v1)',
|
||||
'git clone git@github.com:org/repo.git',
|
||||
'https://user@example.com/path'
|
||||
'https://user@example.com/path',
|
||||
// Hashes, ids and base64 that look random but are not keys (#3846).
|
||||
'git show 3f9a1c2b7e4d5f6a8b9c0d1e2f3a4b5c6d7e8f90',
|
||||
'sha256 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
|
||||
'id 550e8400-e29b-41d4-a716-446655440000',
|
||||
'background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==);',
|
||||
'payload: data:application/json;base64,eyJhIjoxLCJiIjoyLCJjIjozfQ==',
|
||||
'git checkout -b sk-learn-upgrade-for-pipelines',
|
||||
'risk-assessment-for-the-quarterly-report-v2',
|
||||
'ssh deploy@eyeglasses.example.com',
|
||||
'Keys start with the sk- prefix.'
|
||||
];
|
||||
test('keeps ordinary code and credential-free URLs unredacted', () => {
|
||||
const records = capture('post', { tool_name: 'Read',
|
||||
@@ -156,6 +304,51 @@ if (process.platform === 'win32') {
|
||||
for (const line of benign) assert.ok(records.includes(line), `benign text altered: ${line}`);
|
||||
assert.ok(!records.includes('[REDACTED]'));
|
||||
});
|
||||
// Both writers carry the same patterns. Run them on 300 KB of adversarial
|
||||
// input so a pattern that backtracks quadratically (#2278) fails here.
|
||||
test('scrub patterns stay identical in both writers and linear on 300 KB input', () => {
|
||||
const hook = fs.readFileSync(
|
||||
path.join(repoRoot, 'skills/continuous-learning-v2/hooks/observe.sh'), 'utf8');
|
||||
const copies = hook.split('_SECRET_RE = re.compile(').slice(1).map((rest) =>
|
||||
`_SECRET_RE = re.compile(${rest.split(/\n(?:import signal|def scrub)/)[0]}`
|
||||
.replace(/'"'"'/g, "'"));
|
||||
assert.equal(copies.length, 2);
|
||||
assert.equal(copies[0], copies[1], 'the parse-error copy of the patterns drifted');
|
||||
const driver = String.raw`
|
||||
import re, sys, time
|
||||
ns = {"re": re}
|
||||
exec(sys.stdin.read(), ns)
|
||||
patterns = [ns[n] for n in ("_PEM_RE", "_SECRET_RE", "_SECRET_VALUE_RE", "_CUT_TAIL_RE")]
|
||||
n = 300000
|
||||
cases = {
|
||||
"hyphen run": "a-" * (n // 2),
|
||||
"sk- then hyphen run": "sk-" + "a-" * (n // 2),
|
||||
"repeated sk-": "sk-" * (n // 3),
|
||||
"sk- keys followed by a hyphen": (" sk-" + "a" * 40 + "-") * (n // 45),
|
||||
"eyJ segments": ("eyJ" + "a-" * 10 + ".") * (n // 24),
|
||||
"repeated eyJ dots": "eyJ." * (n // 4),
|
||||
"label then hyphens": "token=" + "-" * n,
|
||||
"repeated labels": "token:" * (n // 6),
|
||||
"escaped newline before sk-": "\\nsk-" * (n // 5),
|
||||
"unfinished DSNs": "a://b:" * (n // 6),
|
||||
"unterminated PEM": "-----BEGIN RSA PRIV" + "ATE KEY-----" + "A" * n,
|
||||
}
|
||||
for name, text in cases.items():
|
||||
start = time.perf_counter()
|
||||
for pattern in patterns:
|
||||
pattern.sub("X", text)
|
||||
print("%s\t%.3f" % (name, time.perf_counter() - start))
|
||||
`;
|
||||
const result = spawnSync('python3', ['-c', driver],
|
||||
{ input: copies[0], encoding: 'utf8', timeout: 60000 });
|
||||
assert.equal(result.status, 0, result.stderr || 'timed out');
|
||||
const timings = result.stdout.trim().split('\n');
|
||||
assert.equal(timings.length, 11);
|
||||
for (const line of timings) {
|
||||
const [name, seconds] = line.split('\t');
|
||||
assert.ok(Number(seconds) < 2, `${name} took ${seconds}s`);
|
||||
}
|
||||
});
|
||||
test('keeps a trailing host:port in string output unredacted', () => {
|
||||
const records = capture('post', { tool_name: 'Bash', tool_input: { command: 'npm run dev' },
|
||||
tool_response: 'listening on http://localhost:3000' });
|
||||
|
||||
Reference in new issue
Block a user