Skip to main content
4656SecurityObject AccessSecurity tier 1

Event ID 4656: A handle to an object was requested

Event ID 4656 records that a process asked for a handle to a file, registry key or kernel object, with the access it wanted, and it has a Failure form for refused requests. It generates only when a SACL covers the request, and it proves intent, not use: event 4663 shows what was actually done.

What Triggers Event 4656: A Request, Not an Action

Event 4656 says a process asked for a handle to an object and records what happened to the request. Microsoft's description is that specific access was requested for a file system, kernel or registry object, or a file system object on removable storage or a device. If access was declined, a Failure event is written. Either form generates only when the object's SACL has an entry covering the rights involved. Microsoft is explicit about the limit. The event shows that access was requested and the result of the request, but not that the operation was performed. For that you read 4663.

Four audit subcategories can carry it: File System, Kernel Object, Registry and Removable Storage. They have very different economics. Microsoft states that no events are generated for the default file system SACLs, and its advice for File System and Registry is not to enable them until you have planned how the data will be used. For kernel objects it says the events have little to no security relevance, are hard to parse and need no auditing unless you know exactly what to watch. A policy called "Audit: Audit the access of global system objects" sets the default SACL on kernel objects, so that is the setting to check when kernel-object volume surprises you. A Spiceworks admin counted more than 82 million 4656 events for one user in a month, and the sample in the thread is services.exe requesting access 0x1, "Connect to service controller", on an SC_MANAGER OBJECT named ServicesActive. That is not a file at all.

Only 4656 records refusals. Event 4663 has no failure version, so a refused attempt leaves no trace there. Microsoft's File System page says it directly: Failure events can show you unsuccessful attempts to access specific file system objects. Audit Success and Audit Failure are keyword bits on the event. Microsoft's 4625 sample, a failure event, carries 0x8010000000000000 and its 4624 sample carries 0x8020000000000000.

AccessMask is the access that was requested, which is not the access that was used. Microsoft's own sample is Notepad opening a text file with mask 0x12019f. Break it down with the file right table: ReadData 0x1, WriteData 0x2, AppendData 0x4, ReadEA 0x8, WriteEA 0x10, ReadAttributes 0x80, WriteAttributes 0x100, READ_CONTROL 0x20000 and SYNCHRONIZE 0x100000. Nine rights, and the AccessList field names each of them. Notepad asked for write access to open a file, and nothing in the 4656 says it ever wrote. Treat the requested mask as a ceiling and let 4663 tell you what happened. The simulated event here asks for 0x120089, which is ReadData, ReadEA, ReadAttributes, READ_CONTROL and SYNCHRONIZE: a plain read.

PrivilegeList records which privileges the access check used. Microsoft defines it as the privileges used for the access check, with SeBackupPrivilege as the example, and a hyphen when none were. Microsoft's table says SeBackupPrivilege makes the system grant read access to any file regardless of its ACL. A hyphen means no privilege was involved in the check. Anything else means one was, which is exactly the case where a permissions review says "no access" and the log says the file was read.

The remaining fields are the Subject block, ObjectServer (Security for this event), ObjectType, ObjectName, TransactionId, RestrictedSidCount, ProcessId in hexadecimal and ProcessName. Version 1 on Windows Server 2012 and Windows 8 added ResourceAttributes and AccessReason. Microsoft does not decode the AccessReason codes on the event page, so lean on AccessMask and AccessList for rules and use the rendered text in Event Viewer when you need the reason.

HandleId ties the lifecycle together. A 4656 opens it, a 4663 uses it, and a 4658 closes it, but 4658 only exists if you enable Audit Handle Manipulation, which Microsoft says has little security relevance beyond telling you how long a handle stayed open. Microsoft warns that HandleId can be captured as 0x0, in which case there is nothing to join. The deletion event, 4660, carries only a HandleId and no object name, so the name of a deleted file comes from the 4656 or 4663 with the same handle.

