Coldframe: Securing Supermarket Refrigeration via Operational Technology Honeypots
When we talk about critical infrastructure security, our minds usually jump to power grids, water treatment plants, or massive manufacturing SCADA systems. We rarely think about the local supermarket. Yet, sprawling networks of commercial refrigeration units maintain the global cold chain, ensuring everything from fresh produce to vital pharmaceuticals remains stable. These systems are governed by specialized edge devices connected directly to the internet for remote monitoring and management. And increasingly, those edge devices are sitting in the crosshairs of automated scanners and malicious actors.
Supermarket refrigeration controllers are critical yet frequently overlooked operational technology (OT) assets. Unlike traditional enterprise servers protected behind layers of advanced firewalls and identity providers, these industrial controllers often live on the edge, bridging physical machinery with remote management platforms. Because they are designed for reliability and physical process control rather than robust enterprise IT security, they face constant automated scanning and targeted exploitation attempts.
To better understand how threat actors target these neglected industrial endpoints, security engineers need specialized visibility. This is where Coldframe comes in—a lightweight, purpose-built defense mechanism designed to study attacker behavior against supermarket refrigeration infrastructure.
Anatomy of a Refrigeration Controller Target
To build an effective deception environment, we first need to understand what attackers see when they scan enterprise retail networks. The attack surface of modern commercial refrigeration is largely defined by a few dominant hardware families, most notably the Danfoss AK-SM 800A system manager and the Copeland/Dixell XWEB EVO supervisor.
These units act as the central nervous system for a store’s cooling architecture. They monitor compressor racks, display cases, and condenser temperatures, automatically adjusting valves and fan speeds. To allow remote facility managers to adjust setpoints or review alarm logs, these supervisors expose web interfaces directly to local area networks—and, in many misconfigured deployments, directly to the wider public internet.
Public vulnerability disclosures have repeatedly highlighted the fragility of these interfaces. For instance, researchers have tracked severe issues like path traversal vulnerabilities (such as CVE-2023-25914) and remote command injection flaws (CVE-2023-25915) in Danfoss system managers, alongside analogous authorization bypasses in Dixell XWEB hardware.
| Target System | Primary Function | Common Vulnerability Classes | High-Risk Operational Impact |
|---|---|---|---|
| Danfoss AK-SM 800A | System Manager / Gateway | Path Traversal (CVE-2023-25914), Command Injection (CVE-2023-25915) |
Forced defrost cycles, alarm suppression, compressor lockouts |
| Dixell XWEB EVO | Monitoring & Supervision | Authentication bypasses, hardcoded credentials, code-of-the-day flaws | Temperature setpoint manipulation, log tampering |
The operational risk here goes far beyond traditional data theft. An unauthorized actor gaining high-level access to a refrigeration controller can execute dangerous commands: initiating forced defrost cycles simultaneously across all display cases to overload power draws, manipulating temperature setpoints to spoil tons of perishable inventory, or masking critical system alarms while equipment fails.
Understanding these exact mechanics is just as crucial as studying how modern software supply chain threats operate, much like analyzing the runtime behavior we previously explored in our breakdown of the anatomy of SourTrade Bun runtime malware. In both cases, visibility into early-stage reconnaissance is your best line of defense.
Coldframe Design Architecture: Zero Dependencies, Maximum Signal
Deploying heavy industrial simulation tools in edge locations is rarely practical. Supermarket IT environments are constrained, distributed, and often managed by third-party facilities vendors rather than dedicated security operations teams. Coldframe solves this by adopting a minimalist design philosophy: zero external dependencies and maximum operational signal.
Written entirely in a single Python file using only the standard library, Coldframe eliminates the installation headaches typical of complex honeypot frameworks. You don’t need to wrestle with virtual environments, missing C-compilers, or bloated package managers. You simply drop the script onto a target host, configure your environment variables, and run it.
+-------------------------------------------------------+
| Coldframe |
| (Single Python File) |
+---------------------------+---------------------------+
|
+------------------+------------------+
| |
v v
+-----------------+ +-----------------+
| HTTP/HTTPS Core | | Optional Modbus |
| (Danfoss Persona| | TCP Service |
| & Dixell XWEB) | | (Register Map) |
+-----------------+ +-----------------+
| |
+------------------+------------------+
|
v
+-------------------------+
| Structured JSON/File |
| Logging |
+-------------------------+
The architecture revolves around simulating two distinct personas:
- The Danfoss Persona: Emulates the HTTP response headers, login portals, and navigational file structures typical of an AK-SM 800A series controller, complete with simulated Nginx version strings often found in front of the application firmware.
- The Dixell Persona: Replicates the distinct URI pathways, cookie management styles, and authentication challenges associated with Copeland XWEB EVO supervisors.
Additionally, Coldframe includes an optional Modbus TCP service layer. Industrial scanners frequently probe port 502 to discover exposed registers. By spinning up a lightweight Modbus listener alongside the HTTP server, Coldframe can catch automated threat actors attempting to read holding registers associated with case temperatures, suction pressures, and defrost schedules.
Logging, Tracking, and Attack Signatures
A honeypot is only as valuable as the telemetry it produces. Because Coldframe sits quietly on the network edge, every connection it receives is—by definition—unauthorized scanning or targeted malicious activity. The honeypot logs every interaction with high fidelity, tracking everything from lazy credential stuffing to sophisticated exploit payloads.
Credential Brute-Forcing and Default Passwords
Attackers rarely start with zero-day exploits when default credentials still exist. Coldframe logs every authentication attempt, capturing the exact username and password combinations used. This telemetry frequently reveals automated botnets cycling through well-known factory defaults for refrigeration hardware (such as root:root, admin:danfoss, or maintenance:xweb).
Exploit Pathing and Auth Bypasses
When an automated scanner or human attacker targets known vulnerabilities, they leave distinct fingerprints in the HTTP request URIs. Coldframe specifically monitors and logs requests tied to:
- Traversal sequences targeting configuration files (
CVE-2023-25914). - Parameter injection attempts aimed at underlying shell execution (
CVE-2023-25915). - Attempts to exploit “code-of-the-day” static time-based authentication bypass algorithms found in older firmware iterations.
Here is a simplified snippet illustrating how Coldframe inspects incoming request paths for known vulnerability signatures:
import http.server
import logging
class ColdframeHandler(http.server.BaseHTTPRequestHandler):
def do_GET(self):
# Log the source IP and requested path for threat intelligence
client_ip = self.client_address[0]
path = self.path
logging.info(f"Connection from {client_ip} requested path: {path}")
# Check for known exploit signatures
if "cve-2023-25914" in path.lower() or "../" in path:
logging.warning(f"POTENTIAL EXPLOIT: Path traversal attempt detected from {client_ip}")
self.send_simulated_danfoss_response(404)
elif "/cgi-bin/" in path:
logging.warning(f"POTENTIAL EXPLOIT: Command injection probe detected from {client_ip}")
self.send_simulated_danfoss_response(500)
else:
self.send_simulated_danfoss_response(200)
def send_simulated_danfoss_response(self, code):
self.send_response(code)
self.send_header("Server", "nginx/1.14.2 (Danfoss AK-SM)")
self.end_headers()
self.wfile.write(b"<html><body>Login Required</body></html>")
if __name__ == "__main__":
logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
server = http.server.HTTPServer(("0.0.0.0", 80), ColdframeHandler)
server.serve_forever()
Modbus Register Probing
When the Modbus TCP module is active, Coldframe records specific function codes requested by scanners (such as Read Holding Registers [0x03] or Read Input Registers [0x04]). This data helps security teams differentiate between broad, indiscriminate internet-wide asset discovery scans and targeted intelligence-gathering operations mapping out physical refrigeration layouts.
Hardened Deployment: Running Coldframe Safely
Deploying a honeypot means intentionally introducing a simulated vulnerability onto your network. If not properly contained, a compromised honeypot host could become a staging ground for lateral movement into your production environment. Therefore, running Coldframe requires strict adherence to containerization and hardening best practices.
We recommend deploying Coldframe on Ubuntu 24.04 LTS using modern container runtimes like Podman or Docker, leveraging strict isolation controls.
Containerization Strategy
Packaging Coldframe inside a minimal container image ensures that even if an edge case flaw exists in the Python script itself, the blast radius remains strictly contained to the container namespace.
Here is an example production-grade command using Podman with advanced security flags enabled:
podman run -d \
--name coldframe-edge \
--read-only \
--security-opt no-new-privileges:true \
--cap-drop=ALL \
--userns=auto \
-p 80:8080 \
-p 502:5020 \
-v /opt/coldframe/logs:/app/logs:Z \
coldframe:latest
Breaking Down the Security Controls
--read-only: Mounts the container’s root filesystem as read-only. This prevents any attacker who achieves remote code execution from dropping persistent malware payloads or modifying application code.--security-opt no-new-privileges:true: Blocks processes from gaining new privileges (such as viasuidbinaries), neutralizing privilege escalation attempts.--cap-drop=ALL: Strips away all Linux kernel capabilities from the container, ensuring it runs with zero privileged system access.--userns=auto: Automatically maps container root to an unprivileged user on the host system, mitigating container escape risks.-v ...:/app/logs:Z: Isolates log persistence to a dedicated volume with appropriate SELinux context labeling (:Z), allowing structured logs to stream safely out to your central SIEM or log aggregation pipeline.
By combining these containerization safeguards with network-level segmentation—placing the honeypot in a dedicated DMZ or isolated VLAN separate from actual building management systems—you create a safe, high-signal observation post.
Future Outlook: The Trajectory of Edge OT Threat Intelligence
The deployment of lightweight, sector-specific deception tools like Coldframe highlights a broader shift in industrial cybersecurity. For years, securing operational technology meant relying on passive network monitoring and perimeter firewalls. But as threat actors become more sophisticated—increasingly targeting edge IoT, commercial facilities, and operational infrastructure with default credentials and firmware exploits—passive observation is no longer enough.
We are witnessing a clear trend toward deployable, high-interaction deception environments tailored to vertical industries. Just as advanced IT environments utilize honeypots to catch custom lateral movement techniques, ICS security teams are beginning to adopt localized OT honeypots to capture novel attack vectors before they impact physical operations. This proactive approach mirrors how advanced analysts monitor sophisticated geopolitical cyber threats, such as the autonomous intrusion tactics examined in our analysis of DeepSeek Knaithe autonomous cyberattack analysis.
Ultimately, tools like Coldframe bridge the gap between traditional IT security monitoring and industrial control system defense. By transforming neglected edge controllers into active vantage points, security engineers can turn automated scanning into actionable threat intelligence—securing the cold chain one log entry at a time.