-> Back to Writeups
Security Incident Report, Full Campaign Reconstruction

Honeynet Collapse: Full Kill Chain from Public Web Application to Domain-Wide Compromise

TLP:CLEAR
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
This report consolidates six independently published incident reports (TryHackMe, Honeynet Collapse series) into a single, cross-referenced campaign reconstruction. It supersedes no individual report. Each stage remains available separately for readers who want the compact version. Specific artifact values, exact timestamps, and file paths are generalized or redacted for public publication throughout, consistent with the individual reports. The analytical structure, root-cause reasoning, and cross-stage correlation reflect the actual investigation performed across all six stages.

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 hostPublic-facing web applicationCredential brute-force -> web shell -> SSH key theft -> rootStage 1
Windows Server (internal)Internal target reached from the web hostValid domain credentials -> RDP -> scheduled task hijack -> LSASS dump -> log clearingStage 2
DMZ Gateway ServerLateral pivot pointRemote service execution -> LOLBin proxy -> process injection -> active RDP pivot at captureStage 3
CRM Application ServerCustomer data storeReused domain credentials -> logging disabled -> staged exfiltration tool -> cloud uploadStage 4
Domain ControllerDomain authorityPublic file-share payload -> rename-then-execute -> ransomware deploymentStage 5
macOS WorkstationDeveloper endpoint (parallel, unrelated)Trojanized installer -> TCC permission abuse -> LaunchAgent persistence -> exfiltrationStage 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
01Brute-force success against WordPress login endpointWeb hostInitial Access
02Theme Editor abused to plant disguised web shellWeb hostExecution
03Exposed SSH key backup recovered, authenticate as rootWeb hostPrivilege Escalation
04Internal network sweep, payload staged, persistence installedWeb hostDiscovery, Persistence
05Inbound RDP using domain credentials, from the compromised web host's IPWindows ServerLateral Movement
06Elevated scheduled task hijacked, known post-exploitation stager confirmedWindows ServerPrivilege Escalation
07LSASS dumped via renamed utility, second domain account recoveredWindows ServerCredential Access
08Security event log cleared mid-session, Shimcache used to reconstruct post-clearing activityWindows ServerDefense Evasion
09Remote service execution arrival, LOLBin proxy, injection into a legitimate utilityDMZ GatewayLateral Movement, Defense Evasion
10Outbound RDP to a further internal host, active at time of memory captureDMZ GatewayLateral Movement
11Interactive logon with reused domain credentialsCRM ServerLateral Movement
12Event Log and Sysmon services stopped mid-sessionCRM ServerDefense Evasion
13Cloud-sync utility staged, renamed, full customer export exfiltratedCRM ServerCollection, Exfiltration
14Shadow copies deleted, recycle bin cleared, staged tooling removedCRM ServerDefense Evasion, Impact
15Ransomware payload delivered via public file-sharing serviceDomain ControllerCommand and Control
16Dropper duplicated under IT-tooling-mimicking name, rename-then-executeDomain ControllerDefense Evasion
17Domain-wide file encryption, ransom note replicated across the hostDomain ControllerImpact

5. Stage-by-Stage Technical Findings

Stages 1-2

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

Stage 3

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

Stage 4

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

Stage 5

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

Stage 6

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
1Source IP[redacted], brute-force source, reused as RDP source and payload staging host
1Web shell parameter[redacted, cron-mimicking parameter name]
1Exposed key file[redacted, .bak private key backup]
2Hijacked task[redacted diagnostic scheduled task]
2Service artifactFixed-name remote-execution service binary, survives client renaming
3Disguised DLL[redacted, masquerading as Windows Update component]
3Pivot destination[redacted internal IP]:3389
4Renamed toolCloud-sync utility, renamed to mimic backup software
4Exfil destination[redacted cloud storage account]
5Delivery host[redacted public file-sharing service]
5Attributed groupConfirmed via sandbox / leak-site cross-reference

8. Consolidated MITRE ATT&CK Mapping (Full Kill Chain)

Tactic Technique Stage(s)
Initial AccessT1110 Brute Force1
PersistenceT1505.003 Web Shell1
Credential AccessT1552.004 Credentials in Files1
Initial Access, Lateral MovementT1078 Valid Accounts1, 2, 4
Persistence, Privilege EscalationT1053.005 Scheduled Task Abuse2
Credential AccessT1003.001 OS Credential Dumping (LSASS)2
Defense EvasionT1070.001 Clear Windows Event Logs2
Lateral MovementT1021.002 / T1570 Remote Services / Lateral Tool Transfer2, 3
Defense EvasionT1218.011 Signed Binary Proxy Execution3
Defense Evasion, Privilege EscalationT1055 Process Injection3
Lateral MovementT1021.001 Remote Services (RDP)3
Defense EvasionT1562.001 / .002 Impair Defenses (Disable Logging)4
Defense EvasionT1036.005 Masquerading1, 2, 4
CollectionT1560.001 Archive Collected Data4
ExfiltrationT1567.002 Exfiltration to Cloud Storage4
ImpactT1490 Inhibit System Recovery4
Command and ControlT1105 Ingress Tool Transfer5
ImpactT1486 Data Encrypted for Impact5
ImpactT1657 Financial Theft5

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

  1. Enforce account lockout or rate limiting on all public-facing authentication endpoints. This single control would have prevented the campaign's entry point entirely.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.

END OF REPORT : SIR-2026-MASTER
Full technical detail, exact artifact values, and challenge-identifying information intentionally generalized for public publication throughout. Individual per-stage reports are available in the Writeups section. Happy to walk through the complete investigation in more depth in conversation: get in touch.