Microsoft's registry page has one wrinkle. On Windows 11 and Windows Server 2022 and later, the 4656 for a newly created subkey appears only under the legacy Audit Object Access setting, and earlier versions do not write it during subkey creation.

Event 4656 Fields

FieldWhat it tells youSimulated value
SubjectUserSidSID of the account that requested the handle.S-1-5-21-424242-1187
SubjectUserNameName of the account that requested the handle.t.novak
SubjectDomainNameDomain or computer name of the account.CORP
SubjectLogonIdLogon session ID; correlates to the 4624 that opened the session.0x5c27e1
ObjectServerAlways Security for this event.Security
ObjectTypeType of the object, such as File, Key or Process.File
ObjectNamePath or name of the object the handle was requested for.D:\HR\Compensation\2026-bands.xlsx
HandleIdHandle to the object; may appear as 0x0. Correlates with 4663, 4658 and 4660.0x3b8
TransactionIdGUID of the transaction; all zeros when not captured.{00000000-0000-0000-0000-000000000000}
AccessListMessage codes for the access rights requested.%%1538 %%1541 %%4416 %%4419 %%4423
AccessMaskHexadecimal mask of the requested access. A sum of rights.0x120089
PrivilegeListPrivileges used for the access check; a hyphen when none.SeBackupPrivilege
RestrictedSidCountNumber of restricted SIDs in the token.0
ProcessIdHexadecimal ID of the process that asked for the handle.0x1d44
ProcessNameFull path of the executable that asked for the handle.C:\Windows\System32\robocopy.exe
ResourceAttributesAttributes of the object (version 1); a hyphen when none.-

Inspect Event 4656 Values

Click a field to inspect the full simulated value, the way you would expand it in a SIEM event view.

Example Event 4656 Log

A representative Security entry for Event 4656, generated deterministically by our telemetry engine so every field holds a realistic, internally consistent value.

Simulated example generated by SOCSimulator Research
<Event xmlns="http://schemas.microsoft.com/win/2004/08/events/event">
  <System>
    <Provider Name="Microsoft-Windows-Security-Auditing" />
    <EventID>4656</EventID>
    <Version>0</Version>
    <Level>0</Level>
    <Task>0</Task>
    <Opcode>0</Opcode>
    <Keywords>0x8020000000000000</Keywords>
    <TimeCreated SystemTime="2025-10-26T06:35:16.000Z" />
    <EventRecordID>170778</EventRecordID>
    <Channel>Security</Channel>
    <Computer>WS-SIM-001.corp.socsimulator.example</Computer>
    <Security />
  </System>
  <EventData>
    <Data Name="SubjectUserSid">S-1-5-21-424242-1187</Data>
    <Data Name="SubjectUserName">t.novak</Data>
    <Data Name="SubjectDomainName">CORP</Data>
    <Data Name="SubjectLogonId">0x5c27e1</Data>
    <Data Name="ObjectServer">Security</Data>
    <Data Name="ObjectType">File</Data>
    <Data Name="ObjectName">D:\HR\Compensation\2026-bands.xlsx</Data>
    <Data Name="HandleId">0x3b8</Data>
    <Data Name="TransactionId">{00000000-0000-0000-0000-000000000000}</Data>
    <Data Name="AccessList">%%1538 %%1541 %%4416 %%4419 %%4423</Data>
    <Data Name="AccessMask">0x120089</Data>
    <Data Name="PrivilegeList">SeBackupPrivilege</Data>
    <Data Name="RestrictedSidCount">0</Data>
    <Data Name="ProcessId">0x1d44</Data>
    <Data Name="ProcessName">C:\Windows\System32\robocopy.exe</Data>
    <Data Name="ResourceAttributes">-</Data>
  </EventData>
</Event>

Detecting Event 4656

Handle requests on files that leaned on a privilege instead of the ACL

