betaFeedback

WorksComputer Science

From Attack Tree to Model Checker: Binding CAPEC Patterns to Verify Robotic System Security

Abstract

Security-minded verification of autonomous and robotic systems presupposes an attacker, yet the path from a threat catalogue to a checkable attacker model is still traversed by hand. This research preview presents the theory and construction of a pipeline that mechanises it. Each leaf of an attack tree is mapped to a CAPEC attack pattern and written in first-order logic as a rule: the attacker's prerequisites imply the attack's effect. Casting the pattern as such a rule is what makes it operational - its variables can be bound to a specific system's parts, and its prerequisites can then be tested against that system under a chosen configuration of security controls. Binding is our means of verifying whether a system is vulnerable to a given attack: from a bound pattern we derive an attacker model, turn its effect into a temporal-logic property, and check that property against the system with and without a countermeasure, reporting the control that defeats the attack. We describe the signature, schemas, profiles for approach, and explore how CAPEC can support reasoning about robotics security.

Introduction

Formal verification of autonomous robotic systems has primarily focused on safety concerns [13, 5, 4]; however, there is a growing need to adapt to security properties in the context of an attacker [6, 14]. In our previous work [9] on autonomous satellite docking, the composed attacker-system model was manually constructed and verified in SPIN [7] against security properties expressed in LTL. Although the approach was rigorous, the manual approach was time-consuming and does not scale. This has motivated the use of Attack Trees [21, 15] (as they enumerate, in a structured way, how an adversary might reach a goal) and CAPEC [16] (catalogues several hundred named attack patterns). However, neither is a formal object and today an analyst bridges the gap between them and a model checker by hand. This research preview presents a way that mechanises this bridge. We introduce a pipeline that uses two logics which do different jobs. A CAPEC pattern is written once, for no particular system, so it needs variables: a first-order action schema over a sorted signature says what an attacker must already have, and what changes when the action succeeds. A system deployment is a finite set of ground atoms: a static description of the system. Binding instantiates the schema against the deployment. It turns a catalogue entry into a decidable claim about a system under a named configuration of security controls, and when the claim fails it reports the specific condition responsible, which identifies the control that defeats the attack. Instantiation also fixes a finite propositional vocabulary, and the grounded actions generate an attacker transition system over it. The transition preserves the grounded schema by using its prerequisites as the transition guard and its effect as the transition update; the temporal property then asks whether that same effect is reachable. Only at that point does temporal logic become the right tool: LTL states properties of the runs of the grounded attacker model composed with the system model, TSsys∥chTSattTS_{\mathrm{sys}} \mathbin{\|}_{\mathrm{ch}} TS_{\mathrm{att}}, in the input-mediated form of [9]. This is the mechanised form of the Input-Mediated Interaction (IMI) composition. This is illustrated in Figure 4. A CAPEC pattern does not become part of the system model itself: after binding, it induces a separate attacker transition system which interacts with the system model only through the identified system interfaces.

Figure 4. The composition for the camera case. TSattTS_{att} is the transition system induced by the grounded CAPEC-148 rule; TSsysTS_{sys} is the docking controller. They share no variables: every crossing edge passes through cam_incam\_in, the interface model map declares, and cam_channel_authcam\_channel\_auth acts on that interface, falsifying the guard under C2. □¬IntegrityViolated(pose_estimate)\square\neg\mathrm{IntegrityViolated}(pose\_estimate) mentions only atoms TSattTS_{att} writes, so relevance decides it alone; □¬(s3∧pose_falsified)\square\neg(s_3 \land pose\_falsified) mentions TSsysTS_{sys}’s own state and is decidable only here.

Contributions. A formal grounding construction that transforms catalogue-level attack knowledge into system-specific attacker models suitable for compositional model checking. Supported by (i) CAPEC operational semantics: a many-sorted action-schema representation (§ 3.1); (ii) System grounding: a binding relation between CAPEC schema parameters and robotic-system entities, parameterised by security control configurations (Section 3.2); (iii) Verification: construction of attacker transition systems and temporal properties from grounded attack patterns for composition with system models (§ 3.3).

Background & Related Work

