Research
Pk-IOTA: Blockchain empowered Programmable Data Plane to secure OPC UA communications in Industry 4.0
OPC UA is the de facto standard for Industry 4.0 machine-to-machine communication and has security built into its design, but real deployments frequently fail to configure it properly because…

- arXiv
- 2511.10248
- Published
- 2025-11-13
- Authors
- Rinieri Lorenzo, Gori Giacomo, Melis Andrea, Girau Roberto, Prandini Marco, Callegati Franco
AI summary
Overview
Research area: Industrial Control Systems (ICS) security — specifically securing OPC UA machine-to-machine communications in Industry 4.0 using programmable network switches and a distributed ledger for certificate management.
Technical level: Advanced. The paper assumes familiarity with OPC UA handshakes, X.509 certificates and trust lists, P4 data-plane programming, and DLT/Tangle architectures.
Scope: The paper designs, implements, and empirically evaluates Pk-IOTA, an architecture that moves OPC UA certificate validation into P4 programmable switches and distributes certificate issuance and revocation through the IOTA Tangle, tested on a physical Industry 4.0 testbed.
What This Paper Is About
OPC UA is the de facto standard for Industry 4.0 machine-to-machine communication and has security built into its design, but real deployments frequently fail to configure it properly because certificate and trust-list management is complex and because industrial devices implement security features inconsistently. Pk-IOTA addresses this gap by having the network itself — rather than each individual OPC UA device — check whether a peer's certificate is trusted, with the list of trusted certificates maintained on the IOTA Tangle instead of manually in device trust lists. The goal is a tamper-proof, automated, and scalable certificate management layer that works even with OPC UA devices that have weak or missing native security support.
Key Contributions
- The Pk-IOTA architecture, which combines programmable data plane (P4) switches performing in-network certificate validation with a decentralized PKI built on the IOTA Tangle, organized into four layers: Device, Data Plane, IOTA Clients, and IOTA.
- Two interchangeable IOTA integration modes — an MQTT-based interaction with the Tangle at Layer 1 (
iota-sdkPython library) and a smart-contract-based approach at Layer 2 using Node.js and theweb3library — reaching the same objectives with different performance and functionality trade-offs. - A comprehensive evaluation on a physical testbed modelled on the Purdue Enterprise Reference Architecture, measuring data plane processing overhead, certificate propagation efficiency, and resource consumption of each component.
- A public open-source release of the implementation at
https://github.com/UniboSecurityResearch/Pk-IOTA.
Main Findings
- Prior deployments are badly misconfigured: citing Dahlmanns et al., 92% of OPC UA deployments reachable over the Internet are improperly configured; 24% disable communication security entirely, 25% rely on outdated cryptography such as SHA-1, 35% reuse security-critical certificates across devices, and 44% allow unauthenticated users to read, write, and execute functions on industrial devices.
- Device security support is inconsistent: in Erba et al.'s assessment of 48 real-world OPC UA artifacts, only 10 (20.8%) correctly implement certificate management, 7 do not support security features at all, and the remaining 31 (64.6%) show issues or errors in trust-list management; only 5 artifacts support GDS certificate management features. Pk-IOTA relies solely on features supported by 85.4% of these artifacts.
- Modest per-packet processing overhead: across 1000 OPC UA connection attempts (2000 Open Secure Channel requests and responses), in-network certificate validation increased packet processing time by approximately 38% (2600 μs) per packet.
- Negligible queuing overhead: packet dequeuing time increased by only about 1.04 μs per packet.
- Handshake-level overhead: the introduction reports a minimal overhead of 14% on the OPC UA security handshake without interfering with normal operations. The detailed end-to-end handshake measurement (Figure 5(c)) is cut off in the supplied content, so the underlying numbers for that figure are not available here.
- Feasible resource consumption: the paper states that all architecture components operate within feasible limits, allowing deployment in large-scale industrial settings without significant performance penalties; specific measured values are not available in the truncated content.
- Attack coverage: the authors discuss how Pk-IOTA prevents the Rogue Server, Rogue Client, and Middleperson attacks identified in prior OPC UA security work.
Methodology in Plain English
The authors first motivate the problem with published measurements showing that OPC UA deployments in the field are frequently insecure, then build an architecture around two ideas.
First, they use P4 programmable switches — network hardware whose packet-parsing logic can be rewritten in software — to inspect OPC UA traffic. When a client or server sends an Open Secure Channel (OPN) message, the switch parses past the Ethernet, IPv4, and TCP headers into the OPC UA header, reads the length of the embedded certificate (converting it from big-endian to little-endian so P4 can process it), extracts the certificate in 256-byte chunks because that is the maximum P4 variable size, and finally computes the certificate thumbprint. That thumbprint is matched against a table (thumbprint_table) of allowed certificates; anything without a match is dropped before a secure channel can even be established. This removes the "Trust List Check" burden from the end devices.
Second, the list of valid thumbprints is not maintained by hand. An administrator publishes certificate issuance or revocation transactions to the IOTA Tangle (either as tagged MQTT transactions at Layer 1, or via smart contracts with addCertificate, revokeCertificate, and getAllCertificates functions at Layer 2). A P4 controller listening to IOTA picks up these transactions and installs or removes rules in the switch through the P4Runtime TableEntry API.
The evaluation uses a physical testbed split into IT and OT domains per the Purdue model: a Dell workstation with an Intel i7 and 64 GB RAM running the OPC UA client (opcua-asyncio) and IOTA client; an Aruba switch between domains; sensors/actuators and an embedded IoT device at Level 0; a Revolution Pi at Level 1 emulating PLCs; and an edge node with an Intel i7 and 32 GB RAM at Level 3 hosting the IOTA client and a custom P4 controller, with P4 bmv2 virtual switches. Open Secure Channel packets were tagged in P4 metadata, and processing and dequeuing times were recorded in registers for packet-level analysis.
Why This Matters
Impact on research: The paper shifts security enforcement from endpoints to the network fabric, offering a concrete alternative to the Global Discovery Server for environments where GDS is unsupported — notable because the authors state that no commercial GDS solution is currently certified by the OPC Foundation. It also provides empirical, testbed-based numbers for the cost of in-network cryptographic-adjacent validation, which prior OPC UA security work largely discussed qualitatively.
Real-world applications:
- Brownfield factories with legacy OPC UA devices that cannot maintain trust lists or support GDS.
- Multi-vendor plants where devices from different manufacturers implement security features inconsistently.
- Large-scale OPC UA networks where manually installing certificates into device trust lists is impractical and error-prone.
- Rapid certificate revocation after a compromised device, enforced network-wide in near-real time rather than device by device.
Industry relevance: The work targets the exact failure modes reported in field studies — disabled security modes, deprecated cryptography, certificate reuse, and unauthenticated access — and argues for moving "from security by design to security by default," a framing taken directly from prior measurement work and aligned with OPC Foundation guidance recommending SignAndEncrypt, no anonymous authentication, and only the Aes128_Sha256_RsaOaep, Basic256Sha256, and Aes256_Sha256_RsaPss policies.
Future Directions
- Complete the end-to-end handshake characterization: the truncated results leave open the full latency distribution for the 1000 connection attempts and how the 14% handshake overhead reported in the introduction decomposes across request and response handling.
- Resolve the L1 versus L2 trade-off empirically: Layer 2 smart contracts add computational load and greater automation, while Layer 1 offers lower complexity; the truncated content does not report the latency and resource comparison the paper promises in Q2.
- Address the local L2 node restriction: the authors note that current IOTA community security policies prevent running a local Layer 2 node connected to the official public L2 sidechain, forcing reliance on public nodes or a private sidechain — a deployment constraint that needs revisiting.
- Extend beyond the tested scale and topology: the testbed omits the SCADA Level 2 layer due to its small scale, and a single P4 switch serves the Level 1–2 boundary, so multi-switch, plant-wide deployments and controller failover remain open questions.
Target Audience
Industrial security architects and ICS network engineers evaluating alternatives to GDS-based certificate management; researchers working on programmable data planes, in-network security, and DLT-based PKI; and OPC UA integrators dealing with heterogeneous device fleets. Readers need working knowledge of OPC UA connection establishment and P4 to follow the architecture and parsing pipeline in detail, though the problem statement and findings are accessible to a broader security audience.
Authors’ abstract
The OPC UA protocol is becoming the de facto standard for Industry 4.0 machine-to-machine communication. It stands out as one of the few industrial protocols that provide robust security features designed to prevent attackers from manipulating and damaging critical infrastructures. However, prior works showed that significant challenges still exists to set up secure OPC UA deployments in practice, mainly caused by the complexity of certificate management in industrial…
The full abstract on arXiv