repositories / pi-ext

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

Added
new 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 };
7 +}
9 +function span(
10 + text: string,
11 + value: string,
12 + overrides: Partial<SecretSpan> = {},
13 +): SecretSpan {
14 + const start = text.indexOf(value);
15 + return {
16 + start,
17 + end: start + value.length,
18 + value,
19 + labels: [label(overrides.kind?.toUpperCase() ?? "SECRET")],
20 + kind: "generic",
21 + confidence: 10,
22 + wholeSpan: false,
23 + ...overrides,
24 + };
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")] }),
33 + ]);
35 + expect(selected).toHaveLength(1);
36 + expect(selected[0].labels.map((item) => item.tag)).toEqual(["A", "B"]);
37 + });
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", {
42 + kind: "exact",
43 + confidence: 80,
44 + });
45 + const component = span(text, "pw", { kind: "structure", confidence: 60 });
47 + expect(__test.selectSecretSpans(text, [exact, component])).toEqual([
48 + component,
49 + ]);
50 + });
52 + it("keeps exact learned values over generic regexes", () => {
53 + const text = "send learned-secret-value";
54 + const exact = span(text, "learned-secret-value", {
55 + kind: "exact",
56 + confidence: 50,
57 + });
58 + const generic = span(text, "learned-secret-value", {
59 + kind: "generic",
60 + confidence: 90,
61 + });
63 + expect(__test.selectSecretSpans(text, [generic, exact])[0].kind).toBe("exact");
64 + });
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", {
69 + kind: "builtin",
70 + confidence: 70,
71 + });
72 + const small = span(text, "nested-secret-token", {
73 + kind: "builtin",
74 + confidence: 70,
75 + });
77 + expect(__test.selectSecretSpans(text, [large, small])).toEqual([small]);
78 + });
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",
84 + wholeSpan: true,
85 + confidence: 100,
86 + });
87 + const small = span(text, "abc123", { kind: "generic", confidence: 90 });
89 + expect(__test.selectSecretSpans(text, [small, whole])).toEqual([whole]);
90 + });
92 + it("keeps JWT whole spans over component-looking matches", () => {
93 + const text = "aaa.bbb.ccc";
94 + const whole = span(text, text, {
95 + kind: "jwt",
96 + wholeSpan: true,
97 + confidence: 100,
98 + });
99 + const small = span(text, "bbb", { kind: "structure", confidence: 90 });
101 + expect(__test.selectSecretSpans(text, [small, whole])).toEqual([whole]);
102 + });
104 + it("skips spans inside existing placeholders", () => {
105 + const text = "keep __LEAK_TOKEN_abcdef123456__ visible";
106 + const candidate = span(text, "abcdef123456", {
107 + kind: "builtin",
108 + confidence: 100,
109 + });
111 + expect(__test.selectSecretSpans(text, [candidate])).toEqual([]);
112 + });
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)]],
120 + });
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);
128 + });
129 +});

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";
3 4 import {
4 5 isExistingPlaceholder,
5 6 isPlainObject,
14 15 LeaksEngine,
15 16 PlaceholderStore,
16 17 RUNTIME_SETTING_KEYS,
18 + selectSecretSpans,
17 19 isExistingPlaceholder,
18 20 isPlainObject,
19 21 isWeakValue,

extensions/leaks/src/engine.ts

Modified
1 1 import { PlaceholderStore } from "./placeholders.ts";
2 +import { selectSecretSpans } from "./selector.ts";
2 3 import type {
3 4 DeepRedactionResult,
4 5 Detector,
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

Added
new 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> = {
5 + "private-key": 0,
6 + jwt: 0,
7 + structure: 1,
8 + exact: 2,
9 + custom: 3,
10 + builtin: 4,
11 + generic: 5,
12 +};
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,
18 + }));
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);
25 + if (!current) {
26 + merged.set(key, { ...span, labels: uniqueLabels(span.labels) });
27 + continue;
28 + }
29 + const winner = better(span, current) < 0 ? span : current;
30 + merged.set(key, {
31 + ...winner,
32 + labels: uniqueLabels([...current.labels, ...span.labels]),
33 + });
34 + }
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);
40 + }
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;
71 + seen.add(key);
72 + out.push(label);
73 + }
74 + return out;