An attack tree [21] defines a root goal through OR and AND nodes to leaves, which are the basic attacker actions to achieve the sub-goal (nodes). Mauw [15] gave the standard semantics (a set of multisets of leaves and the attack suites), Jhawar et al. [10] added sequential conjunction (SAND) which provides order in sub-goals to achieve overall goal. We use OR, AND and SAND in our trees with the suite semantics of per-leaf results to whole-tree properties [15]. MITRE’s CAPEC [16] catalogues natural-language attack patterns, each with an abstraction level, prerequisites, execution flow (optional) and consequences of security attacks. Of the 558 non-deprecated patterns in CAPEC (v3.9), 349 (62.5%) have non-empty Prerequisites and Consequences. Both are needed for a schema; former is needed as a precondition to trigger on, and the latter is needed as an effect to assert. This allows expressiblity over the vocabulary (predicate signature of capability, state, progress, and violation predicates) of our inputs. A further 239 (42.8%) carry an execution flow, the source of multi-step schemas. These counts bound what any vocabulary can formalise: the 349 are the patterns a schema can be written for at all, while whether a given one is expressible over our signature is decided pattern by pattern (Table 1). We use first-order logic in many-sorted form, so every name in the model has a declared type (e.g. a camera is a sensor and not a channel), over a fixed signature - list of allowed predicates and types are settled in advance. Table 1 gives an expressible and an inexpressible pattern. A system is a finite set of ground atoms (factual statements with no variables left e.g. camera input is authenticated) taken as all the true atoms (everything that holds of the system) so under the closed-world assumption (anything absent from the list is taken to be false, rather than unknown), entailment of ground literals (deciding whether a given specific fact, or its negation, follows from system description) is membership testing. This is the discipline behind MulVAL’s Datalog (a closed-world logic restricted in the same way) [18]. Properties are LTL [20] (□\square, ◊\Diamond, U\mathcal{U} ; SPIN’s [ ], <>, U in listings) checked with SPIN [7], which returns a counterexample trail on violation. Existential questions (“can attacker reach s?”) are emitted as □¬s\square\neg s and a violation is read as reachability, the trail as witness. Our attacker models follow the IMI construction of [9]: an attacker transition system composed with the system at a designated input channel, TSys∥chTattT_{\mathrm{Sys}}\mathbin{\|}_{ch} T_{\mathrm{att}}.

CAPECDescriptionExpressibleSchema/Reason
148-Content SpoofingModifies content so that it no longer says what its provider intendedYesCanModify⁡(a,r)∧Carries⁡(ch,r)∧¬Authenticated⁡(ch)→IntegrityViolated⁡(r)\operatorname{CanModify}(a,r) \land\operatorname{Carries}(ch,r) \land\neg\operatorname{Authenticated}(ch) \to\operatorname{IntegrityViolated}(r)
25-Forced DeadlockTriggers a deadlock in the target software to deny service, e.g. a ROS 2 node blocked on a synchronous service call that never returnsNoNot a premise: both the deadlock condition and its effect are properties of the system’s runs, not facts about the deployment. Checkable once the attacker is composed with a model of the system.

Table 1. Expressible and inexpressible CAPEC patterns. Schema for 148 is in AT2FOL [8].

Related Work: Audinot et al. [3] label nodes with pre-/post-conditions over a transition system and define when a refinement is admissible, consistent and complete. This is the closest work to our relevance check. Their conditions are hand-authored per node and the focus is the tree’s structural correctness, while our work focuses on the applicability of a bound pattern to a deployment under named controls, produced from a public catalogue via an explicit binding, which is then handed to a model checker. Other work synthesises trees from a system model [19]. MulVAL [18, 17] derives multi-stage attack reachability from scanner-reported host and vulnerability facts using exploit rules written by experts in Datalog. Our applicability check uses the same closed-world fragment, but its rules come from the catalogue: each CAPEC pattern is written once as a schema and reused across systems, and the output is not a reachability graph but, for each control configuration, a verdict naming the control that blocks the attack, together with an attacker process and LTL properties for SPIN [2]. Kumar et al. [12] model-check attack trees for quantitative metrics. Farrell et al. [6] and Maple et al. [14] select properties with STRIDE [22] and verify them in Promela/SPIN and Dafny; we mechanise the step from threat to property that they perform by hand, with CAPEC in place of STRIDE. Unlike STRIDE’s six threat categories, a CAPEC pattern supplies the structure needed to derive precondition/effect schemas and decide applicability under a control configuration mechanically.

Security Verification Mechanisation: Architecture and Overview

