Endpoint ✓ fields verified against sample logs

Windows Security EVTX Log Fields: Reference With Examples

Published

One record per audited Windows security event — a logon, a failed logon, a process start, a group change — with provider metadata in the System section and the event-specific fields as named Data elements in EventData.

Sample record

  <Event xmlns="http://schemas.microsoft.com/win/2004/08/events/event">
    <System>
      <Provider Name="Microsoft-Windows-Security-Auditing" Guid="{54849625-5478-4994-A5BA-3E3B0328C30D}" />
      <EventID>4624</EventID>
      <TimeCreated SystemTime="2024-03-20T07:58:01.123456789Z" />
      <Computer>WKS-ALICE.contoso.com</Computer>
      <Security UserID="S-1-5-18" />
    </System>
    <EventData>
      <Data Name="SubjectUserName">ALICE$</Data>
      <Data Name="SubjectDomainName">CONTOSO</Data>
      <Data Name="TargetUserName">alice.johnson</Data>
      <Data Name="TargetDomainName">CONTOSO</Data>
      <Data Name="LogonType">2</Data>
      <Data Name="IpAddress">10.1.1.50</Data>

From the LogTriage parser test corpus — synthetic data, no real hosts or users.

Field reference

Field Type Meaning Why it matters for security
EventIDe.g. 4624 integer Numeric identifier of the audited event within the provider. 4624 successful logon, 4625 failed logon, 4672 special privileges assigned, 4688 process creation, 4720 user account created, 4728 member added to a global group, 4698 scheduled task created. The number identifies an event only together with the provider name.
Provider Namee.g. Microsoft-Windows-Security-Auditing string (attribute) Attribute of the Provider element naming the source that wrote the record. Security audit events all come from Microsoft-Windows-Security-Auditing; other providers reuse the same ID numbers, so filter on both.
SystemTimee.g. 2024-03-20T07:58:01.123456789Z datetime (UTC) Attribute of the TimeCreated element — when the event was generated, in UTC. Sequence failures and successes per account and source address; the value is UTC even when Event Viewer displays local time.
Computere.g. WKS-ALICE.contoso.com string The machine whose event log the record was written to. Tells you where authentication or the process start was evaluated — a workstation, a member server or a domain controller.
SubjectUserNamee.g. ALICE$ string The account that requested the action (the subject), which may be a machine account or SYSTEM. On 4720 and 4728 this is the account creating the user or adding the member — the actor to investigate.
TargetUserNamee.g. alice.johnson string The account the event is about — the account logging on, failing to log on, or being created. Counting distinct values for one source address is how spraying and name guessing are found.
TargetDomainNamee.g. CONTOSO string Domain or machine name qualifying TargetUserName. Distinguishes a domain account from a local account with the same name.
LogonTypee.g. 3 integer How the logon was attempted: 2 interactive, 3 network, 4 batch, 5 service, 7 unlock, 8 network cleartext, 9 new credentials, 10 RemoteInteractive, 11 cached interactive. Type 3 from the internet on a domain controller is remote credential testing; type 10 is RDP.
IpAddresse.g. 10.1.1.50 string Source address of the logon attempt where the event records one. The pivot for grouping failures by origin; it can be "-" or a loopback or IPv6-mapped value when the client address is not known.
WorkstationNamee.g. WKS-ALICE string Name the client supplied for itself. Attacker-controlled and frequently "-" or an obviously foreign hostname; useful as a pattern, never as proof of identity.
AuthenticationPackageNamee.g. NTLM string Authentication package that handled the logon. NTLM where Kerberos is expected can indicate a tool connecting by IP address rather than hostname.
LogonProcessNamee.g. NtLmSsp string Logon process that submitted the request. Pairs with the package — NtLmSsp for NTLM network logons, Kerberos for Kerberos logons.
Statuse.g. 0xC000006D hex string Result code of the logon attempt; on Kerberos events 4768 and 4771 it carries the Kerberos result or failure code instead. On 4625 it is usually the general failure 0xC000006D with the real reason in SubStatus; 0x0 means success.
SubStatuse.g. 0xC000006A hex string Specific failure reason behind a general Status value. 0xC000006A wrong password for an existing account, 0xC0000064 account does not exist, 0xC0000234 account locked out.
FailureReasone.g. %%2313 string (message reference) Reference into the provider's message table rather than readable text; Event Viewer resolves it when it renders the event. Do not parse it as a reason — read Status and SubStatus, which are stable across languages.
NewProcessNamee.g. C:\Windows\System32\cmd.exe string Full path of the process created, on event 4688. With CommandLine and ParentProcessName it shows what a compromised account actually ran.

What it records

