Assessing IoT safety and security requires looking beyond whether each device works as intended. In connected environments, sensors, actuators, applications, cloud services, and physical processes can influence one another. A door lock and smoke alarm, for example, may each follow their own logic yet produce a hazardous result when their actions conflict. For automation engineers and system integrators, the challenge is to verify the behavior of the whole environment.
Software verification offers a way to analyze these interactions systematically. Model checking can compare a representation of an IoT system against defined safety, security, and functionality requirements. Runtime monitoring can also detect and respond to violations during operation. Neither approach removes the need for careful requirements and system design, but both help expose risks that isolated device testing can miss.
Why IoT safety and security depend on interactions
A typical IoT platform connects devices to a hub, cloud back end, and applications. Sensors report events from the physical world; applications process those events and issue commands to actuators. Apps may also exchange information with external digital services. This event-driven structure makes it possible to automate useful workflows, but it also creates pathways for unexpected behavior.
Risks can arise in several ways:
- Apps trigger one another: One app may turn on a light after detecting smoke, while another locks a door when the light switches on. The combined response could impede escape during a fire.
- Apps compete over an attribute: Two apps may issue conflicting commands to the same device, such as turning an alarm off and on in response to different events.
- Apps respond differently to the same event: One app may switch a light on when a contact sensor opens while another switches it off.
- Device actions change the physical environment: A heating app may raise a room’s temperature, prompting another app to open windows. The resulting physical state can have consequences beyond either app’s intended logic.
- Digital services affect devices or expose data: A trigger-action workflow could connect an email event to a device action, or send information about a door state to a public log.
These cases illustrate why checking devices independently is insufficient. The relevant outcome may depend on the sequence of events, shared device attributes, external inputs, and changes in the physical environment.
Using IoT model checking to assess behavior
Model checking evaluates a system model against properties stated in a formal specification. In an IoT context, a model can represent device states and the transitions caused by events. A model checker then determines whether the specified properties hold across the represented behavior. If a property fails, the tool can produce a counterexample: a sequence of transitions that shows how the system can reach a problematic state.
Many IoT applications follow a sensor-computation-actuator pattern. Sensors generate events, app logic handles those events, and actuators perform actions that may generate further events. This structure can be represented as a state model and used to examine individual apps or a composite of multiple apps.
Properties to check can address three broad concerns:
- Safety: The system should not harm people or the environment. For example, a smoke alarm should sound when its sensor detects smoke.
- Security: Device functions and data should not be subverted by an adversary or an untrusted input.
- Functionality: Devices should behave according to their specified requirements.
Requirements need to reflect the deployment context. A property might state that a door should remain locked when a user is away, or that an event handler must not command a device into conflicting states. Defining these conditions is a technical and operational task: a property that is too broad could block legitimate behavior, while an incomplete one could leave important risks unchecked.
From code analysis to runtime monitoring
Static analysis can extract a state model from application source code and check it against defined properties. Its limitation is that an extracted model may overapproximate possible behavior. That can produce false positives—for example, suggesting that a door could be unlocked in a situation where the application’s actual logic does not allow it.
Dynamic analysis takes a different approach by observing device execution at runtime. A monitoring system can track states and transitions as they occur, including when devices are added to an environment. When a property violation is detected, a system may block the action or ask a user to approve or deny it. The appropriate response depends on the risk: simply blocking an action or prompting a user is not automatically safe in every situation.
Research evaluations of these approaches examined a data set of 95 IoT and trigger-action apps. In that analysis, 10 individual apps violated 11 properties, while composite behavior involving 25 interacting apps revealed 16 violations. Some issues appeared only when apps were considered together. These findings reinforce the need to test combinations of applications and devices, not just each component in isolation.
Practical considerations for automation teams
Applying verification in a real deployment requires more than selecting a tool. Teams need to identify critical assets, document expected behavior, and define constraints on how devices may be used. They should then consider how apps, services, users, and physical processes can affect those requirements.
System scale is another concern. As the number of devices, events, and transitions grows, the model can become too large to analyze efficiently. Partitioning an application into smaller components may help, provided the analysis retains dependencies between components that can affect one another. Testing techniques such as fuzzing can also help explore event sequences and inputs, although they do not provide the same exhaustive verification as model checking.
Finally, teams should plan how the environment will respond when a violation occurs. Response policies need to account for the severity and context of the problem and aim to preserve system integrity. A response that is appropriate for a convenience function may not be appropriate for a safety-critical process.
Verify the environment, not just the device
Connected automation combines software behavior with physical consequences. A device can meet its own specification and still contribute to an unsafe or insecure outcome when it interacts with other devices, apps, or services. Model checking can help identify such interactions before deployment, while runtime monitoring can support detection and response during operation.
For plant managers, integrators, and engineering teams, the practical implication is clear: define properties for the complete environment, assess combinations of components, and establish deliberate response policies. Treating IoT systems as interacting cyber-physical environments—not collections of independent devices—is essential to evaluating their safety, security, and functionality.
Access Official Technical PDF