Figure 1 shows the pipeline, implemented in the prototype AT2FOL [8].1 Analysts author the four inputs, confirm CAPEC mappings and supply bindings. All subsequent stages are mechanically generated; the construction constraints imposed on these artefacts are therefore critical to the validity of the generated verification models.

Figure 1. The Security Verification Mechanisation pipeline. Four authored inputs (signature, schemas, profile, and the attack tree) feed a mapping step, the binding-and-relevance step at the centre, and the emission of LTL properties and a Promela attacker that SPIN checks per configuration. The static relevance verdict is compared with SPIN’s.

Building the inputs: signature, schemas, profiles, and trees

The pipeline takes four inputs, deliberately kept independent: a signature that fixes the vocabulary, schemas that formalise CAPEC patterns without reference to any system, profiles that describe a deployment without reference to any attack, and trees that scope which attacks are considered.

The signature fixes the sorts and predicates in which every artefact; schemas, profiles, properties, must be written so that a CAPEC pattern authored independently of any system can still be grounded against a particular deployment. Without that shared vocabulary there is nothing to bind against: “the camera feed is unauthenticated” in a schema and in a profile would be unrelated strings rather than the same atom, and the relevance check would have no fact to test. Every artefact is written over the single many-sorted signature of Figure 2, whose predicates fall into four classes: capability, state, progress and violation. Capability and state record what a deployment can do and how it is wired up; progress and violation record what an attacker gains mid-attack and what a completed attack causes. A profile may assert only the first two, and a schema step may produce only the last two.

Three artefacts sharing a vocabulary

Figure 2. The three artefacts that must share a vocabulary. The signature fixes the sorts and predicates; the CAPEC-148 schema is written for no particular system, and the satellite-docking profile for no particular attack. A profile asserts capability and state atoms only, and a schema step produces progress and violation atoms only: the profile says what the system is, the schema says what an attack changes. Only the binding θ={a↦attacker, ch↦cam_in, r↦pose_estimate}\theta= \{a \mapsto attacker,\ ch \mapsto cam\_in,\ r \mapsto pose\_estimate\} brings them together.

A schema is the operational reading of one CAPEC pattern: what the catalogue describes in prose, the schema states as conditions and effects. Formally it comprises sorted parameters (placeholders such as “some channel”, instantiated later against a deployment), a precondition (a conjunction of literals over the parameters) and an effect (atoms added or deleted); multi-step patterns carry a list of such steps, each step’s effect supplying facts to the next step. Example schemas have been authored such as CAPEC 148 (Content Spoofing), 125 (Flooding), 94 (Adversary in the Middle), and 157 (Sniffing Attacks). A system profile describes one deployment: entities per sort, which are the actual channels, resources and components of the system under analysis together with a closed-world set of base facts (capability and state atoms only), named controls that add or remove ground atoms to model a defence being switched on or off, and configurations bundling controls, each configuration standing for one hardening level of the same system. The satellite-docking profile from [9] is captured in Figure 2. The model_map ties each channel to its Promela channel and guard variable and each violation atom to a readable name.

We took a collection of attack-tree leaf descriptions and paired them with the CAPEC pattern that we consider to be the best match (goldset). The trees contain alternative, combined, and ordered attack paths using OR, AND, and SAND refinements. Figure 3, for example, presents a satellite-docking scenario in which several alternative attacks may achieve the overall goal, including an ordered path where the attacker first observes a camera channel and then spoofs it.

Figure 3. The satellite-docking attack tree with its SAND refinement. Every leaf carries a CAPEC identifier and a binding of the schema’s parameters (a,ch,r)(a,ch,r) to profile entities. Numbers show sequence.

From leaves to CAPEC to FOL. Given a leaf’s text the tool ranks the CAPEC catalogue (558 patterns; names weighted threefold) by TF–IDF cosine similarity and returns a shortlist with the literal matched terms, so every score is inspectable [11]. Mapping is therefore analyst-assisted: the tool offers a shortlist, and the analyst confirms. A CAPEC entry says in prose what an attacker needs and what happens if they succeed; the schema says it as a rule. For parameters xˉ=(a ⁣: ⁣Agent,ch ⁣: ⁣Channel,r ⁣: ⁣Resource)\bar{x} = (a\!:\!\mathrm{Agent}, ch\!:\!\mathrm{Channel}, r\!:\!\mathrm{Resource}), representing the attacking agent, communication channel, and affected resource, respectively, a single-step schema is ∀xˉ. pre(xˉ)→eff(xˉ)\forall\bar{x}.\, pre(\bar{x}) \to eff(\bar{x}), with prepre a conjunction of literals over capability, state and progress predicates and effeff a conjunction of violation (or progress) atoms. Three of the schemas, CAPEC-125 (Flooding), CAPEC-148 (Content Spoofing) and CAPEC-158/651 (Sniffing Network Traffic and Eavesdropping), read:

