Honeynet Collapse: Full Kill Chain from Public Web Application to Domain-Wide Compromise
| Report ID | SIR-2026-MASTER | Classification | Simulated / Training Environment |
| Analyst | F. Nanos | Date of Report | 2026-06-22 to 2026-06-23 (consolidated) |
| Severity | Critical | Status | Closed (Full Campaign Contained) |
| Affected Assets | 1x public-facing WordPress host, 1x DMZ gateway server, 1x CRM application server, 1x domain controller, 1x macOS developer workstation (5 hosts, single campaign) | ||
| Constituent Reports | SIR-2026-06-22-01, SIR-2026-06-23-02, SIR-2026-06-23-03, SIR-2026-06-23-05, SIR-2026-06-23-04 | ||
1. Executive Summary
Between the initial compromise of a public-facing WordPress host and the final exfiltration of customer data from an internal CRM application server, a single threat actor progressed through five distinct internal systems over the course of a multi-day campaign, culminating in domain controller compromise, ransomware deployment, and a parallel, opportunistic compromise of an unrelated macOS developer workstation. Rather than exploiting a software vulnerability at any stage, the actor relied almost entirely on credential brute-forcing, abuse of legitimate administrative functionality, and living-off-the-land techniques, a pattern that persisted across every host in the chain and is the single most consistent signature of this campaign. Investigation of the full chain required six materially different evidence sources, web-server access logs, host-based audit logging, Volatility 3 memory forensics, Windows Event Log and registry analysis, NTFS metadata-only artifact recovery, and macOS-specific artifact parsing, because the actor deliberately disabled or cleared logging at three separate points in the chain. In every instance, the investigation was able to proceed by pivoting to an artifact category that survives the specific anti-forensic technique used, a pattern that itself became a repeatable methodology over the course of the engagement rather than a one-off improvisation at each stage.
2. Campaign Scope & Methodology
Six independent evidence packages were provided for this campaign, corresponding to the five compromised hosts plus one standalone memory capture: a web-server and host-audit log set for the WordPress host and its underlying Linux server, a full memory capture from a DMZ gateway server reached via lateral movement, a forensic disk image (E01) of a CRM application server, a metadata-only NTFS image (no user files, registry, or event logs) from a domain controller, and a macOS forensic disk image from an unrelated developer workstation, investigated as a parallel, opportunistic incident rather than a continuation of the same intrusion path. Each package was analyzed independently first, using the artifact categories appropriate to its evidence type, before being cross-referenced against the others to establish shared infrastructure, credential reuse, and tooling fingerprints. The consolidated methodology below reflects that two-pass approach: per-host technical findings (Section 4) followed by a dedicated cross-stage correlation pass (Section 6) that was not possible, and was not attempted, at the level of any single constituent report.
# Representative toolchain across the six evidence packages
# Web / Linux host
sudo ausearch -k exec -i
grep "wp-login" /var/log/apache2/access.log
# Windows log source triage (gateway, CRM, DC where available)
Get-WinEvent -ListLog * | Where-Object {$_.RecordCount -gt 0}
Get-WinEvent -FilterHashtable @{LogName='Security'; Id=1102} # log-clear marker
AppCompatCacheParser.exe --csv <out> --csvf shimcache_parsed.csv
# Memory forensics (DMZ gateway capture)
vol -f <capture> windows.pstree
vol -f <capture> windows.malfind
vol -f <capture> windows.netscan
# NTFS metadata-only image (domain controller)
MFTECmd.exe -f "<path>\$MFT" --csv "<out>" --csvf mft_parsed.csv
LogFileParser64.exe /LogFileFile:"<path>" /MftCsvFile:"mft_parsed.csv" /OutputPath:"<out>"
# macOS disk image
python3 mac_apt.py MOUNTED <verified_root> QUARANTINE TCC AUTOSTART INSTALLHISTORY -o <out>
3. Affected Systems
| Host | Role | Compromise Path | Stage |
|---|---|---|---|
| WordPress / Linux host | Public-facing web application | Credential brute-force -> web shell -> SSH key theft -> root | Stage 1 |
| Windows Server (internal) | Internal target reached from the web host | Valid domain credentials -> RDP -> scheduled task hijack -> LSASS dump -> log clearing | Stage 2 |
| DMZ Gateway Server | Lateral pivot point | Remote service execution -> LOLBin proxy -> process injection -> active RDP pivot at capture | Stage 3 |
| CRM Application Server | Customer data store | Reused domain credentials -> logging disabled -> staged exfiltration tool -> cloud upload | Stage 4 |
| Domain Controller | Domain authority | Public file-share payload -> rename-then-execute -> ransomware deployment | Stage 5 |
| macOS Workstation | Developer endpoint (parallel, unrelated) | Trojanized installer -> TCC permission abuse -> LaunchAgent persistence -> exfiltration | Stage 6 |
Stages 1 through 5 form a single, continuous intrusion path: the web host is the entry point, the gateway server and CRM server are successive internal pivots reached with credential material obtained earlier in the chain, and the domain controller is the terminal objective. Stage 6, the macOS workstation, is investigated and reported separately in its own right. Nothing in its evidence links it to the same threat actor or infrastructure, and it is included in this consolidated report only because it was issued as part of the same training series, not because it is part of the same kill chain.
4. Campaign Timeline (Stages 1-5)
The table below sequences the reconstructed activity across all five hosts in the main intrusion path onto a single relative timeline. Because each host's evidence package used a different reference clock (web-server logs, Windows Event Log timestamps, and NTFS metadata each anchor differently), absolute cross-host time alignment was not possible from the available evidence. The sequence below reflects the confirmed logical order of events (each stage's start depends on credential or access material obtained in the previous stage), not a verified shared clock.
| Sequence | Event | Host | Kill Chain Stage |
|---|---|---|---|
| 01 | Brute-force success against WordPress login endpoint | Web host | Initial Access |
| 02 | Theme Editor abused to plant disguised web shell | Web host | Execution |
| 03 | Exposed SSH key backup recovered, authenticate as root | Web host | Privilege Escalation |
| 04 | Internal network sweep, payload staged, persistence installed | Web host | Discovery, Persistence |
| 05 | Inbound RDP using domain credentials, from the compromised web host's IP | Windows Server | Lateral Movement |
| 06 | Elevated scheduled task hijacked, known post-exploitation stager confirmed | Windows Server | Privilege Escalation |
| 07 | LSASS dumped via renamed utility, second domain account recovered | Windows Server | Credential Access |
| 08 | Security event log cleared mid-session, Shimcache used to reconstruct post-clearing activity | Windows Server | Defense Evasion |
| 09 | Remote service execution arrival, LOLBin proxy, injection into a legitimate utility | DMZ Gateway | Lateral Movement, Defense Evasion |
| 10 | Outbound RDP to a further internal host, active at time of memory capture | DMZ Gateway | Lateral Movement |
| 11 | Interactive logon with reused domain credentials | CRM Server | Lateral Movement |
| 12 | Event Log and Sysmon services stopped mid-session | CRM Server | Defense Evasion |
| 13 | Cloud-sync utility staged, renamed, full customer export exfiltrated | CRM Server | Collection, Exfiltration |
| 14 | Shadow copies deleted, recycle bin cleared, staged tooling removed | CRM Server | Defense Evasion, Impact |
| 15 | Ransomware payload delivered via public file-sharing service | Domain Controller | Command and Control |
| 16 | Dropper duplicated under IT-tooling-mimicking name, rename-then-execute | Domain Controller | Defense Evasion |
| 17 | Domain-wide file encryption, ransom note replicated across the host | Domain Controller | Impact |
5. Stage-by-Stage Technical Findings
Web Application Compromise to Windows Lateral Movement
Initial access was gained through sustained credential brute-forcing against the
WordPress login endpoint, succeeding after roughly one minute against an endpoint
with no apparent rate limiting. The same source then abused the platform's built-in
Theme Editor, a documented content-management capability requiring no vulnerability,
to plant PHP code disguised behind a parameter name closely resembling WordPress's
own cron-trigger mechanism. Host-based audit logging, scoped to the web service
account, captured the resulting reconnaissance and reverse-shell activity, including
a targeted search for private key material that recovered an exposed .bak
SSH key backup. This key granted direct root authentication, completing local
privilege escalation without a second exploit. Once privilege escalation moved
activity outside the scope of the service-account-restricted audit rules, root shell
history became the only remaining evidence source, and recorded an internal network
sweep, a further payload retrieved from the same external staging server, and a
disguised persistence service mimicking a legitimate kernel process name.
The credentials and staging infrastructure established here reappear directly in Stage 2: an inbound RDP connection to an internal Windows server, sourced from the web host's own IP address and authenticated with a domain account, is the first confirmed link between the two hosts. On the Windows server, the actor hijacked a pre-existing, elevated scheduled task rather than creating new persistence, replacing its target binary with a payload later confirmed via public threat-intelligence lookup as a known post-exploitation framework stager. A short, base64-encoded PowerShell command, recovered from PowerShell transcription logging rather than process-command logging (which was enabled but not capturing command-line detail on this host), decoded to a renamed LSASS-dumping utility. The resulting memory dump yielded a second, higher-privileged domain credential. The Windows Security event log was then cleared mid-session, confirmed by the log-clear event Windows records automatically as the first entry of any newly cleared log, which itself doubled as a reliable timeline boundary. Activity after that boundary, a renamed remote-execution utility and its associated service installation, was reconstructed entirely from registry-based execution caching (Shimcache), which operates independently of the Event Log subsystem and was unaffected by the clearing.
Full report: SIR-2026-06-22-01
DMZ Gateway Server: Memory Analysis, Process Injection & Lateral Pivot
A full memory capture from a DMZ gateway server, reached from the Stage 2 host via a remote service-execution mechanism, was analyzed using Volatility 3 in place of any log source, since none was collected for this host. Process tree reconstruction traced arrival through a command shell into a signed Windows utility invoked with attacker-controlled arguments (a LOLBin proxy pattern) pointing at a disguised DLL, itself dropped into a plausible system path, followed by a further renamed dropper delivered into a user's Downloads directory. Command-line recovery confirmed the LOLBin proxy invocation directly (a trusted system utility invoked against an attacker DLL with an exported function name), a technique that evades allow-listing based on the executing process's identity rather than its behavior.
The delivery chain terminated at injection into a legitimate, unremarkable system application, selected specifically for its innocuous, expected-to-be-running nature. Memory-region analysis identified a writable-and-executable region within that process not backed by any file mapped from disk, the defining signature of injected code. A second, smaller candidate region in the same process was assessed as a loader stub based on its substantially smaller committed size, with the larger region identified as the actual payload, a distinction the investigation had to make explicitly since both regions initially appeared as equally plausible injection candidates. Network-connection state captured at acquisition time showed an established outbound RDP connection from the same process tree as the injected payload, directed at a further internal host, an active lateral-movement pivot caught mid-flight. This is the clearest instance in the campaign of memory forensics resolving both what already happened on a host and where the actor was going next, from a single artifact source and without waiting for evidence from the next host.
Full report: SIR-2026-06-23-02
CRM Server Data Exfiltration: Anti-Forensics & Cloud Exfil
Using domain credentials consistent with those obtained in Stage 2, the actor reached a CRM application server holding the organization's customer data. A forensic disk image (E01) was investigated after native mounting failed, requiring targeted file export instead. Command-history review, recovered in full from the default-on PowerShell history file rather than any Event Log source, provided a verbatim record of the session: reconnaissance, then explicit commands stopping both the Windows Event Log service and Sysmon mid-session, a materially more thorough anti-forensics technique than the log-clearing already seen in Stage 2, since it prevents any subsequent activity from being recorded at all rather than leaving a single, timestamped gap.
With both logging mechanisms disabled, standard session-duration reconstruction (logon/logoff and process create/terminate correlation) had no data to work from. The registry's shell-usage tracking artifact (UserAssist), written independently of the Event Log subsystem, retained an intact focus-time value for the session and supplied a reliable duration despite the outage, the second time in this campaign that registry-based artifacts resolved a logging gap that a purely Event-Log-centric investigation would not have survived. Shell history further recorded staging of a cloud-sync utility renamed to resemble legitimate backup software, an abandoned initial exfiltration attempt, and a subsequent successful exfiltration of the organization's full customer export, configured entirely through disposable configuration files rather than command-line arguments to keep credentials and destination details out of any process-command logging that might otherwise have survived. Post-exfiltration cleanup, deletion of staged tooling, recycle-bin clearing, and removal of volume shadow copies, was confirmed from the same command-history source.
Full report: SIR-2026-06-23-03
Domain Controller Ransomware Deployment & Threat Attribution
The campaign's terminal stage targeted the domain controller directly, reconstructed from a forensic acquisition deliberately scoped to NTFS metadata only ($MFT, $LogFile, $UsnJrnl), with no live system, registry, or event-log access available at all, the most evidence-constrained host in the entire campaign. An alternate data stream associated with the payload archive recorded referrer and host URLs pointing to a public file-sharing service, recovering the exact external delivery source directly from filesystem metadata alone. The original dropper, delivered under a short, generic filename, was found duplicated under a second name in a path designed to mimic legitimate IT deployment tooling. Identical file size and file-record timestamps placing the renamed binary's execution seconds before the first ransom note was written established it, not the original dropper, as the file that performed encryption, a rename-then-execute evasion pattern.
Threat-actor attribution could not be resolved through the two most obvious avenues: encryption-extension and ransom-note-naming-convention pattern matching against public ransomware family databases each produced multiple superficially plausible, contemporaneously active candidates, none of which were confirmed correct. Attribution was ultimately resolved by abandoning pattern matching in favor of direct evidence, submitting the literal ransom note text to a public malware analysis sandbox, which had already indexed a matching sample and linked to a confirmed dark-web leak-site listing, directly identifying the responsible group. This closes the campaign: the same actor who brute-forced a WordPress login in Stage 1 is, by infrastructure and credential reuse traced across Stages 2 through 4, the actor who encrypted the domain controller here.
Full report: SIR-2026-06-23-05
macOS Endpoint Compromise (Parallel, Unrelated Incident)
Investigated and reported separately from the main intrusion path, this stage documents an opportunistic compromise of a macOS developer workstation via a trojanized installer masquerading as an AI development tool. The application abused macOS's privacy-permission framework to request broad filesystem access, established persistence via a disguised, non-plist auto-start script, and exfiltrated high-value local files to a server disguised as a legitimate update service. Nothing in the delivery infrastructure, credentials, or tooling recovered here overlaps with Stages 1 through 5. It is included in this consolidated report for completeness of the training series it belongs to, not as evidence of a broader campaign against the same organization.
Full report: SIR-2026-06-23-04
6. Cross-Stage Analysis
Three patterns recur across Stages 1 through 5 clearly enough to be treated as campaign-level findings rather than isolated, per-host observations.
Escalating anti-forensics, not static tradecraft. The actor's approach to evading detection intensified at each stage rather than repeating a fixed playbook. Stage 2 cleared the Windows Security log once, after the fact, leaving a detectable log-clear marker as a timeline boundary. Stage 4 disabled the Event Log and Sysmon services outright, mid-session, preventing any record from being written at all rather than clearing one after the fact, a strictly more thorough technique. Stage 5, facing an evidence source with no logging infrastructure to disable in the first place (a metadata-only acquisition), relied instead on rename-then-execute file-level evasion. Read in sequence, this is not three unrelated anti-forensic choices but a single actor's technique maturing across the engagement, and it directly explains why no single evidence category, Event Logs, registry, or filesystem metadata, was sufficient on its own anywhere in this campaign.
Credential reuse as the connective tissue of the campaign. No stage after the first required a new exploitation technique to gain a foothold. Every lateral move, Stage 1 to Stage 2 (RDP with a domain account), Stage 2 to Stage 4 (reused domain credentials on the CRM server), was authenticated with material harvested at an earlier stage rather than a fresh compromise. This is the single strongest piece of evidence tying Stages 1, 2, and 4 together as one continuous intrusion rather than three coincidentally similar incidents, and it is also the campaign's clearest single point of failure from a defensive standpoint: interrupting credential reuse at any one hop, through segmentation, credential rotation, or privileged-account monitoring, would have contained the campaign to a single host.
A consistent recovery methodology, not five unrelated workarounds. Every time the actor removed or disabled a primary evidence source, the investigation resolved it by pivoting to an artifact category that survives that specific technique, and the same small set of fallback sources recurs deliberately across stages: registry-based usage and execution tracking (UserAssist in Stage 4, Shimcache in Stage 2) when the Event Log subsystem was disabled or cleared, shell and command history when privilege escalation moved activity outside audit-rule scope, and memory forensics (Stage 3) when no log source existed for a host at all. Framed at the campaign level, this is not five separate investigative improvisations but one repeatable principle applied five times: identify what the anti-forensic technique in play cannot reach, and go there first.
7. Consolidated Indicators of Compromise
| Stage | Type | Indicator |
|---|---|---|
| 1 | Source IP | [redacted], brute-force source, reused as RDP source and payload staging host |
| 1 | Web shell parameter | [redacted, cron-mimicking parameter name] |
| 1 | Exposed key file | [redacted, .bak private key backup] |
| 2 | Hijacked task | [redacted diagnostic scheduled task] |
| 2 | Service artifact | Fixed-name remote-execution service binary, survives client renaming |
| 3 | Disguised DLL | [redacted, masquerading as Windows Update component] |
| 3 | Pivot destination | [redacted internal IP]:3389 |
| 4 | Renamed tool | Cloud-sync utility, renamed to mimic backup software |
| 4 | Exfil destination | [redacted cloud storage account] |
| 5 | Delivery host | [redacted public file-sharing service] |
| 5 | Attributed group | Confirmed via sandbox / leak-site cross-reference |
8. Consolidated MITRE ATT&CK Mapping (Full Kill Chain)
| Tactic | Technique | Stage(s) |
|---|---|---|
| Initial Access | T1110 Brute Force | 1 |
| Persistence | T1505.003 Web Shell | 1 |
| Credential Access | T1552.004 Credentials in Files | 1 |
| Initial Access, Lateral Movement | T1078 Valid Accounts | 1, 2, 4 |
| Persistence, Privilege Escalation | T1053.005 Scheduled Task Abuse | 2 |
| Credential Access | T1003.001 OS Credential Dumping (LSASS) | 2 |
| Defense Evasion | T1070.001 Clear Windows Event Logs | 2 |
| Lateral Movement | T1021.002 / T1570 Remote Services / Lateral Tool Transfer | 2, 3 |
| Defense Evasion | T1218.011 Signed Binary Proxy Execution | 3 |
| Defense Evasion, Privilege Escalation | T1055 Process Injection | 3 |
| Lateral Movement | T1021.001 Remote Services (RDP) | 3 |
| Defense Evasion | T1562.001 / .002 Impair Defenses (Disable Logging) | 4 |
| Defense Evasion | T1036.005 Masquerading | 1, 2, 4 |
| Collection | T1560.001 Archive Collected Data | 4 |
| Exfiltration | T1567.002 Exfiltration to Cloud Storage | 4 |
| Impact | T1490 Inhibit System Recovery | 4 |
| Command and Control | T1105 Ingress Tool Transfer | 5 |
| Impact | T1486 Data Encrypted for Impact | 5 |
| Impact | T1657 Financial Theft | 5 |
9. Root Cause Analysis
Primary cause. The campaign originated from a public-facing web application with no rate limiting on its authentication endpoint, allowing credential brute-forcing to succeed within roughly one minute. Every subsequent stage of the campaign, five additional hosts, was reachable using either functionality already present on the compromised host (the Theme Editor, an exposed key backup) or credential material harvested at the previous stage. At no point did the actor need a software vulnerability to progress.
Contributing factors.
- No account lockout or rate limiting on the public authentication endpoint that served as the campaign's entry point.
- Predictable, web-accessible storage of a private key backup file, providing root-equivalent access with no further exploitation required.
- Domain credentials valid across multiple internal hosts (web host, gateway, CRM server) with no apparent segmentation or step-up authentication between them.
- Audit logging scoped to individual service accounts rather than extended to cover privilege-escalated activity, creating a documented blind spot the moment any account reached root or SYSTEM.
- Event Log and Sysmon services stoppable by a standard administrative session, with no independent, host-external forwarding to prevent local tampering from blinding central monitoring.
- No memory-capture or equivalent volatile-evidence collection built into standard incident response readiness for at least one host in the chain, a gap only avoided in this campaign because Volatility 3 analysis happened to be available for the DMZ gateway server specifically.
Evidentiary limitations. Absolute time correlation across all five hosts in the main intrusion path was not possible from the available evidence, since each host's evidence package anchored to a different reference clock and no single cross-host timestamp source (e.g., a centralized SIEM ingesting all five hosts) was provided. The Campaign Timeline in Section 4 reflects confirmed logical sequencing, not verified absolute chronology. The domain controller acquisition (Stage 5) was deliberately scoped to NTFS metadata only, meaning no registry, process, or network evidence exists for that host beyond what filesystem metadata could recover. Any findings requiring those artifact types on that specific host could not be pursued within this campaign's evidence.
10. Recommendations
- Enforce account lockout or rate limiting on all public-facing authentication endpoints. This single control would have prevented the campaign's entry point entirely.
- Rotate and segment domain credentials so that a single compromised account cannot authenticate across web-facing, gateway, and internal application-server roles. Credential reuse was the connective thread of this entire campaign.
- Forward Event Log and Sysmon telemetry to a centralized, host-independent SIEM. Local service stoppage and log clearing were used at two separate stages and would not have blinded a properly externalized logging pipeline.
- Extend audit logging scope beyond individual service-account UIDs to cover privilege-escalated activity, which went dark at multiple points in this campaign the moment an account reached root or SYSTEM.
- Treat registry-based artifacts (UserAssist, Shimcache) and default-on shell history as standard, first-pass triage sources on every Windows host investigation, not fallbacks reached only once Event Logs are found to be unavailable.
- Build memory-capture capability into standing incident-response readiness across all critical hosts. The DMZ gateway server investigation in this campaign would not have been possible from disk or log artifacts alone.
- Restrict outbound access to public file-sharing and consumer cloud-storage services from servers handling sensitive data or holding domain-controller privileges.
11. Investigator's Notes
Investigating each stage in isolation, as the individual constituent reports do, is sufficient to answer "what happened on this host." It is not sufficient to answer "what is this actor's operating pattern," and that second question only became answerable once all five hosts were read together. The escalating anti-forensics pattern in Section 6, in particular, was not visible from any single report. It required noticing that Stage 2 cleared a log after the fact, Stage 4 disabled logging before the fact, and Stage 5 faced an environment with no logging to disable at all, and recognizing that ordering as deliberate escalation rather than three unrelated choices. This is the main practical lesson carried forward from this exercise: a campaign-level view, built by deliberately re-reading completed, individually-closed investigations against each other, surfaces actor behavior that per-incident reporting alone does not, and is worth doing even after each constituent case has already been closed.