PrivilegeList holds the privileges used for the access check and a hyphen when there were none. Backup agents will dominate, so baseline them by ProcessName first. The SPL targets the XmlWinEventLog:Security sourcetype.

index=wineventlog sourcetype=XmlWinEventLog:Security EventCode=4656 ObjectType=File PrivilegeList!="-"
| stats count by host, SubjectUserName, ProcessName, PrivilegeList

One account refused on many different files in five minutes

A sweep by an under-privileged account looks like this. Tune the 20 against your baseline. Only 4656 records the refusal, because 4663 has no failure form. In Splunk the Audit Failure text comes from the Splunk Add-on for Microsoft Windows mapping 0x8010000000000000 in its XmlWinEventLog:Security props.conf; without the add-on, search the hex. The KQL tests Keywords against the hex and the Elastic query uses event.outcome.

index=wineventlog sourcetype=XmlWinEventLog:Security EventCode=4656 ObjectType=File Keywords="Audit Failure"
| bin _time span=5m
| stats dc(ObjectName) as objects, count as attempts by _time, host, SubjectUserName, ProcessName
| where objects >= 20

Requests to delete, rewrite permissions or take ownership under the protected folder

AccessMask is a sum, so these queries test bits: DELETE 0x10000, WRITE_DAC 0x40000 and WRITE_OWNER 0x80000, which together make 0xD0000. KQL tolong converts the 0x string. Lucene cannot test bits, so it carries the folder filter only. Replace D:\HR\ with the folder your SACL covers.

index=wineventlog sourcetype=XmlWinEventLog:Security EventCode=4656 ObjectType=File
| where like(ObjectName, "D:\\HR\\%")
| eval mask=tonumber(replace(AccessMask, "^0x", ""), 16)
| eval del=floor(mask/65536)%2, wdac=floor(mask/262144)%2, wown=floor(mask/524288)%2
| where del=1 OR wdac=1 OR wown=1
| table _time, host, SubjectUserName, ProcessName, ObjectName, AccessMask

Refused and then allowed on the same object within ten minutes

Means permissions changed or the account gained a privilege between two attempts. The Lucene line only narrows to files; the denied-then-allowed pairing happens in your SIEM.

index=wineventlog sourcetype=XmlWinEventLog:Security EventCode=4656 (Keywords="Audit Failure" OR Keywords="Audit Success")
| eval outcome=if(Keywords="Audit Failure", "denied", "allowed")
| transaction host SubjectUserName ObjectName maxspan=10m startswith=eval(outcome="denied") endswith=eval(outcome="allowed")
| table _time, host, SubjectUserName, ObjectName, duration

Which object types and processes produce the volume

One Spiceworks admin counted 82 million 4656 events for one user in a month, with services.exe asking for an SC_MANAGER OBJECT. Microsoft says kernel-object events have little to no security relevance and advises planning the data use before enabling File System or Registry auditing. Run this over a week and let the ObjectType column show which subcategory is the volume. Lucene is the base filter; the count runs in your SIEM.

index=wineventlog sourcetype=XmlWinEventLog:Security EventCode=4656
| stats count by Keywords, ObjectType, ProcessName
| sort - count
| head 25

True Positive vs False Positive

Most 4656 traffic is software doing ordinary work. Applications can ask for more rights than they use, as the Notepad sample shows, and antivirus engines, indexers and backup agents request handles all day. Build a per-path baseline of ProcessName values and the unfamiliar one becomes the lead. Microsoft's advice is the same. Compare ProcessName with the process you expect and flag executables outside System32 and Program Files.

Four patterns earn a rule. The first is refusals. One account failing against many different objects in a short window is what a sweep by an under-privileged account looks like, since MITRE notes that some files and directories need elevated or specific permissions to be read at all. The second is privilege-assisted success, a PrivilegeList that is not a hyphen on a file that account has no ACE for. The third is a request that asks for DELETE, WRITE_DAC or WRITE_OWNER from someone who does not own the folder. Microsoft's list of rights to watch, especially in Failure events, is WriteData, AppendData, WriteEA, DeleteChild, WriteAttributes, DELETE, WRITE_DAC and WRITE_OWNER. The fourth is refusal followed by success on the same object, which can mean permissions changed, or the account gained a privilege, between the two attempts.

