pi-ext
bugabingas pi extensions
owned by bugabinga
feat(leaks): select secret spans by confidence
dd071511bc5d8423ce43b9fcf43000da15a7eff0
Oliver Jan Krylow <oliver@bugabinga.net> ·
unsigned
Browse filesCompare with HEAD
Changed files (4)
extensions/leaks/__tests__/selector.test.ts
Addednew file mode 100644 1 +import { describe, expect, it }
from "vitest";
2 +import { __test }
from "../index.ts";
3 +import type { SecretSpan, SpanLabel }
from "../src/types.ts";
5 +function label(tag
: string, source
: SpanLabel[
"source"]
= "generic")
: SpanLabel {
6 + return { tag, source, priority:
10 };
12 + overrides
: Partial<
SecretSpan>
= {},
14 + const start
= text.
indexOf(value);
17 + end: start
+ value.
length,
19 + labels: [
label(overrides.kind?.
toUpperCase()
?? "SECRET")],
27 +describe(
"leaks span selector", ()
=> {
28 + it(
"merges labels for identical spans", ()
=> {
29 + const text
= "token alpha-secret";
30 + const selected
= __test.
selectSecretSpans(text, [
31 + span(text,
"alpha-secret", { labels: [
label(
"A",
"dotenv")] }),
32 + span(text,
"alpha-secret", { labels: [
label(
"B",
"builtin")] }),
35 + expect(selected).
toHaveLength(
1);
36 + expect(selected[
0].labels.
map((item)
=> item.tag)).
toEqual([
"A",
"B"]);
39 + it(
"keeps component spans over enclosing exact learned values", ()
=> {
40 + const text
= "DATABASE_URL=postgres://alice:pw@db/app";
41 + const exact
= span(text,
"postgres://alice:pw@db/app", {
45 + const component
= span(text,
"pw", { kind:
"structure", confidence:
60 });
47 + expect(__test.
selectSecretSpans(text, [exact, component])).
toEqual([
52 + it(
"keeps exact learned values over generic regexes", ()
=> {
53 + const text
= "send learned-secret-value";
54 + const exact
= span(text,
"learned-secret-value", {
58 + const generic
= span(text,
"learned-secret-value", {
63 + expect(__test.
selectSecretSpans(text, [generic, exact])[
0].kind).
toBe(
"exact");
66 + it(
"keeps the smallest secret-bearing span for ordinary overlaps", ()
=> {
67 + const text
= "Authorization: Bearer nested-secret-token";
68 + const large
= span(text,
"Bearer nested-secret-token", {
72 + const small
= span(text,
"nested-secret-token", {
77 + expect(__test.
selectSecretSpans(text, [large, small])).
toEqual([small]);
80 + it(
"keeps private key whole spans over smaller matches", ()
=> {
81 + const text
= "-----BEGIN PRIVATE KEY-----\nabc123\n-----END PRIVATE KEY-----";
82 + const whole
= span(text, text, {
83 + kind:
"private-key",
87 + const small
= span(text,
"abc123", { kind:
"generic", confidence:
90 });
89 + expect(__test.
selectSecretSpans(text, [small, whole])).
toEqual([whole]);
92 + it(
"keeps JWT whole spans over component-looking matches", ()
=> {
93 + const text
= "aaa.bbb.ccc";
94 + const whole
= span(text, text, {
99 + const small
= span(text,
"bbb", { kind:
"structure", confidence:
90 });
101 + expect(__test.
selectSecretSpans(text, [small, whole])).
toEqual([whole]);
104 + it(
"skips spans inside existing placeholders", ()
=> {
105 + const text
= "keep __LEAK_TOKEN_abcdef123456__ visible";
106 + const candidate
= span(text,
"abcdef123456", {
111 + expect(__test.
selectSecretSpans(text, [candidate])).
toEqual([]);
114 + it(
"replaces adjacent spans without index drift", ()
=> {
115 + const left
= "adjacent-secret-left";
116 + const right
= "adjacent-secret-right";
117 + const text
= `${left}${right}`;
118 + const engine
= new __test.
LeaksEngine({
119 + detectors: [()
=> [
span(text, left),
span(text, right)]],
122 + const redacted
= engine.
redactText(text,
"provider");
124 + expect(redacted.count).
toBe(
2);
125 + expect(redacted.
text).not.
toContain(left);
126 + expect(redacted.
text).not.
toContain(right);
127 + expect(engine.
restoreText(redacted.
text)).
toBe(text);
extensions/leaks/index.ts
Modified 1 1 import { LeaksEngine }
from "./src/engine.ts";
2 2 import { PlaceholderStore }
from "./src/placeholders.ts";
3 +import { selectSecretSpans }
from "./src/selector.ts";
4 5 isExistingPlaceholder,
16 17 RUNTIME_SETTING_KEYS,
17 19 isExistingPlaceholder,
extensions/leaks/src/engine.ts
Modified 1 1 import { PlaceholderStore }
from "./placeholders.ts";
2 +import { selectSecretSpans }
from "./selector.ts";
52 - const selected
= spans
53 - .
filter((span)
=> span.
start >= 0 && span.end
> span.
start && span.end
<= text.
length)
54 - .
toSorted((left, right)
=> right.
start - left.
start);
53 + const selected
= selectSecretSpans(text, spans);
55 54 let redacted
= text;
56 55 const placeholders
: string[]
= [];
57 56 const labels
: string[]
= [];
extensions/leaks/src/selector.ts
Addednew file mode 100644 1 +import type { SecretSpan, SpanLabel }
from "./types.ts";
3 +const PLACEHOLDER_RE
= /__LEAK(?:_[A-Z0-9]{1,64})*_[a-f0-9]{12}(?:_\d+)?__/g;
4 +const KIND_RANK
: Record<
SecretSpan[
"kind"],
number>
= {
14 +export function selectSecretSpans(text
: string, spans
: SecretSpan[])
: SecretSpan[] {
15 + const placeholderRanges
= [
...text.
matchAll(PLACEHOLDER_RE)].
map((match)
=> ({
16 + start: match.
index ?? 0,
17 + end: (match.
index ?? 0)
+ match[
0].
length,
19 + const merged
= new Map<
string,
SecretSpan>();
20 + for (
const span
of spans) {
21 + if (span.
start < 0 || span.end
<= span.
start || span.end
> text.
length)
continue;
22 + if (placeholderRanges.
some((range)
=> span.
start >= range.
start && span.end
<= range.end))
continue;
23 + const key
= `${span.start}:${span.end}`;
24 + const current
= merged.
get(key);
26 + merged.
set(key, {
...span, labels:
uniqueLabels(span.labels) });
29 + const winner
= better(span, current)
< 0 ? span
: current;
32 + labels:
uniqueLabels([
...current.labels,
...span.labels]),
36 + const selected
: SecretSpan[]
= [];
37 + for (
const candidate
of [
...merged.
values()].
toSorted(better)) {
38 + if (selected.
some((item)
=> overlaps(item, candidate)))
continue;
39 + selected.
push(candidate);
41 + return selected.
toSorted((left, right)
=> right.
start - left.
start);
44 +function better(left
: SecretSpan, right
: SecretSpan) {
45 + const force
= forceRank(left)
- forceRank(right);
46 + if (force
!== 0)
return force;
47 + const kind
= KIND_RANK[left.kind]
- KIND_RANK[right.kind];
48 + if (kind
!== 0)
return kind;
49 + const length
= left.end
- left.
start - (right.end
- right.
start);
50 + if (length
!== 0)
return length;
51 + const confidence
= right.confidence
- left.confidence;
52 + if (confidence
!== 0)
return confidence;
53 + if (left.
start !== right.
start)
return left.
start - right.
start;
54 + return left.end
- right.end;
57 +function forceRank(span
: SecretSpan) {
58 + return span.wholeSpan
&& (span.kind
=== "private-key" || span.kind
=== "jwt")
? 0 : 1;
61 +function overlaps(left
: SecretSpan, right
: SecretSpan) {
62 + return left.
start < right.end
&& right.
start < left.end;
65 +function uniqueLabels(labels
: SpanLabel[]) {
66 + const seen
= new Set<
string>();
67 + const out
: SpanLabel[]
= [];
68 + for (
const label
of labels) {
69 + const key
= `${label.source}:${label.tag}`;
70 + if (seen.
has(key))
continue;