CAPEC-125:CanTransmit⁡(a,ch)∧Carries⁡(ch,r)→AvailabilityViolated⁡(r)CAPEC-148:CanModify⁡(a,r)∧Carries⁡(ch,r)∧¬Authenticated⁡(ch)→IntegrityViolated⁡(r)CAPEC-158/651:CanObserve⁡(a,ch)∧Carries⁡(ch,r)→ConfidentialityFlag⁡(r)\begin{aligned} \text{CAPEC-125:}\quad&\operatorname{CanTransmit}(a,ch) \land\operatorname{Carries}(ch,r) \to\operatorname{AvailabilityViolated}(r) \\ \text{CAPEC-148:}\quad&\operatorname{CanModify}(a,r) \land\operatorname{Carries}(ch,r) \land\neg\operatorname{Authenticated}(ch) \to\operatorname{IntegrityViolated}(r) \\ \text{CAPEC-158/651:}\quad&\operatorname{CanObserve}(a,ch) \land\operatorname{Carries}(ch,r) \to\operatorname{ConfidentialityFlag}(r) \end{aligned}

The negated literal ¬Authenticated⁡(ch)\neg\operatorname{Authenticated}(ch) is how a pattern says “only on an unauthenticated channel”, exactly the literal a channel-authentication control falsifies. The map from CAPEC patterns to schemas can be many-to-one. CAPEC-158 and CAPEC-651 share the same schema, despite being different attacks, because observation is handled as a single capability (CanObserve⁡(a,ch)\operatorname{CanObserve}(a,ch)). But CAPEC separates the attacks by medium, i.e. eavesdropping does not take place on a network channel while sniffing does. Distinguishing the medium would require a finer signature, for example a predicate marking network channels, which we leave to future work. Multi-step patterns are chains whose later premises read a progress atom an earlier step produced. CAPEC-157 (Sniffing Attacks), the Standard-level parent of CAPEC-158, is the only one of the three whose entry has an execution flow, which gives such a chain:

CanObserve⁡(a,ch)→KnowsProtocol⁡(a,ch);KnowsProtocol⁡(a,ch)→Positioned⁡(a,ch);\operatorname{CanObserve}(a,ch) \to\operatorname{KnowsProtocol}(a,ch);\qquad\operatorname{KnowsProtocol}(a,ch) \to\operatorname{Positioned}(a,ch);
Positioned⁡(a,ch)∧Carries⁡(ch,r)→ConfidentialityFlag⁡(r)\operatorname{Positioned}(a,ch) \land\operatorname{Carries}(ch,r) \to\operatorname{ConfidentialityFlag}(r)

Each step’s effect enables the next: observing the channel yields protocol knowledge. This enables the attacker to position itself on the channel, from where it obtains the information carried by that channel. The chain form is what later yields ordering and partial-progress properties: progress atoms are the only place a temporal dependency between attacker actions is stated rather than assumed.

Binding and relevance: is this system vulnerable to this attack?

A binding θ\theta, supplied by the leaf, maps a schema’s parameters to profile entities of matching sort; a binding is rejected if the sorts disagree or if it names a channel absent from model_map, since an undeclared interface offers no composition point. For leaf-148-cam, θ={a↦attacker,ch↦cam_in,r↦pose_estimate}\theta= \{a \mapsto attacker, ch \mapsto cam\_in, r \mapsto pose\_estimate\}, so θ(pre)=CanModify(attacker,pose_estimate)∧Carries(cam_in,pose_estimate)∧¬Authenticated(cam_in)\theta(pre) = \mathrm{CanModify}(attacker, pose\_estimate) \land\mathrm{Carries}(cam\_in, pose\_estimate) \land\neg\mathrm{Authenticated}(cam\_in) and θ(eff)=IntegrityViolated(pose_estimate)\theta(eff) = \mathrm{IntegrityViolated}(pose\_estimate). Thus, the grounded action is enabled when the attacker can modify the pose estimate carried by the unauthenticated camera channel; executing it establishes IntegrityViolated(pose_estimate)\mathrm{IntegrityViolated}(pose\_estimate). The same schema bound differently is a distinct grounded attack instance. Figure 4 shows this action synchronising with the controller only through cam_incam\_in, where cam_channel_authcam\_channel\_auth disables its guard.