When one fires, pivot on the identifiers. HandleId leads to the 4663 that shows use. SubjectLogonId leads to the 4624 and the source of the session. ProcessId leads to the 4688 for the parent. ObjectName with the time leads to a 4670 if the permissions changed, and to a 4660 if the object was deleted.

Know the blind spots. No SACL means no event, and a SACL edited away leaves silence that looks like health. A denied request tells you someone tried, not why. Prove your SACL works by touching a test file and finding the event before you trust a quiet log.

Which Event Answers Which Question

QuestionEventNote
Did someone ask for access, and was it refused?4656Has Success and Failure forms
Did they use the right they asked for?4663Success only
How long was the handle open?4658Needs Audit Handle Manipulation
Was the object deleted?4660HandleId only, no object name
Did the permissions change?4670Old and new SDDL; SACL entry required

The Simulated Backup-Mode Read

In the simulated event t.novak runs robocopy.exe from System32 and asks for a handle to D:\HR\Compensation\2026-bands.xlsx with mask 0x120089, a read. The process path is clean and the mask is modest. PrivilegeList reads SeBackupPrivilege, so the access check leaned on a privilege and not on the file's ACL.

That one field is the lead. If the account has no entry on the HR folder, the permissions report and the log disagree. The question is whether it belongs to a group that carries the backup right and had a reason to copy that file.

MITRE ATT&CK® Techniques

Event 4656 telemetry feeds detections for these ATT&CK® techniques:

Practice Investigating Event 4656

Reading about a handle to an object was requested is one thing. Working the detection inside a live console is another. These free SOCSimulator operations cover the attack techniques Event 4656 helps you detect:

Start investigating free

Frequently Asked Questions

What is event ID 4656?
It records a request for a handle to an object, with the rights asked for and the result. The object can be a file, a registry key, a kernel object or something on removable storage. It needs a SACL entry that covers the request and has Success and Failure forms.
What is the difference between event 4656 and event 4663?
4656 is the request for a handle and has a Failure form. 4663 is the use of an access right and has no failure form. A write right can appear in a 4656 and never in a 4663 if the process opens the file and never writes. They share HandleId.
Why am I getting millions of event 4656 entries?
Usually a SACL or an audit policy that is too wide, often on kernel objects or the Service Control Manager. Microsoft gives no recommendation to audit kernel objects and notes the default SACL comes from the 'Audit: Audit the access of global system objects' policy. Narrow the SACL to named paths.
How do I tell a failed 4656 from a successful one?
Look at the audit result. Event Viewer shows Audit Failure or Audit Success, and the keyword bits are 0x8010000000000000 for failure and 0x8020000000000000 for success in Microsoft's samples. SIEMs expose the same fact differently: Keywords text in Splunk, the raw keyword in Sentinel, event.outcome in Elastic.
How do I read AccessMask in a 4656 event?
Treat it as a sum of the access rights requested. Subtract the largest right that fits and repeat: 0x12019f is ReadData, WriteData, AppendData, ReadEA, WriteEA, ReadAttributes, WriteAttributes, READ_CONTROL and SYNCHRONIZE. It is what was asked for, not what was done.
Is a 4656 with a privilege in PrivilegeList suspicious?
It is a lead, not a verdict. The field lists privileges used for the access check, so the request succeeded because of a privilege and not the file's ACL. Backup agents do this all day. A user or an unfamiliar process doing it against a sensitive folder is what to chase.

Sources

“4656 description, fields, version 1 additions, access right table, privilege table, sample (Notepad, 0x12019f), monitoring recommendations”

“4663 shows use of an access right, with no failure form”

“4658 handle closed: needs Audit Handle Manipulation, little security relevance, HandleId may be 0x0”

