Security findings
One inbox for every security finding Bucker raises about the application it already watches, ranked by a published order, joined to the issue stream, and changed only through the same governed path every other configuration write takes. This page is the contract: the kinds, the numbers each kind must cross before it becomes an issue, the order, and what a triage may and may not do.
A finding records where something was seen and how often. It never records what matched: no secret, no address, no payload. There is no field a value could be put in, and a writer that tries is refused (see What a finding stores).
Kinds
| Kind | Raised from | Opens an issue at | Alone on a public key |
|---|---|---|---|
secret_exposure |
a secret found in telemetry | 1 observation | yes |
pii_exposure |
personal data found in telemetry | 5 observations | yes |
bucker_credential_exposure |
a Bucker credential found in telemetry | 1 observation | yes |
attack_probe |
exploit patterns in requests | 50 observations | no |
credential_stuffing |
repeated failed sign-ins | 20 observations | no |
api_shadow_endpoint |
an endpoint nobody documented | 10 observations on 2 days | yes |
api_orphan_endpoint |
a documented endpoint nobody calls | 1 observation | yes |
api_schema_drift |
responses that left their schema | 25 observations on 2 days | yes |
vulnerable_dependency |
an advisory against a dependency | 1 observation | yes |
malicious_package |
a malicious-package advisory | 1 observation | yes |
prompt_injection |
injection in model input | 5 observations | no |
exfiltration_attempt |
data leaving through a tool | 1 observation | no |
goal_hijack_suspected |
an agent pulled off its goal | 3 observations | no |
guardrail_block |
a guard blocked a request | 10 observations | yes |
mcp_tool_definition_drift |
an MCP tool changed its definition | 1 observation | yes |
csp_violation |
Content-Security-Policy reports | 100 observations on 2 days | no |
imported_finding |
a finding imported from another scanner | 1 observation | yes |
account_security |
a sign-in or invitation anomaly | 1 observation | yes |
llm_prompt_injection |
injection in an LLM call's input | 5 observations | no |
llm_exfiltration |
data leaving through an LLM call | 1 observation | no |
llm_tool_drift |
an LLM tool definition changed | 1 observation | no |
vulnerability |
a lockfile-derived advisory finding | 1 observation | yes |
Which writer files which kind is its own card's work (secret and personal data in SEC-03, built, probes in
SEC-05, endpoints in SEC-06, dependencies in SEC-12, model input in SEC-10, CSP in SEC-22 (built), imports in
SEC-20, account events in SEC-11). Until a writer exists for a kind, findings_list says so in its
coverage: not checked, never "clean".
The thresholds
The numbers above are code constants (security-findings/kinds.ts), registered as one detector per kind
(security_finding_<kind>, visible in detectors_list) and published here. They move only with a code
change and a new rule-set version (ruleSet.version on every read). A finding below its threshold
stays in the inbox. At the threshold it opens one ordinary issue, grouped on the finding's kind,
rule and location; every later observation joins that issue. Assignment, alert routing, Jira and
Linear links, outbound webhooks and the remediation lane then apply to it unchanged. There is no case
or incident object: a finding is an issue.
Evidence a stranger can write. Anyone holding a project's public key can write the evidence of every
kind derived from telemetry. Each finding carries its provenance (scm_signed, first_party, token
or dsn) and keeps the strongest any observation carried. A dsn finding ranks and never acts
alone: for the kinds marked "no" above, an issue opens only once a stronger provenance has seen the
finding too. One batch also opens at most 20 issues and records at most 100 occurrences, so a public
key cannot mint issues without bound.
The order
findings_list ranks, and says it ranks, by:
- production environment (an unstated environment counts as production)
- evidence seen in the last 24 hours
- KEV-listed or malicious
- a public endpoint
- a personal-data class
- the count of observations, most first
Severity is not a ranking key; it breaks ties (then recency, then id), so the order is total and a cursor over it is stable. There is no model in the ranking.
What a read says about itself
Every findings_list and finding_get answer carries the rule-set version, the freshness of the
newest observation, scanned (how many findings matched), truncated (the page or the token budget
ended before the matches did; the cursor continues after the last row kept) and a coverage
statement for every kind: findings present (with open and total counts), a writer ran and saw
nothing, or not checked (no writer exists yet, or none has reported in 30 days). Nothing found and
nothing checked never read the same.
include: ["policy"] adds the published security scope: what a person alone
decides, and where it is written down. ["detectors"] (SEC-18) and ["suppressions"] (SEC-04) answer
not_available with the card that will build them.
Owner and its basis
A finding's owner comes from the ownership rules (a hand-written rule, or one imported from
CODEOWNERS), and the basis line says which: the rule's pattern, or the CODEOWNERS file and line it came
from. A finding that came from a connection (an imported finding) falls back to the connection's creator.
A model may suggest an owner (SEC-18); it never writes one. A person's own choice (basis manual) is
never replaced by a rule.
Triage: finding_update
One change per call to one finding: its status (open, resolved, accepted_risk), its owner,
its severity, or the issue it is linked to. The act is always finding.triage; what it means
is read from the before-and-after diff, never from an argument.
| The change | Class | Default |
|---|---|---|
| lowers severity, or accepts a risk | SENSITIVE (a silence) | asks |
| raises severity | ELEVATED | allowed |
| sets or clears an owner, links or unlinks an issue, opens or resolves | ELEVATED | allowed |
An organization's approval policy and review mode apply on top, as they do for every governed write.
- A silence ends. A lowered severity or an accepted risk carries a 30-day time-box. When it ends, the previous status and the base severity return, unless a person has touched the finding since: the revert compares revisions, so a later human choice always stands. Assigning, raising or linking is not undone by the clock. (The engine still time-boxes every act of the family at 30 days, so when an allowed assignment's window ends its owners are asked whether to keep it; the answer that changes nothing is the right one. A time-box only on the silencing acts is an engine follow-up.)
- An owner is someone in the organization.
team:<id>must be a team of the finding's organization andprincipal:<id>a member or agent of it, checked where the change is written. Any other id, another organization's included, is the same refusal. - It is bound to what was approved. The yes is bound to the digest of the plan an approver saw, applied
once against the finding's revision, and refused (
TARGET_CHANGED) if the finding moved in between, through any door. - It has an inverse.
operation_revertruns the stored inverse; the audit row for every triage carries the field's before and after. - It is capped. At most 50 triages per agent and project in a day; the 51st is
WINDOW_CAP. A person acting directly is not capped. - It never suppresses.
suppressedis SEC-04's act, andauto_closedis the sweep's. A suppressed finding is not triaged around. - A suggestion is a draft.
suggestion: {field, value, rationale}records one audit row for a person to read and changes nothing about the finding. At most 50 a day per principal and project.
What a finding stores
security_findings has one row per project, kind, rule and location, with the status, severity and
base severity, the provenance, the owner and its basis, the linked issue, first and last seen, the
first release, the running count, and at most five trace ids, five event ids, five session ids and ten
releases as handles (open them with hydrate_trace, hydrate_frames and
hydrate_replay_transcript). security_finding_days counts sightings by day and release.
- A location is a small record whose keys come from a closed list (
path,field,endpoint,package,tool, ...): a path template, a field name, an endpoint pattern. Any other key is refused. Every string is also checked against Bucker's own secret and personal-data detectors, and an observation that carries one is rejected (the rejection names the class, never the text). The identifiers (releases, evidence handles) pass the named detectors too: a release or a trace id can be high-entropy, but it can never be an e-mail address, a key or a token. - Retention. An open finding unseen for 14 days closes itself (30 for a dependency or an endpoint). Findings are deleted when last seen before the plan's event retention window, with their day rows, and with their project.
- Erasure. A subject erasure removes the event, trace and session ids it deleted from every finding's evidence, and deletes a finding whose own location or service text names the subject. The owner of a finding is a pointer at a Bucker account; an account erasure does not clear it.
Secrets and personal data in telemetry (secret_exposure, pii_exposure)
The ingest scrub removes a credential before an event, span, log or replay segment is stored. The
scrub hit rollup keeps what it learned: for every redaction, the rule that fired and a path
template (array indices and dynamic keys collapsed: exception.values.[].stacktrace.frames.[].vars.token),
per project, service, release, environment and hour, with the first trace and event that carried it and
a count. Never the value: the scrubber's manifest has none, and a path segment that looks like a
credential, an e-mail address or a card number becomes *. Hour rows are kept 30 days; the findings
built from them live longer. A request writes at most 50 distinct keys, one upsert each, and counts the
overflow.
| Class | Rules | Opens a finding |
|---|---|---|
| Credential | auth-header, cookie-header, secret-key, secret-key-camel, private-key-block, jwt, aws-access-key-id, vendor-token, auth-scheme-value, url-credentials, query-string-credentials, inline-credential-*, the provider value shapes |
on the first hit (secret_exposure) |
| Noisy | high-entropy-string |
at 25 hits on one path (secret_exposure) |
| Personal data | credit-card, the vocabulary rules an organization promoted to the stored tier, the stored IP rules (IP storage off) and the sampled rules below |
at 5 hits (pii_exposure) |
Each finding names the first release, the first trace and event and the path template (the
field), carries the service and routes to the owner the findings inbox already resolves. Above its kind's
threshold it opens or joins one scrub_hit issue, fingerprinted on kind, rule and path template, so a leak
seen by events, spans and logs on the same path is one finding and one issue. Provenance is dsn: anyone
holding a public key can write telemetry, so these rank and the issue rule of
the thresholds applies. Critical for a private key, a cloud key, a vendor token and URL
credentials; high for the other credential rules and for card, SSN and IBAN hits; medium otherwise.
The sampled personal-data pass. E-mail, public IPv4 and IPv6, SSN and IBAN are stored by design, so the manifest never reports them. Once an hour a worker reads 1 % of the stored events and log records of each project, at least 100 a table while that many exist and at most 1,000, chosen by a hash of the row id, runs the same agent-tier rules over them and counts (rule, path template). It changes nothing it read. Counts are of the sampled rows, and a project hour is sampled once. Spans are not rescanned (OTLP keeps no payload: their hits come from the stored manifest) and there is no name detector: v1 is regex only.
Fixing a leak. start_remediation on the finding's issue opens a patch for a person to merge
(merging is human-only); scrub_rule_propose proposes a redaction rule for the whole organization. A rule
is always pending: scrub_rule.create is ask-floored, so no policy and no review mode lifts it, a
person approves it before it exists, and it can be switched off afterwards. The proposal is checked before
anyone is asked with the same refusals as the dashboard (it must select something, path globs are bounded,
the pattern is run against the ReDoS probe) and a name that is free under the 50-rule cap.
Raw envelopes. The scrub runs before storage, but the raw envelope, which holds the pre-scrub bytes,
is kept for 7 days after processing. GET .../findings/:id/raw-envelopes shows how many there are in the
finding's window and the date they expire on their own. A person can purge them early:
ingest_envelope.purge is human-only (org owner, on their own session; never an agent, a service or an
OAuth client) and irreversible, so it waits a 10-minute cancel window before anything is deleted
(POST .../raw-envelopes/purge, then .../purge/:id/cancel until it starts). It deletes only finished
envelopes of that project received inside the finding's window (from the hour it was first seen to the end
of the hour it was last seen), the inline payload with the row and the object before its row, and clears the
pointer on the events. Pending jobs, other projects and other windows are untouched. Each purge writes a
signed deletion_sweep receipt and an audit row with the count, and the count of finished envelopes still in
the window afterwards (remainingEnvelopes: an object that could not be deleted keeps its row). The
requester must still be an owner when the window ends. A cancel is decided against the same lock the purge
starts under: it either lands before the purge starts or is refused, never both.
Content-Security-Policy violations (csp_violation)
A browser that enforces, or only watches, your Content-Security-Policy reports what it blocked. Point the
policy at Bucker with the project's public key in the query (a report-uri cannot carry a header):
Content-Security-Policy: default-src 'self'; report-uri https://us.ingest.bucker.io/api/<projectId>/csp-reports/?sentry_key=<publicKey>
POST /api/:projectId/csp-reports/ (also without the trailing slash) takes both wire shapes:
application/csp-report (report-uri, one {"csp-report": {...}}) and application/reports+json (the
Reporting API, an array of {"type": "csp-violation", ...}; other report types are ignored). It answers
204 with no body. It is a key-authenticated ingest door like the others: a missing, wrong, revoked or
suspended key is refused, the per-IP ceiling and the key's own bucket apply, and a report lands only on the
project of the key that authenticated it. It is metered under the existing internal category at weight 0,
so it costs no billable units and changes no data category; a refused body is counted with a reason
(csp_malformed, csp_not_a_violation).
What is stored: counts, never a report. One row per project, hour, release, directive, blocked host,
route template, source host and disposition (enforce or report), kept 30 days.
- The
script-sampleis never read. It is the first characters of the blocked inline code and can hold page source or a token. The key is not looked at, so there is nothing to drop by mistake. - No query string, fragment, port or referrer. The page is stored as a route template (ids, hashes
and anything that is not a short word collapse to
:id:/orders/:id/items), the blocked and source sides as a lowercase host only. - The release is the one current at report time: the latest successful production deploy, else any deploy, else the latest release.
- Bounded. The directive is a closed vocabulary (
otherotherwise). A stranger can name any host, so a project-hour keeps at most 500 distinct keys and counts the rest in one__overflow__row. A request reads at most 50 reports and a body is at most 64 KB. - Extensions are counted and never a finding. A blocked
chrome-extension://...ormoz-extension://...is the visitor's browser, not your site. It is counted asext:<scheme>(the extension id is never kept) and cannot open anything.
The finding. Rule new_blocked_host: a blocked host that, on a route, was never reported before the
release that last changed the page (the hour of that deploy). The finding names the directive, the blocked
host and the route, plus the release. Nothing is judged when the project has no release, or no earlier
report to be new against (reporting began after the deploy), so a first-ever flood opens nothing. A request
files at most ten (route, host) pairs, a host the full hour counted into __overflow__ is never judged, and a
project gains at most 100 new csp_violation findings in any 24 hours (joining a finding that already
exists is never capped; the counts are never capped either). A report is written by anyone holding the public key, so its
provenance is dsn and the kind is not allowed to open an issue on that alone (it ranks in the inbox
and opens one only after 100 observations on 2 days and a stronger provenance has seen it too).
Coverage in findings_list reads ran, nothing found once the csp_reports detector is registered, and
not checked before.
Where it shows
- REST.
GET /orgs/:org/projects/:project/findings(the inbox),GET .../findings/:idandPATCH .../findings/:id(one triage, or a suggestion). A triage that needs a person answers202with the approval request; retry the same body withapprovalRequestIdonce it is decided. - MCP.
findings_listandfinding_get(security:read) serve every kind,secret_exposureandpii_exposureincluded;finding_updateandscrub_rule_propose(security:write), all in thesecuritytoolset. These scopes sit outside the live MCP ceiling until the SG-059 review, so the tools are listed only for a token that holds them. With the MCP Apps opt-in,finding_getalso returns a finding card joined to the issue, the first release, the trace and the owner. - Dashboard. A Findings tab on the issue stream: the open issues a finding opened or joined. There is no separate rail entry.
Locations, services, owner bases and an agent's suggestion text are customer- or agent-written: they reach a model scrubbed, scanned for injection, capped, and declared untrusted, and are drawn as data.