A real PLC, on your side of the wire.
Docker-delivered, deterministic PLC simulation that runs entirely inside your VPC. Ladder-logic and Structured Text execution, real industrial protocols on bind-mounted ports, and a cryptographic hash-sealed cycle trace — without telemetry leaving the enclave.
- Image size
- ~280 MB
- Min cycle
- 1 ms
- Outbound
- 0 calls
- Protocols
- 6
Why teams insist on a Virtual PLC.
Real plants don’t share their PLCs. Vendor demos are scripted videos. SaaS simulators leak by definition. A signed Docker image you run in your enclave is the only path that satisfies OT security review.
Air-gapped by design
The PLC image runs inside your own VPC or on a bare Linux host. No outbound telemetry, no phone-home, no licence-server dependency. The evidence chain signs locally with a per-deployment key.
Docker-delivered
One signed image. Operators pull it, set environment flags, and start generating PLC behaviour on day one — no separate installer, no driver hell, no kernel modules.
Enterprise tier only
VPLC is included only with Enterprise and Sovereign plans. The rest of the platform may continue to run in our cloud — the VPLC sits firmly on your side of the wire.
What it does on day one.
Ladder-logic and Structured Text programs run deterministically from a sealed seed.
Configurable cycle time (1 ms – 250 ms), input/output table sizes, scan cadence.
Operator actions scripted, replayed from a captured session, or driven by the SDK.
Modbus/TCP, OPC-UA, BACnet, MQTT, DNP3, and IEC 61850 endpoints exposed on bind-mounted ports.
Full cycle trace persisted as a cryptographic hash-sealed evidence ledger, verifiable offline.
Red-team scenario library: timing attacks, register spoofing, logic-bomb injection.
Physics-honest response model per analog tag; event-driven state machines with safety interlocks for every discrete state.
Per-cycle structured logs ready for ingest into Splunk, Elastic, or your SIEM of choice.
Five layers, each one auditable.
No magic. No kernel modules. No out-of-process daemons your security team has to chase down at 2 a.m.
Each layer below is one responsibility the image already owns. Your OT security review opens the image, reads the scan-cycle log, inspects the bind-mounted protocol ports, replays the evidence bundle, and reads the declarative scenario file — five readings, five answers, no open questions left for support.
The commercial payoff: a deployment that completes in an afternoon without the architecture team needing to negotiate exceptions with the security team. The image is the product; every layer below is how that product is built, so an enterprise buyer reads the same five layers their reviewer will read next week.
A single signed Docker image around 280 MB, built on a distroless base with no shell and no package manager. The build is reproducible from the public CI manifest, every dependency is pinned by digest, and a full SPDX SBOM ships alongside each release. The image itself is signed with cosign under our GitHub Actions OIDC identity — you verify the signature with a one-line command before you load the image, and you never have to trust a separate public key we email you.
A deterministic scan-cycle scheduler runs the loaded ladder-logic or Structured Text program at the configured cycle time, with strict per-cycle accounting: every missed deadline is recorded, every I/O read and write is timestamped, every alarm transition is logged. The per-tag response model is calibrated against the real plant signature the program is meant to simulate, so pressures, flows, and set-points rise and fall with physically plausible dynamics — not linear ramps. No out-of-process daemons. No kernel modules. One container, one scheduler, one log.
Six industrial protocols expose the simulated PLC on bind-mounted ports: Modbus/TCP (502), OPC-UA (4840, anonymous or client-certificate), BACnet/IP (47808), MQTT 3.1.1 and 5 (1883), DNP3 (20000), and IEC 61850 MMS (102). Each protocol is implemented against its binary specification, not a vendor SDK — tag reads, writes, subscription deltas, and GOOSE multicast all behave the way a real RTU on the same segment would behave. You choose which ports to expose per deployment; the unused ones are simply not listened on.
Every run produces an evidence bundle: the cycle trace, the I/O snapshot set, the alarm log, the scenario inputs, and the protocol-level capture are all hashed into a cryptographic chain and written as a signed .tar.zst archive onto a host volume you chose. Nothing leaves the container otherwise. An offline verifier (ships with the SDK, no network required) replays the whole chain and confirms the bundle has not been modified since it was sealed. Every run you can hand to an auditor is provably what the PLC actually did that day.
A REST surface and a typed Python SDK drive the sim: load a program, set tag values, schedule disturbances (storm surge, cold snap, valve stuck), inject red-team events (command injection, firmware replay, rogue master), and step through sequences hands-free. Every scenario is declarative and seeded, so the same scenario replayed on the same image produces the same bundle hash — a stable target for regression tests and detection-engine tuning.
# 1. Enterprise tarball — delivered via signed offline channel.
# Load the signed image into the customer's registry / daemon.
docker load < radmah-vplc-1.4.2.tar
# Keyless Sigstore verification against the GitHub Actions OIDC identity
# used by our CD pipeline. No separate public key to distribute.
cosign verify \
--certificate-identity-regexp '^https://github\.com/ITLOXENT/radmah-ai/\.github/workflows/cd\.yml@' \
--certificate-oidc-issuer 'https://token.actions.githubusercontent.com' \
$VPLC_IMAGE
# 2. Run with bind-mounted ports + evidence volume
docker run -d --name vplc \
-p 502:502 -p 4840:4840 -p 47808:47808/udp \
-p 1883:1883 -p 20000:20000 -p 102:102 \
-v /opt/vplc/evidence:/evidence \
-e VPLC_TENANT=acme-prod \
-e VPLC_LICENSE_FILE=/license/key.bin \
-v /opt/vplc/license:/license:ro \
$VPLC_IMAGE
# 3. Drive a scenario
rady vplc simulate \
--target localhost:502 \
--program ./programs/clarifier.st \
--disturbance storm-surge --duration 30m- $ rady evidence verify ./scada-2841.bundle.tar.zst
- → unpacking 14 artefacts ………………… ok
- → checking cryptographic hash chain ………………… ok
- → verifying cryptographic signature signature ……… ok
- manifest: sha 9c10ab…
- sealed contract: sha a4f2d8…
- pcapng: sha 5e2c1a… 42.7 MB
- signals.parquet: sha 1b8d44… 3.4 MB
- truth.ndjson: sha 5e2c1a… 6 events
- cryptographic hash.chain: sha a4f2d8… root a4f2…d801
- ✓ chain verified — 9 / multi-part evidence intact
- ✓ signed by acme-soc-prod (cosign · key-id 0x4f1c)
- $ rady evidence get job_e2f91b37 --truth
- 6 attack events · 3 MITRE classes · 70% benign
- earliest 14:30:06 latest 14:35:42 span 5m36s
- ✓ ready for IDS scoring
Built so the OT security review signs on the first read.
A Virtual PLC that ships into a regulated enterprise needs more than a Dockerfile. It needs a provenance story, an isolation story, an audit story, and an offline-delivery story — all of them demonstrable on day one without a call to our support team.
Every item below is wired into the image itself. No separate agent, no sidecar, no management plane. If a control can't be enforced locally with the image your operator just pulled, we don't ship it.
Per-tenant isolation
Every Virtual PLC deployment is pinned to a per-tenant encryption identity: a Fernet key distributed as part of the licence, an artefact prefix reserved on the evidence volume, and an evidence-chain root that will never resolve against another tenant's bundles. You can host twenty customers on one Docker host without a single byte of cross-tenant traffic.
Signed image + SBOM
Each release is a distroless image built under a locked GitHub Actions OIDC identity, signed with Sigstore cosign keylessly, and accompanied by a full SPDX 2.3 SBOM and a pinned dependency manifest. Your change-management team gets a verifiable provenance chain from our source commit to the container your operator is about to run. No out-of-band key distribution.
Audit-ready evidence
Every cycle is hashed into the evidence ledger and the ledger is sealed at the end of the run. Offline verifier walks the chain, validates every signature, re-derives every per-artefact digest, and flags any mutation since seal. Auditor-friendly: the chain walks back to the exact signed image digest that produced it. SOC 2 evidence requests take minutes, not weeks.
Governance that fits your review board
Role-scoped licences (operator, engineer, auditor) with a per-role command allowlist. A plain-text deployment policy file the customer edits in-place to remove protocols, pin cycle-time bounds, and lock the evidence root. Everything the OT security review asks for is configurable at `docker run` time — no rebuild, no redeploy, no separate admin console.
Runs where your OT runs
Same image on EC2, Azure VMs, bare metal under a maintenance window, an industrial PC in the plant, or an ARM64 edge box. No dependency on any cloud service, any paid database, any proprietary licence server. If your OT runs on Linux somewhere, VPLC runs on that same Linux somewhere.
Offline-delivery path
Air-gapped customers receive a signed tarball through the delivery channel of their choice: encrypted USB, hardware security module, courier, whatever your compliance team accepts. The image loads with `docker load`, the cosign verification runs entirely locally, the licence key is a single file — no network, no phone-home, no `https://` calls at any point during setup or operation.
Who runs it, and why.
IDS / SIEM detection-engine validation
Replay the same attack sequence dozens of times to prove a detection rule fires at the expected confidence. Ground-truth labels travel inside the bundle.
Operator training without touching prod
Give a trainee a live PLC — synthetic but behaviourally identical to your real plant — and let them drive a full scenario without risk to the running process.
Red-team exercises under NDA
Run intrusion exercises inside the enclave. Nothing about the environment, the attack, or the evidence crosses the boundary unless you push it.
Vendor PoC sandbox
Stand up a clean PLC image per vendor evaluation. Reset to the sealed baseline between PoCs. The evidence bundle gives you an audit-grade record of what each vendor saw.
30-day evaluation licence on a signed image.
Tell us your plant type, your protocol surface, and the scenarios you need to prove. We cut a 30-day evaluation licence pinned to your registry hash.