Tools

Coldframe: An OT Honeypot Disguised as a Cooler

Coldframe uses a single Python file to impersonate Danfoss and Dixell refrigeration controllers. This analysis examines its protocol simulation, logging capabilities, deployment risks, and practical limits.

Font size

If a refrigeration controller in a supermarket stockroom suddenly appeared on Shodan, most people would assume its owner had simply failed to change the default password.

Coldframe deliberately exploits that intuition. It impersonates a Danfoss AK-SM 800A or Dixell XWEB refrigeration controller and quietly waits for attackers to take the bait. Unlike common login-page honeypots, it does more than collect passwords: it also attempts to capture interactions at the industrial protocol level.

The project's author explains: “I built Coldframe, a honeypot that pretends to be a supermarket refrigeration controller.”

It does not add a layer of protection to a real controller. Instead, it sets up a convincing “dummy device” to see what attackers will do.

Not “Protecting” Devices, but Playing Dumb

Traditional honeypots often make the target look too obvious. The login form may display admin/admin, the footer may identify it as a honeypot, and scanners can readily recognize its behavior from known indicators.

Coldframe takes a different approach. It emulates the interfaces of real industrial refrigeration controllers, encouraging attackers to treat the target as a supermarket device exposed to the internet.

This shifts the defender's perspective. Vulnerability scanning tells you that “this device may be at risk.” Coldframe focuses on different questions:

  • Who is scanning it?
  • Which ports and protocols does the attacker try first?
  • Which default credentials does the attacker use?
  • Will the attacker continue probing with protocols such as Modbus?
  • After finding an interactive entry point, what does the attacker do next?

Its output is not a list of security alerts, but a record of attacker behavior.

That distinction matters in OT environments. Real industrial control devices update slowly, rely on old protocols, and often cannot receive patches promptly. Rather than scanning only your own assets, organizations can deploy a convincing decoy that absorbs some of the external scan traffic first.

Two Real Interfaces, and the Discovery Channels They Mislead

Coldframe emulates two classes of industrial refrigeration controller interfaces: the Danfoss AK-SM 800A and Dixell XWEB.

According to the author, Shodan identifies both simulated interfaces as real devices rather than labeling them as honeypots. Researchers or scanners searching Shodan see an industrial device that appears worth investigating, not an obvious trap.

The project did not invent these interfaces from scratch. It builds on eppser/danfoss-ak-sm-decoy and draws on public research from Synacktiv, Claroty, and Ironhackers.

This gives the project a specific character. It is not a general-purpose protocol framework, but a simulation-based decoy modeled on known research targets.

Danfoss and Dixell were not arbitrary choices. Public security research has already documented interface behavior, default credentials, and protocol characteristics associated with this class of refrigeration controller. Attackers may know how to identify them.

Simulation quality therefore determines whether the honeypot is effective. A visually accurate page may fool only shallow scanners. Faithful interface behavior is needed to engage attackers who understand the device class.

This is the main difference between Coldframe and browser-based login honeypots. Its target is not “anyone who is curious,” but people who may understand industrial protocols and the devices they control.

Is One Python File Enough?

Coldframe consists of a single Python file and uses only the Python standard library.

There is no Flask, FastAPI, device-emulation suite, or complex frontend build chain. The tradeoffs are straightforward:

  • Copying one file is enough to run it;
  • There is no large dependency tree to maintain;
  • Deployment in an isolated network is inexpensive;
  • Protocol responses and behaviors are easy to modify while testing.

If the goal is simply to determine whether anyone engages with the decoy, a single file may be sufficient.

git clone https://github.com/hedgerow-dev/coldframe
cd coldframe
python3 coldframe.py

For specific listening ports, emulation modes, and configuration options, consult the repository README and the current version of the project.

An OT honeypot should not be exposed directly on a production control network. A safer approach is to place it in a dedicated test zone or controlled VLAN and clearly identify traffic generated by the experiment.

The single-file design also has limitations. The standard library provides basic support for HTTP, sockets, logging, and concurrency, but it is not a graceful way to support complex protocols, certificates, passive traffic analysis, or high-fidelity device behavior.