“4660 object deleted: carries only a HandleId, not the object name”

“File System subcategory: no events for default SACLs, plan SACLs first, Failure events show unsuccessful attempts”

“Registry subcategory: 4656 for a new subkey appears only under the legacy Audit Object Access setting on Windows 11 and Server 2022 and later”

“Kernel Object subcategory: little security relevance, no recommendation, default SACL set by the global system objects policy”

“The 4625 failure sample carries Keywords 0x8010000000000000”

“4624 success sample carries Keywords 0x8020000000000000”

“File and Directory Discovery (T1083), ATT&CK v20: enumeration of files and directories, some of which need elevated or specific permissions”

“Field report of 82 million 4656 events for one user in a month, sample is services.exe requesting an SC_MANAGER OBJECT”

“Sentinel Windows Audit Checker workbook derives outcome from SecurityEvent Keywords 0x8020000000000000 (Success) and 0x8010000000000000 (Failure)”

“Winlogbeat sets event.outcome from the audit keyword and was fixed (#20564) to use the raw keyword value, because the translated text broke on non-English systems”

“SecurityEvent columns used in the KQL (AccessMask, PrivilegeList, ObjectType, ObjectName, HandleId, Keywords)”

“Splunk Add-on for Microsoft Windows (Splunk_TA_windows, package v9.0.1): default/props.conf, stanza [source::XmlWinEventLog:Security], EVAL-Keywords maps 0x8020000000000000 to Audit Success and 0x8010000000000000 to Audit Failure; read in the package, the listing page does not show it”

“Official add-on documentation: the add-on's default configuration files, props.conf among them, live in Splunk_TA_windows/default; the page does not itself list the Keywords EVAL”

Event ID

Event ID 4663: File Access, AccessMask and Detection Queries

Event ID 4663 shows an access right being used on a file or key. Decode AccessMask, fix 'not logging', and detect stagin…

Read more
Event ID

Event ID 5140: Share Access per Session & Admin Share Alerts

Event ID 5140 is logged once per SMB session. Learn what ShareName, IpAddress and AccessMask tell you, and detect C$ and…

Read more
Event ID

Event ID 5145: Per-File Share Access & PsExec Detection

Event ID 5145 logs every file or folder checked on a network share. Read ShareName and RelativeTargetName, spot ADMIN$ w…

Read more
Glossary

What is Data Exfiltration? SOC Glossary

Data exfiltration in cyber security is the unauthorized transfer of data from an organization's systems to infrastructur…

Read more
Glossary

What is Persistence? SOC Glossary

Persistence is the set of techniques an adversary uses to keep access to a compromised system after whatever gave them t…

Read more
Glossary

What is Threat Hunting? SOC Glossary

Threat hunting is the proactive search through security telemetry for attackers that existing controls missed. The hunte…

Read more
Career Path

SOC Analyst (Tier 2) Career Guide: Salary & Skills

Tier 2 SOC Analysts handle the investigations that Tier 1 escalates. You dig into multi-stage attacks, coordinate contai…

Read more
Career Path

Threat Hunter Career Guide: Salary & Skills

Threat Hunters do not wait for alerts. You develop hypotheses based on threat intelligence and adversary behavior models…

Read more
Technique

File and Directory Discovery (T1083): Detection Training

T1083 File and Directory Discovery is an adversary listing files and folders to decide what is worth stealing, using nat…

Read more
Comparison

SOCSimulator vs. LetsDefend: Platform Comparison

SOCSimulator wins on operational realism. You get multi-tool shift simulation with SLA pressure, noise injection, and al…

Read more
Event ID

Windows Event ID Library: SOC Reference

Windows Security and Sysmon event IDs with simulated log samples, field tables, and tested detection queries.

Read more
Feature

Shift Mode: Real-Time SOC Simulation

Practice alert triage under realistic time pressure with SLA timers and noise injection.

Read more