Safety meets security, the core idea
Real time control systems run the physical world, they regulate pressure, speed, dosage, torque, voltage, and motion in milliseconds. Safety engineering traditionally focuses on random faults, component wear, and foreseeable misuse. Security engineering focuses on intelligent adversaries who intentionally push a system into unsafe or unreliable states. In modern operational technology environments, these are no longer separate concerns. A cyber attack can become a safety incident, and a safety mechanism can become an attack surface. Threat modeling is the practical bridge that aligns safety goals with security controls, early enough to influence architecture, and continuously enough to remain valid across changes.
At QVLx Labs, we describe this alignment as “safety meets security,” meaning that you treat safety hazards and security threats as two views of the same physical risk, then you design your control loops, interfaces, and operational procedures so that neither faults nor attackers can defeat your safety objectives.
What to do first, an action oriented summary
If you only do a few things, do these first. They produce the highest risk reduction per hour in real time control programs.
- Define safety objectives as explicit, testable constraints. Example, “motor torque shall not exceed X for more than Y milliseconds,” “valve shall fail closed on loss of command,” “dose rate shall never exceed Z even under sensor failure.”
- Map safety constraints to security abuse cases. Ask, “How could an attacker violate this constraint through commands, time manipulation, sensor spoofing, configuration changes, or denial of control?”
- Model the control loop and trust boundaries. Include sensors, actuators, controller logic, networks, timing sources, engineering workstations, update paths, and remote access.
- Prioritize scenarios that combine high severity with plausible paths. In real time systems, availability and integrity are often more safety critical than confidentiality.
- Select mitigations that preserve determinism. Use simple, bounded time checks, fail safe states, authenticated command channels, segmented networks, and hardware enforced safety interlocks.
- Validate mitigations with safety aware security testing. Use simulation, hardware in the loop, fault injection, and carefully scoped penetration testing to confirm timing and safe state behavior.
- Maintain the model as a living artifact. Link it to change control, incident response, and periodic safety reviews.
Why threat modeling is different for real time control systems
Threat modeling for typical business software often centers on data theft and identity abuse. Real time control systems are different because the primary impact is physical, and the constraints are temporal. A control loop can be safe at one sampling rate and unsafe at another. A message that is authentic but late can still be dangerous. A defensive control that introduces jitter can destabilize a loop. This changes what “secure” means. Security must support the system’s safety envelope, its deterministic timing, and its ability to fail into known safe states.
Key characteristics that make these systems unique include:
- Hard and soft deadlines. Missing a deadline can cause instability or unsafe outputs, even if logic is correct.
- Closed loop feedback. Sensor integrity and time alignment are critical, because control decisions depend on them.
- Long lifecycles. Controllers and field devices can be deployed for decades, with evolving threats and limited patch windows.
- Heterogeneous interfaces. Legacy fieldbuses, proprietary protocols, and modern Ethernet based networks often coexist.
- Safety functions and interlocks. Safety instrumented systems, emergency stop circuits, and protective relays interact with control logic and can be targeted.
- Operational constraints. Downtime is expensive, testing in production can be dangerous, and changes require rigorous approvals.
The main outputs you want from a safety plus security threat model
A good threat model is not a document you file away. It is a decision tool. For real time control systems, aim for outputs that directly influence design and operations:
- System model. A clear decomposition of components, data flows, timing dependencies, and trust boundaries, including maintenance and update paths.
- Hazard linked threat scenarios. A list of adversary actions that can lead to specific unsafe control actions or hazardous energy states.
- Risk ranking with safety severity. A consistent method to combine safety severity with security likelihood, including attacker capability and exposure.
- Mitigation plan. Security requirements that are compatible with real time constraints, plus residual risk rationale.
- Verification plan. Test strategies and evidence artifacts that satisfy both safety and security stakeholders.
A practical method, integrate safety analysis with threat modeling
The fastest way to connect safety and security is to anchor on safety analysis artifacts you already use, then extend them with adversarial thinking.
- From hazards to threats. Start with hazards, hazardous energy, and unsafe states. For each, identify what control actions prevent the hazard. Then ask how an attacker could cause unsafe control actions by manipulating inputs, outputs, timing, configuration, or operator behavior.
- From failure modes to attacker actions. A failure mode like “sensor stuck high” becomes a threat like “sensor spoofed high via injection, calibration tampering, or bus manipulation.”
- From safety integrity to security assurance. If a safety requirement demands high integrity of a sensor, add security requirements for authenticity, tamper evidence, calibration access control, and robust time stamping.
Common pairings that work well in practice:
- FMEA plus STRIDE. Use FMEA to map failure effects, then use STRIDE categories to brainstorm adversarial causes and system level impacts.
- HAZOP plus attack trees. Use guide words to explore deviations, then build attack trees for the deviations that lead to hazards.
- STPA and STPA Sec. Use system theoretic process analysis to identify unsafe control actions, then add security causal scenarios that could generate them.
Model the system the right way, start with control loops and timing
For real time control, a generic “data flow diagram” is not enough. You need a model that makes timing, control authority, and safety boundaries explicit. Build your model around control loops and operating modes.
Minimum modeling elements
- Operating modes and transitions. Startup, calibration, normal operation, manual override, maintenance, emergency shutdown, degraded modes, and recovery.
- Control authority and arbitration. Who can command an actuator, under what conditions, and how conflicts are resolved.
- Timing sources. Clocks, synchronization protocols, scheduler assumptions, watchdogs, and timeouts.
- Safety functions. Interlocks, limit switches, independent protection layers, safety PLC logic, emergency stop circuits, and protective relays.
- Engineering and maintenance paths. Configuration tools, firmware updates, calibration workflows, removable media, vendor remote support, and diagnostics ports.
- External dependencies. Identity services, logging, historian systems, cloud analytics, or remote monitoring gateways.
Trust boundaries that matter most in OT
- Between safety rated and non safety networks. Any bridge, gateway, or shared switch becomes a critical boundary.
- Between controller and engineering workstation. Programming protocols and project files are high risk.
- Between field devices and controller. Sensor and actuator buses are often weakly authenticated.
- Between onsite and remote access. VPNs, jump hosts, cellular gateways, and vendor tunnels need explicit modeling.
Top threat scenarios that frequently become safety issues
These are recurring patterns across manufacturing, energy, medical, transportation, and robotics. Use them as a starting checklist, then tailor to your system model.
- Command injection to actuators. Unauthorized setpoints, start stop commands, direction changes, or mode switches that violate safe operating envelopes.
- Sensor spoofing or replay. Feeding plausible but false measurements so the controller makes unsafe decisions, such as over speeding a turbine or overdosing a pump.
- Time and sequence manipulation. Delaying, reordering, or accelerating messages so control logic reacts incorrectly. In real time systems, “late but valid” can be hazardous.
- Configuration and calibration tampering. Changing scaling, units, alarm thresholds, safety limits, or tuning parameters that define stability and safe limits.
- Denial of control and loss of view. Flooding a network, exhausting controller resources, or blinding the operator interface so response is delayed.
- Privilege escalation on engineering tools. Compromising an engineering workstation to push malicious logic, disable interlocks, or modify safety routines.
- Firmware and supply chain compromise. Malicious firmware in drives, sensors, PLCs, or safety relays that behaves normally until triggered.
- Safety bypass abuse. Abusing maintenance modes, override keys, force functions, or test bypasses to defeat protective layers.
- Physical access attacks. Connecting to exposed ports, swapping sensors, tapping buses, or manipulating emergency stops.
Risk ranking that respects both safety and security
Classic security scoring can underweight catastrophic physical consequences, and classic safety scoring can underweight exposure to intelligent adversaries. A blended approach works best if it is simple enough to use consistently.
One workable scoring approach
- Safety severity. Define levels based on credible worst case outcomes, such as minor injury, serious injury, single fatality, multiple fatalities, major environmental harm, large scale equipment damage.
- Exposure and accessibility. Consider whether the threat requires physical access, local network access, or remote access. Include how often the system is in vulnerable modes, such as maintenance.
- Attacker capability. Include required skills, tools, and time. A nation state is not required for many OT incidents, but some targets attract them.
- Detectability and response time. In control systems, early detection can prevent hazard escalation. Model the time between compromise and harmful effect.
- Controllability and fail safe behavior. Estimate whether the system moves to a safe state when anomalies occur, and whether operators can intervene effectively.
Then compute a prioritized list. Do not over engineer the math. The goal is aligned decisions about where to add independent protection, strong authentication, monitoring, redundancy, or architectural changes.
Mitigations that fit real time constraints
A mitigation is only “good” if it reduces risk without destabilizing timing or creating new hazards. Prefer controls that are deterministic, bounded in CPU time, and compatible with safe state design.
Design patterns that work well
- Independent safety layers. Keep critical safety functions in an independent safety controller or safety relay path that does not depend on the same network as standard control.
- Authenticated command channels with bounded latency. Use cryptographic authentication and integrity protection sized for real time, and measure worst case latency and jitter.
- Whitelisting and allow lists. In many control networks, the set of valid peers and commands is small and stable. Enforce allow lists at gateways and endpoints.
- Rate limiting and plausibility checks. Constrain setpoint changes per second, validate ranges, and apply physical plausibility checks tied to the plant model.
- Secure boot and signed updates. Prevent unauthorized firmware and logic downloads. Include roll back protection and a controlled recovery process.
- Separation of duties for engineering changes. Require approvals, code reviews, and dual control for safety critical logic and parameter changes.
- Hardened time sources. Protect clock synchronization, detect time jumps, and design control logic that fails safe if time assumptions are violated.
- Deterministic monitoring. Passive network sensors and controller diagnostics that do not interfere with scheduling, plus alerting tuned to operations.
- Physical security for critical paths. Lock cabinets, secure ports, control removable media, and use tamper evidence where appropriate.
Fail safe behavior as a security control
For real time control, fail safe is not just a safety concept, it is also a security mitigation. If the system detects abnormal commands, timing anomalies, or sensor inconsistencies, it should move to a defined safe state. Threat modeling should explicitly define safe states per mode and per subsystem, and define what signals and thresholds trigger them. Beware of nuisance trips that create their own hazards, for example an emergency stop that creates traffic risk if triggered too easily in a transportation system. This is why the model must cover controllability and response.
Verification, prove security without breaking safety
Validation in control environments must be carefully designed. You want evidence that your mitigations work under adversarial conditions, while ensuring you do not create unsafe behavior during tests.
Recommended verification techniques
- Simulation and digital twins. Run attack scenarios against simulated plants to evaluate stability, alarm timing, and safe state transitions.
- Hardware in the loop testing. Test controller firmware, safety logic, and network protections with real hardware connected to simulated plant dynamics.
- Fault injection plus adversarial injection. Combine classic fault injection with malicious patterns, such as replay, delay, and command bursts.
- Protocol fuzzing with safety constraints. Fuzz communication stacks in a lab to find crashes, but also test for timing edge cases and resource exhaustion.
- Security regression tests for timing. After enabling authentication or logging, measure worst case cycle time and jitter, then keep those measurements under version control.
- Operational drills. Practice response to loss of view, loss of control, and safety system trips, including manual fallback procedures.
Concrete workflow, a step by step threat modeling process
This workflow is structured to produce useful results quickly, then add depth. It fits both greenfield design and brownfield retrofits.
Step 1, define scope and the safety envelope
- Identify the controlled process and its hazardous energies, for example motion, pressure, temperature, chemicals, radiation, electricity.
- List safety goals, safe operating limits, and safe states.
- Define the boundaries of the analysis, including connected systems and remote access paths.
Step 2, build a control loop centric model
- Document sensors, controller tasks, networks, actuators, and operator interfaces.
- Add timing requirements and assumptions, including sample rates, watchdog intervals, and network deadlines.
- Mark trust boundaries and privilege boundaries, including maintenance ports and update mechanisms.
Step 3, enumerate assets and safety critical properties
- Assets include physical process integrity, control logic integrity, configuration integrity, sensor authenticity, actuator command integrity, and availability of safety functions.
- For each asset, record what “compromised” means in physical terms, such as overspeed, overpressure, collision, or toxic release.
Step 4, identify threat scenarios tied to hazards
- Use structured prompts, such as spoofing, tampering, repudiation, information disclosure, denial of service, elevation of privilege.
- Translate each into control system terms, such as spoofing a sensor, tampering with tuning parameters, denying network bandwidth, escalating privileges on engineering software.
- For each scenario, describe the attacker goal, entry point, required access, timing considerations, and expected physical outcome.
Step 5, rank and select mitigations
- Rank using safety severity plus likelihood factors.
- Select mitigations that provide defense in depth, including independent protection layers.
- Record residual risk and justify any accepted risk with operational constraints and compensating controls.
Step 6, define verification evidence
- For each mitigation, define how you will test it, measure timing, and demonstrate safe state behavior.
- Capture evidence artifacts that both safety and security reviewers can accept, such as test reports, timing traces, configuration baselines, and code review records.
Step 7, operationalize the model
- Link the model to change management. Any change to network topology, firmware, logic, tuning, or remote access should trigger a review of affected scenarios.
- Use the model to drive monitoring requirements, alert thresholds, and incident response playbooks.
- Review periodically, at least annually, and after any incident or near miss.
Threat modeling focus areas specific to real time control
Beyond the generic categories, real time control systems have special failure and attack surfaces. Modeling them explicitly prevents surprises late in validation.
Timing attacks and scheduler abuse
Many controllers assume bounded execution times and predictable interrupt behavior. Attackers can target timing by flooding inputs, triggering expensive error paths, or exploiting logging and cryptography overhead. Include these in your model:
- CPU starvation through message storms or malformed packets that trigger retries.
- Priority inversion or interrupt saturation that delays control tasks.
- Watchdog manipulation, either forcing resets or preventing resets when needed.
- Clock drift or forced resynchronization leading to incorrect time based logic.
State estimation and sensor fusion abuse
Modern control uses estimators and sensor fusion. These can be resilient to noise but vulnerable to coordinated deception. Model:
- Slow bias injection that stays under alarms but shifts the estimator over time.
- Cross sensor inconsistency attacks that force the system into a degraded mode at the wrong time.
- Replays of previously valid sensor sequences during critical transitions, such as startup or ramp up.
Mode confusion and unsafe transitions
Attackers often target mode logic because safety constraints differ by mode. Typical issues include:
- Forcing a maintenance mode while the process is live.
- Triggering calibration routines at unsafe times.
- Abusing manual override paths or forcing outputs while alarms are suppressed.
Human machine interface and operator decision risk
In many incidents, the attacker goal is not to directly control actuators, but to influence operator actions. Model:
- Alarm flooding that causes missed critical alarms.
- Display deception, such as presenting normal readings while the process is abnormal.
- Unauthorized changes to setpoint entry limits and interlock indicators.
- Loss of view scenarios where operators revert to manual procedures, with limited situational awareness.
Applying the model to common architectures
Different real time control domains share principles but differ in constraints and exposure. Below are domain specific notes you can adapt.
Industrial automation and robotics cells
- Key hazards include collision, crushing, and unexpected motion.
- Threats frequently involve safety gate bypass, altered speed limits, and malicious program downloads.
- Strong mitigations include independent safety controllers, hardwired interlocks, authenticated program transfer, and strict separation between enterprise IT and cell networks.
Power and grid control
- Key hazards include equipment damage, cascading outages, and arc flash risks for field crews.
- Threats include setpoint manipulation, protective relay setting changes, time synchronization attacks, and coordinated denial of control.
- Mitigations include strict change control for relay settings, secure time distribution, segmented substations, and anomaly detection tuned to power flows.
Medical real time devices
- Key hazards include overdose, underdose, inappropriate stimulation, and delayed therapy delivery.
- Threats include tampering with dosage libraries, sensor spoofing, and denial of therapy through battery drain or radio jamming.
- Mitigations include cryptographic integrity for therapy parameters, safety limits enforced in hardware, robust audit logging, and careful usability design for alarms and confirmations.
Automotive and mobility systems
- Key hazards include unintended acceleration, loss of braking, and incorrect driver assistance behavior.
- Threats include bus injection, firmware tampering, sensor spoofing, and escalation through infotainment gateways.
- Mitigations include gateway segmentation, secure diagnostics, signed firmware, runtime monitoring, and safety mechanisms that remain effective under compromise of non safety ECUs.
A worked example, threat model slice for a pumping skid
Consider a pumping skid with a variable frequency drive, flow sensor, pressure sensor, and a PLC controlling speed to maintain pressure. Safety constraints include maximum pressure, maximum pump speed, and emergency shutdown on leak detection.
System elements
- PLC with control task at a fixed cycle time.
- VFD receiving speed commands over an industrial Ethernet protocol.
- Pressure and flow transmitters on a fieldbus.
- HMI used by operators for setpoint entry and mode changes.
- Engineering workstation used for PLC programming and VFD parameter changes.
- Remote vendor access for diagnostics during maintenance windows.
Hazard linked threat scenarios
- Scenario, setpoint manipulation. Attacker changes pressure setpoint beyond safe limit. Outcome, overpressure, potential rupture. Entry points, HMI, engineering workstation, remote access. Mitigations, enforced maximum setpoint in PLC safety logic, role based access, signed configuration, change approval workflow, and alerting on setpoint changes.
- Scenario, sensor spoofing. Attacker spoofs low pressure reading so controller increases speed. Outcome, actual pressure rises above limit. Entry points, fieldbus injection, transmitter tampering, compromised gateway. Mitigations, cross check pressure and flow plausibility, rate of change limits, independent pressure switch for hard trip, authenticated field communications where feasible, and tamper detection for transmitters.
- Scenario, denial of control network. Attacker floods Ethernet network, VFD misses commands, enters last value hold. Outcome, pump continues at unsafe speed. Mitigations, define VFD safe reaction on comms loss, configure to ramp down, isolate traffic with VLANs and industrial firewalls, and monitor bandwidth and error counters.
- Scenario, parameter tampering in VFD. Attacker changes acceleration limits or speed cap. Outcome, overspeed during transients. Mitigations, lock VFD parameters, require authenticated access, periodic parameter integrity checks, and independent PLC enforcement of speed caps.
This slice shows how safety constraints guide the most valuable security questions, and how mitigations combine independent safety trips, access control, and monitoring.
Brownfield realities, threat modeling legacy control systems
Many plants cannot upgrade everything. Threat modeling is still valuable because it clarifies where compensating controls can provide meaningful risk reduction.
Common legacy constraints
- Legacy protocols without authentication or encryption.
- Controllers with limited CPU and memory headroom for new security features.
- Vendors that restrict changes due to certification or support constraints.
- Patch windows that are rare, and high cost of downtime.
Compensating controls that often work in brownfield
- Network segmentation and conduits. Use industrial firewalls and strict rules between zones, reduce reachable attack surfaces.
- Jump hosts and strong remote access governance. Remove direct remote access to controllers, enforce MFA, session recording, and time bound access approvals.
- Passive monitoring. Deploy network sensors that understand OT protocols, and alert on rare commands, new devices, or parameter writes.
- Configuration baselining. Regularly export PLC logic, VFD settings, and safety parameters, then compare to known good baselines.
- Hardwired safety backups. Add independent trips, pressure switches, limit switches, or safety relays that do not rely on the vulnerable network path.
How to tie threat modeling to standards and governance
Threat modeling becomes easier to sustain when it maps to standards that your organization already uses. While each industry differs, several widely used standards provide compatible structure.
- IEC 62443. Useful for zones and conduits, security levels, and lifecycle practices in industrial automation and control systems.
- NIST SP 800 82. Practical guidance for ICS security, including architecture and operational practices.
- IEC 61508. Functional safety lifecycle principles that can anchor safety objectives and verification evidence.
- ISO 26262 and ISO 21434. A natural pairing for automotive, linking functional safety and cybersecurity engineering with hazard analysis and risk assessment and threat analysis and risk assessment.
- DO 178C and related aviation guidance. Emphasizes rigorous verification, configuration management, and safety cases that can incorporate security arguments.
Governance also matters. Define who owns the threat model, who approves changes, and how conflicts are resolved when a security control risks violating timing constraints. A cross functional review board with safety, controls engineering, operations, and security is often necessary.
Building a combined safety and security case
Safety programs often rely on structured argumentation, sometimes called a safety case. Security teams may use risk assessments and control catalogs. A combined approach can reduce friction.
Recommended structure for combined evidence
- Claim. The system maintains defined safe states and constraints under expected faults and credible attack scenarios.
- Argument. Independent protection layers, authenticated control paths, and anomaly detection prevent or mitigate hazard escalation within required time.
- Evidence. Threat model, hazard analysis, test results, timing measurements, configuration baselines, secure update validation, and operational procedures.
This structure forces the question that matters, “What must be true for safety, even if security is partially compromised?” It also helps you identify single points of failure where a cyber attack could disable a safety function.
Operational considerations, keeping security from harming safety
Operational security changes can unintentionally create safety problems, for example blocking a maintenance function needed during an emergency, or adding authentication steps that slow response. Threat modeling should include operational workflows.
Operational scenarios to model
- Emergency response workflows. How operators shut down or isolate equipment, what access is required, and whether security controls allow rapid action with accountability.
- Maintenance and calibration. When bypasses are allowed, how they are tracked, and how the system ensures bypasses are removed.
- Patch and update procedures. How updates are verified, staged, rolled back, and tested for timing impacts.
- Incident response in OT. How you investigate without causing downtime, how you preserve evidence, and when you decide to switch to manual or safe states.
Metrics, how to know your threat modeling is working
Metrics should reflect risk reduction and engineering quality, not just activity. Use a small set that encourages good behavior.
- Coverage of safety constraints. Percentage of defined safety constraints that have at least one linked threat scenario and at least one mitigation.
- Time to update model after change. Median time from approved change request to threat model update and review.
- Reduction in high risk scenarios. Count of scenarios above a defined risk threshold before and after mitigations.
- Security regression timing budget. Worst case control cycle time and jitter before and after security features, tracked across releases.
- Configuration drift events. Number of detected unauthorized or unexpected configuration changes per period, plus mean time to reconcile.
Common mistakes and how to avoid them
Several failure patterns recur when teams try to merge safety and security. Address them early.
- Modeling only the IT perimeter. Real attacks often use engineering tools, removable media, maintenance ports, and vendor pathways. Model those explicitly.
- Ignoring timing in security decisions. Authentication, encryption, and logging can change timing. Measure and include worst case behavior in the threat model and test plan.
- Treating the safety system as implicitly trusted. Safety controllers, relays, and their configuration interfaces can be attacked. Model how safety functions could be disabled, bypassed, or fooled.
- Focusing on confidentiality first. In control systems, integrity and availability frequently dominate safety outcomes. Do not let data secrecy distract from command integrity and reliable safe shutdown.
- One time assessments. A threat model that is not linked to change management becomes outdated quickly, especially as remote access and integrations increase.
- Over complex scoring. If engineers cannot apply the scoring method consistently, it will not guide decisions. Prefer simple severity plus likelihood factors with clear definitions.
Tooling and templates, keep it lightweight but traceable
You can implement threat modeling with anything from spreadsheets to specialized tools. The important property is traceability, you should be able to trace a hazard to a safety constraint, to a threat scenario, to a mitigation, to verification evidence.
Suggested minimal artifact set
- System model. Component list and data flows, with trust boundaries and timing notes.
- Threat scenario catalog. Each scenario includes affected safety constraint, entry point, prerequisite access, attack steps, expected outcome, detection opportunities, and mitigations.
- Mitigation register. Security requirements, owners, target dates, and verification methods.
- Evidence binder. Test reports, timing traces, configuration baselines, and review approvals.
Additional depth, connecting unsafe control actions to attacker actions
System theoretic approaches help because control system accidents can occur without a single component failure. Attacks can exploit interactions, not just vulnerabilities. If you use an unsafe control action list, you can derive a robust set of threat scenarios.
Unsafe control action types and example attacker mappings
- Control action not provided when needed. Attacker causes denial of control, blocks trip signal, or disrupts network timing so protective action is delayed.
- Control action provided when not appropriate. Attacker injects start command, disables interlock, or triggers actuator movement during maintenance.
- Control action provided too early, too late, or out of sequence. Attacker delays sensor updates or reorders messages so controller acts on stale state.
- Control action applied too long or stopped too soon. Attacker holds output high, prevents stop command, or manipulates watchdog behavior.
For each mapping, ask what constraints, monitors, or independent layers prevent a hazardous outcome even if the attacker succeeds partially.
Additional depth, supply chain and update trust
Many control compromises begin upstream, with compromised software, infected engineering laptops, or malicious firmware. Threat modeling should include the entire lifecycle, not just runtime behavior.
Supply chain scenarios to include
- Compromised vendor update server delivering trojan firmware.
- Modified project files or libraries inserted into version control or backup media.
- Unauthorized logic changes during commissioning by third parties.
- Counterfeit field devices with hidden radio or backdoor behavior.
Mitigations
- Signed firmware and signed project artifacts, verified on device where possible.
- Controlled build and release pipelines for controller logic, with reproducible builds where applicable.
- Asset inventory with provenance, and verification at receiving and during maintenance.
- Strict removable media handling, scanning, and dedicated engineering environments.
Additional depth, designing for degraded but safe operation
A key design principle for safety meets security is graceful degradation. Assume that some functions will be impaired during an attack or incident, and design safe fallback behavior.
Questions to answer in the threat model
- What is the safe state for each actuator if communications are lost, and is it always safe, or mode dependent?
- What minimal sensing is required to keep the process safe, and can you operate in a reduced capability mode?
- How does the system detect loss of integrity versus loss of availability, and do those require different responses?
- Can operators safely take manual control, and what training and procedures are required?
- How do you recover from safe shutdown, and how do you verify that configuration and logic are trustworthy before restart?
A checklist you can use in reviews
This checklist is designed for design reviews and periodic reassessments.
- Safety constraints defined. Limits, safe states, and required response times are documented and testable.
- Control loops modeled. Sensors, actuators, tasks, and timing assumptions are captured.
- Trust boundaries marked. Safety versus non safety, remote access, engineering tools, update paths.
- Top hazards linked to threats. Each high severity hazard has at least one credible threat scenario.
- Mode logic assessed. Maintenance, calibration, startup, and override behaviors are threat modeled.
- Denial of control covered. Network floods, CPU starvation, and watchdog behaviors are assessed for safe outcomes.
- Configuration integrity assured. Parameter changes require authorization, are logged, and are compared to baselines.
- Independent protection present. Safety functions remain effective under compromise of standard control paths where feasible.
- Timing impact measured. Security controls are validated against worst case timing budgets.
- Recovery designed. Safe restart procedures, integrity checks, and incident playbooks exist and are exercised.
Conclusion, making safety and security reinforce each other
Threat modeling for real time control systems is most effective when it starts from safety. Define the safety envelope, model the control loops and timing, then identify how an attacker could violate safety constraints through commands, sensors, configuration, time, and operations. Choose mitigations that are deterministic, compatible with safe state behavior, and supported by verification evidence. Finally, keep the model alive through change management and operational practice. When done well, safety and security stop competing for priority and begin reinforcing each other, because both are anchored to the same outcome, keeping the physical process within safe limits.