In short
- A parser that fails loudly is a nuisance; a parser that fails quietly is a wrong conclusion. Ours decoded the envelope of every Windows event record — the channel, the event ID, the timestamp, the computer — and silently returned nothing for EventData, which is where the account name, the command line and the script block live. Every unit test passed. The report looked complete.
- Real logs found it in one run. Against 1,961 records from four Windows channels, 72.6% of records were partial and the EventData value count was zero. Two root causes: an inline element name left the BinXML cursor twenty bytes short, and EventData arrives as a nested fragment (value type 0x21), not a scalar. After both fixes: 86.9% of records decode in full, 5,984 EventData values are recovered, and every record keeps its header-derived identity.
- Parsing .evtx is not the product and we do not claim it is. Open-source tools have done it well for years, in Rust, and we cite them below. What an analyst cannot get from a command-line parser is the part around it: a tenant-isolated workspace, a grade of what the corpus can support, the arithmetic and a computed confidence behind every finding, and a promise that the logs they just uploaded are not stored anywhere.
About this article
- Format
- Original research: numbers we measured, with the method and the intervals.
- Written for
- Security and compliance reviewers · SDETs and automation engineers · Engineering managers
- Where it applies
- Every market. The rules that differ by country are on the country pages.
The twenty-minute problem
Someone forwards you a .evtx file. A laptop did something odd on Tuesday, the endpoint agent was not installed, and the only artefact is the raw Windows event log pulled off the disk. You have twenty minutes before the stand-up and no SIEM ingest pipeline you can point at a single file from a single machine.
The usual answers are all friction. Open it in Event Viewer on a Windows box you may not have, and scroll. Install a command-line parser, learn its flags, and pipe its output into something that can group and count. Or ship the whole file into a platform whose first question is which index to put it in and whose second is what it will cost. None of those is hard, exactly. They are just slow enough that the honest triage often does not happen, and the event log gets attached to a ticket instead of read.
The reframe: quiet failure is the real risk
We built the decoder, tested it against fixtures we constructed from the format specification, and shipped it behind the SOC Analyst module. Every test passed. It was wrong about the format in two independent ways, and the shape of the wrongness is the part worth your attention.
A .evtx record has an envelope and a payload. The envelope is the System block: the channel, the event ID, the timestamp, the computer, the provider. The payload is EventData, and EventData is the part that matters — TargetUserName on a 4624 logon, CommandLine on a Sysmon process creation, ScriptBlockText on a PowerShell 4104. Our decoder read every envelope correctly and returned nothing at all for the payload.
So the report rendered. It had event counts, a timeline, channels and IDs. It just had no fields to run a detection against, and nothing in it said so. That is the failure mode to be afraid of in any parser: not the one that throws, but the one that returns a plausible, incomplete answer with no marker on it. A loud failure costs you an hour. A quiet one costs you the conclusion you drew from it.
What the measurement showed
We stopped reasoning about the format and pointed the decoder at real logs: 1,961 records from four Windows channels — Security, Sysmon, PowerShell operational (including 4104 script blocks) and System — taken from public Windows event-log samples, never from a customer tenant. The first run was unambiguous.
- Defect one: an inline element name. A .evtx record is BinXML, and an element name is written at the cursor the first time it appears and referenced by offset afterwards. Our reader handled the reference and not the inline case, so it never advanced past the name’s own bytes — twenty of them for Event, the root element of every record. It then read the name’s hash as the next token and reported “expected an attribute token, saw 0xba”, which is the low byte of that hash. Three unrelated files from three machines produced the identical error, because every record starts the same way.
- Defect two: EventData is not a scalar. Windows delivers EventData as value type 0x21, a nested BinXML fragment, not a string. The renderer returned an empty string for a type it did not recognise, which is exactly how the entire payload disappeared while the envelope stayed perfect.
- Why the fixtures missed both. Our fixture builder wrote element names into a separate data area, so a name offset could never equal the reader’s cursor. The inline case was structurally impossible to express in the test suite. The decoder was self-consistent with its fixtures and wrong about reality — which is a question worth asking of any fixture helper you own: *which legal input can this builder not produce?* That set is your blind spot.
| Measure | Before | After |
|---|---|---|
| Records decoded in full | 27.4% | 86.9% |
| Records decoded only partially | 72.6% | 13.1% |
| EventData values recovered | 0 | 5,984 |
| Records carrying at least one EventData value | 0% | 83% |
| Records keeping their header-derived identity | 100% | 100% |
And a gate that counted the wrong thing
One more finding, because it is the same mistake one level up. The first version of our validation gate counted every key beginning EventData. and reported 11,859 — green, and meaningless. Checking a single real 4624 logon record by hand showed that all twenty of its EventData keys were @Name attributes: the field labels, with no values attached. The gate would have passed on labels alone.
Recounted against non-attribute keys with a non-empty value, the real figure is 5,984, and the gate now asserts both the total and the share of records carrying at least one (83%), because a few very large records can otherwise carry the number by themselves. A count of keys is not a count of information. Check one real record by hand before you trust the aggregate.
What the module does once the file is readable
Decoding is the entry condition, not the feature. Upload one file of up to 64 MB — CSV, TSV, Excel, JSON, JSONL, syslog, CEF, LEEF, Apache or nginx access logs, plain text, an EvtxECmd CSV export, or now the raw binary .evtx straight off the machine — and SOC Analyst triages what is in it.
- It recognises the tools you already run. Zeek logs with their #fields header and conn_state outcomes, Suricata EVE JSON with its severity translated, Wazuh alerts with rule.level and rule.mitre, Sysmon and osquery exports with quote-aware command lines, OCSF and ECS records where class_uid and event.outcome are treated as authoritative, and Volatility 3 and Sleuth Kit bodyfiles with their MACB timestamps preserved.
- It refuses to mistake a rule for an event. A Sigma or YARA pack you upload is classified as rules and never swept into the event stream; a STIX 2.1 or MISP bundle is classified as intel, with to_ids honoured. A platform that counts your detection rules as suspicious events is a platform that will tell you your rule pack is an attack.
- It says what the corpus can support. The report grades what the uploaded file can support and, when the analysis engine is available, lists what it cannot answer, so a thin log reads as thin rather than as clean; a Suricata alert the sensor blocked is read as blocked, not as a compromise.
- It runs 17 deterministic detections and maps them to ATT&CK. Credential brute force, password spraying, C2 beaconing, DGA-like domains, impossible travel, log tampering and eleven more; each hit carries its ATT&CK technique and the hits are assembled into a kill chain.
- It shows its working. Every finding carries the metric, the threshold and the method that fired it, and a confidence computed as a Bayesian posterior from the rule’s prior, sensitivity and false-positive rate, so you can overturn it rather than trust it.
- It drafts the rule you would deploy (experimental). When the analysis engine is available, the report drafts a detection rule for each finding in Sigma, KQL for Microsoft Sentinel and Defender, and SPL for Splunk. The drafts are labelled experimental; review one before it reaches your SIEM.
- Your assets set the priority. Criticality comes from the asset inventory a team owner or a single-user account maintains, so the same event ID on a build agent and on a domain controller do not arrive at the same priority.
In the product
What we do not claim
Parsing .evtx is commodity work and has been for years. The reference implementation most tooling sits on is a Rust parser under Apache-2.0 and MIT; Hayabusa, in Rust under AGPLv3, is a Sigma-based timeline generator for Windows event logs and does this well. A mature Rust parser would very likely beat our 86.9% on these same files, and we are not going to pretend otherwise to sell a module.
Our own residual gap is narrow and named: the rare CDATA, entity-reference and processing-instruction tokens are flagged partial rather than guessed, so a record we cannot fully read is marked as such instead of being quietly shortened. The Rust reference parser lists CDATA as unimplemented too. A limitation you can read in the report is worth more than a completeness claim you cannot check.
What a command-line parser cannot give an analyst is the rest of the job: a workspace isolated per tenant at the database level, an incident with a priority and a response clock, a report that shows the arithmetic behind every finding, and an answer to "what happened to the logs I just uploaded".
What happens to your logs
The corpus and the report are never stored. They exist in memory for the life of the job and are then evicted — no database row, no file on disk, no history. The one stored record is an incident: once one is opened, it keeps its priority and its response clocks, because an SLA clock that resets on a deploy measures nothing. The corpus it came from still is not stored.
That sentence lives in exactly one place in our source and is imported everywhere it appears, with a test that fails the build if a second copy of it drifts. A promise about a customer’s logs is not a sentence you want in four files.
The manager’s case
The cost of not triaging a single event log is not zero, it is just deferred and invisible: the file gets attached to a ticket, the week moves on, and nobody learns whether Tuesday mattered. If reading one takes an upload rather than an ingest pipeline, the triage happens.
The honest framing of what this is worth: SOC Analyst is not a SIEM and does not replace one. It is the thing you reach for when there is one file, one machine and one question, and the alternative is a tool nobody on the team has installed. It is on Solo Pro and up, on the same entitlement as security scanning, and it is not included on Free.
What to do next
- Open SOC Analyst from the dashboard and upload one log you already have — a .evtx straight off a Windows machine needs no export step first.
- Read the report’s evidence grade before its findings: it tells you what the file was able to support, and the shift handoff lists what it could not answer.
- Check the partial-record count on any .evtx upload. If it is high, send us the channel and the provider; a flagged record is a decoder gap we can close, and a guessed one is a wrong answer we would never see.
- Use Export JSON before you leave the page: the report is not stored, so it cannot be retrieved afterwards.
- Follow the step-by-step guide for every screen and error message, and the module page for the limits and plans.
Questions people ask
Can I upload a raw .evtx file, or do I have to convert it first?
Raw binary .evtx is accepted directly, as of 14 November 2026 — copy the file off the machine and upload it. The EvtxECmd CSV export (.evtx.csv) is still accepted as well, and was the only route before that date. One file per analysis, up to 64 MB.
What does "86.9% decoded in full" mean for the other 13%?
Those records are returned and marked partial, with the count shown in the report. Every record keeps its header-derived identity — its channel, event ID and timestamp — so a partial record still appears on the timeline; what may be missing is some of its EventData, usually because it contains one of the rare BinXML token types we flag rather than guess.
Is this a SIEM, or a replacement for one?
Neither. It is single-corpus triage: one file, analysed on upload, with the report evicted afterwards. There is no continuous ingest, no retention of your events and no alerting on a live stream. Teams that run a SIEM use this for the artefact that never reached it — a laptop with no agent, a file attached to a ticket, an export from a system outside the pipeline.
Are my logs stored, or used to train a model?
The corpus and the report are never stored: they exist in memory for the life of the job and are then evicted. The one stored record is an incident, once opened, which keeps its priority and response clocks. Analysis runs on local models and deterministic rules inside the platform.
Why publish the numbers from before the fix?
Because the before figure is the finding. A decoder that silently returned zero payload fields while passing its whole test suite is a more useful thing for another engineer to read about than a polished after figure on its own, and the measurement is the only reason we know either number. The methodology block below states how both were derived.
Which plans include SOC Analyst?
It carries the same entitlement as security scanning: Solo Pro and above, including Team and Enterprise. It is not included on the Free plan. The pricing page lists every feature by plan.
How we measured this
- The run: 1,961 records from four public Windows event-log sample files covering the Security, Sysmon, PowerShell operational (4104 script blocks) and System channels. No customer data was used, and no tenant log was read. The samples were held outside the repository and the decoder was run against them from a test suite that is skipped unless the sample directory is set, so the published test run stays offline and reproducible without them.
- "Decoded in full" means the record produced its complete field set with no partial marker; the complement is the partial count the report shows. The ratios are record counts over the same 1,961 denominator in both the before and after runs: 537/1,961 = 27.4% and 1,704/1,961 = 86.9% full, 1,629/1,961 = 83% carrying at least one EventData value.
- "EventData values" counts keys that are not @Name attributes and that have a non-empty value. The first version of the gate counted every key beginning EventData. and reported 11,859; that figure was wrong in kind, not degree, and is corrected here rather than omitted — a single real 4624 record showed all twenty of its keys were labels with no values.
- Both fixes were mutation-verified: reverting the inline-name handling reproduces the exact production error text (“expected an attribute token, saw 0xba”) in three fixtures, and disabling the nested-fragment branch drops the EventData value count to zero, which the gate now catches.
- Correction, 2026-11-15: the first version of this article described the module wrongly in four places, found when its step-by-step guide was written from the shipped code. It said detections run as Sigma rules; the analysis runs 17 deterministic detections of its own, and Sigma appears only in experimental detection drafts. It said findings are labelled suspected or confirmed; the SOC screen shows a severity, the arithmetic and a computed confidence instead. It said every tool carries a proves / cannot-prove statement; the report grades what the corpus can support and, when the analysis engine is available, lists what it cannot answer. And it told readers to open an incident from a finding; there is no button for that yet, and incidents are opened through the API. Each sentence was rewritten rather than removed.
- Correction, 2026-11-14: an earlier internal note on this work cited "11,859 EventData fields". The accurate figure is 5,984 values; the higher number counted field labels as payload. The number was corrected in all three places it had been written before this article was published.
Sources
- Microsoft Learn — Windows Event Log (the API that supersedes the older Event Logging API from Windows Vista onwards) read
- SigmaHQ — Sigma, the generic signature format for SIEM systems, whose main repository states it carries more than 3,000 detection rules read
- omerbenamram/evtx — the Rust parser for the Windows XML Event Log format, dual-licensed Apache-2.0 and MIT, whose README lists CDATA nodes and the EVTHandle node type as unimplemented read
- Yamato-Security/hayabusa — a Sigma-based threat-hunting and forensics timeline generator for Windows event logs, written in Rust and licensed AGPLv3 read
- MITRE ATT&CK — the globally accessible knowledge base of adversary tactics and techniques based on real-world observations, to which findings are mapped read