Each record in a Windows Security event log is one audited event: a logon, a failed logon attempt, a privilege assignment, a process creation, an account or group change, a scheduled task registration. Rendered as XML, every record has the same two halves. The System section identifies the record — the provider that wrote it, the EventID, the TimeCreated timestamp in UTC, the Computer the log belongs to, and the SID of the security context under Security UserID. The EventData section holds the event-specific payload as Data elements, each with a Name attribute such as TargetUserName, LogonType, IpAddress, Status or SubStatus.

Which Data elements appear depends entirely on the event ID. A 4624 describes who logged on, how and from where; a 4625 adds Status, SubStatus and FailureReason; a 4688 carries NewProcessName, CommandLine and ParentProcessName; a 4728 carries MemberName and MemberSid. Treat EventID as the schema selector before reading anything else.

Where to get it

The live log is %SystemRoot%\System32\winevt\Logs\Security.evtx, which cannot be copied while in use without a backup API. Practical sources:

# Export the Security log to a portable .evtx file
wevtutil epl Security C:\export\Security.evtx

# Render failed logons as XML
wevtutil qe Security /q:"*[System[(EventID=4625)]]" /f:xml /c:50

# Or read an exported file in PowerShell
Get-WinEvent -Path C:\export\Security.evtx -FilterXPath "*[System[(EventID=4625)]]" |
  ForEach-Object { $_.ToXml() }

At scale the same records arrive through Windows Event Forwarding, an EDR agent, or the Azure Monitor Agent, where they land in Microsoft Sentinel’s SecurityEvent table with the Data names exposed as columns.

Parsing pitfalls

  • Binary on disk, XML only when rendered. Anything that reads EVTX as text finds nothing useful. The XML in these samples is the rendered form.
  • No message text in the record. The readable description comes from the provider’s message resources, so exports and SIEM rows show field values only.
  • Named Data elements are not guaranteed. When a template is missing or a provider emits positional values, you get bare <Data> elements and must rely on order instead of names.
  • Hex case varies. 0xC000006D renders uppercase here and lowercase elsewhere; compare case-insensitively (in KQL, =~).
  • Placeholder values. IpAddress and WorkstationName are often -; addresses may arrive IPv6-mapped. Strip and normalise before joining on them.
  • Client-supplied fields lie. WorkstationName and the account name are whatever the client sent.
  • Status is not one thing. On 4625 it is an NTSTATUS value; on 4768 and 4771 it holds a Kerberos code, and on 4776 the sample shows 0x0 for a successful validation. Interpret it per event ID.
  • Event IDs repeat across providers. Always filter on Provider Name as well.
  • UTC. SystemTime is UTC with sub-second precision, while Event Viewer shows local time — a common source of timeline drift.

Detection ideas

  • Password spraying: one IpAddress producing 4625 events with SubStatus 0xc000006a across many distinct TargetUserName values in a short window, as in the malicious sample — the basis of the 4625 password-spray rule.
  • Name guessing: the same burst but with 0xc0000064, meaning the names do not exist.
  • Brute force that succeeded: a run of 4625 for one account followed by a 4624 with LogonType 3 from the same address, then 4672 showing privileged rights.
  • Persistence after takeover: 4720 creating an account and 4728 adding it to a privileged group by the same SubjectUserName, followed by 4698 registering a scheduled task.
  • Kerberos failures: 4771 and 4768 with a non-zero Status on a domain controller, read against the Kerberos failure codes.

The browser log analyzer runs these checks on an exported XML file locally.

Detections and guides for Windows Event Log

Frequently Asked Questions

Why can't I grep an .evtx file?
EVTX is a binary, chunked format that stores records as binary XML against per-provider templates, so account names and addresses are not contiguous text. Render it first with wevtutil or Get-WinEvent, or parse it with a library that understands the format, then search the output.
Why does event 4625 show Status 0xC000006D and SubStatus 0xC000006A?
Status carries the general result, which for a rejected logon is usually 0xC000006D — the logon was invalid without saying which half was wrong. The specific reason sits in SubStatus, here 0xC000006A, meaning the account exists and the password was wrong.
Which computer writes the failure event?
The computer that evaluated the logon. A failed network logon against a server is recorded in that server's Security log, while credential validation for domain accounts is recorded on the domain controller — 4776 for NTLM validation and 4768 or 4771 for Kerberos ticket requests.
Where did the readable message text go in my XML export?
The record stores only the provider, the event ID and the Data values. The sentence you see in Event Viewer is assembled from the provider's message resources at display time, which is why raw XML exports and SIEM ingestion show field values but no description paragraph.

Analyze a Windows Event Log file in your browser

The free analyzer detects this format, parses every field above and flags attack patterns — the file never leaves your machine. For threat-intel enrichment and an AI-written incident report, run it through LogTriage.