Create Account
Adversaries may create an account to maintain access to victim systems. With sufficient privilege, creating accounts establishes secondary credentialed access that does not require persistent remote access tools. Accounts may be created on local systems, within a domain, or in cloud tenants. Threat actors including Indrik Spider (WastedLocker), LockBit 2.0, Scattered Spider, and Salt Typhoon have all used account creation as a persistence mechanism. In cloud environments, attackers may create accounts with access limited to specific services to reduce detection likelihood.
What is T1136 Create Account?
Create Account (T1136) maps to the Persistence tactic — the adversary is trying to maintain their foothold in MITRE ATT&CK.
This page provides production-ready detection logic for Create Account, covering the data sources and telemetry it touches: User Account: User Account Creation, Process: Process Creation, Command: Command Execution, Windows Security Event Log, Microsoft Defender for Endpoint. The queries below are rated high severity at high confidence, and ship for 7 SIEM platforms — KQL, SPL, Elastic, QRadar, Sumo, YARA-L, LogScale.
MITRE ATT&CK
- Tactic
- Persistence
- Technique
- T1136 Create Account
- Canonical reference
- https://attack.mitre.org/techniques/T1136/
// T1136 — Create Account: Multi-platform account creation detection
// Covers: Windows local/domain accounts (Security Event 4720), WMIC-based creation, net.exe, PowerShell cmdlets, Linux useradd, Azure AD
let SuspiciousAccountNames = dynamic(["a", "admin1", "support", "helpdesk", "svc", "test", "user", "guest1", "temp"]);
let SuspiciousParentProcesses = dynamic(["cmd.exe", "powershell.exe", "wscript.exe", "cscript.exe", "mshta.exe", "rundll32.exe", "regsvr32.exe"]);
// Branch 1: Windows Security Event 4720 (User Account Created)
let WindowsAccountCreation =
SecurityEvent
| where TimeGenerated > ago(24h)
| where EventID == 4720
| extend NewAccountName = tostring(TargetUserName)
| extend CreatedBy = tostring(SubjectUserName)
| extend CreatedByDomain = tostring(SubjectDomainName)
| extend TargetDomain = tostring(TargetDomainName)
| extend ShortAccountName = tolower(NewAccountName) in (SuspiciousAccountNames)
| extend IsServiceAccount = NewAccountName startswith "svc-" or NewAccountName startswith "srv-"
| extend OffHours = hourofday(TimeGenerated) < 7 or hourofday(TimeGenerated) > 19
| project TimeGenerated, Computer, EventID, NewAccountName, CreatedBy, CreatedByDomain, TargetDomain,
ShortAccountName, IsServiceAccount, OffHours,
Source="Windows-Security-4720";
// Branch 2: Process-based account creation (net user, wmic, PowerShell New-LocalUser)
let ProcessAccountCreation =
DeviceProcessEvents
| where Timestamp > ago(24h)
| where (
(FileName =~ "net.exe" or FileName =~ "net1.exe") and ProcessCommandLine has "user" and ProcessCommandLine has "/add"
or (FileName =~ "wmic.exe" and ProcessCommandLine has "useraccount" and ProcessCommandLine has "create")
or (FileName =~ "powershell.exe" or FileName =~ "pwsh.exe") and (
ProcessCommandLine has "New-LocalUser" or ProcessCommandLine has "net user" and ProcessCommandLine has "/add"
)
or (FileName =~ "useradd" or FileName =~ "adduser")
)
| extend SuspiciousParent = InitiatingProcessFileName in~ (SuspiciousParentProcesses)
| extend OffHours = hourofday(Timestamp) < 7 or hourofday(Timestamp) > 19
| project TimeGenerated=Timestamp, Computer=DeviceName, EventID=0, NewAccountName="",
CreatedBy=AccountName, CreatedByDomain="", TargetDomain="",
ShortAccountName=false, IsServiceAccount=false, OffHours,
ProcessCommandLine, InitiatingProcessFileName,
SuspiciousParent, Source="ProcessCreate";
// Union results and surface high-confidence indicators
WindowsAccountCreation
| extend ProcessCommandLine="", InitiatingProcessFileName="", SuspiciousParent=false
| union ProcessAccountCreation
| extend RiskScore = toint(ShortAccountName) + toint(OffHours) + toint(SuspiciousParent)
| sort by TimeGenerated desc Detects account creation activity across Windows endpoints and Azure AD using two parallel branches. Branch 1 monitors Security Event ID 4720 (user account created) in the SecurityEvent table, flagging short/generic account names, off-hours creation, and unexpected creators. Branch 2 monitors DeviceProcessEvents for process-based account creation via net.exe /add, wmic useraccount create, New-LocalUser PowerShell cmdlets, and Linux useradd/adduser commands. A risk score is computed based on suspicious account name, off-hours activity, and suspicious parent process.
Data Sources
Required Tables
False Positives
- IT provisioning scripts that create service accounts or user accounts during onboarding workflows
- Software installers that create local service accounts (e.g., backup agents, monitoring tools like Datadog, SolarWinds)
- Domain join processes that create computer accounts triggering related audit events
- Automated testing infrastructure that creates and removes ephemeral accounts
- Password reset or account unlock scripts using net.exe that get flagged on the process branch
Sigma rule & cross-platform mapping
The detection logic for Create Account (T1136) above is provided in a vendor-neutral
form so you can deploy it on any SIEM. The same logic is shipped here as native
KQL (Microsoft Sentinel / Defender), SPL (Splunk), Elastic (Elastic Security (EQL)), QRadar (IBM QRadar (AQL)), Sumo (Sumo Logic CSE), YARA-L (Google Chronicle / SecOps), LogScale (CrowdStrike LogScale (CQL)) queries. In Sigma terms, this detection targets the
following logsource:
logsource:
category: process_creation
product: windows Browse the community-maintained Sigma rules for this technique:
Platform-specific guides for T1136
References (8)
- https://attack.mitre.org/techniques/T1136/
- https://docs.microsoft.com/en-us/windows/security/threat-protection/auditing/event-4720
- https://symantec-enterprise-blogs.security.com/blogs/threat-intelligence/wastedlocker-ransomware-us
- https://unit42.paloaltonetworks.com/lockbit-2-ransomware/
- https://www.cisa.gov/news-events/cybersecurity-advisories/aa23-320a
- https://www.cisco.com/c/en/us/td/docs/security/salt-typhoon-advisory.html
- https://github.com/redcanaryco/atomic-red-team/blob/master/atomics/T1136.001/T1136.001.md
- https://github.com/SigmaHQ/sigma/tree/master/rules/windows/builtin/security
Testing Methodology
Validate this detection against 4 adversary techniques from Atomic Red Team. Each test below lists the behaviour to exercise and the telemetry you should expect to see. Executable commands and cleanup steps are available with Pro.
- Test 1Create Local User Account via net.exe
Expected signal: Security Event 4720: 'A user account was created' with TargetUserName=df00tech-testacct, SubjectUserName=<running user>. Sysmon Event ID 1: Process Create with Image=net.exe (or net1.exe), CommandLine='net user df00tech-testacct P@ssw0rd123! /add'. Security Event 4722 (account enabled) may follow immediately.
- Test 2Create Local User via WMIC (Indrik Spider TTP)
Expected signal: Sysmon Event ID 1: Process Create with Image=wmic.exe, CommandLine containing 'useraccount'. Followed by net.exe process create. Security Event 4720 generated by the net user /add call. Parent process chain visible in Sysmon logs.
- Test 3Create Local User via PowerShell New-LocalUser
Expected signal: Sysmon Event ID 1: Process Create with Image=powershell.exe, CommandLine containing 'New-LocalUser'. Security Event 4720: new account df00tech-pstest created, SubjectUserName shows running user. PowerShell ScriptBlock Log Event ID 4104 will show the full New-LocalUser command with parameters.
- Test 4Linux Account Creation via useradd
Expected signal: Syslog / /var/log/auth.log: 'useradd: new user: name=df00tech-linuxtest, UID=<uid>, GID=<gid>'. If auditd is configured with -a always,exit -F arch=b64 -S execve rules: audit log entry for useradd execution with full command line. If Sysmon for Linux is deployed: process creation event for useradd.
Response Playbook
Triage
- Identify the account name — is it generic/short (e.g., 'a', 'support', 'temp', 'user') or does it match a naming pattern seen in ransomware groups like LockBit 2.0? Cross-reference against your org's naming conventions.
- Identify the creator — which account or process created the new account? If created by SYSTEM, a web application process (IIS, Tomcat), or a non-admin user account, treat as high priority.
- Check the parent process — if account creation was performed via net.exe or wmic.exe, examine the parent: was it spawned from a scripting engine (wscript, mshta), a document (winword.exe), or a C2-associated process?
- Determine if the new account was immediately added to privileged groups — query Event ID 4728 (global group add), 4732 (local group add), or 4756 (universal group add) for the new account name within ±5 minutes of creation.
- Check for off-hours creation — creation at 2–4am on a production server with no change ticket is strongly anomalous. Verify against ITSM/change management records.
- Review whether the new account has already been used — check Security Event 4624 (logon) for the new username post-creation to determine if it was immediately leveraged for access.
- For cloud environments: check if the account was created with privileged roles (Global Administrator, Owner) and whether MFA was configured at creation time.
Containment
- If the account appears malicious: immediately disable it in Active Directory (Disable-ADAccount) or local SAM (net user <username> /active:no) before full investigation to prevent further use.
- If the account was already used for logon: review all sessions from that account — check for lateral movement (Event 4648, 4624 type 3) and remote service authentication.
- If account creation was triggered by a compromised process (e.g., IIS, web app): isolate the host from the network via EDR network isolation or VLAN change, then begin full incident response.
- If created via a compromised admin account: rotate credentials for the compromised account, revoke active sessions (revoke Kerberos TGTs, invalidate OAuth tokens), and audit all actions performed by that account in the past 30 days.
- For cloud accounts: remove the newly created cloud user or service principal immediately, revoke any access tokens, and audit the creator's activity in Azure AD / AWS CloudTrail / GCP Cloud Audit Logs.
Evidence Collection
- Windows Security Event 4720 — 'A user account was created' — captures: new account name, SID, creator account name, creator SID, logon ID, and domain. Available in Security.evtx.
- Windows Security Event 4722 — 'A user account was enabled' — often follows 4720 for accounts created in disabled state then activated.
- Windows Security Event 4728/4732/4756 — Group membership changes — check if the new account was added to Administrators, Remote Desktop Users, or Domain Admins.
- Windows Security Event 4624/4648 — Logon events — did the new account immediately log on? From where? What logon type?
- Sysmon Event ID 1 — Process Creation — if account was created via net.exe or wmic.exe, collect full command line, parent process, and process tree from creation time.
- Prefetch — C:\Windows\Prefetch\NET.EXE-*.pf or NET1.EXE-*.pf — confirms execution of net.exe and provides timestamps.
- Command history — PowerShell: $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history.txt — check for New-LocalUser or net user /add commands.
- SAM database snapshot — if account persists, extract SAM hive (reg save HKLM\SAM) to enumerate all local accounts and their creation timestamps.
- For Linux: /etc/passwd and /etc/shadow modification timestamps — if Salt Typhoon-style attack, look for manual edits rather than useradd tool usage. Also check /var/log/auth.log or /var/log/secure for useradd/adduser entries.
- For Azure AD: AuditLogs table — Operation: 'Add user' or 'Add service principal' — includes initiating user, target, and timestamp.
Escalation Criteria
- ! New account immediately added to Domain Admins, Administrators, or Enterprise Admins — this indicates preparation for privileged persistence or lateral movement.
- ! Account was created by a non-human process (web application, scheduled task, service) rather than a human administrator — indicates code execution or service compromise.
- ! Account name matches known ransomware patterns — LockBit 2.0 creates accounts named 'a', Scattered Spider creates accounts mimicking existing IT staff.
- ! Account creation followed by immediate logon (Event 4624) from a remote IP, especially over RDP (logon type 10) or network logon (type 3).
- ! Account creation event has no corresponding change ticket in ITSM — contact the purported creator to verify authorization before proceeding.
- ! Multiple accounts created in a short window (3+ accounts within 10 minutes) — indicates automated backdoor account seeding common in ransomware pre-encryption stages.
- ! Account creation on a critical server (domain controller, jump host, backup server, security tooling) regardless of timing or naming.
Investigation Guide
Forensic Artifacts
- >
Windows Event Log: Security.evtx — Event 4720 (account created), 4722 (account enabled), 4724 (password reset), 4728/4732 (group membership), 4624 (logon after creation). - >
Registry: HKLM\SAM\SAM\Domains\Account\Users — contains SID-keyed entries for all local accounts; last write time indicates account creation or modification. - >
Registry: HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList — user profile entries; absence for a new account may indicate it was created but never logged in. - >
File System: C:\Windows\System32\config\SAM — offline SAM database; parse with impacket secretsdump.py or SIFT workstation tools to enumerate all local accounts with creation metadata. - >
Linux — /etc/passwd: new line for created user with UID/GID/home/shell; modification timestamp on file indicates recent account activity. - >
Linux — /etc/shadow: password hash entry for new account; if directly edited (Salt Typhoon TTP) rather than created via useradd, the format may differ from other entries. - >
Linux — /var/log/auth.log or /var/log/secure: useradd/adduser invocations logged with invoking user, new username, and UID assignment. - >
Linux — /var/log/wtmp (last -f /var/log/wtmp) and /var/log/btmp: login history including first logon of newly created accounts. - >
Prefetch: C:\Windows\Prefetch\NET.EXE-*.pf and NET1.EXE-*.pf — confirms net.exe execution and timestamps. - >
Network: Kerberos TGT requests (Event 4768) — if domain account was created and immediately used, TGT issuance will appear in DC logs shortly after 4720. - >
Azure AD: AuditLogs (Operation: Add user), SigninLogs (first sign-in for new user) — available in Microsoft Entra admin center and Log Analytics.
Tuning Guidance
Account creation detections tend to generate moderate false positive volumes in environments with active user provisioning pipelines. Start by building an allowlist of expected creator accounts — typically your Identity Management system service account (e.g., the Okta provisioning agent, Azure AD Connect sync account, or your ITSM service account). These can be excluded by SubjectUserName in the Security Event 4720 branch. For the process-based branch, exclude known-good parent processes used by your deployment tools — SCCM (ccmexec.exe), Ansible WinRM sessions (wsmprovhost.exe), and Puppet agent (ruby.exe) are common legitimate sources. The highest-fidelity signals are: (1) account creation by an unexpected account at off-hours, (2) account creation immediately followed by group membership changes, (3) account names matching known threat actor patterns (single character, generic IT names). Consider setting a baseline for your environment's normal account creation rate — more than 3 accounts per hour outside of business hours with no change ticket is a reliable threshold. For ransomware hunting specifically, filter for account names of length <= 4 characters, which matches LockBit 2.0's 'a' account pattern and similar short-name tactics used by other groups pre-encryption.
Hunting Queries
Hunt for user accounts that were created and then had a successful logon within one hour. Legitimate provisioned accounts typically do not log in immediately — rapid first use strongly indicates adversarial backdoor account creation and immediate exploitation.
// Hunt: Accounts created then used within 1 hour (rapid exploitation)
let AccountCreations =
SecurityEvent
| where TimeGenerated > ago(7d)
| where EventID == 4720
| project CreationTime=TimeGenerated, NewUser=TargetUserName, Computer, Creator=SubjectUserName;
let AccountLogons =
SecurityEvent
| where TimeGenerated > ago(7d)
| where EventID == 4624
| where LogonType in (2, 3, 10)
| project LogonTime=TimeGenerated, LogonUser=TargetUserName, LogonHost=Computer, IpAddress=IpAddress;
AccountCreations
| join kind=inner AccountLogons on $left.NewUser == $right.LogonUser
| where LogonTime between (CreationTime .. (CreationTime + 1h))
| project CreationTime, LogonTime, NewUser, CreationHost=Computer, Creator, LogonHost, IpAddress
| sort by CreationTime desc index=wineventlog sourcetype="WinEventLog:Security" EventCode=4720
| eval NewUser=trim(mvindex(split(Message, "Account Name:"), 2))
| eval NewUser=trim(mvindex(split(NewUser, "\n"), 0))
| eval CreationTime=_time
| rename host as CreationHost
| join type=inner NewUser [
search index=wineventlog sourcetype="WinEventLog:Security" EventCode=4624 LogonType IN (2, 3, 10)
| eval LogonUser=trim(mvindex(split(Message, "Account Name:"), 2))
| eval LogonUser=trim(mvindex(split(LogonUser, "\n"), 0))
| eval LogonTime=_time
| rename host as LogonHost
| rename LogonUser as NewUser
| table NewUser, LogonTime, LogonHost
]
| where (LogonTime - CreationTime) <= 3600 AND LogonTime >= CreationTime
| table CreationTime, LogonTime, NewUser, CreationHost, LogonHost
| sort - CreationTime Hunt for accounts created and then immediately added to security groups within a 10-minute window. Adversaries often create a backdoor account and immediately escalate its privileges by adding it to Administrators or Domain Admins. This query correlates Events 4720/4728/4732/4756 by account name and time proximity.
// Hunt: Account creation followed by group membership change (privilege escalation)
SecurityEvent
| where TimeGenerated > ago(7d)
| where EventID in (4720, 4728, 4732, 4756)
| extend AccountAffected = iff(EventID == 4720, TargetUserName, MemberName)
| extend Actor = SubjectUserName
| extend Action = iff(EventID == 4720, "Account Created", "Added to Group")
| extend GroupName = iff(EventID == 4720, "", TargetUserName)
| project TimeGenerated, EventID, Action, AccountAffected, GroupName, Actor, Computer
| sort by AccountAffected asc, TimeGenerated asc
| summarize EventSequence=make_list(Action), Groups=make_set(GroupName), TimeWindow=max(TimeGenerated)-min(TimeGenerated), FirstEvent=min(TimeGenerated), LastEvent=max(TimeGenerated) by AccountAffected, Actor
| where EventSequence has "Account Created" and EventSequence has "Added to Group"
| where TimeWindow < 10m
| sort by FirstEvent desc index=wineventlog sourcetype="WinEventLog:Security" EventCode IN (4720, 4728, 4732, 4756)
| eval AccountAffected=trim(mvindex(split(Message, "Account Name:"), 2))
| eval AccountAffected=trim(mvindex(split(AccountAffected, "\n"), 0))
| eval Action=case(EventCode==4720, "Account Created", EventCode==4728, "Added to Global Group", EventCode==4732, "Added to Local Group", EventCode==4756, "Added to Universal Group", true(), "Other")
| bin _time span=10m
| stats values(Action) as Actions, values(EventCode) as EventCodes, count by AccountAffected, host, _time
| where mvcount(Actions) > 1
| search Actions="*Account Created*" Actions="*Added to*"
| sort - _time Hunt for account creation commands spawned from unusual parent processes — specifically web application processes (w3wp.exe, java.exe), scripting engines (wscript, cscript, mshta), or proxy execution tools (rundll32, regsvr32). This pattern indicates that account creation was triggered through code execution rather than a legitimate administrative action.
// Hunt: Account creation via unusual parent process on endpoint (process-based)
DeviceProcessEvents
| where Timestamp > ago(7d)
| where (
(FileName in~ ("net.exe", "net1.exe") and ProcessCommandLine has "user" and ProcessCommandLine has "/add")
or (FileName =~ "wmic.exe" and ProcessCommandLine has "useraccount" and ProcessCommandLine has "create")
or ((FileName in~ ("powershell.exe", "pwsh.exe")) and ProcessCommandLine has "New-LocalUser")
)
| extend IsHighRiskParent = InitiatingProcessFileName in~ (
"cmd.exe", "powershell.exe", "wscript.exe", "cscript.exe",
"mshta.exe", "rundll32.exe", "regsvr32.exe", "svchost.exe",
"w3wp.exe", "java.exe", "python.exe", "python3"
)
| where IsHighRiskParent
| project Timestamp, DeviceName, AccountName, FileName, ProcessCommandLine,
InitiatingProcessFileName, InitiatingProcessCommandLine
| sort by Timestamp desc index=wineventlog sourcetype="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational" EventCode=1
((Image="*\\net.exe" OR Image="*\\net1.exe") AND CommandLine="*user*" AND CommandLine="*/add*")
OR (Image="*\\wmic.exe" AND CommandLine="*useraccount*" AND CommandLine="*create*")
OR ((Image="*\\powershell.exe" OR Image="*\\pwsh.exe") AND CommandLine="*New-LocalUser*")
| eval HighRiskParent=if(match(ParentImage, "(wscript\.exe|cscript\.exe|mshta\.exe|rundll32\.exe|regsvr32\.exe|w3wp\.exe|java\.exe|python\.exe)"), 1, 0)
| where HighRiskParent=1
| table _time, host, User, Image, CommandLine, ParentImage, ParentCommandLine, HighRiskParent
| sort - _time Atomic Red Team Tests
Creates a local user account using net.exe, the most common method observed in threat actor activity including Indrik Spider (WastedLocker) and LockBit 2.0. The account is created with a password and then cleaned up. This generates Security Event 4720 and Sysmon Event ID 1.
Command
net user df00tech-testacct P@ssw0rd123! /add Cleanup
net user df00tech-testacct /delete Expected Telemetry
Security Event 4720: 'A user account was created' with TargetUserName=df00tech-testacct, SubjectUserName=<running user>. Sysmon Event ID 1: Process Create with Image=net.exe (or net1.exe), CommandLine='net user df00tech-testacct P@ssw0rd123! /add'. Security Event 4722 (account enabled) may follow immediately.
Expected Detection
KQL Branch 2 fires on FileName=net.exe + ProcessCommandLine has 'user' + has '/add'. SPL Branch 2 fires on Image=*\net.exe with CommandLine matching user and /add patterns. Security Event 4720 branch fires independently. Risk score elevated if executed outside business hours.
Creates a local user account using wmic.exe useraccount create — the exact technique documented for Indrik Spider (WastedLocker ransomware group). This bypasses the more obvious 'net user' command and may evade simple string-matching rules focused only on net.exe.
Command
wmic useraccount where "name='nonexistent'" get name 2>nul & net user df00tech-wmictest P@ssw0rd123! /add Cleanup
net user df00tech-wmictest /delete Expected Telemetry
Sysmon Event ID 1: Process Create with Image=wmic.exe, CommandLine containing 'useraccount'. Followed by net.exe process create. Security Event 4720 generated by the net user /add call. Parent process chain visible in Sysmon logs.
Expected Detection
KQL Branch 2 fires on FileName=wmic.exe with ProcessCommandLine has 'useraccount'. SPL Branch 2 matches Image=*\wmic.exe with CommandLine=*useraccount*. Also triggers Security Event 4720 detection.
Creates a local user account using the PowerShell New-LocalUser cmdlet. This technique is harder to detect with simple command-line matching and is commonly used in post-exploitation frameworks and custom ransomware scripts to create backdoor accounts.
Command
powershell.exe -Command "$Password = ConvertTo-SecureString 'P@ssw0rd123!' -AsPlainText -Force; New-LocalUser -Name 'df00tech-pstest' -Password $Password -Description 'Test account'" Cleanup
powershell.exe -Command "Remove-LocalUser -Name 'df00tech-pstest'" Expected Telemetry
Sysmon Event ID 1: Process Create with Image=powershell.exe, CommandLine containing 'New-LocalUser'. Security Event 4720: new account df00tech-pstest created, SubjectUserName shows running user. PowerShell ScriptBlock Log Event ID 4104 will show the full New-LocalUser command with parameters.
Expected Detection
KQL Branch 2 fires on FileName=powershell.exe + ProcessCommandLine has 'New-LocalUser'. SPL Branch 2 matches Image=*\powershell.exe with CommandLine=*New-LocalUser*. Security Event 4720 fires independently. SuspiciousParent flag set if invoked from a suspicious parent.
Creates a user account on Linux using useradd — the standard account creation utility. Salt Typhoon was observed creating Linux-level users on network devices, sometimes bypassing useradd in favor of direct /etc/passwd and /etc/shadow modification. This test covers the useradd path.
Command
sudo useradd -m -s /bin/bash df00tech-linuxtest && echo 'Account created' && id df00tech-linuxtest Cleanup
sudo userdel -r df00tech-linuxtest 2>/dev/null; true Expected Telemetry
Syslog / /var/log/auth.log: 'useradd: new user: name=df00tech-linuxtest, UID=<uid>, GID=<gid>'. If auditd is configured with -a always,exit -F arch=b64 -S execve rules: audit log entry for useradd execution with full command line. If Sysmon for Linux is deployed: process creation event for useradd.
Expected Detection
KQL Branch 2 fires on FileName=useradd in DeviceProcessEvents. SPL Branch 2 fires on Image=*useradd in Sysmon for Linux logs. If using auditd, Syslog-based queries on 'useradd' command invocation will fire.