As interactions become more sophisticated, maintenance costs quickly rise from “one file” to “a protocol emulator that requires serious testing.”

Thus, “one Python file” suits rapid deployment and protocol-level experiments; it does not mean Coldframe can replace a full industrial control simulation platform.

What the Honeypot Actually Records Is Attacker Behavior

Coldframe's core value does not lie in the number of failed login attempts it logs. The question is whether those logs can reconstruct a realistic attack path.

At least four categories of information deserve attention.

The first is the discovery stage. Which IP addresses and ports did attackers use, and which search channels, such as Shodan, Censys, or FOFA, led them to the decoy?

The second is credential attempts. Which usernames and passwords did they try, and did those strings include vendor names, model numbers, or industry-specific terms?

The third is protocol interaction. After connecting, which registers, function codes, or administrative interfaces did they request? Did they attempt to move beyond refrigeration control logic toward other functions?

The fourth is follow-on activity. Did attackers download files, establish reverse connections, deliver payloads, or begin scanning laterally?

This adds a controlled comparison to ordinary log collection. Production logs tell you what happened in the live environment. A honeypot provides a controlled experimental environment in which to observe how attackers choose when they encounter a target.

The two can work together. Logs from real devices answer “Were we touched?” Coldframe answers “If we appeared more exposed, how would the attacker proceed?”

Vulnerability scanning serves a different purpose. Scanners enumerate vulnerabilities and exposed services according to known rules, producing results that resemble a risk inventory. A honeypot has no predefined attack script. It records actual behavior, including new combinations that a rules-based scanner does not yet cover.

Of course, these signals cannot be interpreted if the logs contain nothing more than a single “connection failed” line. At minimum, they should preserve timestamps, source IPs, destination ports, request content, protocol responses, and session correlation. A single file does not imply single-line logging.

It Cannot Replace OT Network Segmentation

Deploying Coldframe does not mean that real controllers have been protected.

It cannot patch vulnerabilities in Danfoss, Dixell, or other vendors' devices. It also cannot stop attackers from bypassing the honeypot and continuing to scan real HVAC systems, PLCs, HMIs, and industrial gateways. Attackers may even recognize the simulated behavior and redirect their traffic toward production assets.

A more practical risk is that the honeypot exposes itself. Once running, it may attract scans, payload deliveries, and other attack traffic. Its logs may contain malicious files, credentials, or exploit code. If evidence collection is handled insecurely, the honeypot can become a new infection source.

It also cannot replace these foundational controls:

  • Segment OT and IT networks with VLANs or firewalls;
  • Maintain an accurate inventory of assets and device fingerprints;
  • Restrict the source addresses allowed to access administrative interfaces;
  • Track vendor firmware and patches;
  • Monitor and control access to legacy protocols.

Coldframe fills the gap in “external visibility.” It shows how attackers search for industrial entry points without touching real devices.

Editorial Assessment

Coldframe is worth examining not because the security community gained another honeypot, but because it moves observation of the OT attack surface away from production assets. Ordinary device logs emphasize forensics, vulnerability scanning emphasizes known rules, and simulated decoys capture what attackers actually do when confronted with a particular device. For OT teams that lack an external perspective, this is a low-cost addition.

Simple deployment is only the first threshold. The accuracy of the protocol simulation determines how long the decoy can remain convincing. If its responses are too polished, attackers may quickly identify it as an experimental device. Future scanners may also add fingerprint checks designed to recognize this type of decoy.

Coldframe differs from many earlier honeypots. Older designs often attract traffic through obvious interface anomalies, while Coldframe seeks to reduce suspicion by appearing like a normal device. However, the available material provides no detection rates, interaction-depth measurements, or real-world deployment data, so its effectiveness against advanced attackers cannot be confirmed. The sensible approach is to place it in an isolated test area, validate its protocols and logs, and then decide whether to maintain a long-term deployment.

Original project: hedgerow-dev/coldframe

Source

https://github.com/hedgerow-dev/coldframe

Source: https://github.com/hedgerow-dev/coldframe