For each configuration CC, let FCF_C be the facts holding once its controls have been applied. A bound action is applicable in CC when every positive literal of θ(pre)\theta(pre) is in FCF_C and every negated one is absent. Multi-step chains are checked in order, effects carried forward. When a literal fails we report it as the blocking atom, with reason missing / present_but_negated, so a blocked verdict points to the control that defeats the attack. The camera leaf is applicable under C1 and blocked under C2, where cam_channel_authcam\_channel\_auth establishes Authenticated(cam_in)\mathrm{Authenticated}(cam\_in) and so falsifies the premise’s negated literal, reported present_but_negated. Verdicts are also relative to profile completeness: an unrecorded capability makes an attack look blocked, so we report “blocked under FCF_C”, never “secure”.

From bound rules to LTL and SPIN

A grounded rule yields the attacker and its properties in one move. Atoms become Promela variables via model_map; capability and state atoms are constants of the configuration, progress and violation atoms mutable and initially false. Each step becomes one guarded atomic branch of an attacker process, with a τ\tau branch letting the attacker decline to act. Each emitted property carries a polarity recording how to read SPIN’s verdict: a violation of a universal claim means the property fails, whereas a violation of an existential one means the target is reachable and the trail is the witness. With v1,…,vkv_1,\ldots,v_k the leaf’s grounded violation atoms, pi=θ(prei)p_i = \theta(pre_i) the grounded precondition of step ii and did_i its completion, we emit the templates of Table 2: per leaf, an obligation, adequacy guards that detect vacuity, partial progress and step ordering; per tree, an ordering claim for each SAND node and a reachability claim for each attack suite. The listing shows the instances emitted for the tree of Figure 3.

PropertyFormulaIntended claimPolaritySPIN counterexample means
Obligation□¬(v1∨⋯∨vk)\Box\neg(v_1 \lor\cdots\lor v_k)the attack’s effect never occursuniversalthe attack succeeds; the trail is the attack
Adequacy□¬pn\Box\neg p_nthe final step’s precondition is reachableexistentialit is reachable, so the obligation is not vacuous
Step adequacy (i<ni < n)□¬pi\Box\neg p_istep ii is reachableexistentialstep ii is reachable
Ordering (i≥2i \ge2)□¬di∨(¬diUdi−1)\Box\neg d_i \lor(\neg d_i \mathbin{\mathsf{U}} d_{i-1})step ii never completes before step i−1i-1universala step can be skipped
Partial progress (i<ni < n)□¬(pi∧□¬dn)\Box\neg(p_i \land\Box\neg d_n)some run reaches step ii and never completes the chainexistentialsuch a run exists
SAND ordering□¬done(l2)∨(¬done(l2)Udone(l1))\Box\neg done(l_2) \lor(\neg done(l_2) \mathbin{\mathsf{U}} done(l_1))leaf l2l_2 never completes beforeuniversalthe tree’s order is not enforced

Table 2. LTL templates emitted per leaf (top) and per tree (bottom). done(l)done(l) is the conjunction of leaf ll’s grounded violation atoms.

ltl leaf_148_cam_obligation { [] !pose_integrity_violated }
ltl leaf_148_cam_adequacy { [] !(can_modify_attacker_pose_estimate && carries_cam_in_pose_estimate
                              && !authenticated_cam_in) }
ltl leaf_157_step2_partial { [] !(knows_protocol_attacker_cam_in && [] !pose_confidentiality_flag) }
ltl leaf_157_cam_step1_partial { [] !(can_observe_attacker_cam_in
                              && [] !pose_confidentiality_flag) }
ltl sand_sniff_then_spoof { ([] !pose_integrity_violated) || (!pose_integrity_violated U
                              pose_confidentiality_flag) }

