Exploit Public-Facing Application
Adversaries may attempt to exploit a weakness in an Internet-facing host or system to initially access a network. The weakness in the system can be a software bug, a temporary glitch, or a misconfiguration. Exploited applications are often websites/web servers, but can also include databases (like SQL), standard services (like SMB or SSH), network device administration and management protocols (like SNMP and Smart Install), and any other system with Internet-accessible open sockets. On ESXi infrastructure, adversaries may exploit exposed OpenSLP services or VMware vCenter servers. If an application is hosted on cloud-based infrastructure and/or is containerized, exploiting it may lead to compromise of the underlying instance or container, allowing adversaries to access cloud or container APIs, escape to the container host, or exploit weak identity and access management policies.
What is T1190 Exploit Public-Facing Application?
Exploit Public-Facing Application (T1190) maps to the Initial Access tactic — the adversary is trying to get into your network in MITRE ATT&CK.
This page provides production-ready detection logic for Exploit Public-Facing Application, covering the data sources and telemetry it touches: Process: Process Creation, Microsoft Defender for Endpoint. The queries below are rated critical severity at high confidence, and ship for 7 SIEM platforms — KQL, SPL, Elastic, QRadar, Sumo, YARA-L, LogScale.
MITRE ATT&CK
- Tactic
- Initial Access
- Technique
- T1190 Exploit Public-Facing Application
- Canonical reference
- https://attack.mitre.org/techniques/T1190/
let WebServerProcesses = dynamic(["w3wp.exe", "httpd.exe", "nginx.exe", "apache2.exe", "java.exe", "python.exe", "python3.exe", "php.exe", "php-cgi.exe", "node.exe", "ruby.exe", "perl.exe", "tomcat9.exe", "tomcat8.exe", "ews.exe", "umworkerprocess.exe", "msexchangeservicehost.exe"]);
let SuspiciousChildProcesses = dynamic(["cmd.exe", "powershell.exe", "pwsh.exe", "wscript.exe", "cscript.exe", "mshta.exe", "rundll32.exe", "regsvr32.exe", "certutil.exe", "bitsadmin.exe", "curl.exe", "wget.exe", "nc.exe", "ncat.exe", "net.exe", "net1.exe", "whoami.exe", "ipconfig.exe", "systeminfo.exe", "nltest.exe", "ping.exe", "nslookup.exe", "tasklist.exe", "quser.exe", "schtasks.exe", "at.exe", "sc.exe", "reg.exe"]);
DeviceProcessEvents
| where Timestamp > ago(24h)
| where InitiatingProcessFileName in~ (WebServerProcesses)
| where FileName in~ (SuspiciousChildProcesses)
| extend ExploitEvidence = case(
FileName in~ ("cmd.exe", "powershell.exe", "pwsh.exe", "wscript.exe", "cscript.exe", "mshta.exe"), "Shell Spawned",
FileName in~ ("certutil.exe", "bitsadmin.exe", "curl.exe", "wget.exe", "nc.exe", "ncat.exe"), "Download/C2 Tool",
FileName in~ ("whoami.exe", "ipconfig.exe", "systeminfo.exe", "nltest.exe", "net.exe", "net1.exe", "tasklist.exe", "quser.exe"), "Reconnaissance",
FileName in~ ("schtasks.exe", "at.exe", "sc.exe", "reg.exe"), "Persistence Attempt",
"Suspicious Child"
)
| project Timestamp, DeviceName, AccountName, FileName, ProcessCommandLine,
InitiatingProcessFileName, InitiatingProcessCommandLine, InitiatingProcessParentFileName,
ExploitEvidence, SHA256
| sort by Timestamp desc Detects web application exploitation by monitoring for web server processes (IIS w3wp.exe, Apache httpd.exe, Nginx, Java/Tomcat, Exchange worker processes) spawning unexpected child processes such as command shells, reconnaissance tools, download utilities, or persistence mechanisms. This parent-child process anomaly is a strong indicator of successful remote code execution via exploitation of a public-facing application, consistent with techniques used by APT28, Volt Typhoon, Sandworm, FIN7, and ransomware operators targeting Exchange, IIS, WebLogic, and similar platforms. Classifies spawned processes into Shell Spawned, Download/C2 Tool, Reconnaissance, and Persistence Attempt categories for analyst prioritization.
Data Sources
Required Tables
False Positives
- Legitimate web application frameworks that invoke system utilities as part of normal operation — e.g., Node.js applications using child_process.exec() for image processing, PDF generation, or video transcoding
- Application deployment automation where IIS app pools or Java application servers execute build tools, packaging scripts, or health check commands as part of CI/CD pipelines
- Exchange Hybrid Configuration Wizard and other Microsoft management tools that run Exchange worker processes spawning PowerShell for legitimate configuration and maintenance tasks
- Application Performance Monitoring (APM) and diagnostic agents (Dynatrace, AppDynamics, New Relic) that fork child processes for JVM or CLR diagnostics from within the web server process context
- DevOps tooling such as Octopus Deploy, TeamCity agents, or Ansible running under an IIS-hosted application pool identity to execute deployment scripts
Sigma rule & cross-platform mapping
The detection logic for Exploit Public-Facing Application (T1190) 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 T1190
References (8)
- https://attack.mitre.org/techniques/T1190/
- https://owasp.org/www-project-top-ten/
- https://cwe.mitre.org/top25/index.html
- https://www.mandiant.com/resources/blog/fortinet-malware-ecosystem
- https://www.recordedfuture.com/blog/esxiargs-ransomware-targets-vmware-esxi-openslp-servers
- https://www.microsoft.com/security/blog/2021/03/02/hafnium-targeting-exchange-servers/
- https://www.cisa.gov/news-events/cybersecurity-advisories/aa21-116a
- https://www.secureworks.com/research/bronze-silhouette
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 1Web Server Process Spawning Reconnaissance Commands
Expected signal: Sysmon Event ID 1: Process Create events for cmd.exe, whoami.exe, ipconfig.exe, net.exe, systeminfo.exe with respective command lines. Security Event ID 4688 (with command line auditing enabled) for each spawned process. Sysmon Event ID 11: File creation at %TEMP%\argus-t1190-recon.txt.
- Test 2Drop Test Webshell File in IIS Web Root
Expected signal: Sysmon Event ID 11: File Create with TargetFilename='C:\inetpub\wwwroot\argus-test-shell.aspx'. Sysmon Event ID 1: Process Create for powershell.exe with Set-Content command visible in CommandLine. DeviceFileEvents in Microsoft Defender for Endpoint will show the .aspx file creation with the initiating process context.
- Test 3Log4Shell JNDI Lookup Payload in HTTP Request Headers
Expected signal: Web server access log entry (Apache: /var/log/apache2/access.log, Nginx: /var/log/nginx/access.log) showing the JNDI payload strings in User-Agent and custom header fields. If a Java application with Log4j is running on port 80, Sysmon EventCode=3 (or /proc/net/tcp) will show an LDAP connection attempt to 127.0.0.1:1389 from the java.exe/java process.
- Test 4SQL Injection Payloads in Web Application Query Parameters
Expected signal: Web server access logs will contain entries with SQL injection strings in the cs-uri-query field (IIS) or request URI (Apache/Nginx). The HTTP response codes (200, 400, 404, 500) are printed to stdout for each payload. WAF alert events generated if a WAF is in the request path. No database query is executed — the payloads are evaluated only at the HTTP layer.
Response Playbook
Triage
- Identify the parent web server process — which application server (IIS w3wp.exe, Apache httpd.exe, Nginx, Tomcat java.exe, Exchange umworkerprocess.exe) spawned the suspicious process, and what application pool identity or service account is it running under?
- Capture the exact command line of the spawned child process — is it a reconnaissance command (whoami, ipconfig, systeminfo), a download cradle (certutil -urlcache, curl, wget), or an interactive command shell spawned with no arguments or with a /c flag?
- Correlate the process creation timestamp with web server access logs — check IIS logs at C:\inetpub\logs\LogFiles\W3SVC*\u_ex*.log or Apache/Nginx logs at /var/log to identify the triggering HTTP request: source IP, URI, HTTP method, user agent, and response code
- Determine the vulnerability class from the triggering request — look for JNDI strings (${jndi:ldap://}) indicating Log4Shell, unusual Exchange endpoints (/autodiscover/autodiscover.json, /OAB/) indicating ProxyShell, OGNL expressions in Confluence/Struts parameters, or unusually long POST bodies indicating deserialization payloads
- Check whether a webshell was written to disk — query DeviceFileEvents or Sysmon Event ID 11 for .aspx, .ashx, .php, .jsp, .war files created by the web server process in or under web root directories around the exploitation timestamp
- Assess the scope — check for the same exploitation pattern across other internet-facing hosts, and look for any lateral movement indicators (SMB connections, RDP attempts, Kerberoasting) originating from the compromised server in the hours following initial exploitation
- Review application patch level — cross-reference the application version against the suspected CVE to confirm exploitability and assess whether other instances of the same software in the environment are vulnerable
Containment
- If RCE is confirmed: immediately isolate the host using EDR network isolation to prevent lateral movement while preserving volatile memory and process state for forensics
- Block the attacking source IP(s) at the perimeter firewall and WAF — pull IPs from web server access logs and create deny rules; also check for IP rotation patterns from multiple source IPs using the same payload structure indicating automated tooling
- Disable or take the vulnerable application offline if an emergency patch cannot be applied immediately — assess service impact but weigh against continued exploitation risk; if offline is not possible, enable WAF virtual patching rules for the specific CVE
- If a webshell or implant was dropped: preserve the file hash and full path for forensics before removal, then delete all instances and scan all web-accessible directories for additional webshells using known patterns (.aspx files with Request.Form, eval(base64_decode()), or System.Diagnostics.Process references)
- Rotate all credentials accessible from the compromised application server — application service account passwords, API keys and connection strings in web.config or application.properties, database passwords, and any secrets stored in environment variables or configuration files
- For Exchange exploitation (ProxyShell, ProxyLogon): immediately apply applicable patches, run Microsoft's Exchange On-premises Mitigation Tool (EOMT), and audit for malicious OABVirtualDirectory, autodiscover endpoint modifications, and unauthorized mailbox rules or forwarding
- Notify the security operations center of the confirmed source IP(s) for threat intelligence enrichment and cross-customer blocking if applicable; also check CISA KEV (Known Exploited Vulnerabilities) for the CVE to understand active threat actor use
Evidence Collection
- Web server access logs — IIS: C:\inetpub\logs\LogFiles\W3SVC*\u_ex*.log (W3C Extended Log Format with timestamp, client IP, method, URI stem, URI query, status, bytes); Apache: /var/log/apache2/access.log; Nginx: /var/log/nginx/access.log. The exploit request will appear with characteristic SQL injection strings, JNDI payloads (${jndi:ldap://}), or unusually long URIs/POST bodies.
- IIS Failed Request Tracing logs: C:\inetpub\logs\FailedReqLogFiles\ — XML files with full raw request/response details including POST body content, essential for capturing deserialization or OGNL injection payloads that are not visible in standard access log URI fields
- Windows Event Log — Security Event ID 4688 (Process Creation with command line auditing enabled) and Sysmon Event ID 1: capture the full process tree from web server parent through all child and grandchild processes spawned post-exploitation
- File system timeline — new files created in web root directories (C:\inetpub\wwwroot\, deployed application directories, /var/www/html/) within minutes of the exploitation event; focus on script files (.aspx, .ashx, .php, .jsp, .py) and uploaded executables
- Network connection logs — Sysmon Event ID 3 (Network Connect) or DeviceNetworkEvents for outbound connections from the web server process following exploitation — reverse shell callbacks (TCP to non-standard ports), C2 beaconing, or LDAP/DNS queries from java.exe (Log4Shell JNDI callback)
- Windows Application Event Log — events sourced from 'ASP.NET', 'ISAPI Filter', or application-specific sources may capture exception stack traces that reveal the vulnerability being exploited (deserialization exceptions, OGNL evaluation errors)
- Memory dump of the web server worker process — if the exploit is fileless or uses in-memory staging, capture w3wp.exe or java.exe process memory using Task Manager, ProcDump (procdump -ma w3wp.exe w3wp.dmp), or EDR memory acquisition for shellcode analysis
- Prefetch files: C:\Windows\Prefetch\ — entries for cmd.exe, powershell.exe, whoami.exe with execution timestamps correlated to the exploitation window provide additional confirmation of process execution even if event logs are incomplete
Escalation Criteria
- ! Interactive command shell spawned by web server process (cmd.exe or powershell.exe with no /c flag, sh or bash with -i or without arguments) — indicates an operator-controlled interactive session, not automated post-exploitation
- ! Download tool or download cradle execution (certutil -urlcache, curl, wget, bitsadmin /transfer, Invoke-WebRequest) fetching from an external IP — indicates staged payload delivery and active threat actor operation beyond initial access
- ! Webshell file confirmed in web-accessible directory — persistent backdoor that will survive patching and reboots; escalate immediately as attacker likely has re-entry capability
- ! Credential access activity observed post-exploitation — LSASS access (Sysmon Event ID 10 with TargetImage=lsass.exe), SAM registry access, Kerberoasting artifacts, or known credential dumping tool invocations (comsvcs.dll MiniDump, mimikatz references in command lines)
- ! Evidence of internal reconnaissance or lateral movement originating from the compromised server — SMB connections to internal subnets, domain controller queries (LDAP/RPC to DC IPs), WMI remote queries, or PsExec-style service creation on internal hosts
- ! Multiple hosts in the same environment or multiple CVEs being exploited in the same time window — indicates automated exploit tooling or a coordinated campaign, warranting enterprise-wide isolation and incident response escalation
Investigation Guide
Forensic Artifacts
- >
IIS Logs: C:\inetpub\logs\LogFiles\W3SVC*\u_ex*.log — W3C Extended Log format containing client IP, HTTP method, URI stem, URI query string, status code, and bytes transferred. SQL injection payloads appear in cs-uri-query; JNDI strings appear in cs(User-Agent) or custom header fields. Rotate daily by default — collect immediately before log rollover. - >
IIS Failed Request Tracing: C:\inetpub\logs\FailedReqLogFiles\ — XML trace files capturing raw request/response including POST body content; critical for deserialization, OGNL injection, or template injection attacks where payloads are in the request body not visible in standard access logs. - >
Webshell artifacts: web root directories (C:\inetpub\wwwroot\, application deployment directories) — look for .aspx/.ashx files containing System.Diagnostics.Process, Request.Form access patterns, eval(base64_decode()), or Runtime.exec() calls. Check file creation timestamps against exploitation window. - >
Windows Event Log: Application Log with sources 'ASP.NET 4.0.30319.0', 'W3SVC-WP', or application framework sources — deserialization exceptions (TypeConfuseDelegate, BinaryFormatter errors), OGNL evaluation errors from Confluence/Struts, and Java RCE exception stack traces may appear here. - >
Windows Event Log: System Log Event ID 7045 (A new service was installed) — attackers frequently establish persistence by installing a Windows service from the exploited application server; correlate service install timestamp against exploitation window. - >
Linux: /var/log/auth.log and /var/log/syslog — commands executed via webshell under the www-data or apache service account appear here; auditd execve syscall records with full command lines if auditd is configured for process execution monitoring. - >
Prefetch files: C:\Windows\Prefetch\ — WHOAMI.EXE-*.pf, NET.EXE-*.pf, SYSTEMINFO.EXE-*.pf with anomalous execution timestamps during business-off-hours or correlated with access log exploitation events confirm post-exploitation reconnaissance. - >
Registry: HKLM\SYSTEM\CurrentControlSet\Services — new service entries created post-exploitation; HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks — scheduled tasks created by attacker for persistence after initial web application RCE.
Tuning Guidance
The primary challenge with T1190 detection is distinguishing legitimate web application behavior from exploitation. Begin by profiling each internet-facing application: document which child processes each web server is legitimately permitted to spawn, and build application-specific exclusions scoped to (parent process path, child process name, command line prefix) tuples rather than broad process name exclusions. For IIS environments, scope exclusions to specific application pool identities using the AccountName field — never exclude by parent process name alone. Java application servers (Tomcat, WebLogic, JBoss, WebSphere) frequently invoke system utilities for legitimate operations such as JVM diagnostics, garbage collection reporting, and application deployment; baseline each Java application individually before applying detections. Exchange environments require particular care since Exchange worker processes (umworkerprocess.exe, msexchangeservicehost.exe) run PowerShell as part of normal operation for health checks and configuration; restrict Exchange exclusions to known good PowerShell module paths (C:\Program Files\Microsoft\Exchange Server\) and verify scripts are signed. For the outbound connection hunting query, build an allowlist of legitimate external destinations for each web application (update servers, APM SaaS endpoints, license servers) to reduce noise. Consider tiering your detection threshold: web server spawning cmd.exe or powershell.exe should be high-severity with immediate paging regardless of false positive rate, while reconnaissance commands (whoami, ipconfig) can have slightly higher thresholds with analyst review rather than immediate escalation. Enable IIS Failed Request Tracing for all internet-facing applications to ensure POST body content is captured for forensic analysis when detections fire.
Hunting Queries
Hunt for web server processes creating new files with web-executable extensions (.aspx, .php, .jsp, .py, .war, .cfm, etc.) in any directory. This identifies webshell drops — the most common persistence mechanism following T1190 exploitation. Legitimate web deployments do not write server-side script files through the running application process; any match outside of a documented deployment window requires immediate investigation.
DeviceFileEvents
| where Timestamp > ago(7d)
| where InitiatingProcessFileName in~ ("w3wp.exe", "httpd.exe", "nginx.exe", "java.exe", "python.exe", "python3.exe", "php.exe", "php-cgi.exe", "node.exe", "tomcat9.exe", "tomcat8.exe")
| where FileName endswith ".aspx" or FileName endswith ".ashx" or FileName endswith ".asmx"
or FileName endswith ".php" or FileName endswith ".jsp" or FileName endswith ".war"
or FileName endswith ".py" or FileName endswith ".rb" or FileName endswith ".pl"
or FileName endswith ".cfm" or FileName endswith ".cfc"
| project Timestamp, DeviceName, AccountName, FileName, FolderPath, InitiatingProcessFileName, InitiatingProcessCommandLine, SHA256
| sort by Timestamp desc index=wineventlog sourcetype="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational" EventCode=11
| eval TargetFilenameExt=lower(mvindex(split(TargetFilename,"."),-1))
| eval InitiatingImageLower=lower(Image)
| where match(InitiatingImageLower, "(w3wp\.exe|httpd\.exe|nginx\.exe|java\.exe|python\.exe|python3\.exe|php\.exe|php-cgi\.exe|node\.exe|tomcat[0-9]*\.exe)")
| where TargetFilenameExt IN ("aspx", "ashx", "asmx", "php", "jsp", "war", "py", "rb", "pl", "cfm", "cfc")
| table _time, host, TargetFilename, Image, CommandLine
| sort - _time Hunt for web server processes initiating outbound connections to public IPs on non-standard ports. Legitimate web servers respond to inbound requests but do not initiate outbound connections to arbitrary external IPs. This pattern identifies reverse shell callbacks (common attacker ports: 4444, 1337, 8888, 443 with unusual process parents), C2 beacon traffic, Log4Shell JNDI LDAP callbacks (port 1389), and data exfiltration channels established from the compromised web application process after T1190 exploitation.
DeviceNetworkEvents
| where Timestamp > ago(7d)
| where InitiatingProcessFileName in~ ("w3wp.exe", "httpd.exe", "nginx.exe", "java.exe", "python.exe", "python3.exe", "php.exe", "php-cgi.exe", "node.exe", "tomcat9.exe", "umworkerprocess.exe")
| where RemoteIPType == "Public"
| where RemotePort !in (80, 443, 8080, 8443, 25, 587, 465)
| summarize Connections=count(), UniqueDestinations=dcount(RemoteIP), Ports=make_set(RemotePort), FirstSeen=min(Timestamp), LastSeen=max(Timestamp) by DeviceName, InitiatingProcessFileName, RemoteIP
| sort by Connections desc index=wineventlog sourcetype="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational" EventCode=3
| eval InitiatingImageLower=lower(Image)
| where match(InitiatingImageLower, "(w3wp\.exe|httpd\.exe|nginx\.exe|java\.exe|python\.exe|python3\.exe|php\.exe|php-cgi\.exe|node\.exe|tomcat[0-9]*\.exe|umworkerprocess\.exe)")
| where NOT (DestinationIp="10.*" OR DestinationIp="172.16.*" OR DestinationIp="192.168.*" OR DestinationIp="127.*")
| where NOT (DestinationPort=80 OR DestinationPort=443 OR DestinationPort=8080 OR DestinationPort=8443 OR DestinationPort=25 OR DestinationPort=587)
| stats count as Connections, dc(DestinationIp) as UniqueDestinations, values(DestinationPort) as Ports, earliest(_time) as FirstSeen, latest(_time) as LastSeen by host, Image, DestinationIp
| sort - Connections Hunt for web server processes exhibiting high-frequency child process spawning over a 7-day window where at least one known reconnaissance or exploitation tool appears in the child process set. Legitimate web servers rarely spawn more than a handful of child processes. A server with an active webshell or RCE backdoor will show repeated child process creation as the attacker returns to execute commands across multiple sessions. This aggregated view reveals persistent attacker presence that individual per-event detections may miss if rate-limited or suppressed.
DeviceProcessEvents
| where Timestamp > ago(7d)
| where InitiatingProcessFileName in~ ("w3wp.exe", "httpd.exe", "nginx.exe", "java.exe", "python.exe", "python3.exe", "php.exe", "php-cgi.exe")
| summarize ChildProcesses=make_set(FileName), AllCommandLines=make_set(ProcessCommandLine), TotalSpawns=count(), FirstSeen=min(Timestamp), LastSeen=max(Timestamp) by DeviceName, InitiatingProcessFileName
| where TotalSpawns > 5
| extend SuspiciousChildCount = array_length(set_intersect(ChildProcesses, dynamic(["cmd.exe", "powershell.exe", "pwsh.exe", "sh", "bash", "whoami.exe", "net.exe", "certutil.exe", "curl.exe", "wget.exe", "nc.exe", "systeminfo.exe", "nltest.exe"])))
| where SuspiciousChildCount > 0
| project DeviceName, InitiatingProcessFileName, TotalSpawns, SuspiciousChildCount, ChildProcesses, FirstSeen, LastSeen
| sort by SuspiciousChildCount desc index=wineventlog sourcetype="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational" EventCode=1
| eval ParentImageLower=lower(ParentImage)
| eval ChildImageLower=lower(Image)
| where match(ParentImageLower, "(w3wp\.exe|httpd\.exe|nginx\.exe|java\.exe|python\.exe|python3\.exe|php\.exe|php-cgi\.exe)")
| stats dc(Image) as UniqueChildProcs, values(Image) as ChildProcesses, count as TotalSpawns, earliest(_time) as FirstSeen, latest(_time) as LastSeen by host, ParentImage
| where TotalSpawns > 5
| eval SuspiciousMatch=if(mvmatch(ChildProcesses, "(cmd\.exe|powershell\.exe|pwsh\.exe|whoami\.exe|net\.exe|certutil\.exe|curl\.exe|wget\.exe|nc\.exe|systeminfo\.exe|nltest\.exe)"), 1, 0)
| where SuspiciousMatch=1
| sort - TotalSpawns Atomic Red Team Tests
Simulates the post-exploitation command sequence executed after a threat actor gains RCE via web application exploitation. Runs a series of reconnaissance commands (whoami, ipconfig, net user, hostname, systeminfo) chained together as they appear in real Exchange ProxyShell and IIS exploitation incidents from APT28, Threat Group-3390, and FIN7. Execute from a cmd.exe session to generate Sysmon Event ID 1 telemetry matching the detection pattern.
Command
cmd.exe /c "whoami > %TEMP%\argus-t1190-recon.txt && ipconfig /all >> %TEMP%\argus-t1190-recon.txt && net user >> %TEMP%\argus-t1190-recon.txt && hostname >> %TEMP%\argus-t1190-recon.txt && systeminfo >> %TEMP%\argus-t1190-recon.txt" Cleanup
del %TEMP%\argus-t1190-recon.txt 2>nul Expected Telemetry
Sysmon Event ID 1: Process Create events for cmd.exe, whoami.exe, ipconfig.exe, net.exe, systeminfo.exe with respective command lines. Security Event ID 4688 (with command line auditing enabled) for each spawned process. Sysmon Event ID 11: File creation at %TEMP%\argus-t1190-recon.txt.
Expected Detection
Main detection fires when child process names match the SuspiciousChildProcesses list with ExploitEvidence='Reconnaissance'. To fully replicate the T1190 trigger, this test should be run FROM a w3wp.exe or java.exe process context using a test webshell — in that configuration, InitiatingProcessFileName will match the WebServerProcesses list and the alert will fire. Running from standard cmd.exe tests the child process telemetry generation but not the parent process filter.
Creates a test ASPX file in the IIS default web root directory, simulating the webshell drop that follows successful T1190 exploitation. This is the most common persistence mechanism deployed after Exchange ProxyShell, IIS deserialization, and ASP.NET ViewState exploitation. The file content is an HTML comment — not an executable webshell. Tests file integrity monitoring (Sysmon Event ID 11) and the hunting query for web-executable files created in web directories.
Command
powershell.exe -NoProfile -Command "Set-Content -Path 'C:\inetpub\wwwroot\argus-test-shell.aspx' -Value '<!-- ARGUS SECURITY TEST - NOT A REAL WEBSHELL - REMOVE AFTER TESTING -->'" Cleanup
powershell.exe -NoProfile -Command "Remove-Item 'C:\inetpub\wwwroot\argus-test-shell.aspx' -ErrorAction SilentlyContinue" Expected Telemetry
Sysmon Event ID 11: File Create with TargetFilename='C:\inetpub\wwwroot\argus-test-shell.aspx'. Sysmon Event ID 1: Process Create for powershell.exe with Set-Content command visible in CommandLine. DeviceFileEvents in Microsoft Defender for Endpoint will show the .aspx file creation with the initiating process context.
Expected Detection
Hunting query 1 (webshell file creation by web server processes) will detect this if the test is run from within a w3wp.exe context or if file integrity monitoring on C:\inetpub\wwwroot\ is active. The file extension .aspx in the web root directory matches the hunting query filter. Note: Requires C:\inetpub\wwwroot\ to exist (IIS installed on the test system); adjust path to the active web root if IIS is installed to a different location.
Sends HTTP requests containing Log4Shell-style JNDI lookup payloads (CVE-2021-44228) in multiple HTTP headers to a local web server. This simulates the initial exploitation attempt pattern used by Magic Hound, Sandworm, and automated scanning tools targeting Log4j-enabled applications. The payload targets localhost only — no actual exploitation occurs. Tests WAF detection rules and web server access log monitoring pipelines.
Command
curl -v -H 'X-Api-Version: ${jndi:ldap://127.0.0.1:1389/argus-test}' -H 'User-Agent: ${jndi:ldap://127.0.0.1:1389/argus-ua}' -H 'X-Forwarded-For: ${jndi:ldap://127.0.0.1:1389/argus-xff}' -H 'X-Originating-IP: ${jndi:dns://127.0.0.1/argus-dns}' http://127.0.0.1/ 2>&1 | tail -5 || true Expected Telemetry
Web server access log entry (Apache: /var/log/apache2/access.log, Nginx: /var/log/nginx/access.log) showing the JNDI payload strings in User-Agent and custom header fields. If a Java application with Log4j is running on port 80, Sysmon EventCode=3 (or /proc/net/tcp) will show an LDAP connection attempt to 127.0.0.1:1389 from the java.exe/java process.
Expected Detection
WAF rules matching ${jndi: pattern strings in any HTTP header should fire. SIEM log parsing rules on web server access logs matching 'jndi:ldap://' or 'jndi:dns://' strings will alert. If Log4j is present in the application, the DeviceNetworkEvents hunting query for web server outbound connections will detect the LDAP callback. Verify web server is running on port 80 before executing — adjust port if needed.
Sends HTTP GET requests containing common SQL injection payloads (UNION SELECT, OR '1'='1', time-based blind, and stacked query patterns) to a local web server. Simulates reconnaissance-phase SQL injection testing used by APT28, sqlmap automated tooling, and financially motivated actors targeting web-connected databases. Tests SIEM log parsing, WAF rule coverage, and web server access log monitoring. No database interaction occurs.
Command
curl -s -o /dev/null -w '%{http_code}\n' "http://127.0.0.1/?id=1'+OR+'1'='1" && curl -s -o /dev/null -w '%{http_code}\n' "http://127.0.0.1/?id=1+UNION+SELECT+null,null,null--" && curl -s -o /dev/null -w '%{http_code}\n' "http://127.0.0.1/?id=1;SELECT+SLEEP(5)--" && curl -s -o /dev/null -w '%{http_code}\n' "http://127.0.0.1/?id=1'+AND+1=CONVERT(int,@@version)--" && echo 'SQL injection test complete' Expected Telemetry
Web server access logs will contain entries with SQL injection strings in the cs-uri-query field (IIS) or request URI (Apache/Nginx). The HTTP response codes (200, 400, 404, 500) are printed to stdout for each payload. WAF alert events generated if a WAF is in the request path. No database query is executed — the payloads are evaluated only at the HTTP layer.
Expected Detection
WAF rules matching UNION SELECT, OR '1'='1', SLEEP(), CONVERT(int,@@version) and similar SQL injection patterns should fire and block or log the requests. SIEM rules ingesting web server access logs should alert on SQL keywords in URI parameters. ModSecurity (Apache) will generate audit log entries at /var/log/apache2/modsec_audit.log if configured. Verify a web server is listening on port 80 before running; adjust port if needed.