Space-based navigation systems rely on satellites to operate in orbit and have lifetimes of 10 years or more. Engineers employ Reliability, Availability, and Maintainability (RAM) analysis during the design phase to maximize a satellite's mean time between failures (MTBF). These design parameters help to optimize maintenance plans, enhance overall reliability, and extend the satellite's lifespan. The paper presents a novel approach using concurrent stochastic games (CSG) to model a single satellite with logical and formal specifications of RAM properties in rPATL. We leverage the PRISM-games model checker for quantitative analysis while considering collaborative behaviors between involved players in orbit and on the ground. This CSG-based approach offers a rich design space where actors considered as players involved in satellite maintenance can collaborate and learn optimal strategies.

The development of distributed computing systems and of their usage in domains such as the Internet of Things, Big Data, etc., raises numerous questions on the tools available to model the complexity of such systems. Non-formal modeling methods fail to create a rigorous way to describe and analyze these systems. In this paper, we propose an approach to model and analyze the structural and behavioural aspect of these systems using formal techniques. As a prerequisite, we build reusable model libraries to specify and verify communication paradigms for modeling software architectures of distributed systems in a component-based system engineering (CBSE) context. First, we describe high-level concepts for system architecture in a component-port-connector fashion as a metamodel. Then, we develop an Event-B interpretation of the metamodel adding communication characteristics such as buffering, FIFO and synchronicity. To validate our work, we studied the two well-known communication paradigms, namely message passing and remote procedure call.

Designing a large and complex software system depends not only on the nature of the system itself, but also on human-centric characteristics of the team of architects, developers, and managers involved in the design activity. Each of these team members often comes with varying levels of knowledge, experience, attitudes, and behaviors (i.e., human factors) towards securing systems that impact the decision-making process of the individual team members and of the team as a whole. Thus, these human factors can influence architectural design decisions impacting many different system qualities including security. In this paper, we propose a framework for considering human factors in collaborative decision-making for secure architecture design. At the core of the proposed framework, are conceptual models for security human factors and architectural design decisions. We describe the steps and our preliminary results towards creating the proposed framework using a combination of model-driven engineering techniques and human science approaches. We also provide a simple design scenario to illustrate the envisioned design workflow of the proposed framework. With the proposed framework, we aim to improve our understanding of how decisions are made by a team of diverse members, and to provide better traceability of decisions impacting system security.

The use of Artificial Intelligence (AI)-based systems, using particularly Machine Learning (ML) classifiers, is growing rapidly and finding uses in many industries. Most of these industries have critical safety, security, and dependability requirements. Despite this rapid growth, interest in the security of these systems has only arisen in the last few years and it is not yet well-studied. There is a want for a formal notion of security for ML systems, similar to that used in classical information security. We took this statement toward security threat modeling and analysis in ML-based systems, focusing on the adversarial example threat. An adversarial example threat is an input of the classifier that was maliciously modified to induce a misclassification. Identifying this threat at the architecture design stage before proceeding with system development is a critical milestone in the development process of secure ML systems. In this paper, we propose an approach to adversarial example threat specification and detection in component-based software architecture models. We use first-order and modal logic as an abstract and technology-independent formalism. The general idea of the approach is to specify the threat as property of a modeled system such that the violation of the specified property indicates the presence of the threat. We demonstrate the applicability of the method through a classifier used in a recommendation system.

The specification and the verification of security requirements is one of the major computer-based systems challenges. Security requirements need to be precisely specified before a tool can manipulate them, and though several approaches to security requirements specification have been proposed, they do not provide the scalability and flexibility required in practice. We take this problem towards an integrated approach for security requirement specification and treatment during the software architecture design time. The general idea of the approach is to: (1) specify security requirements as properties of a modeled system in a technology-independent specification language; (2) implement the developed model in a suitable language with tool support for requirement satisfaction through model verification; and (3) suggest a set of security policies to constrain the operation of the system and to guarantee the security properties. In the scope of this paper, we use first-order logic as a formalism that is abstract and technology-independent and Alloy as a tooled language used in modeling and software development. To validate our work, we explore a set of representative security properties from categories based on CIA classification in the context of secure component-based software architecture development.

This work is devoted to the problem of spanning trees maintenance in the presence of crash failures in a distributed environment using only local knowledge. Using a pre-constructed spanning tree of a k-connected graph, we present a protocol to maintain a spanning tree in the presence of k-1 consecutive failures. The contribution of this paper is threefold. First, the problem is formalized as an occurrence of Menger's theorem in a distributed setting. The second result shows an implementation of the protocol which is composed of a set of modules encoded using a graph relabeling systems model. The last contribution is the implementation of this protocol in the asynchronous message passing model. For a given graph G =(V,E), where M is the number of its edges, N is the number of its nodes, and Δ is its degree; After each failure occurrence, our algorithms need the following requirements: The first one uses O(Δ × N) steps and O(Δ) bits per node. The second one uses O(N+M) messages and O(N) time and O(Δ) bits per node. In addition, we investigate the possible specification and verification of the presented algorithm using Alloy as a tooled formal language.

