Study guide
8.2 Threat Hunting Techniques with PowerShell and Scripting
EC-Council Certified SOC Analyst CSA 312-39
Track your progress as you read
Finished sections get a check mark.
1 Introduction: Current Exam Facts and Blueprint
0.1 Current Exam Facts, Blueprint, and Study Plan
2 Chapter 1: Security Operations and Management Fundamentals
1.1 SOC Overview, Capabilities, and Operational Workflow 1.2 SOC Architectures, Sourcing Models, and Organizational Components 1.3 SOC Maturity, Generations, Metrics, and KPIs
3 Chapter 2: Cyber Threat Vectors, TTPs, and Attack Techniques
2.1 Network, Host, and Password Attack Techniques 2.2 Application, Web, and Session Attack Vectors 2.3 Social Engineering, Email Threats, and Insider Attacks
4 Chapter 3: Threat Frameworks, Methodologies, and Indicators
3.1 Indicators of Compromise (IoCs), Indicators of Attack (IoAs), and Pyramid of Pain 3.2 Cyber Kill Chain and Diamond Model of Intrusion Analysis 3.3 MITRE ATT&CK and MITRE D3FEND Frameworks for SOC Defense
5 Chapter 4: Log Management, Formats, and Centralized Architecture
4.1 Log Fundamentals, Sources, and Host Logging 4.2 Network Device, Web Server, and Database Logs 4.3 Centralized Logging Architectures and Pipeline 4.4 Log Parsing, Normalization, and Field Extraction
6 Chapter 5: SIEM Architecture, Deployment, and Use Case Engineering
5.1 SIEM Architecture, Components, and Deployment Models 5.2 SIEM Use Case Development Lifecycle 5.3 Detection Rule Engineering and Sigma Rules
7 Chapter 6: SIEM Alert Triage, Detection Scenarios, and SOC Operations
6.1 Host and Application-Level Incident Detection Use Cases 6.2 Network-Level and Behavioral Anomaly Detection Use Cases 6.3 Alert Triage Methodology and False Positive Elimination 6.4 SOC Dashboards, Visualizations, and Reporting
8 Chapter 7: Cyber Threat Intelligence (CTI) and Threat-Informed Defense
7.1 Cyber Threat Intelligence (CTI) Lifecycle and Intelligence Types 7.2 Threat Intelligence Sources, Formats, and Platforms 7.3 Integrating Threat Intelligence into SOC and SIEM Operations
9 Chapter 8: Threat Hunting Methodologies and Proactive Detection
8.1 Threat Hunting Principles, Frameworks, and Process 8.2 Threat Hunting Techniques with PowerShell and Scripting 8.3 YARA Rule Crafting and Threat Hunting Tooling
10 Chapter 9: Incident Response Lifecycle, Governance, and Handling Procedures
9.1 Incident Response Frameworks and the SOC-IRT Interface 9.2 Incident Triage, Ticketing, and Prioritization 9.3 Containment, Eradication, Recovery, and Root Cause Analysis
11 Chapter 10: Incident Response Playbooks and SOC Automation
10.1 Specialized Incident Response Playbooks 10.2 Endpoint Detection and Response (EDR) and Extended Detection and Response (XDR) 10.3 Security Orchestration, Automation, and Response (SOAR) Playbooks
12 Chapter 11: Digital Forensics and Evidence Handling for SOC Analysts
11.1 Digital Forensics Fundamentals and Evidence Preservation 11.2 Host, Network, and Memory Forensics Triage 11.3 Malware Analysis Techniques for SOC Responders
13 Chapter 12: Cloud SOC Architectures and Monitoring
12.1 Cloud SOC Foundations and Shared Responsibility 12.2 Azure Security Operations with Microsoft Sentinel 12.3 AWS and Google Cloud Platform SOC Architectures
8.2 Threat Hunting Techniques with PowerShell and Scripting
Key Takeaways Explain This Topic AI
Least Frequency of Occurrence (LFO) or stack counting aggregates high-volume endpoint telemetry across fleets to isolate rare, anomalous binaries, command lines, or parent-child processes that hide among routine enterprise noise.
PowerShell provides deep host-level hunting capabilities via Get-CimInstance for WMI inspection, Get-NetTCPConnection for active network socket analysis, and Get-WinEvent with XML XPath filtering for high-speed event log queries.
Comprehensive PowerShell hunting covers process lineage, active sockets, service creation, registry Run keys, scheduled tasks, and WMI event subscriptions (__EventFilter, CommandLineEventConsumer, __FilterToConsumerBinding).
Lateral movement hunting focuses on administrative shares (C , A D M I N , ADMIN , A D M I N ), remote service creation (Event ID 7045), and anomalous named pipe creation (Sysmon Event ID 17/18) used by tools like PsExec and Cobalt Strike.
Python scripting with pandas and matplotlib/seaborn empowers SOC hunters to aggregate millions of proxy, DNS, or authentication logs, compute statistical baselines, and visually identify periodic beaconing intervals.
Last updated: September 2026
Threat Hunting Techniques with PowerShell and Scripting
Effective threat hunting requires transitioning from abstract conceptual frameworks to programmatic interrogation of endpoint and network telemetry. In Windows enterprise environments, PowerShell represents both an adversary's preferred post-exploitation tool and a threat hunter's most powerful native investigative utility. By mastering native PowerShell cmdlets, Common Information Model (CIM) queries, high-performance event log filtering, and data science scripting in Python, SOC analysts can rapidly uncover stealthy footholds, persistence mechanisms, and lateral movement across thousands of endpoints.
Threat Hunting Telemetry: Host vs. Network Requirements
A comprehensive threat hunting campaign requires balancing two distinct telemetry domains: host-level telemetry and network-level telemetry. Each provides unique visibility into different phases of the MITRE ATT&CK matrix.
Host Telemetry
Host telemetry captures the internal operational state of endpoints, hypervisors, and servers. Because modern attackers frequently encrypt network communications (via TLS 1.3 or proprietary obfuscation), host-level visibility is essential for inspecting process execution, memory allocation, and operating system API calls prior to encryption.
Process Execution Tracking : Process creation events containing full command-line arguments, parent process names, execution directory, user security identifiers (SIDs), and cryptographic hashes (SHA-256). Captured via Sysmon Event ID 1 or Windows Security Event ID 4688 (with command-line process auditing enabled via Group Policy).
Process Network Connections : Correlating network sockets with the specific process ID (PID) and executable image that initiated the connection. Captured via Sysmon Event ID 3 .
Module and DLL Loading : Identifying dynamic link libraries loaded into process memory spaces to detect DLL sideloading and DLL search order hijacking. Captured via Sysmon Event ID 7 .
Persistence Stores : Monitoring registry modifications (Sysmon IDs 12, 13, 14), file creation in startup folders (Sysmon ID 11), scheduled task registrations ( Security Event ID 4698 / TaskScheduler Operational ID 106), and WMI event consumer bindings (Sysmon IDs 19, 20, 21).
Authentication and Privilege Escalation : Tracking interactive, network, and service logons via Security Event ID 4624 (specifically Logon Types 2, 3, 9, and 10), explicit credential delegations ( Event ID 4648 ), and special privilege assignments ( Event ID 4672 ).
Network Telemetry
Network telemetry captures communications visible to sensors across internal subnets, boundaries, and egress points. Out-of-band sensors can retain observations when an endpoint agent is impaired, but only for traffic that crosses the monitored path and survives sampling, encryption, packet loss, filtering, and retention.
Network Flow Data (NetFlow v9 / IPFIX) : High-level session metadata providing IP 5-tuples (Source IP, Destination IP, Source Port, Destination Port, Protocol), packet counts, byte volumes, and flow duration. Ideal for identifying large-scale data exfiltration and beaconing cadence.
Protocol-Aware Transaction Logs (Zeek / Bro) : Deep protocol inspection yielding structured logs such as dns.log (query domains, record types, response codes, TTLs), http.log (URIs, user-agent headers, response sizes), ssl.log (SNI hostnames, TLS cipher suites, certificate subjects, JA3/JA4 fingerprint hashes), and conn.log .
Perimeter and Proxy Telemetry : Egress firewall logs, web proxy authentication records, and VPN connection logs tracking external IP origins and geographic coordinates.
Host vs. Network Telemetry Comparison
Attribute Host Telemetry (Sysmon / EDR / OS Logs) Network Telemetry (Zeek / NetFlow / Proxies)
Visibility Depth Process lineage, selected memory/registry/file events, and script telemetry when configured Inter-host traffic, boundary crossings, protocol metadata, and byte counts within sensor coverage
Impact of Encryption Endpoint sensors may observe activity before encryption or after decryption, depending on hook and product Network sensors usually lose payload visibility under strong encryption but retain metadata; fields such as SNI can also be hidden or absent
Vulnerability to Tampering Attackers with sufficient privilege may impair agents or local logs Out-of-band sensors are harder for an endpoint attacker to modify directly, but taps, SPAN configuration, packet loss, and blind spots still matter
Data Volume & Retention Massive: Millions of local events per host daily; requires aggressive filtering Variable: NetFlow is extremely lightweight; full packet capture (PCAP) is cost-prohibitive
Primary Hunting Value Code execution, persistence, credential dumping, local privilege escalation Command & Control beaconing, lateral network reconnaissance, data exfiltration
Frequency Analysis & Stack Counting (Least Frequency of Occurrence - LFO)
The fundamental challenge of threat hunting is data volume. In an enterprise of 10,000 workstations, standard operational tasks occur millions of times every day. Sophisticated adversaries understand this and attempt to blend their activities into normal system noise. Stack Counting , also known as Frequency Analysis or Least Frequency of Occurrence (LFO) , is the mathematical technique used by threat hunters to filter out the noise and expose hidden threats.
The Mathematical Principle of LFO
Stack counting relies on an inverse probability distribution: legitimate system operations and standardized administrative management tools occur with high frequency across an enterprise fleet. In contrast, tailored adversary attacks, custom staging scripts, unique backdoor binaries, and novel persistence mechanisms appear with extremely low frequency—often on only a single host or across two endpoints in the entire enterprise.
To execute LFO, a hunter selects a combination of key attributes (e.g., ProcessName + ParentProcess + CommandLine + SHA256 ), groups the fleet-wide telemetry by these attributes, counts the total occurrences across all endpoints, and sorts the results in ascending order (lowest count first). The items residing at the absolute bottom of the stack—the 1-of-10,000 occurrences—represent high-priority candidates for human investigation.
Worked Stack Counting / LFO Numerical Example
Consider a threat hunt across 10,000 Windows workstations analyzing process execution telemetry over a 7-day window. Fleet-wide data is stacked by Process Name, Parent Process, and Command Line Arguments:
Process Name Parent Process Execution Path & Command Line Arguments Fleet Count (N=10,000) Frequency % Threat Hunting Verdict & Action
svchost.exe services.exe C:\Windows\System32\svchost.exe -k LocalServiceNetworkRestricted -p -s Dhcp 10,000 100.0% Baseline : Standard Windows DHCP client service; normal enterprise operation.
chrome.exe explorer.exe C:\Program Files\Google\Chrome\Application\chrome.exe --type=utility 9,842 98.42% Baseline : Legitimate enterprise browser worker process launched by desktop shell.
conhost.exe cmd.exe \??\C:\Windows\system32\conhost.exe 0xffffffff -ForceV1 4,215 42.15% Baseline : Console window host supporting standard command-line sessions.
powershell.exe sccm_client.exe powershell.exe -ExecutionPolicy Bypass -File C:\Windows\CCM\Cache\deploy.ps1 2,450 24.50% Known Admin : Enterprise SCCM package deployment script; signed and verified.
powershell.exe excel.exe powershell.exe -w hidden -enc JABjAGwAaQBlAG4AdAAgAD0AIABOAGUAdwAt... 2 0.02% High-Severity Anomaly : Office macro spawning hidden, Base64-encoded PowerShell payload.
cmd.exe spoolsv.exe cmd.exe /c whoami > C:\ProgramData\out.txt 1 0.01% Critical Outlier : Print Spooler service spawning command shell; indicates PrintNightmare exploitation.
rundll32.exe wmiprvse.exe rundll32.exe C:\Users\Public\update.dll,DllRegisterServer 1 0.01% Critical Outlier : WMI provider spawning unsigned DLL execution from public user directory.
Rare-event ranking helps surface unusual parent-child relationships for investigation, but rarity alone is not maliciousness. The cutoff should be tuned to the environment, and analysts must validate signer, path, account, asset role, prevalence history, and surrounding behavior.
Hunting with PowerShell on Windows: WMI/CIM, Sockets, and Event Logs
PowerShell provides deep, agentless inspection capabilities across Windows operating systems. To hunt effectively, analysts must master three core primitives: querying the Common Information Model (CIM), inspecting active network sockets, and executing high-performance event log searches.
Querying WMI/CIM via Get-CimInstance
While legacy administration relied on Get-WmiObject , modern threat hunting utilizes Get-CimInstance . Get-CimInstance communicates over WS-Management (WS-Man / WinRM) on ports 5985/5986 (HTTP/HTTPS), bypassing restrictive DCOM/RPC firewall barriers and providing faster binary object serialization. # Inspect all running processes with their Process ID, Parent PID, and full Command Line
- Get-CimInstance -ClassName Win32_Process |
- Select-Object ProcessId, ParentProcessId, Name, ExecutablePath, CommandLine |
- Format-Table -AutoSize
- # Audit all installed services executing out of non-standard directories using path wildcards
- Get-CimInstance -ClassName Win32_Service |
- Where-Object { $_.PathName -notlike "C:\Windows\System32*" -and $_.PathName -notlike "C:\Program Files*" } |
- Select-Object Name, DisplayName, State, StartMode, PathName
- Inspecting Network Sockets via Get-NetTCPConnection
Adversaries maintaining interactive command-and-control (C2) channels leave active TCP sockets. Hunters can query the network stack directly and correlate socket owners with the underlying process: # Query active established TCP connections and correlate with Process Image Names
- Get-NetTCPConnection -State Established |
- Select-Object LocalAddress, LocalPort, RemoteAddress, RemotePort, OwningProcess, @{
- Name = "ProcessName"
- Expression = { (Get-Process -Id $_.OwningProcess -ErrorAction SilentlyContinue).Name }
- }, @{
- Name = "Path"
- Expression = { (Get-Process -Id $_.OwningProcess -ErrorAction SilentlyContinue).Path }
- } | Format-Table -AutoSize
- High-Performance Event Log Querying: Get-WinEvent XML XPath Filtering
A common operational pitfall in SOC threat hunting is retrieving event logs using client-side pipeline filtering: Get-WinEvent -LogName Security | Where-Object { $_.Id -eq 4688 } . This approach forces Windows to deserialize hundreds of thousands of events from disk into PowerShell memory before filtering, causing severe memory bloat, high CPU utilization, and query runtimes exceeding hours.
To reduce client-side work across large event sets, hunters should use supported source-side filtering through -FilterXPath or -FilterHashtable where practical. The Windows Event Log service applies supported criteria before PowerShell materializes returned event objects; speed still depends on source, indexing, selectivity, transport, and resources: # High-Performance XPath Filter for Process Creation (Event ID 4688) targeting LOLBins
- $XPathFilter = @"
- *[System[(EventID=4688) and TimeCreated[timediff(@SystemTime) <= 604800000]]]
- and
- *[EventData[
- Data[@Name='NewProcessName'] and (
- contains(Data[@Name='NewProcessName'], 'powershell.exe') or
- contains(Data[@Name='NewProcessName'], 'certutil.exe') or
- contains(Data[@Name='NewProcessName'], 'mshta.exe') or
- contains(Data[@Name='NewProcessName'], 'rundll32.exe')
- )
- ]]
- "@
- Get-WinEvent -LogName Security -FilterXPath $XPathFilter | ForEach-Object {
- $xml = [xml]$_.ToXml()
- [PSCustomObject]@{
- TimeCreated = $_.TimeCreated
- ComputerName = $_.MachineName
ProcessName = $xml.Event.EventData.Data | Where-Object { $_.Name -eq 'NewProcessName' } | Select-Object -ExpandProperty '#text'
CommandLine = $xml.Event.EventData.Data | Where-Object { $_.Name -eq 'CommandLine' } | Select-Object -ExpandProperty '#text'
ParentProcess = $xml.Event.EventData.Data | Where-Object { $_.Name -eq 'ParentProcessName' } | Select-Object -ExpandProperty '#text'
AccountName = $xml.Event.EventData.Data | Where-Object { $_.Name -eq 'SubjectUserName' } | Select-Object -ExpandProperty '#text'
- }
- } | Format-Table -AutoSize
- Comprehensive PowerShell Threat Hunting Cmdlets Reference
Cmdlet / Subsystem Telemetry & Artifacts Inspected Example Hunting Syntax Target Adversary Technique / TTP
Get-CimInstance Win32_Process Process ID, Parent PID, full command line, image path Get-CimInstance Win32_Process | Select ProcessId, ParentProcessId, Name, CommandLine LOLBin execution (T1059.001), anomalous parent-child relationships (T1059)
Get-CimInstance Win32_Service Service name, display name, state, start mode, binary path Get-CimInstance Win32_Service | Where { $_.PathName -notmatch '(?i)system32|program files' } Malicious Windows service creation, PsExec staging (T1543.003)
Get-NetTCPConnection Active sockets, local/remote IPs, ports, owning PID Get-NetTCPConnection -State Established | Where { $_.RemotePort -notin @(80,443) } C2 beaconing (T1071.001), reverse shells, non-standard outbound egress
Get-WinEvent -FilterXPath High-speed kernel filtering of Security, System, Sysmon logs Get-WinEvent -LogName Security -FilterXPath "*[System[EventID=4688]] and *[EventData[...]]" Process creation, LSASS dumping (Event 4688, Sysmon 10) without memory bloat
Get-ScheduledTask Task name, path, state, triggering actions, binary payload Get-ScheduledTask | Where { $_.Actions.Execute -match 'powershell|cmd|mshta' } Persistence via scheduled tasks and jobs (T1053.005)
Get-ItemProperty (Registry) Registry Run, RunOnce, Winlogon, Startup keys Get-ItemProperty 'HKLM:\Software\Microsoft\Windows\CurrentVersion\Run' Autostart persistence across reboots (T1547.001)
Get-CimInstance (root\subscription) WMI __EventFilter , CommandLineEventConsumer , __FilterToConsumerBinding Get-CimInstance -Namespace 'root\subscription' -ClassName __FilterToConsumerBinding Fileless persistent WMI event subscriptions (T1546.003)
Get-FileHash Cryptographic hashes (SHA-256, MD5) of suspicious files Get-ChildItem 'C:\Users\Public\' -Recurse -File | Get-FileHash -Algorithm SHA256 Ingress tool transfer, unverified staging binaries (T1105)
Production-Ready PowerShell Hunting Scripts
Threat hunters deploy specialized, production-ready hunting scripts to interrogate endpoints for specific adversary tradecraft.
Script 1: Detecting Anomalous Process Parentage
Adversaries exploiting document macros, web servers, or print spoolers force benign parent processes to spawn command shells. This script scans running processes and identifies high-risk parent-child anomalies: <#
.SYNOPSIS
Hunts for anomalous parent-child process relationships across running processes.
.DESCRIPTION
Identifies office applications, web servers, and spooler services spawning command shells.
- #>
- $AnomalousPairs = @(
- @{ Parent = "winword.exe"; Children = @("cmd.exe", "powershell.exe", "wscript.exe", "cscript.exe") },
- @{ Parent = "excel.exe"; Children = @("cmd.exe", "powershell.exe", "mshta.exe", "certutil.exe") },
- @{ Parent = "w3wp.exe"; Children = @("cmd.exe", "powershell.exe", "whoami.exe", "net.exe") },
- @{ Parent = "spoolsv.exe"; Children = @("cmd.exe", "powershell.exe", "rundll32.exe") },
- @{ Parent = "sqlservr.exe"; Children = @("cmd.exe", "powershell.exe", "bitsadmin.exe") }
- )
- $AllProcesses = Get-CimInstance -ClassName Win32_Process
- $ProcessLookup = @{}
- $AllProcesses | ForEach-Object { $ProcessLookup[$_.ProcessId] = $_ }
- $Findings = foreach ($proc in $AllProcesses) {
- if ($ProcessLookup.ContainsKey($proc.ParentProcessId)) {
- $parent = $ProcessLookup[$proc.ParentProcessId]
- $parentName = $parent.Name.ToLower()
- $childName = $proc.Name.ToLower()
- foreach ($rule in $AnomalousPairs) {
- if ($parentName -eq $rule.Parent -and $rule.Children -contains $childName) {
- [PSCustomObject]@{
- AnomalyType = "Suspicious Parent-Child Process"
- ParentProcessName = $parent.Name
- ParentPID = $parent.ProcessId
- ParentPath = $parent.ExecutablePath
- ChildProcessName = $proc.Name
- ChildPID = $proc.ProcessId
- ChildCommandLine = $proc.CommandLine
- CreationDate = $proc.CreationDate
- }
- }
- }
- }
- }
- $Findings | Format-List
- Script 2: Hunting for C2 Network Beaconing Connections
Threat actors establish outbound C2 connections to external IP addresses on non-standard ports. This script inspects active sockets, excludes private RFC 1918 subnets, and identifies external connections initiated by suspicious LOLBins: <#
.SYNOPSIS
Hunts for active outbound network connections initiated by native Windows utilities.
#>
$SuspiciousBinaries = @("powershell", "cmd", "rundll32", "regsvr32", "certutil", "mshta", "bitsadmin", "cscript", "wscript")
$PrivatePrefixes = @("10.", "172.16.", "172.17.", "172.18.", "172.19.", "172.20.", "172.21.", "172.22.", "172.23.", "172.24.", "172.25.", "172.26.", "172.27.", "172.28.", "172.29.", "172.30.", "172.31.", "192.168.", "127.", "169.254.")
- Get-NetTCPConnection -State Established | ForEach-Object {
- $socket = $_
- $remoteIP = $socket.RemoteAddress
- # Check if destination IP is private
- $isPrivate = $false
- foreach ($prefix in $PrivatePrefixes) {
- if ($remoteIP.StartsWith($prefix)) { $isPrivate = $true; break }
- }
- if (-not $isPrivate -and $remoteIP -ne "::1") {
- $proc = Get-Process -Id $socket.OwningProcess -ErrorAction SilentlyContinue
- if ($proc -and ($SuspiciousBinaries -contains $proc.Name.ToLower())) {
- [PSCustomObject]@{
- Timestamp = (Get-Date).ToString("yyyy-MM-dd HH:mm:ss")
- ProcessName = $proc.Name
- PID = $proc.Id
- ProcessPath = $proc.Path
- LocalSocket = "$($socket.LocalAddress):$($socket.LocalPort)"
- RemoteSocket = "$($socket.RemoteAddress):$($socket.RemotePort)"
- NonStandardPort = ($socket.RemotePort -notin @(80, 443, 8080, 8443))
- }
- }
- }
- } | Format-Table -AutoSize
- Script 3: Autorun, Scheduled Task, and WMI Persistence Hunter
Adversaries establish persistence across system reboots via registry Run keys, scheduled tasks, and WMI event subscriptions. This script audits all three persistence vectors simultaneously: <#
.SYNOPSIS
Comprehensive persistence hunter auditing Registry Run keys, Scheduled Tasks, and WMI Subscriptions.
- #>
- Write-Host "[+] Auditing Registry Run / RunOnce Keys..." -ForegroundColor Cyan
- $RegPaths = @(
- "HKLM:\Software\Microsoft\Windows\CurrentVersion\Run",
- "HKLM:\Software\Microsoft\Windows\CurrentVersion\RunOnce",
- "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run",
- "HKCU:\Software\Microsoft\Windows\CurrentVersion\RunOnce"
- )
- foreach ($path in $RegPaths) {
- if (Test-Path $path) {
- $key = Get-ItemProperty -Path $path
- $key.PSObject.Properties | Where-Object { $_.Name -notmatch "^PS" } | ForEach-Object {
- if ($_.Value -match "powershell|cmd|AppData|Temp|Public|rundll32|wscript") {
- [PSCustomObject]@{
- Vector = "Registry Run Key"
- Location = $path
- Name = $_.Name
- Payload = $_.Value
- Suspicious = $true
- }
- }
- }
- }
- }
- Write-Host "[+] Auditing Non-Standard Scheduled Tasks..." -ForegroundColor Cyan
- Get-ScheduledTask | Where-Object { $_.State -ne "Disabled" } | ForEach-Object {
- $task = $_
- $action = $task.Actions | Select-Object -First 1
- if ($action.Execute -match "powershell|cmd|mshta|cscript|wscript" -or
- $action.Arguments -match "AppData|Temp|Public|-enc|-w hidden") {
- [PSCustomObject]@{
- Vector = "Scheduled Task"
- Location = $task.TaskPath
- Name = $task.TaskName
- Payload = "$($action.Execute) $($action.Arguments)"
- Suspicious = $true
- }
- }
- }
Write-Host "[+] Auditing Permanent WMI Event Subscriptions..." -ForegroundColor Cyan
$Consumers = Get-CimInstance -Namespace "root\subscription" -ClassName CommandLineEventConsumer -ErrorAction SilentlyContinue
$Filters = Get-CimInstance -Namespace "root\subscription" -ClassName __EventFilter -ErrorAction SilentlyContinue
$Bindings = Get-CimInstance -Namespace "root\subscription" -ClassName __FilterToConsumerBinding -ErrorAction SilentlyContinue
- if ($Bindings) {
- foreach ($binding in $Bindings) {
- [PSCustomObject]@{
- Vector = "WMI Persistence"
- Location = "root\subscription"
- Name = $binding.Consumer
- Payload = $binding.Filter
- Suspicious = $true
- }
- }
- }
- Hunting for Lateral Movement: Named Pipes, Admin Shares, and Remote Services
Once an adversary establishes an initial foothold, they propagate across the internal network to compromise secondary systems. Hunters focus on three primary Windows lateral movement mechanisms:
Named Pipes Inspection
Named pipes provide inter-process communication (IPC) locally and across SMB (port 445). Attack frameworks like Cobalt Strike, Metasploit, and Empire utilize named pipes for pivot listeners, lateral execution, and token impersonation.
Default Cobalt Strike Pipes : Default configurations frequently generate distinct pipe naming structures, such as \pipe\msagent_* , \pipe\status_* , \pipe\mypipe_* , or randomized GUID formats like \pipe\mojo.5688.8033.34892485 .
Auditing Named Pipes : Threat hunters inspect named pipes using Sysmon Event ID 17 (Pipe Created) and Sysmon Event ID 18 (Pipe Connected). A rare named pipe created by a non-system binary in C:\Users\Public\ or C:\ProgramData\ indicates active lateral pivot communication.
Administrative Shares ( ADMIN$ , C$ , IPC$ )
Adversaries map network drives and stage payloads across administrative shares:
Detection Telemetry : Windows Security Event ID 5140 (A network share object was accessed) and Event ID 5145 (A network share object was checked to see whether client can be granted desired access).
Hunting Logic : Stack network share accesses by client IP address, target share name ( ADMIN$ , C$ ), and accessed relative target name ( RelativeTargetName: *.exe , *.dll , *.bat ). Legitimate users rarely access ADMIN$ directly.
Remote Service Installation
Tools such as PsExec, Cobalt Strike's jump psexec , and native administrative tools stage an executable on ADMIN$ and subsequently interact with the Service Control Manager (SCM) via RPC over SMB to create a remote service:
Detection Telemetry : Windows System Event ID 7045 (A new service was installed in the system) and Security Event ID 4697 .
PsExec Artifacts : Default PsExec installs a service named PSEXESVC with binary path %SystemRoot%\PSEXESVC.exe . Threat actors frequently rename the service to mimic legitimate drivers (e.g., WindowsDefenderUpdateSvc ) but execute out of C:\Windows\Temp\ under the NT AUTHORITY\SYSTEM account.
Python and Jupyter Notebooks for SOC Threat Hunting
When dataset sizes exceed the memory handling limits of PowerShell or when complex statistical distributions must be evaluated, threat hunters leverage Python within Jupyter Notebooks . Python provides access to the pandas library for high-speed data manipulation and matplotlib / seaborn for mathematical visualization.
Hunting Network Beaconing with pandas
Network beaconing is characterized by automated, programmatic callbacks initiated by an agent to a C2 listener at regular intervals (e.g., every 60 seconds). While attackers introduce jitter (randomized variation, such as +/- 20%) to defeat naive threshold alerts, statistical analysis reveals the underlying cadence.
In a Jupyter Notebook, a hunter loads 1,000,000 firewall/proxy connection records and computes the inter-arrival time (Delta T) between consecutive connections to identical destination IP addresses: import pandas as pd
- import numpy as np
- import matplotlib.pyplot as plt
- import seaborn as sns
- # Load connection telemetry
- df = pd.read_csv('proxy_connections.csv')
- df['timestamp'] = pd.to_datetime(df['timestamp'])
- # Filter for outbound external connections and sort temporally
- df = df.sort_values(by=['source_ip', 'dest_ip', 'timestamp'])
- # Calculate inter-arrival time (Delta T) in seconds between successive callbacks
- df['delta_t'] = df.groupby(['source_ip', 'dest_ip'])['timestamp'].diff().dt.total_seconds()
- # Compute statistical metrics per destination: Count, Mean Delta T, and Standard Deviation (Jitter)
- beacon_stats = df.groupby(['source_ip', 'dest_ip']).agg(
- connection_count=('delta_t', 'count'),
- mean_interval=('delta_t', 'mean'),
- std_dev=('delta_t', 'std'),
- median_interval=('delta_t', 'median')
- ).reset_index()
- # Identify beaconing candidates: High connection count and low coefficient of variation (std_dev / mean)
- beacon_stats['cv'] = beacon_stats['std_dev'] / beacon_stats['mean_interval']
- beacon_candidates = beacon_stats[
- (beacon_stats['connection_count'] > 100) &
- (beacon_stats['cv'] < 0.25)
- ].sort_values(by='cv', ascending=True)
print(beacon_candidates.head(10))
- # Visualize Delta T distribution for top beaconing suspect
- top_suspect = beacon_candidates.iloc[0]
- suspect_data = df[
- (df['source_ip'] == top_suspect['source_ip']) &
- (df['dest_ip'] == top_suspect['dest_ip'])
- ]
- plt.figure(figsize=(10, 4))
- sns.histplot(suspect_data['delta_t'].dropna(), bins=50, kde=True, color='crimson')
- plt.title(f"C2 Beaconing Heartbeat Analysis: {top_suspect['source_ip']} -> {top_suspect['dest_ip']}")
- plt.xlabel("Inter-Arrival Time (Seconds)")
- plt.ylabel("Connection Frequency")
- plt.grid(True, linestyle='--', alpha=0.6)
- plt.show()
If the histogram displays a sharp, concentrated Gaussian peak centered around 60 seconds (even with jitter distributed between 48 and 72 seconds), the analyst has statistically proven the presence of an automated C2 beacon rather than human web browsing.