SPIN runs once per (tree, configuration, property), checking the emitted obligation, adequacy, partial-progress and ordering properties over the composition TSsys∥chTSattTS_{\mathrm{sys}} \mathbin{\|_{\mathrm{ch}}} TS_{\mathrm{att}}. We plan to run every configuration in turn showing which control discharges which leaf.

Evaluation Plan & Conclusion

There are four dimensions to the evaluation. We evaluate on CAPEC retrieval effectiveness and extend against ATT&CK-BERT and other embeddings for comparability with [11, 1]. We assess schema coverage, static grounding to look at expected applicability vs actual applicability and finally evaluate the formal generation and look at generated SPIN result vs expected/manual model.

We have presented, as a research preview, a pipeline that takes an attack tree, attaches a CAPEC pattern to each leaf, writes it as a first-order rule, binds the rule to a system profile, decides under each control configuration whether the bound attack applies and which control defeats it, and emits the LTL and Promela attacker that SPIN checks. Binding is the centre: where a catalogue pattern becomes a verifiable claim about a deployment, and the mechanised form of the input-mediated attacker composition of our earlier hand-built verification. The pipeline addresses (i) Applicability: Is the CAPEC attack applicable to the system/configuration? (ii) Reachability: Can the instantiated attacker achieve its CAPEC-defined effect? (iii) Vulnerability: Does the attacker cause a violation of a security property of the actual system? In our previous work [9] we established TSsys∥chTSattTS_{\mathrm{sys}} \mathbin{\|_{\mathrm{ch}}} TS_{\mathrm{att}} for a manually authored attacker. We are now defining a pipeline that generates the attacker model G(CAPEC,θ,FC)=TSattG(CAPEC,\theta,F_C) = TS_{\mathrm{att}} and so TSsys∥chG(CAPEC,θ,FC)TS_{\mathrm{sys}} \mathbin{\|_{\mathrm{ch}}} G(CAPEC,\theta,F_C) will be verified.