Securing critical systems such as Cyber-Physical Systems (CPS) is an important feature especially when it comes to critical transmitted data in a real-time environment. At the same time, the implementation of security counter-measures in such systems may impact transmission delays of critical tasks. For this reason selecting proper security mechanisms in such critical systems is an important issue. In this context, we propose a model-based approach for selecting proper security solution alternatives composed of security patterns at early design stage against real-time requirements. We provide a generalizable and tool-supported solution to support the approach using UML and its profiles. A validation of the work is presented via a simplified version of SCADA (Supervisory Control and Data Acquisition) system case study.

Development processes for software construction are common knowledge and widely used in most development organizations. Unfortunately, these processes often offer only little or no support in order to meet security requirements. In our work, we propose a methodology to enhance these process models with security concepts, backed by a security-oriented process model specification language. The methodology supports existing process models, which will be extended by established security approaches, as well as information security risk management standards, to fulfill the demand for secure software engineering. The methodology and the process modeling language we propose, have been successfully evaluated by the TERESA project for specifying development processes for trusted applications and integrating security concepts into existing process models.

Summary In this paper, we propose a model‐driven approach allowing to build reconfigurable distributed real‐time embedded (DRE) systems. The constant growth of the complexity and the required autonomy of embedded software systems management give the dynamic reconfiguration a big importance. New challenges to apply the dynamic reconfiguration at model level as well as runtime support level are required. In this direction, the development of reconfigurable DRE systems according to traditional processes is not applicable. New methods are required to build and to supply reconfigurable embedded software architectures. In this context, we propose an model‐driven engineering based approach that enables to design reconfigurable DRE systems with execution framework support. This approach leads the designer to specify step by step his/her system from a model to another one more refined until the targeted model is reached. This targeted model is related to a specific platform leading to the generation of the most part of the system implementation. We also develop a new middleware that supports reconfigurable DRE systems. Copyright © 2013 John Wiley & Sons, Ltd.

Complexity in Distributed Real time Embedded Systems (DRTES) is rising due to richer functionality that is enabled by more powerful hardware. Component-Based Software Engineering (CBSE) and Model Driven Engineering (MDE) help to capture several facets of this complexity. With these two approaches, we build on two main currents in embedded systems research: synchronization and communication. In this paper, we propose a DRTES meta-model to deal with software and hardware aspects of synchronization and communication at a model level. The elements of this meta-model will be used to describe software and hardware specifications and requirements using component as a first class artifact to build such systems. Each component type (generic component) has several instances and multiple views, principally software or hardware one with specific links. The link offers an interface to choose the map between a software and a hardware component at an even greater level using UML profiles derived from DRTES meta-model. This is to allow an automatic exploration at component instance level via Model Driven Engineering. As a proof of concept we examine a test case that has software and hardware synchronization and communication requirements: a GPS.

In this paper, we present a method to build an homogeneous and interactive visualization of self-stabilizing distributed algorithms using Visidia platform. The approach developed in this work allows to simulate the transient failures and their correction mechanism. We use local computations to encode self-stabilizing algorithms like the distributed algorithms implemented in Visidia. The resulting interface is able to select some processes and incorrectly change their states to show the transient failures. The system detects and corrects these transient failures by applying correction rules. Many examples of self-stabilizing distributed algorithms are implemented.

We present a formal method to design self-stabilizing algorithms by using graph rewriting systems (GRS). This method is based on two phases. The first phase consists of defining the set of illegitimate configurations (GRSIC). The second phase allows to construct some local correction rules to eliminate the illegitimate configurations. Then the graph relabeling system composed of the initial graph rewriting system improved with the addition of the correction rules is a self-stabilizing system (LSGRS). We obtain a general approach to deal with fault-tolerance in distributed computing. We illustrate our approach by various self-stabilizing algorithms for computing distributed spanning trees and SSP's algorithm.

A geometric constraint solver is a major component of recent CAD systems. Graph constructive solvers stem from graph theory. We describe a 2D constraint based modeller that uses a graph constructive approach to solve systems of geometric constraints. The graph based approach provides means for developing sound and efficient algorithms. We present a linear algorithm that solves a large subset of the rule and compass constructive problems. Methods for handling over- and under-constrained schemes are also given.