Self-host AiSOC
v22.2.0AI Security Operations Center with auditable agent decisions
- Stars
- 6 755
- RAM
- 8 GB
- Storage
- 20 GB
- Ports
- 3000 (Web console (frontend)), 8080 (Ingest API), 8000 (Core API), 8084 (Agents service), 4000 (Realtime gateway / LiteLLM)
- Requires
- Kafka, LiteLLM, Ollama, PostgreSQL, Qdrant, Redis, ZooKeeper
ghcr.io/beenuar/aisoc-core-apiWhat is AiSOC?
AiSOC is an open-source AI Security Operations Center that security teams can self-host to detect, investigate, and respond to threats with full auditability. It ingests telemetry from 87+ connectors including EDR, SIEM, cloud, and identity providers, normalizes events to a common schema, and runs a detection engine with 2,535 executable rules from a 6,991-rule library. Alerts are correlated into incidents and investigated by LangGraph-based AI agents that write all prompts, tool calls, and reasoning to a replayable Investigation Ledger. The system includes a local LLM (Ollama with Llama 3.2 3B) for CPU-only triage, a CISA KEV threat intelligence feed, UEBA baselines, honeytokens, purple-team emulation, and compliance dashboards for major frameworks. It deploys via Docker Compose (CORE profile: 16 services, ~8 GB RAM), Helm charts for Kubernetes, or a one-click installer script. Authentication supports built-in credentials, SAML 2.0, OIDC, and TOTP MFA. The project is MIT licensed and funded by Cyble with no commercial gating.
AiSOC alternatives
riskkernelRiskKernel is an open-source, self-hosted runtime for AI agents that enforces spending caps, iteration limits, and time bounds with crash recovery and approval gates.Compareriskkernel with AiSOC
DarkMoonDarkMoon is an autonomous AI penetration testing platform with 50 specialist agents that runs on your infrastructure using local LLMs behind a Privacy Gateway.CompareDarkMoon with AiSOC
checkmateSelf-hosted, open-source uptime and infrastructure monitor: HTTP, ping, DNS, Docker and gRPC checks with incidents, status pages and Slack or email alerts.Comparecheckmate with AiSOC
litellmSelf-hosted gateway unifying 100+ LLM providers under one OpenAI-compatible API with usage tracking, safety controls, and admin console.Comparelitellm with AiSOC
StackResumeSelf-hosted AI resume builder with multi-agent pipeline, JD tailoring, and export to PDF, Word, and OpenDocument.CompareStackResume with AiSOC
All self-hosted alternatives to Closed-source AI SOCs → All self-hosted alternatives to Commercial SIEM platforms →
Should you self-host AiSOC?
AiSOC scores 80/100 on selfhost.directory (how scoring works) and ranks #3 of 78 in Security. It has 6 755 GitHub stars, +4 373 in the last 30 days.
It shipped 44 stable releases in the past year. The latest, v22.2.0, came out on 6 November 2026. New versions land roughly every 1 days.
Setup is advanced: plan for several services and some ongoing maintenance. An official Docker image is available. It is MIT-licensed and written mostly in Python.
Its closest alternative on selfhost.directory is CyberChef (83/100, 36 346 stars). It scores higher overall, so compare the two before you pick. See AiSOC vs CyberChef side by side.
Features
- AI-powered alert triageRuns with local Ollama model (Llama 3.2 3B) by default; hosted LLMs optional
- Alert Correlation
- Compliance dashboards
- Detection engineRules must pass replay proof to be counted as executable
- Entity graphFull profile
- HoneytokensExtras profile
- Investigation LedgerOCSF 1.9.0 format
- MCP Server
- Multi-tenancy with RBAC
- Playbook engineThree opt-ins required; preview by default
- Plugin SDKBeta
- Purple team emulationExtras profile
- Retro-huntsOpt-in, full profile
- Threat IntelligenceCISA KEV works out of the box with no API key
- UEBARequires full profile
AiSOC README
An open-source, self-hostable AI Security Operations Center. It ingests your security telemetry, detects and correlates threats, investigates them with AI agents whose reasoning is fully auditable, and proposes responses a human approves.
Technical Guide (PDF) · Docs · Architecture · What actually works · Discussions
Telemetry arrives from your security tools. AiSOC normalizes it, runs the 2966 executable rules of its 7407-rule library, groups what fires into incidents, investigates each one with an AI agent whose every prompt and tool call is recorded, and proposes an action. New threat intelligence re-sweeps the history you already collected, and a human approves before anything reaches a vendor.
How to install AiSOC
Install AiSOC with Docker Compose
AISOC_VERSION, AISOC_PULL_POLICY, ENVIRONMENT, SECRET_KEY, AISOC_CONSOLE_URL, AISOC_CONSOLE_BIND_ADDR, AISOC_BIND_ADDR, AISOC_DEMO_MODE, AISOC_REALTIME_JWT_SECRET, JWT_SECRET, METRICS_TOKEN, AISOC_CREDENTIAL_KEY, POSTGRES_PASSWORD, AISOC_APP_DB_PASSWORD, REDIS_PASSWORD, CLICKHOUSE_PASSWORD, KAFKA_BOOTSTRAP_SERVERS, OPENSEARCH_URL, QDRANT_URL, OPENAI_API_KEY, OPENAI_MODEL, LITELLM_MASTER_KEY, LLM_GATEWAY_URL, AISOC_LITELLM_REQUEST_TIMEOUT, SSO_ENABLED, SSO_PROVIDER, OIDC_ISSUER, OIDC_CLIENT_ID, OIDC_CLIENT_SECRET, OIDC_REDIRECT_URI, OIDC_SCOPES, SSO_GROUPS_CLAIM, SSO_LOGIN_LABEL, SSO_LOCAL_ADMIN_ONLY, and many moregit clone https://github.com/beenuar/AiSOC && cd AiSOC make up
CORE profile (16 services, ~8 GB RAM); full profile adds ClickHouse, Neo4j, OpenSearch, enrichment
Install AiSOC with Windows
iwr -useb https://raw.githubusercontent.com/beenuar/AiSOC/main/install.ps1 | iex
Bootstraps WSL2, Docker Desktop, Node.js, pnpm, git, clones repo, runs make up and make smoke
Install AiSOC with macOS
AISOC_DIR to override clone directorycurl -fsSL https://raw.githubusercontent.com/beenuar/AiSOC/main/install.sh | bash
Bootstraps Docker, Node.js, pnpm, git, clones repo, runs make up and make smoke
How to configure AiSOC
AISOC_VERSION=latest─── Image Pinning ──────────────────────────────────────────────────────────── Tag pulled by every `image: ghcr.io/beenuar/aisoc-*:${AISOC_VERSION:-latest}` in docker-compose.yml. Docker pulls this tag on first boot and skips the local build (~90 s vs ~15 min). Pin to a release tag (e.g. v12.0.0) for reproducible deploys; leave as `latest` to track the newest release.ENVIRONMENT=production─── Core Configuration ─────────────────────────────────────────────────────── `development` enables the dev auth bypass in services/api/app/api/v1/dev_auth.py. Set `production` for anything network-reachable; docker-compose.yml reads this value, so changing it here is enough. Production is the default because the value of this variable used to decide whether an uncredentialed request was served aLOG_LEVEL=infoSECRET_KEYHS256 signing key for console sessions, shared by the API and the connectors service. Left empty here and generated by `scripts/ensure_env.py` — see the note on AISOC_CREDENTIAL_KEY below for why a placeholder is not used.AISOC_REALTIME_JWT_SECRETShared HS256 secret used ONLY for short-lived realtime WS/SSE tickets (Issue #239). The API mints tickets at `POST /api/v1/realtime/ticket` and the Node realtime service (`services/realtime`) verifies them on every WebSocket upgrade and SSE request — both sides MUST read the same value. This is intentionally separate from SECRET_KEY so the realtime edge can be rotated independently and a leaked ti
AiSOC releases & version history
AI summary Connector paging enforced for HTTP requests
Added
-
A connector must now read its poll window to the end, and CI enforces it.
(#1714)
scripts/check_connector_paging.pyrequires every connector whose
fetch_alertsissues an HTTP request to either follow a continuation — the
sharedapp/connectors/_paging.pyhelpers, its own paging loop, or a boto3
paginator that is not cut short byMaxItems— or carry a written reason in
_REVIEWEDrecording what the vendor's own documentation says it returns.
Six connectors shipped the same defect inside two days, so this stopped
being a review question.The gate has no silent third state, which was the design problem worth
solving. "I could not find a page cap" and "this vendor returns the whole
window" are different statements and only the second is a reason, so a
connector that neither pages nor carries a reason is named in the output
on every run and counted.MAX_UNCLASSIFIEDis a debt balance rather than
a target: it may only be lowered, and lowering it means somebody read a
vendor's document and wrote down what they found. Twenty of the connectors
it names were identified by the audit as matching the data-loss shape but
could not be confirmed against a citable vendor document —slack_audit,
carbon_black,cloudflare,cortex_xdr,cortex_xsiam,github,
gitlab,salesforce,servicenow,crowdstrikeand the two AWS
connectors whose paginators carry a silentMaxItemscap among them. A
change that cites the vendor contract for any one of them and then fixes or
clears it is exactly the contribution that is wanted.The detector keys on loop shape rather than on a vocabulary of cursor
names. The first cut matchednextLink,pageTokenand their siblings and
flagged every connector that pages by page number or offset — Auth0,
CrowdStrike and Cisco Umbrella among them, all correct — and a gate that
flags correct code is switched off within a week.
Fixed
-
A fusion worker that lost its broker reported the loss and could never
undo it. (#1725, closing
#1724 — thanks
@alexmateescu for the analysis and the
original patch.)FusionWorker.start()ran one start/consume/stop cycle, so
any exception that escaped the consume loop — a broker not up yet at cold
boot, a connection lost mid-stream — ended the task, and nothing started it
again. Recovery meant a human noticing and restarting the container.Reporting the death and healing from it are separate properties and only the
first was in place:app/main.pyalready registersattachedas a
readiness subscription andbroker_reachableas a bounded dependency
probe, so/readyzhas answered 503 withdetached: ["alerts+raw_events"]
since those landed. Verified rather than assumed, by driving the real worker
and the real route: healthy reads 200, dead reads 503, and the dead one
never came back. The missing half was the coming back, and no second probe
was added —attachedis already false for the whole of a backoff window,
so one probe covers both directions and a second reading the same flag would
publish the same answer under a different name.start()now supervises, retrying with capped exponential backoff, and
readiness returns to 200 on its own when consumption resumes. Three
properties a bare retry loop would have got wrong, each with a test that
fails when it is reverted:- A retry is attempted only where retrying can help. The same three
classesstreamhealthgives the Go consumer inservices/ingest: a
transient fault backs off; a permanent one — a refused credential, a
missing ACL, an unsupported SASL mechanism — stops and names the operator
action, because a loop retrying a misconfiguration every 60 seconds turns
it into churn an operator reads as ordinary noise; a poison message is
still dead-lettered by the consume loop, which is the right place for it.
An unrecognised error is treated as transient and escalated to an error
naming where to look once it has outlived any transient explanation. - Teardown runs exactly once per attempt. A bootstrap failure is the
commonest retry there is, and the next attempt reassigns the Kafka
handles, so an attempt that raised before reaching the consume loop left
both clients open and unreachable — measured at six leaked consumers and
six leaked producers over seven attempts. Teardown now covers the
bootstrap as well as the loop, and is idempotent so the two callers that
legitimately race on shutdown do not stop the alert sink twice. - A healthy worker is unaffected. It attaches, builds exactly one
consumer and is never restarted — a supervisor stuck retrying reads as
working caution, which has shipped here before.
- A retry is attempted only where retrying can help. The same three
-
The cancelled-run gate on
mainoverstated the window it graded by about
100x, so it went green by forgetting.
(#1723)
scripts/check_main_run_cancellations.pyprintedgraded window created at or after 2026-09-29— about five weeks — on a fetch of 300 push runs, which
at this push rate is 8.8 hours. Roughly sixty workflows run on every
push, so the constant and the fetch were describing completely different
spans and only the constant was printed. The finding logic was never wrong;
the coverage it claimed was. The consequence is the one that matters: a
cancelled run ages out of reach within a day, so the gate reports clean
because the evidence scrolled past rather than because anyone fixed
anything — a passing condition that is not the property it claims, inside
the gate written to catch exactly that.SINCEturned out to be unreachable by construction. The Actions
workflow-runs API refuses any result past offset 1,000 for this query —
per_page=100page 11 andper_page=50page 21 both answer empty, the
same boundary from two page sizes, so it is a result-offset cap and no
paging strategy gets past it — and 1,000 push runs reaches 20.6 hours.
No value ofFETCH_LIMITcould ever have made the printed claim true.The window is now derived from the oldest run actually returned and printed
with both durations it has: the span those runs cover, which is the rate
that decides how fast a finding ages out, and how far back that reaches
from now.SINCEis kept as a declared floor and reported as reached or
NOT REACHED rather than printed as though it had been graded, because the
relationship is not permanent — if push volume fell, 1,000 runs would reach
past it again. The warning against moving the date to silence a finding is
unchanged and now sits beside a separate note on why the date is currently
out of reach.FETCH_LIMITis raised 300 → 1,000, taken once the backlog in
reach was measured at zero: over the full depth there were 3 cancelled runs,
allpublish-images.yml, already excepted with a written justification.Two things the output now says that it could not before. The horizon is
printed every run — a cancellation has to be noticed and re-run inside about
a day or it is not findable here at all, which is an operational deadline
rather than a footnote — and a populated fetch whose runs carry no readable
created_atnow fails instead of reporting clean. Those runs were
previously dropped insideclassify, leaving a count of zero that was read
as a young window and exited 0: a window that cannot be established is an
unknown, and an unknown is never a pass. -
The grading-integrity gate was being killed by its own timeout, and a
killed job reportscancelled— which the gate beside it correctly reads
as a commit nothing graded.
(#1721)timeout-minutes: 15
on therequired-check-substancejob was not derived from anything. Over
the 100 most recent runs of the workflow (2026-11-03 22:14Z → 2026-11-05
13:49Z) it completed successfully 31 times: fastest 8m13s, median 12m51s,
slowest 14m30s. The ordinary worst case finished about 3% inside its
own ceiling, so any slowdown in the Actions API pushed it over — and it
did, one run killed at 15m16s, three red boards on a non-defect in two
days.The failure mode is what makes the number worth a release note rather than
a line in a diff. GitHub reports a job that hitstimeout-minutesas
cancelled, notfailed, socheck_main_run_cancellations.pyin the
same workflow then reports — accurately — that a commit onmainwent
ungraded. The gate was right and the budget was what was broken, which is
the one case where moving a threshold is the fix rather than the evasion.
It is now 40 minutes, sized from the measured 14m30s plus the 300-second
rate-limit ceiling below, doubled; it still binds, so a genuinely hung job
dies here instead of running to the six-hour default.The rate limit is the other half, because raising a budget without it would
have traded a timeout for a hard failure. GitHub answers both a primary and
a secondary rate limit with 403 or 429, so the status code alone cannot
separate "you are going too fast" from "this token may not read this" — and
waiting on the second would hang the gate on an answer that will never
change. The discriminator is the headers, as GitHub documents it: a
rate-limited answer carriesretry-afterorx-ratelimit-remaining: 0, and
a 403 carrying neither is still raised immediately. Pauses are bounded
three ways — a singleretry-afteris honoured only up to 60 seconds, so
the API cannot decide when this job dies; the process may spend 300 seconds
in total across every call it makes; and spending it leaves the gate
reporting "could not read", which is still a failure, because an
unknown is never a pass — but an honest one naming the API rather than a
cancelledconclusion that reads as a grading hole.check_main_run_cancellations.pykept its own single-attempt copy of the
same request and now delegates to that reader. The two gates run in the
same workflow against the same API, so whatever makes one unreadable makes
the other unreadable at the same moment, and only one of them rode it out.
The semgrep ceiling falls 114 → 113 as a consequence rather than as a
concession: deleting that duplicated request removed one real
dynamic-urllib-use-detectedcall site, attributed by scanning the single
file atmainand on the branch with the same pinned scanner and vendored
packs (1 finding against 0) because two runs reading 113 against a ceiling
of 114 is also what this scanner's recorded ±1 drift looks like. No
suppression was added anderroris unchanged at 44, which is the control:
the drift moveserrorandtotaltogether. -
Google Workspace OAuth token grants and revocations had never once been
ingested, on any deployment.
(#1713) Google withholds a
Reports API log event until it has published it, and that delay is
documented per application across three orders of magnitude: Admin, Drive,
Devices and Login events are "near real time (couple of minutes)" while
Token log events are "a couple of hours".fetch_alertssent only
startTime, and withendTimeunset the report "returns all activities
from the startTime until the current time" — a window pinned tonow. The
next poll began where that one ended, so the unpublished tail of every
window was read once while empty and never requeried. For Token, whose lag
exceeds the default 300-second interval by a factor of about twenty-four,
no poll ever overlapped the published part of the timeline at all: the loss
was not a fraction of that feed, it was the whole of it.Each window now ends where Google has published rather than at
now, per
application, and keeps its length so consecutive polls stay contiguous
across that boundary. Each figure sits above the documented one, because
the same page warns that some events are delayed beyond the stated times
and undershooting puts the window back inside the band Google has not
published. An application absent from the table takes a conservative
default rather than a window pinned tonow, so adding one cannot silently
reintroduce the defect. The cost is latency; the alternative was silence. -
Microsoft Entra directory audits and risky sign-ins never followed
@odata.nextLink, and what truncation discarded was the oldest part of a
burst. (#1708) Graph returns
$topentries and an@odata.nextLinkwhile more of a collection remains.
Both feeds read the first page at$top=200and stopped.fetch_alerts
derives its window from the clock with no checkpoint and the scheduler
passes the poll interval assince_seconds, so consecutive windows abut
exactly and nothing re-reads an earlier one — anything past the first page
fell below the next window's lower bound and was never requested again.
Both queries are ordered newest-first (activityDateTime descfor directory
audits,createdDateTime descfor risky sign-ins), so what went missing was
the beginning of whatever burst overflowed the window, which is the part
an investigation needs. Both feeds now follow the link as-is through a
shared_read_pages()helper, bounded and logged when the bound binds.Independently diagnosed and fixed by
@rudycelekli. -
Microsoft Defender and Sentinel each read one page of every poll window.
(#1711) Graph answers
Defender's$top=200alerts request with a first page and an
@odata.nextLink; Azure Resource Manager answers Sentinel's$top=100
incidents request with a first page and anextLinkcarrying a
$skipToken. Neither was followed, and the contiguous-window argument above
applies unchanged: the remainder of the window was never requested again.
Defender's query is orderedcreatedDateTime desc, so there too it was the
earliest alerts of a burst that went missing.Both now use
read_linked_pages()from the new
services/connectors/app/connectors/_paging.py, which holds three
properties, each of which is a defect somebody has shipped: a partial read
is kept rather than thrown away when a later page fails, the page cap is
announced when it binds rather than silently cutting the result, and the
link is requested verbatim — Graph states outright that the$skiptoken
must not be extracted and reused in a different request. -
Google Cloud Audit, Security Command Center and Workspace each read one
page per window, and Cloud Logging could return nothing at all from a window
that was full of events.
(#1712) All three page by
nextPageTokenand none of them followed it. Cloud Audit read 200 entries
of atimestamp descquery; SCC read onelistFindingspage; Workspace's
loop walked a fixed set of applications issuing one request each, so a
single noisy application —driveon a busy tenant — displaced the rest of
the window behind it.Cloud Logging's variant is worse than truncation, and it is why the loop
ends on the token rather than on an empty page. Its reference states that a
nextPageTokenreturned with an emptyentriesfield means the search
"found no log entries so far but it did not have time to search all the
possible log entries", and that the method should be retried with that
token. A connector that stopped at the first empty response therefore
returned zero events from a full window, which reads downstream as a
quiet estate rather than as a read that did not finish.All three now go through a shared
read_token_pages()in the same
_paging.py. The Google Workspace half of this was independently diagnosed
and fixed by @rudycelekli in
#1715; that fix was correct
and lost only to the shared-helper version landing first as595ab1aa7. -
Wiz issues past the first 100 of a poll window were never ingested.
(#1720)
WizConnector.fetch_alertssentfirst: 100, readdata.issues.nodes
once and returned. There was nopageInfoin the query, no cursor and no
loop — while the same module already defined a correct_paginate()that
walkspageInfoto the end, and the three context reads added later all
used it. The alert path was the one read that did not. The window is clock
derived and contiguous like every other connector in this family, so a
tenant raising more than one page of issues in a poll interval lost the
remainder permanently;apply_checkpoint()cannot recover it, because it
de-duplicates rows the vendor already returned and never widens a later
request.fetch_alertsnow goes through that same_paginate(), so the alert path
inherits the cursor walk, the page cap and the behaviour of raising on a
GraphQLerrorsblock rather than reading a missing scope as a clean cloud
estate. The issues query gains$afterand apageInfoselection, which
the request needs in order to mean anything: a GraphQL server coerces only
the variables an operation declares, so sendingafterto a query that did
not declare it would have been silently ignored. The test drives the real
fetch_alertsthrough a transport serving three pages and asserts both the
issues returned and the cursor the connector sent, because a canned page
sequence will answer any request and cannot by itself tell a correct
implementation from a wrong one.MAX_UNCLASSIFIEDin the paging gate
falls from 59 to 58 with it. -
Entra directory-audit alerts named the Microsoft service that performed a
change, never the user, group or device that changed.
(#1722, reported in
#1718 by
@gdncomm-dika-wibowo)
Measured across ten alerts from one tenant: an "Add member to group" alert
readaffected_users: ["Microsoft Teams Services"]and named neither the
member added nor the group, and a device update carried no host at all. Six
causes across four layers, and a fix in any one of them reaches nothing —
the fusion promoter builds an alert'susernamefrom OCSF
actor.user.nameand itshostnamefromdevice.name, so a target
sitting anywhere else reached no column, no entity and no correlation key.azure_entra.normalize()now prefersinitiatedBy.user.userPrincipalName
for the actor: Graph puts a first-party client inuser.displayNamewhen a
person acts through one, so the display name named Teams, Intune or the
password-reset service as the actor on events a person performed. The
display name is carried asactor_display_namerather than dropped,
because nothing downstream can tell from the value alone whether that slot
held a person or a client._target_fieldskeeps every target and every
modified property —modifiedProperties[0]on a device update is the empty
Included Updated Propertiesmarker, so a device's id, OS and trust type
were lost on every device event. Its docstring had refusedtarget_user_2
on the reasoning that a rule written against it would pass its fixture and
miss the real shape; that hazard is position, not plurality, so nothing
added is positional —targetsandmodified_propertiesare keyed by what
a thing is, andtarget_group_name/target_hostnameare found by
searching for the group or the device wherever Graph put it. The original
flat fields still describetargetResources[0]byte for byte.The ingest normalizer maps
target_useronto OCSFtarget_user.nameand
target_hostnameontodevice.name(nottarget_name, which is the
display name of whatever the target is and would put a person in the host
column), and the fusion sink lists the target beside the actor in both
affected_usersandentitiesfrom one shared helper, so the two can
never name a different set of people. A device change now also correlates
per device instead of collapsing every device event in the tenant onto the
Intune client that performed them.det-identity-210("Entra User Password Reset By An Administrator", high)
required onlyactivity == "Reset user password", so every self-service
reset raised a high-severity administrator reset. It now also requires
initiator_type == "user". One rule with a clause rather than a split: the
defect is that the condition did not match the rule's own name, and an SSPR
rule would be new coverage rather than a fix. The id is unchanged, no new
id was allocated, and the negative fixture is a real self-service reset
rather than a flipped literal.method_execution_resultadditionally
surfaces the directory's own result, so an "add member" that returned
DirectoryValueExistsExceptionis distinguishable from a real add without
rewriting Graph's ownresult: success.Not fixed, and recorded as such: the group is available to rules and on the
alert's raw event but is not an entity chip, because the Investigation
Rail's entity vocabulary has no group kind and adding one is an API change
the report did not ask for. Nothing here was exercised against a live Entra
tenant; the fixtures are the anonymised shapes from the report and Graph's
published schema. -
The Agentmetry connector page said its live leg was "not verified" after
somebody had verified it, so the one claim that was wrong was the modest
one. (#1719, contributed by
@blitzcrieg1, Agentmetry's maintainer)
A flat "not verified" reads as honest and functions as an exemption: it
says nothing about what was never run, so nobody can tell a leg that
failed from one nobody attempted, and nobody can tell which part is still
open. It had in fact been run — on 2026-11-02, Agentmetry 0.10.4 installed
from PyPI postingcanonicalevents over HTTP to a local AiSOC v21 stack
brought up withmake upandmake smokepassing 10 of 10 first, at an
inbox minted with this template. 11 of 11 events were forwarded and
accepted with none dead-lettered; both detections (credential-exfil,
remote-staging-then-execute) arrived as critical alerts carrying their
ATT&CK techniques; the nine routine events — tool calls, a denial, session
start and end — raised no alert; andclaudeandcursorappeared in the
AI estate with the operator attached.The page now states that run with its date, its versions and its result,
and says plainly that no CI job repeats it, so a later change on either
side can break it without a gate failing. What remains unverified is named
rather than implied: a deployment with the sensor and AiSOC on different
hosts, and any AiSOC release after v21.The claim-matrix row stays GATED and only its caveat moves. The gated
claim — that Agentmetry telemetry lands split, routine tool calls in the
lake and correlated detections as alerts with severity and ATT&CK ids
preserved — is proved by the same ingest, fusion and graph tests as before
and did not change. Promoting a row because a human ran something once
would make the matrix a record of what somebody remembers rather than of
what CI enforces, which is the failure the file exists to prevent. -
Published figures re-derived from the tree, in two passes, because the
first one did not reach every surface.
(#1709 and this release's
documentation sweep) #1709 corrected nine surfaces that published a
detection-corpus figure counted before the corpus moved — 2,511 / 2,530 /
2,535 against 2,966 executable, 6,991 / 7,015 against 7,407 on disk — and
found the claim matrix's connector row stale in both cells while its gate
printed OK, because that gate reconciles the README phrase against the
generated artefact and never reads the table.The sweep for this release found the surfaces the first pass missed, which
is the useful half: the glossary, the feature index, the operations FAQ,
detections/README.md,services/connectors/README.mdand the funnel-KPI
page were each still quoting a superseded count, and
docs/architecture/README.mdsaid "of the 87 declared connector types, 45
name a class of their own and the other 42" against a real 91 / 46 / 45. A
figure gated at one claim site goes stale at every other site silently,
so correcting the gated one is not the same as correcting the figure.Two numbers were deliberately not rewritten. The fusion rule-index
measurement in
ADR-0012
and on the performance page was taken against a 2,511-rule corpus and was
not re-run, so restating it against 2,966 would be falsifying a
measurement rather than refreshing a claim. Both now say what corpus they
were measured on and that the ratio, not the absolute count, is the part
that carries forward.The claim matrix gains rows for the two capabilities this release shipped
without one — the connector paging gate and fusion worker supervision —
and its "rules that cannot fire" row is corrected from a ratchet of 45 to
the 2 the gate actually enforces. The matrix moves 398 rows / 389
GATED to 400 / 391, with 9 PARTIAL and 0 NO GATE unchanged; the
summary is recomputed withcheck_claim_gate_matrix.py --writerather
than hand-edited, because that figure is published in three places and a
disagreement between them reds every open pull request.The technical guide is re-rendered with the pinned toolchain and gains the
poll-window contract and three new troubleshooting rows; it is 28 pages
now rather than 27, and the README badge moves with it.
AI summary Session tokens now securely signed
Security
-
A deployed demo signed session tokens with the default
SECRET_KEY
published in this repository.
(GHSA-m57m-6p4p-cq6p,
critical, CVSS 9.1)enforce_secure_defaultsrefuses an insecure default at
boot, but only whenENVIRONMENT=production.infra/railway/railway.toml
setsENVIRONMENT = demoand never setSECRET_KEY, and nothing in its
README told the operator to — so the documented one-click deploy came up on
the internet signing session tokens with a string anyone could read here.
Anyone who could read the repository could mint a token for any tenant in
any role on any deployment that followed the recipe.demois the only member ofDEV_ENVIRONMENTSthat denotes a deployed
environment;development,dev,localandtestare on somebody's
machine, where the placeholder is the documented value and a per-process key
would break every local flow that signs something and reads it back. It had
been grouped with them for the secret check, which is the whole defect.A deployed demo now substitutes a per-process key rather than refusing,
deliberately: refusing is what production does, but it would break the
one-click deploy for everyone following the documented path, and a security
default that breaks the documented path is one that gets patched out
downstream. The cost is said out loud at boot rather than discovered —
the key lives for one process, so sessions end at a restart, and a demo
running more than one replica must setSECRET_KEYitself or the replicas
reject each other's tokens. The wholeINSECURE_SECRET_KEY_DEFAULTSset is
covered, not only the spelling the report named. -
The connector egress guard had two ways around it, both reachable by the
same authenticated tenant user that reproduced the original report.
(GHSA-32q9-5fvr-8wcx,
high, CVSS 7.7) GHSA-cq4g-g6wp-4m2w closedPOST /connectors/{id}/testand
the scheduler poll path. Three construction sites still called
cls(**kwargs)directly rather than through_instantiate_or_422, where the
guard lives:POST /connectors/{id}/query,POST /connectors/{id}/resource_configand the saved-instance resource-config GET.
The first two take the destination straight from the request body, so the
earlier fix had moved the vector one route sideways. There is now one
construction path and the guard is on it.The guard also matched only values shaped like an
http(s)://URL. Nine
connectors assemble their URL from a hostname instead, so
api_hostname = 169.254.169.254reached cloud metadata under a guard that
had looked at the value and called it not a URL. A value is now read as an
authority whenhttps://<value>parses to a plausible host — an IP literal,
localhost, or a dot-bearing name obeying the DNS grammar.The narrowness is the point. An opaque token, a saved-search name, a glob
index pattern and a bare label such asprod-splunkall fail the grammar and
are never looked up, and that floor is pinned by test: a guard that breaks a
working connector on upgrade is worse than the bug it closes. -
A password reset did not end existing sessions, and one TOTP code could
open more than one session.
(GHSA-6465-rp4f-ppj6,
high, CVSS 7.4)bootstrap_admin --reset-passwordwrotehashed_password,
is_active,is_verifiedandroleand leftsessions_revoked_atalone,
so every token minted before the reset kept working — up to seven days for a
refresh token, which re-mints access on its own. The operator had done the
one thing the product offers for "somebody else has my password" and the
other session was untouched.deps.get_current_userandPOST /auth/refresh
already read the column and SCIM already stamps it; one revocation site had
been missed.POST /auth/mfa/verifyreadlast_used_step, verified against it and issued
an unconditionalUPDATE, so concurrent requests carrying one TOTP code all
read the same mark before any of them wrote. The step is now claimed with one
conditionalUPDATEscoped by the prior state the verification depended on,
with the row count deciding — the same claim pattern a dispatched action uses
before it touches a vendor. -
Committed
.envbackups remain in history, and.gitignoredid not cover
the namespace.
(GHSA-57rw-w33m-cp5v,
medium, CVSS 5.9) Two backups of a working.envwere committed and removed
a few commits later. A deletion is not a redaction: every clone and fork
still carries the blobs, and between them they hold a generatedSECRET_KEY,
the FernetAISOC_CREDENTIAL_KEYthat unlocks the connector vault, and the
Postgres, Redis and ClickHouse passwords. No third-party vendor credential
was in them — every vendor key slot was empty — so the exposure is bounded to
any deployment that reused that file. Rotate those four secrets if you
deployed from a clone that reused it..gitignorenamed.env,.env.localand.env.*.localand nothing else,
so a backup written beside the real file was simply not ignored. That is now
a namespace deny with the published template as the one exception.
Enumerating the backup spellings would have closed the two names that
happened; denying the namespace closes the next one too. An ignore rule has
no effect on a file that is already tracked, so
scripts/check_env_backup_files.pyasks the question the ignore rule cannot
— is one tracked right now — and asks the ignore rule's own question back at
it, so the two halves cannot drift apart. -
Agent tool arguments were not checked against the tool's own schema.
(GHSA-4hxg-m5rw-gw3x,
medium, CVSS 5.9)ToolRegistry.executeresolved the tool, checked the agent
scope, then calledtool.fn(**args)with whatever the model produced. Every
tool ships a JSON schema — it is whatbind_toolssends the provider, so the
schema exists and is already authoritative about what the arguments are — and
nothing compared the two. Python enforces no annotation, so a wrong type
reached the body untouched: a tool declaringindicator: strran on a list,
a dict or an integer. Where that value is interpolated into a query, a vendor
request or a lookup key, the tool's own reasoning about its input was the only
thing standing there, and the argument came from a model whose context
includes attacker-controlled alert text.The check is a method on
Toolrather than logic in the registry, because it
is a property of the tool's own contract, and it runs at the chokepoint every
call passes through. The refusal is a structured error rather than an
exception — the loop contract is that a tool failure reaches the model rather
than aborting the run — and it is audited as a denial with its reason, so a
model steered into malformed calls is visible in the same rows as one steered
out of scope rather than looking like a tool that happens to be failing.
Fixed
-
The gate that proves published images match the tree compared
VERSION,
which does not move after a release — so every post-release commit was
invisible to it.scripts/check_published_images.py --require-freshreads
org.opencontainers.image.revisionoff each image and then compares
git show <revision>:VERSIONagainst the tree.VERSIONchanges on a
release commit and on no other, so two different commits of the same release
compare equal and the check passes.That is not theoretical.
v22.0.0was tagged at95bad815c; the jobs
publishing the moving tags then failed on a drained Actions token, leaving
:lateston all 16 images at95e397f7b, seven commits behindmain.
make upserved a stack missing three of the five security fixes published
hours earlier, two of them for advisories rated 9.1 and 7.7 — while the gate
printedOK — all 42 first-party image reference(s) resolve ... and the version inside each matches the treeand exited 0, becauseVERSIONat the
stale revision was already22.0.0.--require-currentcompares the commit rather than the version, for tags
that move. An immutablevX.Y.Zis a snapshot of a past commit and still
answers toVERSION; comparing it against today's head would red every
release tag forever. A moving tag must hold the tip ofmain, and is
tolerated behind it only while both bounds hold: the head commit is inside a
240-minute publish window (above the slowest of the last 100 successful
publish runs, at 168 minutes) and the lag is at most 40 commits (above the
24 that is the most ever to land inside one such window — the window alone
has a hole, because publishes cancel in progress and a stream of merges
keeps the head young indefinitely). A tag ahead of the head is a race and
not drift. A revision that is off the branch, absent, or unplaceable by this
checkout is a finding and never a pass.Passed by the daily
image-availability.ymlrun, which is what can catch a
moving tag that went stale with no commit to trigger anything, and by
publish-images.ymlafter it pushes its manifests. Deliberately not passed
byrelease.yml, whose checkout is a release tag rather than a branch tip.
The gate's--self-testwent from 30 assertions to 59, covering both
directions — stale must fail, current and ahead and in-window must pass —
anddocs/operations/publishing.mddocuments the operator remedy. -
CrowdStrike polling 404'd on every deployment, and the investigation read
answered "no detections" rather than failing. (#1695)
CrowdStrike decommissioned the/detects/*endpoints on 2025-09-30. Both
callers in this tree still used them, and they failed differently:services/connectorsraised the 404 on each poll, so a saved connector
never synced. Visible, and the way the bug was reported.services/actions'CrowdStrikeRTRClient.get_detectionslogged a warning
and returned[], soCrowdStrikeGetDetectionsreportedSUCCEEDEDwith
count: 0. An investigation read that as the EDR having nothing on the
host — the strongest exonerating evidence there is — from a call that had
404'd. That one was silent, and is why this fix covers both.
Both now use
POST /alerts/combined/alerts/v1, and a failed alerts read
raises instead of returning an empty list, matching the contract the
SentinelOne and Defender reads already held. A 403 names the Alerts: Read
scope rather than presenting as an empty result, because an API client
carrying only the RTR scopes authenticates perfectly well and is then
refused.Action required: grant Alerts: Read to your CrowdStrike API client.
No reconfiguration can work around a removed endpoint, so an older build
cannot be made to poll CrowdStrike at all. -
Duo authentication polling never read the last two minutes of any window,
so roughly 40% of Duo authentication events were never ingested on any
deployment. (#1706)
DuoSecurityConnector.fetch_alertsbuilt a purely clock-derived window
[now - since_seconds, now]with no checkpoint or high-watermark anywhere in
the connector, and the scheduler passes the poll interval assince_seconds,
so consecutive windows are contiguous and non-overlapping. Duo documents an
intentional two-minute delay before a new authentication is served by the
logs API and answers a more recent range as empty, so the final 120 seconds
of every window came back empty — and the next poll's window started at
now, so those entries were never requeried. At the default 300-second
interval that is 120 seconds in every 300 lost on each poll.The window now ends at
now - 120s, which keeps consecutive polls contiguous
across the boundary Duo actually serves. The test drives the real
fetch_alertsthrough a transport that emulates Duo's availability cutoff
and asserts that two back-to-back polls between them read every
authentication — a path test rather than a source-inspection one. -
cloudflare_ztWAF mode polled a route that does not exist, so it could
never have returned an event on any deployment.
(#1691, closes
#1686) WAF mode called
GET /zones/{zone_id}/security/events, described in the module docstring as
a mid-2024 replacement forfirewall/events. Measured against the live API,
both firewall paths answer 404 / code 10404 "No route for that URI" for
any zone id, with or without a token, while an unrelated zone route answers
9106 "Missing Authorization headers" — an auth refusal, which is what an
existing route returns. So the probe discriminates, and the absence is a
fact rather than an inference. Access mode was and is unaffected.WAF mode now posts a GraphQL query against
firewallEventsAdaptive. The
scope changes with it to Zone: Analytics: Read, which is what the
analytics dataset reads — notZone: Firewall Services: Read, which governs
rule management and is what every surface here had asked for. Paging is by
time because the dataset has no cursor, and since that bound is inclusive,
emittedrayNamevalues are remembered for the poll so repeats are dropped
within a page as well as across one. A GraphQL scope failure arrives as a
200 carryingerrorsand a nulldata, and is now read as the failure
it is. -
Two flushes of the event lake could run at once, and a cached triage
verdict was never persisted. (#1694)
The periodic timer and the consumer both callLakeWriter.flush, and the
native client and the spool cursor had no single owner between the insert and
its disk commit; a flush is now serialized under a lock for the whole of that
window.EBADF,ENOTCONNandEPIPEare also now classified as connection
failures rather than data failures, so a socket torn down mid-insert retries
in the outage direction instead of counting against the data-failure budget.Separately, when the deduplication cache answered an alert, the worker
assigned the cached verdict and confidence to locals while persistence and
source writeback readstate— so the verdict was computed and then dropped.
The cached verdict is now written onto the state it is read from, normalised
through the same disposition vocabulary as a fresh one and clamped to
[0, 1], and it carries an explicit basis recording that the evidence
fingerprint matched a previous assessment, that no new model call was made,
and that this is not evidence of remediation or authorization to close the
alert. -
A tenant could not be created without naming every column the schema fills
in, so a brand-new database failed its seed.
(#1696, closes
#1693)tenants.mssp_role
has beenNOT NULL DEFAULT 'standalone'since migration 012 while the ORM
declared itnullable=Truewith no default. Those two statements look
compatible and are not: a column the ORM believes is nullable is named in the
INSERTwith an explicitNULL, and a column named in anINSERTdoes not
receive the columnDEFAULT. The database's own default could therefore
never fire, and every caller that constructed aTenantwithout naming the
field gotNotNullViolationError. The seed was simply the first thing to
insert a tenant, so it was the first caller to find out.Both
default=andserver_default=are now stated — the first covers the
ORM path, the second covers inserts that bypass it, and either alone leaves
one path to rediscover this.scripts/check_orm_nullability.pygates the
class, because nothing had compared a model against its own table. -
Five surfaces published an ATT&CK figure and none said which measurement it
was, so any two of them contradicted each other.
(#1668) On one deployment at
one moment: 392/392 on SOC Operations and the Coverage Advisor, 1/201 on the
Operations Funnel, 22.22% on SLA Tracking, 494 in the Marketplace facet and
14 in the agents health probe. Each surface now names what it counted. The
operations card also shipped "100% of known techniques have an enabled rule",
which is false:GET /detection/coveragereturns one row per technique that
at least one of the tenant's rules already references, so a technique with no
rule never appears — and the Coverage Advisor states that scope correctly for
the identical number.The Advisor also rendered every one of 392 rows as Tactic "unmapped" while
the alert detail page resolvedT1059.001to Execution on the same
deployment. The API reads its tactic fromrule.mitre_tactics[0]and the
compiled built-in corpus carries no tactic key, so the column could never be
populated from the response alone, whilemitreTactics.tshad the
technique-to-tactic map all along one directory from the heatmap that uses
it.displayTacticnow prefers the rule's own declaration — an author who
placed a technique in a specific tactic knows something a parent-technique
table does not — and still answersnullwhen neither can place it, so
"unmapped" keeps meaning genuinely unknown. -
Three console figures described a different set from the one measured.
(#1669)_correlate_stageset
backlogto the number of alerts that absorbed exactly one event, and the
strip rendered "Backlog 7", telling an operator seven items were queued when
nothing was. That count is a correlation outcome, not a queue depth, and
fusion emits no per-correlation queue depth for the stage to read;backlog
now joinsunmeasuredand the observation travels indetailunder its own
description, so the number is not lost with the wrong label.landing/Hero.tsxandonboarding/StartHero.tsxboth rendered a hardcoded
value="26"against a registry of 91 — the second 35 lines below a correct
dynamic use ofCONNECTOR_COUNTin the same file. The gate that owns this
figure reconciled markdown prose and had never opened a.tsx, so it
reported OK throughout; it now scans every component underapps/web/srcand
refuses a numeric literal rendered as a connector count, with a self-test
proving it catches that shape, leaves a dynamic use and an unrelated number
alone, and refuses a scan that walked no components.DashboardViewalso
paired a liveactiveSourceCountwith the fixed caption "EDR, SIEM, Cloud,
IAM, SaaS", which did not describe what had been counted. -
A required connector select submitted an empty value while showing the
operator a chosen option.
(#1688, closes
#1685) A required select with
no schema default started on an empty form value but rendered no blank
placeholder, so the browser displayed the first option as selected. Leaving
it as it appeared submitted an empty value —cloudflare_zt mode='', for
one — and Test connection failed with an opaque API 502. Such selects now
start on their first option so the submitted value matches what the operator
sees, pinned by a test that a required select starts on a value it can submit
(#1692). -
The sandbox demo aborted part-way on a console with a legacy encoding.
(#1679) The investigation
ledger writes non-ASCII separators, and a Windows console exposing a legacy
encoding such as cp1252 raisedUnicodeEncodeErrormid-render, so a reader
on that terminal saw a traceback instead of the rest of the demo. Glyphs the
console cannot represent are now replaced so the complete ledger still
prints. -
A transient GitHub 502 reddened
mainas though a gate could not read its
input. (#1698)
check_required_check_substance.pyread the Actions API once per workflow
with no retry, so a single 502 from GitHub's own side failed the job with
could not read runs for ci.yml— for a reason no commit caused and no
author could act on. It happened twice in a row on the same commit, while the
identical endpoint answered 200 three times in a row from outside the runner
at the same moment, which is what places the fault on GitHub's side rather
than on the query._getnow retries only while the failure is transient —
500/502/503/504,URLErrorandTimeoutError— over four attempts with a
bounded backoff.This does not weaken the refusal the gate exists for. A durable answer is
raised immediately and never waited on: a 403 from a token without the scope,
or a 404, is a fact about this token or this resource, and retrying it would
only delay reporting it. A 502 that persists still fails after the attempts
are spent — "could not read" remains a failure, never a pass.
BREAKING
-
GET /posture/summarynow returnsnullrather than0for every count
when nothing has collected. The eight integer fields onPostureSummary
—total,critical,high,medium,low,open,resolvedand
suppressed— become nullable, which changes their generated SDK types
frominttoint | None.The break could not be preserved, because the old type was the defect.
posture_findingshad no production writer at all, so the endpoint counted
an empty table and answeredtotal: 0, critical: 0on every deployment —
a sentence that reads "your cloud estate is clean" about an estate nobody
has looked at. No integer can carry that distinction:0has to mean
"collected, and found nothing", which leavesnullas the only honest
value for "nothing has collected". Keeping the type and addingcollected
beside it would have left the old fields still saying zero, so every client
that did not adopt the new flag would keep reading the same false clean
bill.Migrating a client is reading
collectedfirst: when it is false the
counts are absent and the correct render is "not scanned", not a zero.
Security
Seven advisories, all in the approval and authorization path. The unifying
shape is that the control existed and compared the wrong thing: a value the
caller supplied rather than one the credential proved.
Three of these refuse calls that used to succeed. If a deployment relies
on any of them, it needs a change before upgrading:
-
An
aisoc_API key can no longer enrol or remove an authentication factor. -
A
tenant_admincan no longer reach the deployment-wide tenant and
waitlist surfaces; those now needadmin:tenants/admin:waitlist, which
only the wildcard roles hold. -
A
viewercan no longer create, update, delete or run a playbook. Listing
is unchanged. -
GHSA-fm3f-p5jv-6hcg
(critical) — a tenantless approver could approve another tenant's action,
and an ungraded dispatch executed.approve_actiontookapproverand
requesterfrom the request body, so separation of duties compared two
strings the caller chose; both now come from the verified principal. A
principal with no tenant skipped the tenant comparison entirely — and
_tenant_ofreturnsNonefor that same principal, leaving the record
read unscoped too, so one identity could approve any tenant's containment.
An approver with no tenant is not "all tenants", it is an identity nobody
scoped, and it is refused with the configuration to fix named in the
message. A request with no tenant was also governed by the environment tier
rather than failing closed, so a tenant's kill switch did not apply to it.
Finally, a live capability with no contract bypassed the autonomy gate, and
a test pinned that as intended behaviour. -
GHSA-vf98-8367-45mp
(critical) — ChatOps approval decisions were accepted unauthenticated,
replayable and unaudited. WithSLACK_SIGNING_SECRETempty the Slack
interactions route accepted ablock_actionspayload carrying no
signature and answered 200. The Teams bot took the approver from
from.aadObjectIdin the card callback and validated no Bot Framework JWT.
Replay protection lived in process memory, so the same payload was accepted
again after a restart; the claim is now a durable conditional write scoped
by(tenant_id, action_id), because an unscoped claim lets one tenant's
reply consume another's. Andbuild_audit_sinkresolved a path that exists
in a source checkout and not inside the built image, so the shipped
container recorded no approval decisions at all, silently, while every
developer running from source saw them recorded. -
GHSA-jfvq-94hv-4wrj
(high) — a scoped API key could enrol a passkey on its owner's account and
sign in with it. Anaisoc_key, however narrow its scopes — even[]—
was accepted at the passkey and TOTP enrolment routes. The key resolves to
aCurrentUsercarrying its owner's id and role, so a key scoped to
alerts:readregistered a passkey bound to the owner's account and signed
in with it, receiving a console session with the owner's full role. Driven
to completion before the fix: the sign-in carried noAuthorizationheader
at all and answered 200 atGET /connectors, the exact route the key
itself is refused on.require_interactive_sessionrefuses by credential
type, not by permission, because a permission would be mintable onto the
very credential it refuses. -
GHSA-6cwm-cx8p-h7f5
(high) — asettings:writefallback exposed every tenant and all waitlist
PII to anytenant_admin. The deployment-wide tenant-provisioning and
waitlist routes gated onadmin:tenants/admin:waitlistor
settings:write, documented as a bridge until a seed migration landed. It
never landed, so neither permission existed, no role could resolve either,
and the fallback was the only reachable branch — whiletenant_adminholds
settings:writeandGET /admin/tenantsselects every tenant with no
predicate. Migration 159 seeds both permissions, granted to no
tenant-scoped role. -
GHSA-8cpf-mchw-jpf2
(high) — any tenant member could create and run response playbooks, and a
revoked session kept working. The playbooks router authenticated every
caller and then required no permission to author a playbook or to run one,
while the API gates the same step dispatch onactions:execute. Separately,
verify_console_tokenconsulted no user record, so a token minted before an
operator deactivated that user stayed valid on these routes until it
expired — while the API refused the same token. An unreadable user record
is a 503, never a pass. -
GHSA-q388-w896-9jr2
(high) — approval decisions lacked separation of duties, a named-approver
check and an expiry check. A requester could approve their own request,
any eligible user could decide an approval addressed to a named approver,
and a decision was accepted afterexpires_at. One principle governs the
fix: approving is the governed act and denying executes nothing, so every
rule narrows who may approve and leaves denial open. -
GHSA-xhmc-69rh-h3rr
(medium) — one person could request and approve an MCP tool call, and one
approval could be spent twice. Separation of duties compared the API-key
prefix with the session email rather than the person, so the key's owner
could approve their own key's request. The decision was a read-then-write
rather than a conditional update, so approve and deny could both succeed on
one request, and consuming an approval was keyed by a(tenant, tool)
fingerprint rather than by approval id.
Fixed
-
The syslog LEEF parser truncated every attribute value at its first
|
and dropped every attribute after it.parseLEEFcut the header with
splitEscaped(body, '|', 7), but a LEEF header has five fields (1.0) or
six (2.0), so the extra cuts landed inside the attribute string — where
|is legal.cmd=powershell -enc AAA | iexreached detection as
cmd=powershell -enc AAA, and asev=5following it was lost outright.
The half a rule reads is the half past the pipe, so this was silent
evidence loss on the syslog ingest path rather than a formatting nit.The sibling CEF parser on the HTTP route already re-joined its extension
under a comment naming this exact hazard; the syslog LEEF path missed it.
splitEscaped's own doc comment promised "at mostlimitfields" when it
returns at mostlimit+1, which is how the off-by-one came to be written,
and now states the separator semantics instead.Found while resolving CodeQL
go/index-out-of-boundsatkv.go:125, which
was itself a false positive — the flagged read was guarded by
len(fields) >= 7inside a taglessswitchcase the query does not model,
proven by walking every one-byte truncation of four real CEF/LEEF lines
through the parser without a panic. The alert is dismissed as such; the
truncation bug it led to is the real defect. -
The offline sandbox read two spellings of "timestamp" and silently
computed nothing for the rest. Found by writing a payload the way a
stranger would: the same benign login as the previous report, timed with
"ts"instead of"published", returnednot_computableon every
time-based signal. The behaviour was honest — it named the missing input
rather than inventing a verdict — but
_parse_timestamp(event.get("published") or event.get("timestamp"))
accepted exactly two spellings while the actor reader accepted four and
the address reader four, which is backwards: a timestamp has more
ordinary spellings than an actor, not fewer. Measured over the spellings
a stranger would plausibly write, 13 of 63 probes passed. Since the
package is used by running it against your own alert file, that is the
difference between a tool that works and one that appears to do nothing.No existing test could have caught it, and that is the part worth
keeping: every bundled fixture sayspublished, so replaying the corpus
could only ever confirm thatpublishedworks. A corpus written in its
parser's own dialect cannot reveal a dialect gap.All field reads now go through one declared table,
FIELD_VOCABULARY,
covering event time (16 spellings, ISO-8601 or epoch), actor (14, plus 4
honoured only when nested), source address (13), city, country,
coordinates, domain age and destination. Actor, address and position are
also read through declared container objects up to three levels deep, so
the shapes Okta, Microsoft Entra and Elastic Common Schema actually ship
resolve without reshaping. Position now prefers coordinates the payload
carries over a city centroid: explicitlat/lonis not a weaker
input than the table but a strictly better one, while the table stays
narrow and still names a city it cannot resolve rather than substituting
a country centroid. 63 of 63 probes pass after.Widening was not allowed to buy a new confident answer, which took three
guards. Two events timed only to a calendar date both land on midnight,
so the elapsed time is zero and the implied speed infinite — without a
precision guard the sandbox reports "one actor was in two places at once"
from a payload that never carried an hour, proven by reverting the guard
alone and watching it fire. Event times are read from the top of the
event only, so a nesteduser.created_atcan never stand in for the time
of the event. And0,0, out-of-range coordinates and half a coordinate
pair are refused or fall back to the city table, never plotted. An
unrecognised spelling still returnsnot_computednaming the field.
Gated by a new vocabulary arm inscripts/check_sandbox_honesty.pythat
generates its fixtures from the vocabulary table itself, plus
test_field_vocabulary.py(134 cases). Signal output for all five
bundled scenarios is unchanged, byte for byte. -
The offline sandbox's verdict followed the label on the input file, not
the events. Reported by a community reviewer who fedaisoc-sandboxa
harmless login — same user, same address, New York both times, eight hours
apart, taggedT1078at severityhigh— and got back "the geo pivot
between sequential events is physically impossible", high confidence,
83/100. Relabelling genuine impossible-travel eventsinforeturned
"L4 — fully autonomous closure" and "auto-execute eligible". Every claim
reproduced againstmain, and the cause was visible in three signatures:
_confidence_band(*, severity, technique_count),_automation_tier(severity)
andexplain(*, technique)— none of the three decision functions could
see the events. The rationale came from a fixed table keyed on the MITRE
technique, soT1078always produced that sentence; 83 is
75 (high) + 4 x 2 techniques; and the tier was a dict keyed on severity,
so a self-declared label in an input file selected the autonomy posture.
Several canned rationales also asserted measurements nothing had taken —
a Welford-online baseline, a domain registration age, a file-extension
churn rate — and the class docstring named the goal outright: that a reader
"can't tell the rendered ledger apart at a glance" from the live demo. This
is the family the project deletes rather than rewords, so all of it is gone
rather than reworded.What replaces it:
aisoc_sandbox.signalscomputes what the event payload
genuinely allows — impossible travel is a great-circle distance over an
elapsed time, so the sandbox performs that division and prints it. The
reporter's benign payload now reports0.0 km apart, implied speed 0.0 km/hand says theT1078tag is not supported by anything computed
here; their relabelled payload still identifies the travel as impossible
from the arithmetic, and determines no tier at all. Everything the sandbox
cannot compute — confidence score, L0–L4 tier, approval posture,
related-case count, entity risk, hunt matches — is now an explicit
not_computedcarrying its reason, never a plausible figure and never a
zero (a hunt that did not run reportsunknown, since it looked nowhere
rather than finding nothing). Tool calls are markedexecuted: false; the
ruleset figure is derived fromcorpus-stats.jsonby
scripts/sync_sandbox_corpus_figures.pyinstead of the hand-typed"800+"
that had gone stale by a factor of three; and the synthetic-run notice
moved onto every decision line, because the reporter read the verdict
several screens below the banner. Guarded by
scripts/check_sandbox_honesty.py, which also refuses the shape — a
table mapping a technique id or a severity name to a sentence or a score —
and which reports 222 problems against the pre-fix tree and 0 after.
Thanks to the reporter for a careful, well-scoped report that was right on
every count, including about what they had not tested.
Added
-
A CNAPP's findings reach a verdict as context about the resource, not as
more alerts (depth plan wave 2, item 8.1). The Wiz connector read
issuesand nothing else; it now also reads vulnerability findings,
configuration findings and runtime detections, each off until the tenant
enables it, and none of them becomes an alert.What was absent, and it was not the connector.
posture_findingshas
shipped since migration017with RLS, six indices, a REST surface and a
compliance-evidence mapper, and its only writer in the whole tree was
POST /posture/findings— a route a human calls by hand. No connector, no
scanner and no scheduler had ever written a row.posture_scan_runshad no
writer at all. A module-reachability gate passes on both, because the code
does run; what it reads is a table nothing fills.So the measurable consequence was a confident zero:
GET /posture/summary
counted an empty table and answeredtotal: 0, critical: 0on every
deployment, which says "your cloud estate is clean" about an estate nobody
has looked at. The summary now carriescollected, derived from a run row
the collector writes on every poll including a poll that found nothing,
and returns null rather than0when nothing has collected. The same
distinction reaches the prompt: a tenant with no CNAPP gets no posture
block at all rather than a line saying the resource has no findings, which
a model would reasonably read as exculpatory.Where each class lands is the design. Vulnerabilities go to
asset_vulnerabilitiesthrough thefetch_vulnerability_findingshook
that already existed and was implemented by two connectors — a second home
for per-asset CVE state would be a second answer to "are we exposed".
Configuration findings and runtime detections go toposture_findings,
which a verdict queries by resource. Matching is an array overlap over
every identifier a resource answers to, because an alert knows a bucket by
its ARN while the CNAPP knows it by its own graph id and a display name.Read through Postgres rather than the graph, deliberately: the five
incident-context dimensions are 100% Neo4j, which is afull-profile
service, so a posture finding that only reached a verdict there would be a
capability most deployments do not have, described as one they do.Secrets are refused rather than built. Wiz detects exposed secrets, but
no public reference documents a top-level secrets query the way it
documents the other three, and writing one from the product's marketing
surface would be inventing an endpoint. The three queries that did ship
were verified against two independently maintained, shipped third-party
integrations that drive the same shapes.One vendor quirk worth recording: Wiz applies a default type filter of
GENERATED_THREATthe moment any filter is sent, silently dropping
MATCH_ONLYdetections — the weak signals the read exists to supply. Both
types are named explicitly and a test asserts it on the request, because
a tenant missing the filter still gets rows, just the wrong subset.Proven live: eight cases against real Postgres as the DML-only
aisoc_app
role, with a negative control that makes a re-poll resetfirst_detected_at
and requires the suite to go red. A sixth channel was added to the
injection scan, because a cloud resource name is chosen by whoever created
the resource.apps/docs/docs/connectors/cloud-security-depth.mdrecords
the same depth check across all five registered cloud-security connectors,
naming six further gaps and the one refusal. -
ExtraHop RevealX 360 network detections, with the vendor's own risk
bands intact (depth plan wave 2, item 8.2). Detections arrive as alerts
on a schedule, and two read-only verbs --lookup_network_flowsand
lookup_network_device-- let an investigation pull the flows and the
device record around one address.What was absent: no NDR connector beyond Zeek/Suricata and Darktrace. The
reproduction had two halves, because this is an item that can be wired
wrong in two places. The connector half was an import error. The ingest
half was quieter and worse: with noconnectorProfilesentry the
normalizer logsUsing generic profile for unknown connector, files the
event atclass_uid: 4001, andshould_promote()then drops every
mid-band detection. The connector would have polled successfully,
reported healthy and produced an empty queue.This connector never emits
critical, deliberately. ExtraHop
publishes three risk bands and no fourth; from the vendor's own
documentation the score is "color coded by severity as red (80-99),
orange (31-79), or yellow (1-30)". Promoting the top band would assert a
tier the vendor does not publish, which is the same defect as collapsing
a vendor's realcriticalintohigh, in the other direction. Nothing
is lost: these are OCSF Security Findings at category 2, which promote
regardless of severity.A read that could not happen is not an empty result. RevealX 360 record
search needs a cloud recordstore with Premium Investigation, and a
deployment without one gets a refusal naming the reason rather than a
list of no flows -- because an investigation reporting an address was
quiet when nothing was ever searched has stated a fact it did not
establish.The gate that keeps it fixed is the ingest profile test, proven against
the pre-fix tree: removing the profile fails all three assertions and the
normalizer logs the generic-profile warning again.Not built: Corelight. Its documentation answers 401, so no honest
mock payload can be written. Recorded as blocked with exactly what it
needs rather than substituting the Zeek-log connector that already
exists, which reads different data for a different purpose.
Fixed
-
The enrichment service's rate limit is applied (depth plan wave 2,
item 8.3, first half).RATE_LIMIT_RPSandRATE_LIMIT_BURSTwere parsed
into config, assigned to struct fields, and read by nothing else in the
service. That is worse than a missing setting, because an operator reading
the environment believed the service was bounded.A token bucket per tenant, applied on
/enrichand on/enrich/bulk,
with one token per item on the bulk path so a hundred-indicator call
cannot be the way around the limit. An unset rate means unlimited rather
than blocked: a malformed environment variable parses to 0, and reading
that as "allow nothing" would turn enrichment off across a deployment
with no message anywhere. A request with no tenant shares one bucket
rather than bypassing the limit.Six tests, every grant with a partner refusal, because a limiter asserted
only on the allowed path is indistinguishable from no limiter, which is
exactly what shipped.The enrichment cache key is now tenant-scoped as well. Two tenants
legitimately enable different providers, so a shared key would serve
tenant A's verdict from a provider tenant B switched off straight to
tenant B.
Added
-
Response reaches the cloud, SaaS and code-platform estate. The live
action surface covered hosts, user sessions, mail, network blocks, SIEM
and tickets, and stopped there: an AWS key in an attacker's hands, a
compromised GCP service account, a leaked GitHub token, a Slack or
Salesforce or Snowflake or 1Password account under someone else's
control, or a phishing page on a shared host all ended with "open a
ticket for the cloud team". Measured before the change by the new gate,
the tree carried 89 executor arms over 39 verbs; it now carries
151 over 60 verbs across 34 vendors, including AWS access-key
deactivation, role-session revocation keyed onaws:TokenIssueTime,
agentless instance quarantine and IAM-user containment; GCP and Entra
service-identity containment; Workspace, Entra and Okta OAuth-grant and
application-password revocation; GitHub member, deploy-key and workflow
containment plus credential revocation through GitHub's own revocation
API; Slack, Salesforce, Snowflake and 1Password user and session
containment; and single-URL blocks at Cloudflare Gateway, Zscaler and
Netskope. Each verb declares a capability contract, and the conservative
answer wins at verb level rather than the most capable vendor's:
revoke_tokendeclares no platform rollback because GitHub states a
revoked credential cannot be reactivated, even though GCP can re-enable
a key — which has its own verb an operator dispatches deliberately.
Verification is a recorded gap, not a claim: every client here has a
real read-back andPostActionVerifieris keyed onActionType, which
live-action capabilities do not have, so none of these verbs is
automatic at any confidence and the read-backs ship as dispatchable read
verbs instead. -
An arm count that cannot be quoted three ways.
scripts/check_executor_arm_count.pycounts by the declared rule —
class-levelcapability = "..."declarations under
services/actions/app/live_actions/— rather than the looser grep that
also matchesreverse_capabilityarguments and reports 22 arms that do
not exist. It cross-checks the declared set against
builtins._BUILTIN_ADAPTERSin both directions, so a class that
declares a capability and never registers cannot pad the headline while
answeringexecutor_not_foundat dispatch. The artefact at
docs/audit/executor-arms.jsonis generated, and a hand edit fails the
gate.make statsnow carries the line. -
A playbook can ask the model one bounded question and cannot be steered
into an action by the answer. A newask_modelstep asks a
multiple-choice question about the evidence and branches on it. The
answer set is closed and written by the playbook author; an answer
outside it takes a declared fallback branch, which is required, because
the case that matters is the one where the model does not decide. The
answer selects a key in the author's own branch map, so the model's text
never becomes a step id. It cannot call a verb, pinned three ways: it is
routed through the control-flow table rather than the handler table that
reaches the action bridge, an AST test asserts the module imports
nothing that can dispatch, and a tripwire test makes the model answer
with the name of a containment verb and watches the step decide nothing.
The step type is in sync across all five vocabularies the parity gate
reads. -
Time gates on automatic response. A tenant may declare when
automatic execution is acceptable — outside business hours, with nobody
on call, or during a change freeze — each opt-in, each applying from a
declared impact floor. The direction is fixed and asserted over every
impact and requirement the approval matrix emits: a schedule may only
raise AUTOMATIC to ANALYST and returns a decision that already requires
a human untouched. An on-call state the platform could not read counts
as nobody on call, because a failed rota lookup must not silently
re-enable containment at three in the morning. A tenant with no schedule
configured is byte-identically unaffected. -
Approval deadlines that do something. Until now every approval
behaved identically at its deadline: the action did not happen and
nothing else happened either, which for the step that isolates a host
believed to be exfiltrating is a decision nobody made on purpose. A step
may now declarestay_paused(the existing behaviour, chosen rather
than implied),rollback, or one named limited containment verb.
The named verb is graded by its own contract through the ordinary
governed path, so a timeout is not a tier promotion: a verb the tenant's
autonomy tier would not auto-execute queues here exactly as it would
anywhere else. -
AI-estate containment. The AI inventory could score a provider key's
exposure and nothing could act on it, so a key found in a public
repository was a finding with a recommendation and no verb. Fourteen
arms across OpenAI, Anthropic and an AI gateway now cover key
revocation, role demotion, workspace removal and spend caps where the
provider API offers them, with an approved kill-switch playbook
composing them. The three providers give three different answers to "can
this be undone" and the arms carry each honestly rather than claiming
the most capable vendor's.
Fixed
-
A vendor retry no longer reopens a closed case. Inbound ITSM sync
compared the mapped status to the current one with an exact equality, so
a case a human had closed in AiSOC, receiving an ordinary Jira
redelivery ofDone— which maps to the intermediateresolved— was
moved backwards out of its terminal state. No unusual sequence was
needed, only a close followed by a retry, and Jira retries up to five
times while ServiceNow retries until it gets a 2xx. Found by driving the
production handler end to end for the first time: four correct unit
tests could not see it because each mocks the next layer. The guard is
scoped to terminal states only, because an ITSM moving a ticket from
Resolved back to In Progress is a real transition this product should
mirror. -
HR and managed-device context, kept current by a connector on a
schedule (depth plan wave 2, item 1.3). Three new connectors --
BambooHR, Rippling and Microsoft Intune -- feed employment status, start
and last-day dates, manager, department, worker type, device owner,
compliance state, OS version, encryption and threat-defence agent state
into triage.What was absent, measured: 88 registered connectors and not one of them
HR or MDM, andimport_contextwith exactly one production caller, a
manual POST route. A tenant's HR context was only ever as current as the
last file somebody uploaded.The wiring is the half that makes it real. The connector scheduler calls
the workforce sync on every poll, in its owntry, modelled on the
vulnerability sync beside it: a context sync that fails must not cost the
poll its events.Migration 131 puts the context in Postgres so it exists on CORE. The graph
import stays and is richer, but Neo4j is afull-profile service, so on
the deploymentmake upproduces the HR dimension did not exist at all
and every triage input reading it was silently dead.Tenure, departing-within-30-days, contractor status and device compliance
are derived and cited in the confidence basis as well as rendered in the
prompt, because a fact in one and not the other is either invisible to a
reviewer or absent from the model. Every absence keeps its direction: a
missing start date is not a new joiner, a missing end date is not
"staying", an unmapped employment type is not an employee, and a device
the MDM never evaluated is not a compliant one.Data minimisation is in the request and in the schema rather than in a
filter. All three vendors return compensation, date of birth and home
address; none is requested, and migration 131 has no column that could
hold one. The BambooHR directory endpoint, which would have been the
obvious single read, is deliberately not used for the facts: its own
reference says it never includes employment status or history in any
configuration and excludes former employees entirely, which removes every
field this item needs and the whole population it exists to see.Not built: Workday and Kandji, recorded as blocked with exactly what
each needs rather than built against an invented payload shape.
Added
-
Anonymizer and hosting classes stamped on public addresses at ingest
(depth plan wave 2, item 1.6). An event's source address now carries
tor_exitorhosting_providerwhere a pinned local dataset has a record
for it, along with the dataset version that answered.What was absent: nothing in the tree classified an address at all. The
reproduction was a Go test driving the realNormalizeentry point, which
failed to compile becauseactivity.Locationhad no such field.How it works: the dataset is embedded in the ingest binary, so CORE and an
air-gapped install classify with no enrichment service and no network call
of any kind. It is built byscripts/fetch_ip_class_dataset.pyfrom the
Tor Project's own bulk exit list (CC BY 3.0 US) and from seven cloud
providers' own published range endpoints, with per-source provenance,
terms link and upstream digest recorded in the manifest. The snapshot is
21,726 records: 1,228tor_exitand 20,498hosting_provider.Three of the five classes ship with no records.
vpn,public_proxy
andresidential_proxyhave no redistributable source - the widely cited
community list carries no licence file at all, verified as a 404 on its
default branch - so they are tenant-supplied only and tenant-supplied
lists are not yet implemented. An unclassified address therefore means the
dataset had no entry and never that the address is ordinary: the column is
NULL, the rail renders nothing, and no surface says "not an anonymizer".
Reasoning and alternatives in ADR 0018.Carried end to end: three ClickHouse columns (fresh-volume DDL and lake
migration005_ip_classmoved together, because a column added to one
alone lands on new deployments and silently not on existing ones), two
alertscolumns (migration 130), the alert API response, and a rail
section that renders only when there is a class to show.The gate that keeps it fixed:
scripts/check_ip_class_dataset.pyruns the
Go classifier and the Python one over 400 sampled addresses and requires
identical answers. They answer in different places - Go stamps live events
at ingest, Python classifies committed fixtures during detection replay -
and if they disagreed, a rule matchingip_classwould pass its fixtures
and never fire on real traffic. A missing Go toolchain fails the gate
rather than reporting "not checked", because a gate that skips silently is
indistinguishable from one that passed.
Fixed
-
The only throughput gate a pull request runs is now derived from a
published figure (depth plan wave 2, item 8.4).perf.ymlasserted
--assert-floor 1000on the in-process fusion hot path, under a comment
claiming a ">200x margin below the measured number" — a number that
appeared on no page, so nobody could check either figure or say what
regression the gate would catch. The end-to-end job whose floors are
bound to the published page is nightly, so on a pull request this was the
only throughput assertion running at all.The harness was measured at 140,692 events/s and published with hardware,
date and commit; the floor moved to 7,000, a stated 20.1x. Two negative
controls: reverting the floor fails at 140.7x against a 25x ceiling, and
deleting the published section fails with the reason rather than passing
over an absent claim.The performance page also separated two gaps it had been conflating: no
cloud-hardware run and no managed-Kubernetes run are different missing
things, and thekindtable is neither of them. -
The Wiz connector's documented severity ladder was wrong. The page said
AiSOC collapses Wiz's five tiers into four withCRITICALmapping to
high; the connector has mappedCRITICALtocriticalall along. Wiz
was also the only one of the five cloud-security connectors shipping
without a marketplace manifest.
BREAKING
- Correlation grouping narrows on missing identifiers (the Changed
entry below). On upgrade, future alerts that carry no tactic group
per rule instead of per entity, and alerts with no identifiers at all
stop cross-rule merging entirely. Existing incidents are untouched;
the measured effect on a detection-shaped cohort is reduction moving
42.6% → 24.5% because unrelated alerts stop counting as grouped.
There is no API change in this release; the major marks this grouping
change plus the redefinition of published evaluation semantics
(serving-model provenance, full-cohort denominators, closure
contamination) that older scorecards do not carry.
Added
-
Serving-model attribution, end to end. Every published verdict-eval
row hadresolved_models: []— 72 calls placed, answered, and
unattributable, because the only serving-identity reader was the LiteLLM
gateway header and the measured runs talked to an OpenAI-compatible
endpoint directly. The extractor now reads the gateway header first
(verified) and the response body's ownmodelsecond
(self-reported), credited only with evidence it came from the body —
langchain falls back to the requested name when the body carries none,
and a requested alias is never copied into serving metadata. Scorecards
carry aprovenance_status(verified/self_reported/
unattributed/serving_mismatch/no_calls); a live run whose
serving identity mismatches the requested model is refused as that
model's performance and preserved as a diagnostic; the benchmark table
gained an Attribution column with the five historical rows reading
"unverified" rather than receiving invented attribution; and a measured
auto-closure precision can no longer be bound to a call whose serving
model no party vouched for — a clearing measurement over an unattributed
call now blocks instead of authorising. -
Full-cohort and closure accounting in the replay scorer. Selective
malicious recall silently dropped errored cases from its denominator; the
scorer now also publishes full-cohort recall over every labelled
malicious case with the four buckets that sum to it (caught, abstained,
errored, answered-as-negative), the four proposed-closure cuts
(malicious closure rate, closure contamination, benign closure coverage,
unknown-label share —closures_executedpinned at zero because replay
executes nothing), request reliability as five visible counts
(requested / attempted / completed / failed / unattempted), per-severity
segments, and per-source attribution counts. -
The reflex path reports its stages and its decision contract.
Auto-triage summaries, logs and replay decisions now carry named stage
timings (queue delay, business context, context fetch, decide,
verification, persist, escalate, approvals, writeback) plus a structured
decision contract — verdict, operational disposition, supporting and
contradictory decisive claims, groundedness, missing prerequisites, and
the escalation reason — assembled from signals that already ran, with
Nonefor a signal that never ran rather than an empty list pretending
the check happened. -
Retro-hunt rehearsal mode.
RETRO_HUNT_DRY_RUNruns every sweep
exactly as live (the warehouse scan still consumes the tenant's sweep
budget) and withholds every mutation at the write boundary inside
sweep_tenant: matches come back as recorded proposals, no alert opens,
no sighting row lands, and the dedup branch leaves its counters
untouched — so a re-hunt can be rehearsed over history with no ability
to touch production state. -
A live-Redis proof for the correlator, and the suite that was wired to
nothing.integration.ymlgains afusion-redis-livejob (keyed on
the existing spine filter) runningservices/fusion/tests/integration/
against a real server — window expiry, tenant boundaries, restart
continuity, per-rule fallback grouping and concurrent-creator
convergence — which also gives the windowed engine's claim-protocol
suite its first workflow. An all-skipped run is refused rather than
green. -
The verdict model matrix.
run_model_matrix.py --task verdict
grades the balanced corpus per model throughrun_verdict_eval.py
(still a thin collator defining no scoring), records each row's
configuration — pins, endpoint, prompt provenance, corpus digest,
provenance status, serving models — and the runtime in
comparable-but-unidentifying terms, and renders the constant-answer
baselines beside the table. The committed verdict scorecard gained the
deterministic-fallback baseline row: balanced accuracy exactly at the
0.250 constant floor, zero of 36 malicious cases caught — the rules
floor every measured model is read against. -
An annotated unsupported-claim measurement. Sixteen hand-annotated
(rationale, evidence, label) cases measurescore_claim_supportwith an
exactly-pinned confusion matrix (TP 7, FP 0, FN 1, TN 8), a recorded
known miss that must stay missed until the pins move with it, and the
annotation-independence limit stated where the number lives. The
measurement found and drove a real detector fix: the claim pattern
recognised "scheduled scan" while the support keys did not, so an alert
whose evidence recordedscheduled_scancould state the claim and still
be refused support. -
Agentmetry ingest template: AI coding-agent activity as an input
(GitHub Discussion #1577). Agentmetry
records the tool calls Claude Code, Cursor, Codex and Copilot make through
their own hooks and correlates them into ATT&CK/ATLAS-mapped detections;
its webhook sink posts one canonical JSON event per request, routine
activity and detections down one URL. The discussion asked whether
generic-json "should land" them — checked against the real template with
real captured events: they land, but severity flattens to Unknown on every
event including critical detections (generic-json reads a top-level
severity; theirs lives ataction.outcome/detection.severity),
every routine tool call is promoted to an alert (class 2001 is always
promoted — one busy agent is a queue flood), and titles, technique ids and
the event timestamp are lost. The bundledagentmetrytemplate fixes
exactly that: the template language gainsclass_field/class_map(one
URL, per-event-kind class: tool calls stay 6003 API Activity in the lake,
action.type: detectionroutes to 2001 Security Finding, always promoted)
andtechnique_fields(vendor-supplied ATT&CK ids carried as supplied
through the samemitre_attckblock the connector path emits, shared via
the newly exportedEnrichTechniqueIDs/TechniqueIDsFromPaths; ATLAS
AML.T****ids are preserved in evidence fields and refused from
ATT&CK-typed ones, matching Agentmetry's own warning). The five-tier
severity ladder survives end to end — critical maps to its own tier,
never high. Agentmetry-observed coding agents feed the AI-estate
inventory and graph (agentmetryjoins theai-runtime/ai-finding
source-type branch in both consumers), the template is mintable from the
console catalog, and the docs page states plainly what was verified
against captured events versus what remains unexercised live. Also fixes
theai-estate.mdtable row that claimedai-findingis class 6003 —
the template is and was 2001. -
Asset criticality reaches fusion confidence and action approval —
tighten-only. Fusion stamps what each alert landed on at fuse time
(enrichments["asset_context"], resolved from the tenant's ownassets
inventory by name/FQDN/IP with the highest criticality winning) and the
confidence scorer gains a boundedasset_criticalityfactor (weight 0.06,
weights rebalanced to keep summing to 1.0) — an absent stamp contributes
exactly 0.0 and the rationale row saysunknown (no inventory match)
rather than being omitted, because "we do not know what this host is" is a
fact an analyst needs. On the response side,evaluate_contractgrades a
verb one impact rank higher when the target asset is critical/high in the
tenant's inventory — never lower, with two deliberate non-raises:
READ_ONLY stays READ_ONLY (a read against a domain controller is still a
read) and SEVERE never becomes IRREVERSIBLE (context can demand a human,
it cannot make an undoable action undoable). The positive control is the
point: unknown criticality grades every verb identically, so a deployment
with no CMDB loses nothing. Both approval doors thread the resolution;
the console's vendored copy stays byte-identical. -
Business context reaches the triage model, and impact statements must
cite it. The business-context applier's result used to die in the
worker's local variable: a tenantset_severitymutated the alert
silently, the model explained a severity nobody chose in the evidence,
and the persisted verdict carried no record of which rules fired. The
triage prompt now names the rules that fired and the mutation they made;
the verdict may carry one optionalbusiness_impactsentence whose
citations must resolve to those rule ids (uncited or fabricated elements
are dropped and counted, never rendered — and the instruction is injected
only when context exists, so an uninformed model never sees the element's
name); both travel to the ledger event and surface in the Investigation
Rail's new Business context section, which renders nothing when no
rule fired. Rule ids join the injection-scanned prompt channels. -
Asset criticality orders the investigation queue. The priority scorer
(severity as base, asset criticality / exploited-vulnerability / internet
exposure as bounded multipliers) existed with zero callers, so two alerts
of equal severity — one on a domain controller, one on a meeting-room
display — arrived in the order they were raised.build_queuenow
resolves each page against the tenant's ownassetsinventory in two
batched queries (hostname/FQDN/IP-overlap match;is_exploited AND NOT remediatedas the KEV signal) and orders within (bucket, SLA) by the
score. Every row carriespriority_scoreand a factor-by-factor
priority_basis; no inventory means severity alone, and the basis says
so. Proven on live Postgres with a negative control that removes the
resolver and watches the order collapse. -
An opt-in ack-clock escalation bridge (
services/escalations, compose
profileescalations; externally contributed). The native outbound-webhook
subsystem is complete but itsenqueue_eventhas no production callers, so
a CRITICAL case nobody acknowledged produced no notification at all. The
bridge watchesaisoc_cases.acknowledged_at: unacknowledged CRITICAL cases
get a Teams card after a grace period with capped re-nags, unacknowledged
HIGH cases arrive as one daily digest with a pipeline-health line, and
dedup/nag state survives restarts. Deployment-wide by design (one
operator-configured webhook; per-tenant routing stays the native
subsystem's job, into which this retires when the emitters are wired) and
the webhook must be https. The sweep's cross-tenant reads are recorded on
the tenant-predicate ratchet with that reasoning, the service is
SLO-exempt with its reason, and its status filter is pinned against the
case table's own CHECK constraint by test.
Changed
-
A missing identifier narrows the correlation group instead of widening
it. Neither detection engine has ever emittedmitre_tactics(the
ruleset carries technique ids only), so every detection alert's
correlation key fell back to the literalunknowntactic and all of an
entity's detection alerts collapsed into one incident per window;
entity-less alerts merged tenant-wide. The fallback now scopes to the
detection rule with an entity, never groups across rules without one,
and groups only exact fingerprint repeats with no identifiers at all.
Measured on a fixed detection-shaped cohort: 42.6 % reduction with 36
cross-rule incident groups before, 24.5 % with zero after — the honest
direction, because the difference was unrelated alerts counted as
grouped. The tactic-carrying headline cohort is unchanged at 33.3 %. The
correlator's creation race is closed withSET NX(concurrent first
arrivals converge on one incident instead of orphaning an alert); the
narrower merge/merge window is documented, not closed. -
Verdict scorecards disclose the model-knowledge limit. Evidence
cutoffs constrain supplied context only; each scorecard now records the
model's training cutoff when the operator states one andunknown
otherwise, with the disclosure that pretrained weights may postdate the
replayed events.
Fixed
-
The rail's business-context leg reads the event the writer actually
writes. Its query filteredkind LIKE 'auto_triage:%'while the ledger's
verdict INSERT hardcodeskind = 'triage_verdict'(theauto_triage:{tier}
string lives in theagentcolumn) — so the section could never render on
a real deployment while every suite stayed green, because the live test had
seeded the assumed shape rather than the writer's. Found by the end-to-end
QA slice (console rule row -> real worker -> real ledger -> rail), fixed,
and the literal is now pinned on both sides: the writer's recording-pool
test asserts the executed INSERT carries'triage_verdict'and the
business keys land in the payload, and the reader's live test seeds that
same literal. -
The context graph's business dimension authenticates. The bundle's
incident-context fetch sentX-Tenant-ID(a header the API's auth never
reads) with an optionalAISOC_AGENTS_API_KEYbearer that no compose
file,.env.exampleor Helm value delivers — so the graph's
identity/asset/cloud/business/threat dimensions answered 401 on every
default deployment and the prompt said "unavailable" forever. It now
presentsAISOC_AGENTS_SERVICE_TOKEN(orAISOC_SERVICE_TOKEN) with
X-AiSOC-Tenant-ID, and an unconfigured token refuses without dialing so
the dimension reads unavailable, never empty. A vestigial copy of the
dead credential block was removed from the investigation tool client. -
The rule builder could only author rules that never match. Every
field it suggested was prefixedalert.against engines that resolve
plain dotted paths (hostname,severity,raw_event.*), its starter
rule used an inventedtarget/timestructure, it offered aneq
operator neither engine implements (the term isne) — and the preview
endpoint manufactured a nestedalert.{target,time}shape so the
broken paths previewed as working and then never fired in production.
The suggestion list is now the fused alert's real vocabulary, pinned on
both sides (a web test and an api test naming the same literals), and
the preview sample is shaped exactly like the alert the worker evaluates
(raw_eventunder its real key, notmetadata).
Security
-
Dependencies: the Oct-31
minimatch/globadvisory wave worked
across all three npm lockfiles (root pnpm,apps/mobilepnpm,
services/realtimenpm). Both overrides are range-scoped to>=9.0.0,
which is the crux of the fix rather than a detail:minimatchfloors at
11.0.1 (resolves 11.0.3) for
GHSA-g3hv-75wg-m249
(CVE-2026-118764, medium — globparts-amplification ReDoS) andglobat
14.0.2 (resolves 14.0.3) for
GHSA-3g3m-2fjr-6pw4
(medium) — but the legacyglob@7.2.3(not vulnerable; <9) and its
minimatch@3.1.5are left in place, becauseglob@7 + minimatch@11is
broken (a blanket minimatch floor forced that pairing and broke
react-native 0.81's iOS codegen with acharAtTypeError). The
still-<11minimatchcopies that remain (3.1.5, 5.1.9) are all
lint/build tooling — eslint 9 and its plugins,@redocly/openapi-core,
glob@7via react-native/expo codegen,test-exclude,serve-handler—
none shipped in a runtime bundle, none fed attacker-controlled patterns,
and none upgradable without breaking the toolchain that pins them;
tracked for a tolerable-risk dismissal pending upstream support. Verified:
all three frozen installs pass andservices/realtime(the one runtime
service touched) builds clean onminimatch@11. -
Dependencies: the Oct-30 npm advisory wave cleared across both
lockfiles. Root:follow-redirectsfloored at 1.16.2
(GHSA-mrwp-f3q8-3g9p,
high) andjoiat 17.13.9
(GHSA-4528-x5fx-h6hg,
high) — both already carried overrides from earlier waves, so the existing
floors move rather than new keys landing (a duplicate key in
pnpm.overridesis silently discarded by last-key-wins, which is exactly
how a first attempt at this fix produced an unchanged lockfile). Mobile:
node-forgeoverridden to 1.4.1+ (resolves 1.4.2), clearing five high
and three low advisories
(GHSA-7wch-p9px-956x
et al., all fixed in 1.4.1). Published aftermain's last audit pass, so
they reddened the push-eventSecurity Auditat the v20.4.0 release
commit through no change of its own.
AI summary Security dependency updates
Security
- Dependencies:
graphql-corefloored at 3.3.1
(CVE-2026-119286,
high) andpyasn1at 0.6.5
(CVE-2026-119194
/ 119195 / 119196 / 119197, high) inservices/api. Both are
transitive —graphql-coreviastrawberry-graphql,pyasn1via the
SAML/crypto stack — so the floors are declared directly in the manifest
to keep the resolver off the vulnerable versions, andpoetry.lockmoves
only those two packages. Published aftermain's lastsecurity-audit
pass, so they reddened every open pull request through no change of its
own; cleared at the source here rather than suppressed per branch.
Fixed
- Activating SSO OIDC no longer locks the administrator out (reported in
discussion #1568).resolve_permissionsuses the static role map only while
a tenant holds zerouser_rolesgrants; the first SSO sign-in provisions a
user and grants it a role, which flips the tenant to database-backed RBAC,
and from that instant the bootstrap admin — created bybootstrap_admin.py
after migration 092's membership backfill, so the one account with
users.role = 'admin'and no grant — resolved to zero permissions and
every route answered 403 (users, investigations, the alert queue alike).
bootstrap_adminnow grants the admin itsadmincatalog role on every
startup, in an isolated session so it can never disturb admin creation, and
as a no-op when the catalog is unseeded. Because it runs on every startup it
also heals a deployment already locked out, on the next restart. The
resolver's deprovisioning semantics are unchanged and still separately
pinned; a live-Postgres test reproduces the lockout and proves the fix. - The alert-funnel's "events of interest" count queried a column the lake
does not have._events_of_interestfilteredaisoc.raw_eventson
ingested_at, which raised ClickHouseCode: 47, Missing columns: 'ingested_at'on every call (surfaced alongside #1568), so the funnel
silently served its Postgres fallback on every deployment with a reachable
lake. It now filters oningest_time— when the event landed, the column
usage_meteringalready counts arrivals by — with a test that checks the
query's filter columns against the committed ClickHouse DDL so any
non-existent column is caught, not only this one.
@ Every self-hosted release, weekly
One Monday email with the week's stable releases across the directory.
More in Security
AlarmoEasy to use alarm system integration for Home Assistant
altchaSelf-hosted, open-source CAPTCHA alternative that swaps image puzzles for a silent proof-of-work widget plus MIT-licensed server libraries for 10+ languages.
am-i-exposedam-i-exposed is a self-hosted, open-source Bitcoin privacy scanner running 34 client-side heuristics with Boltzmann entropy via WebAssembly.
amiuniqueSelf-hosted browser fingerprinting research platform collecting device fingerprints to study web tracking. Built with Play Framework and MySQL.
anondeAnonde is an open-source, self-hosted PII anonymization engine that tokenizes data before LLMs see it, restoring originals only in your environment.
AnubisWeighs the soul of incoming HTTP requests to stop AI crawlers- Apache HTTP ServerApache HTTP Server (httpd) is a fast, reliable, and extensible open-source web server for modern operating systems, supporting virtual hosts, reverse proxy, load balancing, TLS/SSL, HTTP/2, and dynamic module loading.
ArrakisOpen-source, self-hosted sandbox platform that runs AI agent code in isolated MicroVMs with snapshot-and-restore backtracking, a REST API and a Python SDK.
artifact-keeperSelf-hosted artifact registry with 45+ formats, security scanning, peer replication, Artifactory migration. MIT licensed, no feature gates or per-user fees.
auliteSelf-hosted HTTP proxy that checks AI interactions for EU AI Act compliance, records them in a tamper-proof audit log, and produces legal-grade PDF reports.
autheliaSelf-hosted, open-source IAM portal providing single sign-on, multi-factor authentication and an OpenID Certified OpenID Connect provider for proxied apps.
AuthorizerSelf-hosted open-source auth and authorization server: OAuth2/OIDC, social logins, magic links, MFA, passkeys, SAML SSO, RBAC plus embedded OpenFGA, on 13+ databases.




0 comments