Formats and normalization
On this page
Parsing has to live with the formats it gets. Four families dominate enterprise telemetry, each with its own conventions, gaps, and gotchas. Normalization is the layer that gives all of them one queryable shape.
This page covers the plumbing under the behavioral surfaces: the formats telemetry arrives in, the platform sources that generate it, and the normalization that makes it all queryable as one dataset. It is not a surface of adversary behavior. It is the layer that determines whether you can read the surfaces at all.
The four format families
Windows Event Logs (EVTX)
Windows writes structured records to log channels (Security, System, Application, and many subscribed providers) using the EVTX file format. Each record has a numeric Event ID Event ID A short integer that identifies what kind of event the record describes. Windows publishes a catalog of event IDs (4624 for a successful logon, 4688 for a process creation, and so on). Within a provider the same ID always means the same kind of event, which is what makes EVTX queryable; across providers IDs collide (Event ID 1 is process creation in Sysmon but a system-time change from Kernel-General in the System log), so always read the ID together with its channel and provider. Different providers also use different IDs for the same thing: Sysmon 1 and Security 4688 both record process creation. identifying what happened. Triage tooling parses the relevant IDs into structured fields.
Common IDs an analyst will read:
- Process events: 4688 (creation), 4689 (termination)
- Authentication: 4624 (successful logon), 4625 (failed logon), 4768/4769 (Kerberos ticket requests)
- Privileged logon: 4672 (special privileges assigned to a new logon; routine for SYSTEM, admins and service accounts, notable for a standard user; pair it with the matching 4624 by Logon ID and baseline it rather than reading it as escalation)
- Account and group changes: 4720 (user account created), 4738 (user account changed), 4728/4732/4756 (member added to a security-enabled global, local or universal group), 4704 (user right assigned)
- Persistence: 4697 (service installed, Security log) / 7045 (service installed, System log), 4698 (scheduled task created)
- Script content: 4104 (PowerShell script block, Microsoft-Windows-PowerShell/Operational; full coverage requires Script Block Logging)
- Tampering: 1102 (Security audit log cleared), 104 (System log cleared)
4688 appears only if the Audit Process Creation subcategory is enabled, and includes the command line only if “Include command line in process creation events” is also enabled. Neither is on by default.
Syslog (RFC 5424 / RFC 3164)
Syslog Syslog A standard protocol for message logging in network devices and systems (RFC 5424; legacy BSD format RFC 3164). Classic syslog over UDP 514 drops messages silently, can be spoofed, and RFC 3164 timestamps lack year and timezone, so normalize time before correlating. is the long-standing standard for streaming text-formatted log messages over the network. Each message carries a severity, a facility, a timestamp, and a free-form text body. RFC 5424 is the modern spec, but most network gear still emits the older BSD framing (RFC 3164), so expect both in one pipeline. It remains the lingua franca for network devices and for forwarding Linux logs, though many modern distributions (Debian 12 and later, for example) record locally only to the systemd journal (queried with journalctl) and need a forwarder to emit syslog or JSON. Watch the timestamps: RFC 3164 carries no year and no time zone, so the receiving collector’s clock and configuration silently decide when the event happened.
Where you will see syslog:
- Network devices: firewalls, routers, switches, load balancers
- Linux systems: kernel logs, application events, auth events
- Cloud platforms: container orchestration, microservice logs
- IoT and OT: ICS, embedded devices
Common Event Format (CEF)
CEF CEF Common Event Format. A log format pioneered by ArcSight (now OpenText ESM) that adds a structured header (vendor, product, event name, severity) and key-value extensions to a syslog-style line. CEF made it possible for many vendors to ship logs that SIEMs could parse without writing a custom parser per product. is the format that made multi-vendor SIEM ingestion practical. It overlays a structured header on a syslog message so the SIEM knows the vendor, product, severity, and event class without guessing.
Common ecosystems:
- SIEM platforms: OpenText ESM (formerly ArcSight ESM, where CEF originated), Splunk (now part of Cisco), Microsoft Sentinel (CEF via the Azure Monitor Agent), IBM QRadar SIEM (which also has its own LEEF format)
- Standardized fields: device vendor, product, version, signature
- Custom extensions: vendor-specific attributes
- Integration: broad SOAR compatibility
JSON / structured data
Modern cloud and SaaS platforms emit logs as structured JSON. Every event is an object with named fields, which makes field extraction easier, though not free: nested arrays, version drift, and JSON-inside-a-string fields still need flattening before cross-source queries work. Most modern SIEMs ingest JSON natively and store it as-is, preserving fidelity that older text formats lose.
Where JSON dominates:
- Cloud services: AWS CloudTrail, Azure Activity Logs, GCP audit logs
- Modern SIEMs: native JSON ingestion
- API streams: RESTful webhooks, event buses
- Container telemetry: Kubernetes audit, container runtime events
What the raw records look like
A console shows you its parsed view of a record. Before you trust that view, read one raw record per source and find the fields you will rely on. The samples below are trimmed and fictional; the field names are real. Raw records carry what the parsed view hides, including passwords, tokens and session cookies in command lines, URLs and headers: redact secrets before you paste a raw record into a ticket, a chat or an AI assistant, and keep the unredacted original in the evidence store.
Annotated samples: Sysmon, syslog, CEF, auditd
Sysmon Event ID 1 (process creation), XML event data:
<EventData>
<Data Name="UtcTime">2026-03-10 14:22:04.871</Data>
<Data Name="ProcessGuid">{6a1f0c3e-2b7d-65f0-4c1a-000000001a00}</Data>
<Data Name="ProcessId">8128</Data>
<Data Name="Image">C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe</Data>
<Data Name="CommandLine">powershell.exe -nop -w hidden -enc SQBFAFgAIAAoAE4AZQB3AC0ATwBiAGoAZQBjAHQA...</Data>
<Data Name="User">CORP\jdoe</Data>
<Data Name="LogonId">0x3e7a21</Data>
<Data Name="IntegrityLevel">Medium</Data>
<Data Name="ParentProcessGuid">{6a1f0c3e-2b7c-65f0-3b19-000000001a00}</Data>
<Data Name="ParentImage">C:\Program Files\Microsoft Office\root\Office16\WINWORD.EXE</Data>
<Data Name="ParentCommandLine">"WINWORD.EXE" /n "C:\Users\jdoe\Downloads\remittance.docm"</Data>
</EventData>ProcessGuidandParentProcessGuidare the join keys for the process tree. Windows reuses PIDs, so a PID alone can point at the wrong process.CommandLineandParentCommandLinecarry intent; the next page decodes the first one.LogonIdties the process to a logon session (the matching 4624).IntegrityLevelsays whether the token was elevated.UtcTimeis UTC. Security 4688 carries the same facts under other names (NewProcessName,ParentProcessName,SubjectLogonId,TokenElevationType,MandatoryLabel), and itsCommandLinefield exists only if the policy is on.
Syslog, the same firewall event in both framings:
<134>1 2026-03-10T14:22:05.003Z fw01.corp.example filterlog 2211 - - pass out tcp 10.20.4.17:51544 -> 198.51.100.23:443
<134>Mar 10 14:22:05 fw01 filterlog[2211]: pass out tcp 10.20.4.17:51544 -> 198.51.100.23:443<134>is the priority: facility 16 (local0) times 8, plus severity 6 (informational).- The RFC 5424 line (first) carries a version, a full timestamp with a zone, the host, app name and process ID, then empty message-ID and structured-data fields (
-). - The RFC 3164 line (second) carries no year and no zone. Whatever time your SIEM shows for it, the collector decided.
CEF, a secure web gateway record:
CEF:0|ExampleVendor|SecureGateway|5.2|url-allowed|URL allowed|3|rt=1773152525003 suser=jdoe src=10.20.4.17 dst=198.51.100.23 request=https://cdn-relay.example/upd cat=Newly Registered Domain act=allowed- Seven pipe-delimited header fields: CEF version, vendor, product, product version, signature ID, event name, severity.
- Then space-separated
key=valueextensions.rtis the receipt time in epoch milliseconds (UTC);suser,src,dstandrequestare the fields you will join on.
auditd, a process execution on a Linux build server:
type=SYSCALL msg=audit(1773152530.412:8812): arch=c000003e syscall=59 success=yes exit=0 ppid=2140 pid=2187 auid=1003 uid=1003 comm="bash" exe="/usr/bin/bash" key="exec"
type=EXECVE msg=audit(1773152530.412:8812): argc=3 a0="bash" a1="-c" a2=69643B20756E616D65202D61- One event spans several records that share the
msg=audit(…)stamp: epoch seconds (UTC) plus a serial number. Join theSYSCALLrecord (who and which binary) to theEXECVErecord (the arguments) on that stamp. - The arguments arrive split across
a0toaN.a2has no quotes because it is hex: auditd hex-encodes any argument that contains a space, a quote or a control character. It decodes toid; uname -a, the first discovery commands of a hands-on intruder, or of an administrator. A search for “uname” in the raw log misses it. auidis the login user ID, which survivessudoandsu;uidis the user the process ran as. When they differ, the person behind the process is theauid.
Where the telemetry comes from, per platform
Formats are only half the story. The behavioral surfaces in this chapter (process trees, command lines, file activity) depend on a telemetry source actually recording them, and the source differs by platform. Knowing which source feeds your console tells you what the data can and cannot show.
Sysmon Sysmon Microsoft Sysinternals service that writes detailed endpoint telemetry (process creation with command lines, network connections, driver and DLL loads, file-time changes) to the Windows event log for SIEM ingestion. Now also a built-in optional feature on Windows 11 and Server 2025 (rendered messages are localized, so parse the XML); Sysmon for Linux exists too.
Sysinternals System Monitor: a free standalone download and, since 2026, also a built-in optional feature of Windows 11 and Windows Server 2025 (off until enabled; built-in and standalone cannot run side by side). Its process-creation event (Event ID 1) carries the full command line, parent command line, hashes, and a ProcessGuid that survives PID reuse. Network connections (3) and image loads (7) are off by default; what else you see (file creates 11, registry writes 13, DNS queries 22) depends entirely on the configuration. Parse the XML event data, not the rendered message, which built-in Sysmon localizes. It is the de facto standard source for the process and command-line telemetry this chapter teaches, and the usual compensating control when Security 4688 is missing its command line.
auditd and eBPF sensors
The kernel audit framework (auditd) records syscall-level events; an execve rule gives you process executions with arguments. Two parsing stumbles: the arguments arrive split across a0, a1 … aN fields, and any argument containing a space or special character is hex-encoded, so decode before you search. Modern EDR and open tooling increasingly use eBPF sensors for the same visibility with less overhead. Either way, output typically flows out as syslog or JSON.
Endpoint Security framework and unified log
Since macOS 10.15, EDR agents get process, file, and signing telemetry from Apple’s Endpoint Security framework Endpoint Security framework Apple’s kernel-supported API (introduced in macOS 10.15) that delivers real-time process execution, file, and code-signing events to security agents. It replaced kernel extensions as the sanctioned way for EDR products to observe macOS activity. , which is where a macOS process tree like that of Case B in the Alert worked example (a macOS developer workstation running the Cursor IDE) comes from. The unified log holds the OS’s own high-volume record, queryable with log show.
osquery
Exposes the live state of Windows, macOS, and Linux hosts as SQL tables (processes, users, launch items, listening ports). Strong for point-in-time interrogation and fleet-wide hunting; it complements, rather than replaces, the streaming sources above.
Data quality is half the work
Alerts often arrive without full metadata. Parent process missing, asset identifier truncated, command line Command Line In SOC analysis, the argument string a process was launched with. Often the load-bearing forensic field on an EDR alert because it reveals what the process was actually told to do. cut off at a byte boundary. Advanced parsing systems integrate enrichment from CMDBs Configuration Management Database (CMDB) A database of an organization's systems and services (configuration items) and the relationships between them; during triage an analyst queries it to learn what an alerting system actually is: its owner, business role, criticality, and dependencies. A stale CMDB is a common reason a scoping question takes hours instead of minutes. , identity directories (Active Directory, Microsoft Entra ID Microsoft Entra ID (formerly Azure AD) Microsoft's cloud identity provider: SSO, MFA, Conditional Access. Triage evidence lives in the sign-in logs (interactive and non-interactive), audit logs, and Microsoft Entra ID Protection risk detections. , Okta Okta Identity platform with SSO, MFA, lifecycle management, and federation across thousands of apps. ), and threat-intelligence Threat Intelligence Evidence-based knowledge about existing or emerging threats, including context, mechanisms, indicators, implications, and actionable advice (after Gartner's widely cited definition). It is consumed at strategic, operational, and tactical levels. Before acting on it, weigh the source's reliability, the information's credibility (the Admiralty code is one common scheme), and its age. feeds (Google Threat Intelligence, which now carries Mandiant’s research; CrowdStrike; Recorded Future Recorded Future Threat-intelligence platform combining machine learning with human analysis across open, dark, and technical sources. Owned by Mastercard since December 2024. ) so the structured output is complete enough to act on.
Why standardization matters
A single intrusion almost always produces telemetry across more than one format. Imagine an attacker phishes a user on a Windows laptop, the laptop reaches out through the corporate firewall to an external domain, the secure web gateway logs the same request, and the cloud identity provider records the resulting authentication. That is four formats describing one event:
The Windows laptop writes a 4688 process-creation event to its Security log: the mail client spawning an unexpected child process under the user’s account.
The firewall sends a syslog message describing the outbound HTTPS connection: source IP, destination IP, port, and traffic volume.
The secure web gateway sends a CEF record for the same HTTPS request: vendor and product in the header, then user, URL, URL category, and action as extensions.
The cloud identity provider records a JSON event describing the federated login that followed (timestamp, user, IP, MFA result).
Four formats. Four different field names for the same concept. Four different timestamp conventions. Without standardization, the analyst has to write four parallel parsers in their head just to ask the basic question: did the same user account that triggered the laptop alert show up in the cloud identity log within the next ten minutes?
| Format | Where the time lives | What it means |
|---|---|---|
| EVTX | TimeCreated SystemTime | UTC |
| Syslog (RFC 3164) | The header timestamp | Local time, no year, no zone: the collector guesses |
| CEF | rt= | Epoch milliseconds or MMM dd yyyy HH:mm:ss, depending on the device |
JSON (CloudTrail eventTime) | A named field | ISO 8601, UTC |
Normalize to UTC and write times in RFC 3339 form with an explicit offset (2026-03-10T14:22:05Z), so nobody downstream has to guess the zone. Record whether each timestamp is event time or ingest time, and note any known clock skew between sources: a ten-minute correlation window is meaningless across a five-minute skew.
That question is trivial when every event uses the same field names. It is hard when each format has its own vocabulary. Standardization is the engineering investment that makes the trivial version possible at scale.
Cross-source correlation. An identity field that means the same thing in EVTX, syslog, CEF, and JSON lets the SIEM join events across sources automatically.
Automation that works on more than one source. SOAR playbooks need a predictable shape. Standardized data is what makes a playbook portable across alert sources.
Trend analysis at scale. Asking “how many failed authentications happened across all of our identity sources this week” is one query if the field names match. It is a research project if they do not.
Defensible audit trails. When an auditor or regulator asks how an event was investigated, consistent field names let you show the evidence and the queries that found it side by side. Without them, the answer is a reconstruction across four consoles.
One shape: schema normalization
Normalization Normalization Converting logs and events from different sources into a common field schema, such as OCSF, ECS, Splunk CIM, Microsoft Sentinel ASIM or Google SecOps UDM, so a username, IP, or timestamp means the same thing regardless of which tool recorded it. SIEM correlation rules and cross-source queries depend on it; fields that were never normalized are where searches silently miss. maps every source’s vendor-specific fields into a common schema, so a malicious PowerShell PowerShell Microsoft's shell and scripting language: Windows PowerShell 5.1 on .NET Framework, cross-platform PowerShell 7 on .NET. The most abused interpreter on Windows (ATT&CK T1059.001). Triage tells: -EncodedCommand or -enc (Base64 of UTF-16LE text), -NoProfile, -WindowStyle Hidden, IEX with a download cradle, and an Office or browser parent. Script Block Logging (Event ID 4104) records de-obfuscated script content. execution reported by the EDR and the related connection logged by the firewall land in the same structure with the same field names. These are the event schemas you will meet. Your console almost certainly speaks one of these; learn its field names for user, host, process and source IP first.
OCSF
Open Cybersecurity Schema Framework, a Linux Foundation project since November 2024. Vendor-neutral, the native storage schema of Amazon Security Lake, and increasingly the default for cross-tool integration. If your platform supports it, prioritize it; check which schema version your tools emit, because OCSF ships several releases a year.
ECS
Elastic Common Schema, now merged into the OpenTelemetry semantic conventions. What you query in Elastic Security, and the field vocabulary a growing share of open collectors emit.
CIM
Splunk’s Common Information Model: data models (Authentication, Endpoint, Network Traffic) that searches and Enterprise Security correlation rules run against.
ASIM
Advanced Security Information Model: query-time parsers that let one Sentinel query cover every source of a given event type.
UDM
Unified Data Model: the normalized event and entity schema Google Security Operations parses every source into before rules and searches run.
Two standards often appear next to these and are not event schemas: STIX 2.1 Structured Threat Information Expression (STIX) OASIS's JSON language for threat intelligence (STIX 2.1): indicators, attack patterns, threat actors and their relationships, usually exchanged over TAXII. Respect the sharing marking (TLP 2.0) on what you receive. carries threat intelligence (what an IOC means); OpenC2 OpenC2 An OASIS standard language for machine-to-machine commands to cyber-defense tools (block this address, isolate this host), meant to let orchestration platforms drive devices from different vendors through one vocabulary. Adoption is still limited. expresses response actions (what to do about it). Both matter to a SOC, but neither normalizes event telemetry.
Whatever schema you adopt, normalization maps diverse vendor-specific fields into four buckets. They line up with the three buckets in Reading any alert: in schema terms, its Technical detail bucket splits into affected entities and primary observables.
Detection metadata
Alert name, detection logic, severity, confidence. Timestamps standardized to UTC in ISO 8601.
Affected entities
Hostnames, IPs, user accounts, cloud assets, containers. Anything the alert references.
Primary observables
File hashes, domains, URLs, registry keys, IoC IoC Indicator of Compromise. An artifact that suggests intrusion: a file hash, domain, IP, registry key, or behavioral pattern. IOCs feed signature detection and post-event correlation. . The artifacts to correlate against.
Contextual data
MITRE ATT&CK mappings, enrichment tags, kill-chain stage, threat-intelligence annotations.
Normalization also requires flattening nested structures where useful and harmonizing identifiers so automated cross-tool correlation works. Within ASSURED, prioritize normalization of detection metadata, affected entities, and primary observables. Those are the fields downstream phases depend on.
Severity, confidence, and priority are three different numbers
The detection-metadata bucket carries two fields that read alike and mean different things, and triage adds a third. Severity is the detection engineer’s estimate of how bad the activity would be if real, set when the rule was written, before your environment entered the picture. Confidence is the detector’s estimate of how likely the match is to be what it claims: a statement about the rule’s precision, not about the threat. Priority is what triage produces: a provisional queue position set at intake from severity, confidence and asset or user criticality (see criticality), then confirmed or revised in the Risk phase once the evidence is in. It is the only one of the three the analyst owns. A critical-severity, low-confidence alert on a lab host and a medium-severity, high-confidence alert on a domain controller can rightly land in opposite queue positions.
For platform owners, not the triage queue
Maintaining the normalization layer is engineering work, not triage work. If you own the pipeline rather than the queue: document and version the mapping logic, test mappings against representative payloads before rollout, review on a cadence so vendor format drift gets caught early, and share ownership across security operations Security Operations The people, processes and technology that monitor, detect, investigate and respond to threats day to day, usually organized as a SOC. ASSURED covers the triage slice, from an alert firing to a documented close or escalation. , data engineering, and tool owners. Tools that help: Cribl Cribl Data routing and processing for observability pipelines; filter, enrich, and reduce log data before forwarding. , Logstash Logstash Server-side pipeline that ingests, transforms, and forwards data; the 'L' in the classic ELK stack. Still widely used but no longer required: Elastic now describes Elastic Agent with an integration as usually the simplest ingest path. , Fluentd Fluentd Open-source data collector that unifies log collection and processing across distributed systems via plugins. and Fluent Bit, Vector, the OpenTelemetry Collector, and the native normalization in modern SIEMs. The analyst’s job is narrower: know which schema your console speaks and what got dropped on the way in.
Check yourself
The Sysmon record, the firewall lines and the CEF record above describe the same minute on the same laptop. Before reading on, write down the fields you would join on and the first thing you would check about the times.
One way to answer
Join on the user (User is CORP\jdoe in Sysmon, suser is jdoe in CEF, so normalize the domain prefix first), on the host’s address (src=10.20.4.17, confirmed as the laptop’s address at that time from DHCP or the EDR’s host record), and on the destination (198.51.100.23:443). Then the times: Sysmon UtcTime and CEF rt are UTC, but the RFC 3164 firewall line has no zone, so confirm the collector’s configuration before you put it on the same timeline. The process half of the connection (which process opened it) would come from Sysmon Event ID 3 or the EDR’s network events, if they were collected.
For practice on a full record, Lab 1 hands you a scheduled-task event and asks what the alert summary dropped and whether a second source agrees.
Key takeaway
Format diversity is the cost of having visibility everywhere. Schema normalization Schema Normalization Another name for normalization: mapping events from different log sources into one common field schema. See Normalization. (OCSF, ECS, Splunk CIM, ASIM, UDM) is the investment that turns that diversity into one queryable dataset. Invisible when it works, painful when it does not, and the foundation every behavioral surface in this chapter builds on.
Next up
Command line analysis
Decoding the true intent of process execution. The encoded-command workflow, obfuscation patterns, execution context.
Read command lineTechnical details verified . Product names, defaults and retention change; check your own tenant.