Skip to content

AiSOC v23.1.0

Choose a tag to compare

@github-actions github-actions released this 10 Nov 20:13
· 167 commits to main since this release
0d547c1

Added

  • The first community detection rule: an AI agent's file tool reading a
    credential-bearing file.

    community-toufiqtoufiqbo-ai-agent-credential-file-read (high,
    application, T1552.001) matches the ai_runtime fields the
    aisoc-ai-sdk actually emits (tool_name, resource), names the files
    that hold long-lived credentials — id_rsa, .aws/credentials,
    /etc/shadow and their kin — and excludes public-key reads (*.pub,
    authorized_keys). Prompt-level secret scanning cannot see this path: the
    prompt is clean, and the disclosure happens on the way out — into the
    model context, a tool argument, or a second call. It ships
    enabled: false with a quarantine_reason, which is what the truth-table
    gate requires of a tier the engine does not load, with positive and
    negative fixtures alongside. The published counts follow: 7408 rules on
    disk, and the community tier moves 1 → 2. Contributed by @Toufiqtoufiqbo
    (#1804).

Fixed

  • The first make up on a fresh install built the schema and then refused
    to start the stack it had just built.
    The Postgres initdb hook
    (infra/postgres/initdb/10_apply_migrations.sh) applied the whole migration
    chain but recorded none of it, so to scripts/pending_migrations.py the
    database it produced — every table present, no aisoc_schema_migrations —
    read as behind the entire chain. make up's schema guard then stopped the
    very first run with "behind — 157 migration(s) pending" and sent the
    operator to make upgrade, which re-applied all ~160 files under strict
    mode. The hook now records each migration as it lands, in the same table the
    runtime runner (app.scripts.run_migrations) uses, so a fresh install reads
    as up to date, an interrupted chain leaves an accurate record of what did
    apply, and the first in-place upgrade starts from the truth instead of from
    zero. A live regression test boots a container with the repository's own
    init hooks mounted and asserts the detector's verdict — and CI executes it
    rather than skipping it: the docker guard is for machines without a
    daemon, and the merge's Python — Tests job ran it to a pass. Reported by
    @Dhanu188 on #353.

  • Datadog Cloud SIEM read 100 signals per poll and lost the rest.
    DatadogCloudSIEMConnector.fetch_alerts sent page[limit]=100 with
    sort=-timestamp and ignored meta.page.after, which Datadog documents as
    "the cursor used to get the next results" and its OpenAPI document declares as
    the x-pagination cursor for GET /api/v2/security_monitoring/signals. A poll
    window opens where the last one closed, so a window holding more than 100
    signals lost its oldest ones for good, and those are the start of whatever
    caused the burst. It now reads through read_token_pages, sending the cursor
    back as page[cursor] with the window, order and page size unchanged.
    read_token_pages gains empty_page_ends, off by default: Datadog's
    generated Python, Go and TypeScript clients all end this read on an empty page
    as well as on an absent cursor, so a cursor beside an empty page must not
    spend the page cap on a quiet window. Every existing caller keeps the rule that
    an empty page carrying a token is followed. MAX_UNCLASSIFIED falls from 54
    to 53. Contributed by @officialasishkumar (#1801).

  • make demo failed before seeding anything — the demo seeder wrote case
    statuses the schema refuses.
    The two random case makers in
    app.scripts.seed_demo drew from the pre-consolidation cases vocabulary
    ("open" / "in_progress" / "pending", 75% of the weighted draw), while
    migration 083 repointed the ORM Case model at aisoc_cases, whose CHECK
    constraint (migration 012) admits only the console's states. The first
    invalid case aborted the whole seed transaction, so nothing landed — not the
    catalogue, not the INC-RT-001 LockBit showcase the contributor guide tells
    newcomers to open. The makers now draw from app.services.case_status, and
    _alert_status_for_case keys on the live vocabulary instead of answering
    its default for every real status. New tests pin the seeder's vocabulary to
    the constants, the constants to the CHECK constraint text in migration 012,
    and the incident specs to both; verified live both ways against a
    schema-complete Postgres (unfixed: CheckViolationError on the first batch;
    fixed: 43 cases including INC-RT-001, only schema-valid statuses on disk).
    Reported by @Dhanu188 on #353.

  • Duo authentication logs read 100 entries per poll and lost the rest.
    DuoSecurityConnector.fetch_alerts read the first response of
    GET /admin/v2/logs/authentication and ignored metadata.next_offset. Duo
    documents that endpoint as a paged list, 100 entries by default, and says "to
    fetch all results, call repeatedly with the next_offset paging parameter as
    long as the result metadata has next_offset values". A poll window opens where
    the last one closed, so a window holding more than 100 authentications lost
    the rest for good. It now asks for Duo's documented maximum of 1,000 per page
    and follows next_offset, sent back as the timestamp and txid "separated by a
    comma" with the window unchanged and each page signed for its own parameters.
    A failed later page keeps what was read, the 25-page bound is announced when
    it binds, and a refused opening request still raises so the scheduler records
    a failed poll. MAX_UNCLASSIFIED falls from 53 to 52. Contributed by
    @officialasishkumar (#1802, carried as #1805).

  • The marketplace builder asserted enabled: false about rule files it
    never opened.
    build_marketplace.py's fallback quarantine_reason told
    every non-quarantined, non-executable row it was "disabled in the rule
    file (enabled: false)" — a claim reached precisely when the builder had
    not looked. The reason now names the real cause per tier, a rule file's
    own quarantine_reason still wins when it carries one, and a new test
    walks every published entry whose reason quotes enabled: false (99
    today), reads the rule file it cites, and fails if the flag disagrees — or
    if it ever ends up checking nothing. (#1804)

  • Five artefact generators' --check modes compared text that line-ending
    translation had already corrected.
    The marketplace, curation,
    corpus-stats, truth-table and llms generators wrote the platform's line
    endings and str(Path) separators, and their checks read in text mode —
    so a CRLF artefact and an LF template agreed with each other and the drift
    was invisible, while pnpm marketplace:curate --check could never pass on
    Windows at all (601 backslashed paths, rewritten on every regenerate).
    Every artefact write is now explicit \n with .as_posix() manifest
    paths, and the checks compare bytes and reject b"\r". (#1804)

  • Every in-run IOC enrichment failed during a deep investigation. The
    investigator's enrich_ioc tool defaulted to http://enrichment:8080 —
    the host-published port, not the 8082 the enrichment service listens on
    inside the compose network — and posted type where POST /enrich
    requires ioc_type. The agents service sets no ENRICHMENT_SERVICE_URL
    override in compose, so the broken default is what ran: every
    investigation IOC enrichment raised "All connection attempts failed" and
    the case recorded "IP enrichment failed", while fusion, which pins the
    correct URL, enriched the same IP correctly. The tool now defaults to
    :8082 like the two other in-process consumers and sends ioc_type,
    pinned by a respx test that drives the module's default URL against the
    real /enrich contract and fails on either the old port or the old field
    name. Contributed by @43n51c (#1806).

  • A federated Splunk search against a self-hosted index returned nothing
    useful.
    SplunkConnector.query kept the configured saved_search whole
    when it began with index=, so index=main — the common self-hosted case
    — rendered as search index=index=main …, which Splunk parses as a
    literal and answers with zero rows; a connector on the default notable
    index was unaffected, which is why it slipped through. And the SPL
    translator emitted no field projection, so even matching events came back
    carrying only Splunk's default fields, missing the signature / src_ip
    / dest_ip-class fields the pivot exists to show. The index= prefix is
    now stripped before the name reaches to_spl (falling back to notable
    only when none is configured), and the rendered SPL appends | fields *
    before | head N. Both halves are pinned by tests that fail on the
    pre-fix tree. Contributed by @43n51c (#1807).

  • The Hello, hunt tutorial claimed community rules are replay-graded; they
    are not.
    scripts/validate_detections.py replays fixtures only for
    native-tier rules (the ones with a compiled spec) — community-tier fixtures
    ship alongside the rule and are first replayed at promotion. The tutorial's
    enabled bullet now says exactly that instead of promising a grading that
    never runs at that tier.

Security

  • The Splunk connector validates the operator-supplied index= token
    before splicing it into SPL.
    Both ad-hoc search paths — _dispatch() on
    the polling side and query() on the federated side — strip index= from
    the configured saved_search and interpolated the remainder unquoted, so a
    value like main | collect index=other dispatched a two-stage pipeline the
    configuration never meant to write. Not exploitable across a trust boundary
    (the operator holds the Splunk token already), but nothing downstream
    re-validated, so the connector now holds the same line the AQL translator
    holds: a token outside [A-Za-z0-9_*:-] falls back to the default
    notable index with a warning naming the rejected value. Wildcards,
    cluster prefixes, underscores and dashes pass through unchanged, pinned by
    tests on both paths.

Documentation

  • The Wazuh guide said the connection test needs no cluster permissions;
    it calls GET /_cluster/health.
    The connector page now documents the
    minimal cluster:monitor/health permission and the Indexer role-mapping
    steps that grant it, notes that the default cluster_composite_ops_ro
    does not include health monitoring, explains the 401/403 error message the
    two causes share, adds a CA-verified cURL probe, and says plainly that a
    successful health probe does not prove alert-index search permission.
    Contributed by @knowlet (#1800).

  • The Hello, hunt tutorial told contributors to ship community rules
    enabled: true — the one thing detection_truth_table.py --check
    rejects.
    Nothing loads a community rule into the compiled set, so the
    tutorial's claim that community rules run in production by default was
    false on both halves. The enabled bullet now says what the gate
    enforces: enabled: false plus a quarantine_reason naming what
    promotion would take. (#1804)