Back to glossary

Security Information and Event Management (SIEM)

SIEM is a platform that collects, normalizes, and correlates security logs across an environment to detect, investigate, and report on threats.

Also known as Security Incident and Event Management, SIEM tool, SIEM platform

Security Information and Event Management (SIEM) is a platform that collects logs and security events from across an environment, normalizes them into a common schema, and runs detection rules over the stream to raise alerts and support investigations. A SIEM turns millions of unrelated log lines into a short queue of incidents a person can triage.

SIEM is sometimes expanded as Security Incident and Event Management; that is the same product category. The term merges two older ones: security information management (SIM), which meant long-term storage and reporting on logs, and security event management (SEM), which meant real-time correlation and alerting.

The most important fact about a SIEM is that it only knows what its log sources tell it. That limit matters most in software supply chain attacks. The decisive event, a package install that runs attacker code, usually happens on a developer laptop or a CI runner that ships few logs anywhere, and the malware is written to look like ordinary package traffic. Our position: a SIEM is essential for scoping and responding to a supply chain incident, but it cannot be the control that stops one. Malicious dependencies have to be blocked before install, and package-level intelligence has to flow into the SIEM so it can answer the first question of every such incident: which of our machines ran it?

What is SIEM in cybersecurity?

#

SIEM in cybersecurity is the central system a security operations center (SOC) uses to see, search, and alert on activity across the whole environment. ASD's Australian Cyber Security Centre describes a SIEM as a platform that "collects, centralises, and analyses log data from sources within a network or system" (source).

A SIEM does three jobs. It detects: rules and models fire when a pattern of events looks like an attack. It investigates: analysts search months of normalized history to reconstruct what happened during incident response. It proves: retention and reporting give auditors evidence for compliance frameworks that require log review, such as PCI DSS.

Government guidance treats SIEM as baseline infrastructure. On May 27, 2025, the NSA, CISA, the FBI, ASD's ACSC, and agencies from Canada, the UK, New Zealand, Japan, South Korea, the Czech Republic, and Singapore jointly published three SIEM and SOAR guides, including a list of priority logs to ingest. The categories it names are endpoint detection and response (EDR) tools, Windows and Linux hosts, network devices, and cloud environments. Package managers and build systems, where supply chain attacks execute, are not a category of their own.

How a SIEM works: from log line to alert

#

A SIEM is a pipeline with five stages. Each stage exists because the stage before it produces data that is too raw to act on.

Log sources

Hosts: agents, event logs Network: syslog, Zeek Identity & cloud: APIs Webhooks, e.g. Socket alerts Build runners & package managers: not a priority-log category
1

Collect

Agents tail files, devices send syslog, services are pulled by API or push webhooks. A host without a source does not exist to the SIEM.

2

Parse & normalize

Vendor fields map to one schema: id.orig_h → src, qtype_name → record_type.

3

Store & index

Hot window for fast search, cheaper tier after. Cost tracks volume: Microsoft Sentinel bills per GB.

4

Detect

Single-event rules, cross-source correlation over time windows, behavioral baselines (UEBA).

5

Alert & respond

Alert with context goes to the analyst queue; a SOAR playbook may isolate a host or disable an account.

The figure shows five kinds of log source feeding the pipeline: hosts through agents and event logs, the network through syslog and sensors such as Zeek, identity providers and cloud services through APIs, and webhooks such as Socket alerts. A fifth, dashed source, build runners and package managers, is marked as absent from the joint guidance's priority-log categories. Events then pass through five stages in order: collect, parse and normalize, store and index, detect, and alert and respond. Each stage is described below.

Collection. Agents on hosts tail files and Windows event channels, network devices send syslog, and cloud services are pulled through APIs or pushed through webhooks. Collection is where coverage is won or lost. A host without an agent does not exist to the SIEM.

Parsing and normalization. Every source has its own format. Zeek, a common network sensor, writes a DNS lookup like this (illustrative values):

JSON
{"ts":1762700001.21,"uid":"C4J4Th3PJpwUYZZ6gc","id.orig_h":"10.20.4.17","id.orig_p":53211,"id.resp_h":"10.20.0.2","id.resp_p":53,"proto":"udp","query":"dnslog-cdn-images.freemyip.com","qtype_name":"TXT","rcode_name":"NOERROR"}

The SIEM maps those vendor fields onto a shared schema, so one rule works across every DNS source. In Splunk's Common Information Model, id.orig_h becomes src, query stays query, and qtype_name becomes record_type. A Windows DNS client log, a firewall log, and a resolver log that all describe the same lookup now share field names.

Storage and indexing. Normalized events are indexed for fast search over a hot window and moved to cheaper storage after that. Storage is where SIEM economics bite. Microsoft Sentinel bills analytics-tier data per gigabyte, and its commitment tiers start at 100 GB per day (Microsoft Learn). Volume pricing forces teams to rank log sources, and build infrastructure has to compete for that budget with domain controllers and firewalls.

Detection. Rules run against the normalized stream. Simple rules match one event. Correlation rules join events across sources and time, for example a DNS lookup followed by an outbound connection from the same host within 60 seconds. Many SIEMs add behavioral baselines (often called UEBA, user and entity behavior analytics) that score deviations from normal.

Alerting and response. A match becomes an alert with context attached, lands in an analyst queue, and may trigger a SOAR (security orchestration, automation, and response) playbook that isolates a host or disables an account.

A detection rule you can run

#

Many teams write detection rules once in Sigma, a vendor-neutral YAML format, and compile them to each SIEM's query language. This rule catches the DNS beacon from the shopsprint/decimal Go typosquat, a malicious copy of github.com/shopspring/decimal that our threat research team disclosed in May 2026:

YAML
title: DNS TXT beacon from shopsprint/decimal Go typosquat
status: experimental
description: github.com/shopsprint/decimal v1.3.3 polls this TXT record every five minutes and executes the answer.
references:
    - https://socket.dev/blog/popular-go-decimal-library-typosquat-dns-backdoor
logsource:
    category: dns
detection:
    selection:
        query|endswith: 'dnslog-cdn-images.freemyip.com'
        record_type: 'TXT'
    condition: selection
level: high
tags:
    - attack.t1071.004
    - attack.t1195.002

Compiling it with pySigma 2.0.3 and its Splunk and Kusto backends produces queries for Splunk and Microsoft Sentinel:

Python
from sigma.collection import SigmaCollection
from sigma.backends.splunk import SplunkBackend
from sigma.backends.kusto import KustoBackend

rules = SigmaCollection.from_yaml(open("shopsprint_dns.yml").read())
print(SplunkBackend().convert(rules)[0])
print(KustoBackend().convert(rules)[0])
Shell Session
$ python3 compile.py
query="*dnslog-cdn-images.freemyip.com" record_type="TXT"
query endswith "dnslog-cdn-images.freemyip.com" and record_type =~ "TXT"

The rule is precise because the indicator of compromise is precise. The malicious init() function polls that hostname every five minutes and passes each TXT answer to exec.Command. Socket's write-up recommends exactly this control: "A single TXT query from a build agent or production host is a high-confidence indicator." The rule only fires, though, if the build agent's DNS traffic reaches the SIEM at all.

What is an example of a SIEM tool?

#

Examples of SIEM tools include Splunk Enterprise Security, Microsoft Sentinel, Google Security Operations, IBM QRadar, Elastic Security, Sumo Logic, Panther, and the open source Wazuh. As of November 2026, the main options look like this:

SIEMDetection or query languageDeploymentNotes
Splunk Enterprise SecuritySPLSelf-hosted or cloudOwned by Cisco since March 2024
Microsoft SentinelKQLAzure cloudBilled per GB ingested, with free ingestion for some Microsoft sources
Google Security OperationsYARA-L 2.0Google cloudFormerly Chronicle
IBM QRadarAQLOn-premises; SaaS sold to Palo Alto NetworksSaaS customers are offered migration to Cortex XSIAM
Elastic SecurityKQL, EQL, ES|QLSelf-hosted or cloudBuilt on Elasticsearch
Sumo LogicSumo Logic query languageCloudCloud-native log analytics
PantherPython detections, SQLCloudDetections as code
WazuhRules in XMLSelf-hostedOpen source, mostly GPLv2

The market has consolidated fast. Cisco closed its roughly $28 billion acquisition of Splunk on March 18, 2024 (Cisco), and Palo Alto Networks closed its purchase of IBM's QRadar SaaS assets on September 4, 2024 (Dark Reading). At the other end, Wazuh describes itself as "Unified XDR and SIEM protection" and is free to self-host.

The query language matters more than the logo. Your detection engineers will write and maintain hundreds of rules in it, which is why Sigma-style portability is worth adopting early.

How SIEM differs from log management, SOAR, EDR, and XDR

#

SIEM overlaps with several adjacent categories, and vendors blur the lines on purpose. The distinction that holds up is where each tool sits relative to the event: before it, during it, or after it.

DimensionLog managementSIEMSOAREDR / XDRPre-install package scanning
Primary jobStore and search logsCorrelate events across sources, alertAutomate response playbooksWatch and contain endpointsBlock malicious dependencies
SeesWhatever ships to itWhatever ships to it, normalizedSIEM and tool alertsProcesses, files, network on enrolled hostsPackage contents, metadata, install scripts
ActsNeverAlertsIsolates, disables, ticketsKills processes, isolates hostsRefuses the install
Timing vs. a malicious installAfterAfterAfterDuring, if the host is enrolledBefore
Blind spotNo detection logicUnlogged hosts, look-alike trafficOnly as good as its triggersUnenrolled laptops and ephemeral CI runnersRuntime behavior of code it allowed

Verdict. Use a SIEM as the system of record for detection and investigation across the estate. Pair it with SOAR when alert volume outgrows your analysts. Use EDR or XDR for endpoint depth, and enroll CI runners, not just laptops. For open source dependencies, put the control before install, because every other column on this table sees a malicious package only after its code has run.

Why do SIEMs miss software supply chain attacks?

#

SIEMs miss software supply chain attacks because the attack executes inside trusted tooling, on hosts that often send no logs, using traffic designed to look normal. The axios compromise of March 2026 shows each failure in turn.

On March 30, 2026 at 23:59:12 UTC, an attacker published plain-crypto-js@4.2.1 to npm and then published axios@1.14.1 and axios@0.30.4 with it as a new dependency. Socket's scanner flagged the malicious package within six minutes, at 00:05:41 UTC. Any project resolving a caret range like ^1.14.0 without a lockfile could pull it in. A postinstall script then ran setup.js, which fetched platform-specific second-stage payloads, including a remote access trojan, and then cleaned up after itself. That path existed because npm ran lifecycle scripts by default. npm v12, released in July 2026, makes install scripts opt-in, which closes it for teams that upgrade; runners pinned to older npm versions, and projects that allowlist scripts, still have it.

Attack stepTypical SIEM sees

  1. Publish. plain-crypto-js@4.2.1 at 23:59:12 UTC, Mar 30, 2026, then axios@1.14.1 and axios@0.30.4

    ✕ Nothing
  2. Socket flags it within six minutes, 00:05:41 UTC. An alert webhook reaches the SIEM only if integrated.

    ◐ If integrated
  3. Resolve. npx or a fresh install in CI resolves ^1.x to axios@1.14.1. No lockfile entry.

    ✕ Nothing
  4. Execute. postinstall runs node setup.js

    ◐ Only with EDR
  5. Beacon. POST body packages.npm.org/product2 to sfrclak[.]com:8000, built to read as npm traffic

    ◐ Proxy logs, disguised
  6. Clean up. setup.js deletes itself; package.md becomes package.json

    ✕ Nothing

Walk the attack through a typical SIEM's log sources:

StepWhat happenedWhat a typical SIEM sees
1. Publishplain-crypto-js@4.2.1 and two axios versions reach npmNothing. Registry events are not a SIEM log source.
1b. Upstream detectionSocket flags plain-crypto-js@4.2.1 at 00:05:41 UTCOnly if Socket alerts are integrated as a log source.
2. Resolvenpx or a fresh npm install in CI resolves ^1.x to axios@1.14.1Nothing. npm writes its debug log to the runner's disk, and the runner is destroyed after the job.
3. Executenpm runs the postinstall hook: node setup.jsOnly if EDR is installed on the runner image.
4. Beaconcurl POSTs packages.npm.org/product2 to sfrclak[.]com:8000Possibly, via proxy or firewall logs. The body is built to read as npm traffic.
5. Clean upsetup.js deletes itself and swaps package.md in as package.jsonNothing. The evidence a responder would look for in node_modules is gone.

Three structural problems explain that table.

The install host is unmonitored. CI runners are ephemeral by design. They are created, run one job with powerful credentials, and are destroyed when it ends. Unless an agent is baked into the runner image and ships logs in real time, the evidence leaves with the runner. Our analysis of the axios blast radius found a CI pipeline that ran a CLI through npx, pulled the malicious dependency transitively, and produced command-and-control traffic during a build step. The package never appeared in the project's lockfile, so a lockfile audit afterward would have shown nothing.

The traffic is camouflaged. The axios payload sent packages.npm.org/productN as its POST body. npm.org is not the npm registry, which lives at registry.npmjs.org. Our write-up notes the naming is deliberate: SIEM rules that log request bodies "will see what looks like routine npm registry traffic at a glance." The shopsprint backdoor goes further and uses DNS TXT lookups as its command and control channel, because outbound DNS from developer machines is rarely inspected.

The persistence is the dependency. EDR and SIEM content is full of persistence detections: new services, scheduled tasks, launch agents, registry run keys. The shopsprint payload needs none of them. Its init() function runs every time any binary that imports the module starts. Socket's analysis puts it plainly: "The persistence mechanism is the dependency itself." The malicious version was live from August 19, 2023 until disclosure, roughly 33 months, and the legitimate module it imitated had 38,634 known importers on pkg.go.dev at disclosure.

Even a perfectly instrumented SIEM leaves responders inferring. As our axios follow-up put it, "Even with perfect logs, you are often reconstructing behavior indirectly."

How do you get open source supply chain signals into a SIEM?

#

You get supply chain signals into a SIEM by adding package-level data as a log source, so dependency events can be correlated with host, network, and identity events. Socket exposes four paths, all documented publicly as of November 2026.

Alert webhooks. Socket sends alert:created, alert:updated, and alert:cleared events as signed HTTP POSTs (docs), available on Business and Enterprise plans. Each event carries a stable alert ID and the affected repositories, so a SIEM can join "malicious package added to repo X" with "build host for repo X resolved a suspicious domain." Organizations with the threat feed entitlement can also subscribe to threat-feed:* and campaign:* events and treat them as threat intelligence. The envelope follows the Standard Webhooks shape:

JSON
{
  "type": "alert:updated",
  "eventId": "SOCKET-DUMMY-2751@5",
  "schemaType": "alert@1",
  "data": { "alert": { ... }, "organization": { ... } },
  "timestamp": "2025-11-19T20:53:53.148713Z"
}

Verify the x-webhook-signature header before forwarding anything to your SIEM. The header is t=<timestamp>,s=<signature>, where the signature is a base64 HMAC-SHA256 of <timestamp>.<raw body> keyed with your whsec_ signing secret:

JavaScript
import { createHmac, timingSafeEqual } from "node:crypto";

// header: "t=<timestamp>,s=<base64 HMAC-SHA256 of `${t}.${rawBody}`>"
export function verify(rawBody, header, secret) {
  const [t, sig] = header.split(",").map((p) => p.slice(2));
  const expected = createHmac("sha256", secret).update(`${t}.${rawBody}`).digest("base64");
  const a = Buffer.from(sig), b = Buffer.from(expected);
  return a.length === b.length && timingSafeEqual(a, b);
}

Hash the raw request bytes, not re-serialized JSON, or valid signatures will fail. The length check matters too: Node's timingSafeEqual throws on buffers of different lengths, so without it a malformed header becomes an exception instead of a rejection.

Data Exports. Since April 2026, Enterprise organizations can have Socket write alert data daily to an S3, Google Cloud Storage, or Azure Blob bucket in JSON, CSV, or Parquet, as a full snapshot or an incremental diff (announcement). Most SIEMs can ingest from object storage, which makes this the low-maintenance path.

Audit log API. GET /v0/orgs/{org_slug}/audit-log returns organization activity such as API token creation, member changes, and policy updates, filterable by event type and requiring the audit-log:list scope, on Enterprise plans (reference). This is the source for detecting someone weakening your dependency policy.

The open source connector. socket-siem-connector pulls issues from Socket reports and pushes them to Microsoft Sentinel, Sumo Logic, Elasticsearch, Panther, BigQuery, or a generic webhook.

None of these paths fix the timing problem. A SIEM that receives a Socket alert still learns about a malicious package after someone added it. The value is correlation and scoping: knowing within minutes which repositories, branches, and hosts touched a package, instead of grepping lockfiles across the company during an incident.

Where SIEM stops and prevention has to start

#

A SIEM answers "what happened, where, and when." For most attack classes that is enough, because there is time between initial access and damage for a correlation rule to fire. Install-time supply chain attacks collapse that window. In the axios case, the payload ran during npm install with access to everything the runner could reach, and the dropper erased its own install script before the job ended.

That is why we put the primary control in front of the install. A package firewall or pre-install scan that refuses a known-malicious or newly suspicious version prevents the event the SIEM would otherwise be reconstructing. It has its own blind spot: it judges packages, not the runtime behavior of code it allowed. That gap is the SIEM's job.

The open problem is the one shopsprint exposed. When the persistence mechanism is a line in go.mod or package.json, no endpoint rule will find it, and none of the default log sources a SIEM ingests records it. Until dependency graphs are treated as security telemetry, with every resolve on every runner logged like an authentication event, the SIEM will keep seeing typosquatting and hijacked releases only through their side effects.