References

  1. [1]Alan Birchler De Allende, Bastien Sultan & Ludovic Avprille (2024): Automated Attack Tree Generation Using Artificial Intelligence & Natural Language Processing. In: Risks and Security of Internet and Systems – CRiSIS 2024, Springer. Available at https://doi.org/10.1007/978-3-031-89350-6_9.
  2. [2]Paul Ammann, Duminda Wijesekera & Saket Kaushik (2002): Scalable, Graph-Based Network Vulnerability Analysis. In: 9th ACM Conference on Computer and Communications Security (CCS), ACM, pp. 217–224, doi:10.1145/586110.586140.DOI
  3. [3]Maxime Audinot, Sophie Pinchinat & Barbara Kordy (2017): Is My Attack Tree Correct? In: Computer Security – ESORICS 2017, LNCS 10492, Springer, pp. 83–102, doi:10.1007/978-3-319-66402-6_7.DOI
  4. [4]Rafael C. Cardoso, Louise A. Dennis, Marie Farrell, Michael Fisher & Matt Luckcuck (2022): Towards Compositional Verification for Modular Robotic Systems. arXiv preprint arXiv:2208.05507. Available at https://doi.org/10.48550/arXiv.2012.01648.
  5. [5]Louise Dennis, Clare Dixon & Michael Fisher (2022): Verifiable autonomy: From theory to applications. AI Communications 35(4), pp. 421–431, doi:10.3233/AIC-220115.DOI
  6. [6]Marie Farrell, Matthew Bradbury, Michael Fisher, Louise A. Dennis, Clare Dixon, Hu Yuan & Carsten Maple (2019): Using Threat Analysis Techniques to Guide Formal Verification: A Case Study of Cooperative Awareness Messages. In: Software Engineering and Formal Methods – SEFM 2019, LNCS 11724, Springer, pp. 471–490, doi:10.1007/978-3-030-30446-1_25.DOI
  7. [7]Gerard J. Holzmann (2003): The SPIN Model Checker: Primer and Reference Manual. Addison-Wesley. Available at https://dl.acm.org/doi/10.5555/1405716.
  8. [8]Juel Hussain (2026): AT2FOL: From Attack-Tree Leaves to CAPEC-Bound Schemas, LTL and Promela. https://github.com/juelhussain/AT2FOL. Release fmas2026; prototype, work in progress.
  9. [9]Juel Hussain, Louise A. Dennis, Clare Dixon & Marie Farrell (2026): Security-Minded Modelling and Verification of Autonomous Satellite Docking. In: Rigorous State-Based Methods – ABZ 2026, LNCS 16579, Springer, doi:10.1007/978-3-032-26752-8_5.
  10. [10]Ravi Jhawar, Barbara Kordy, Sjouke Mauw, Saša Radomirović & Rolando Trujillo-Rasua (2015): Attack Trees with Sequential Conjunction. In Hannes Federrath & Dieter Gollmann, editors: ICT Systems Security and Privacy Protection, Springer International Publishing, Cham, pp. 339–353. Available at https://doi.org/10.1007/978-3-319-18467-8_23.
  11. [11]Kenta Kanakogi, Hironori Washizaki, Yoshiaki Fukazawa, Shinpei Ogata, Takao Okubo, Takehisa Kato, Hideyuki Kanuka, Atsuo Hazeyama & Nobukazu Yoshioka (2021): Tracing CVE Vulnerability Information to CAPEC Attack Patterns Using Natural Language Processing Techniques. Information 12(8), p. 298, doi:10.3390/info12080298.DOI
  12. [12]Rajesh Kumar, Enno Ruijters & Mariëlle Stoelinga (2015): Quantitative Attack Tree Analysis via Priced Timed Automata. In: Formal Modeling and Analysis of Timed Systems – FORMATS 2015, LNCS 9268, Springer, pp. 156–171, doi:10.1007/978-3-319-22975-1_11.DOI
  13. [13]Matt Luckcuck, Marie Farrell, Louise A. Dennis, Clare Dixon & Michael Fisher (2019): Formal Specification and Verification of Autonomous Robotic Systems: A Survey. ACM Computing Surveys 52(5), pp. 100:1–100:41, doi:10.1145/3342355.DOI
  14. [14]Carsten Maple, Matthew Bradbury, Hu Yuan, Marie Farrell, Clare Dixon, Michael Fisher & Ugur Ilker Atmaca (2020): Security-Minded Verification of Space Systems. In: IEEE Aerospace Conference, IEEE, pp. 1–13, doi:10.1109/AERO47225.2020.9172563.DOI
  15. [15]Sjouke Mauw & Martijn Oostdijk (2006): Foundations of Attack Trees. In Dong Ho Won & Seungjoo Kim, editors: Information Security and Cryptology - ICISC 2005, Springer Berlin Heidelberg, Berlin, Heidelberg, pp. 186–198. Available at https://doi.org/10.1007/11734727_17.
  16. [16]MITRE Corporation (2023): CAPEC: Common Attack Pattern Enumeration and Classification, version 3.9. https://capec.mitre.org.
  17. [17]Xinming Ou, Wayne F. Boyer & Miles A. McQueen (2006): A Scalable Approach to Attack Graph Generation. In: 13th ACM Conference on Computer and Communications Security (CCS), ACM, pp. 336–345, doi:10.1145/1180405.1180446.DOI
  18. [18]Xinming Ou, Sudhakar Govindavajhala & Andrew W. Appel (2005): MuLVAL: A Logic-based Network Security Analyzer. In: 14th USENIX Security Symposium, USENIX Association, pp. 113–128. Available at https://www.usenix.org/conference/14th-usenix-security-symposium/mulval-logic-based-network-security-analyzer.
  19. [19]Sophie Pinchinat, Mathieu Acher & Didier Vojtisek (2015): Towards Synthesis of Attack Trees for Supporting Computer-Aided Risk Analysis. In: Software Engineering and Formal Methods – SEFM 2014 Collocated Workshops, LNCS 8938, Springer, pp. 363–375, doi:10.1007/978-3-319-15201-1_24.DOI
  20. [20]Amir Pnueli (1977): The Temporal Logic of Programs. In: 18th Annual Symposium on Foundations of Computer Science (FOCS), IEEE, pp. 46–57, doi:10.1109/SFCS.1977.32.DOI
  21. [21]Bruce Schneier (1999): Attack Trees. Dr. Dobb’s Journal 24(12), pp. 21–29. Available at https://www.schneier.com/academic/archives/1999/12/attack_trees.html.
  22. [22]Adam Shostack (2014): Threat Modeling: Designing for Security. John Wiley & Sons, Hoboken, NJ.

Paper details

vlnc:W_8rbwqk9x
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 2

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents