Brahim Hamid

Enforcing S&D pattern design in RCES with modeling and formal approaches

The requirement for higher security and dependability of systems is continuously increasing even in domains not traditionally deeply involved in such issues. Yet, evolution of embedded systems towards devices connected via Internet, wireless communication or other interfaces requires a reconsideration of secure and trusted embedded systems engineering processes. In this paper, we propose an approach that associates model driven engineering (MDE) and formal validation to build security and dependability (S&D) patterns for trusted RCES applications. The contribution of this work is twofold. On the one hand, we use model-based techniques to capture a set of artifacts to encode S&D patterns. On the other hand, we introduce a set of artifacts for the formal validation of these patterns in order to guarantee their correctness. The formal validation in turn follows the the MDE process and thus links concrete validation results to the S&D requirements identified at higher levels of abstraction.

Designing Fault-Tolerant Component Based Applications with a Model Driven Approach

The requirement for higher reliability and availability of systems is continuously increasing even in domains not traditionally strongly involved in such issues. Solutions are expected to be efficient, flexible, reusable on rapidly evolving hardware and of course at low cost. Model driven approaches can be very helpful for this purpose. In this paper, we propose a study associating model-driven technology and component-based development. This work is illustrated by the realization of a use case from aerospace industry that has fault-tolerance requirements: a launch vehicle. UML based modeling is used to capture application structure and related non-functional requirements thanks to the profiles CCM (CORBA Component Model) and QoS&FT (Quality of Service and Fault Tolerance). The application model is enriched with infrastructure component dedicated to fault-tolerance. From this model we generate CCM descriptor files which in turns are used to build bootcode (static deployment) which instantiates, configures and connects components. Within this process, component replication and FT properties are declaratively specified at model level and are transparent for the component implementation.

Model-based security and dependability patterns in RCES: the TERESA approach

The requirement for higher reliability and availability of systems is continuously increasing even in domains not traditionally deeply involved in such issues. In particular Resource Constrained Embedded Systems solutions are expected to be efficient, flexible, reusable on rapidly evolving hardware and at low cost. Model driven approaches can be very helpful to deal with these strong requirements. In this paper, we propose a first step to a study associating model driven technology and patterns development to build security and dependability patterns based on MDE solutions. The contribution of this work is twofolds. On one hand, we use meta-modeling techniques to encode security and dependability (S&D) patterns at even greater level of abstraction. On the other hand, we propose an implementation of these patterns using a profiled UML. This offers an homogeneous way to store them in a repository and to integrate them in a MDE process to build S&D applications in RCES for several domains.

Towards a model-based approach for reconfigurable DRE systems

This paper defines a model-based approach, which treats the reconfiguration issues for Distributed Real time Embedded (DRE) systems at a high level of abstraction. We aim at specifying reconfigurable DRE systems using a characterization approach. To treat the reconfiguration requirements, we propose a meta-model and a UML profile as implementation of this meta-model. This leads to a simple way to model reconfigurable systems thanks to UML tools, our RCA4RTES meta-model and profile, and the MARTE profile and library.

A Model-Driven Engineering Framework for Fault Tolerance in Dependable Embedded Systems Design

This paper proposes a model based framework for the design of dependable embedded systems. First we define a meta-model to encompass the different concepts to capture fault tolerance. This will be used to derive a UML profile for the specification and the management of the redundancy. Based on this profile, we propose a model library as reusable and composable UML components to construct a fault tolerant infrastructure. As proof of concept, a GPS use case with fault tolerance requirements is evaluated using the proposed framework.

Towards a Unified Meta-model for Resources-Constrained Embedded Systems

The complexity in embedded systems is increasing steadily due to richer functionalities offered by more powerful hardware to attain market demands. Model Driven Engineering(MDE) is a promising approach for handling this complexity by using models which help to capture several concerns of these systems. In this paper we analyze the modeling of embedded systems that have restrictions on memory, autonomy, and/or computation processing which refer to RCES (Resources-Constrained Embedded Systems). In particular we study existing works including those from standards and industry such as MARTE, SysML and AADL. The first step is to encompass the different concepts introduced in these works to capture computations and resources. This yields a homogeneous formalism to model RCES and we will propose this formalism as a meta-model. In the same way we propose a modeling framework based on a model library as reusable and composable models for RCES. Finally we are evaluating the feasibility of our approach to an industrial control system that has constraints on software and hardware resources.

Model-Driven Engineering for Trusted Embedded Systems Based on Security and Dependability Patterns

Nowadays, many practitioners express their worries about current software engineering practices. New recommendations should be considered to ground software engineering on two pillars: solid theory and proven principles. We took the second pillar towards software engineering for embedded system applications, focusing on the problem of integrating Security and Dependability (S&D) by design to foster reuse. The framework and the methodology we propose associate the model-driven paradigm and a model-based repository of S&D patterns to support the design of trusted Resource Constrained Embedded System (RCES) applications for multiple domains (e.g., railway, metrology, automotive). The approach has been successfully evaluated by the TERESA project external reviewers as well as internally by the Ikerlan Research Center for the railway domain.

Towards a better integration of patterns in secure component-based systems design

Security has become an important challenge in current software and system development. Most of designers are experts in software development but not experts in security. It is important to guide them to decide how and where to apply security mechanisms in the early phases of software development to reduce time and cost of development. To reach this objective, we propose to apply security expertise as security patterns at software design phase. Our methodology is based on the use of a component metamodel to capture the domain concepts and security patterns to encode solutions to security problem. The expected result is a model as design solution for specific domain. Here, we promote a modeling technique based on UML profiles to facilitate the integration of patterns solutions into model driven engineering approach (MDE). As a proof of concept, we illustrate the methodology to produce an UML profile associated with RBAC security pattern. A case study of GPS system is also provided to demonstrate the application of generated profile.

Security patterns modeling and formalization for pattern-based development of secure software systems

Pattern-based development of software systems has gained more attention recently by addressing new challenges such as security and dependability. However, there are still gaps in existing modeling languages and/or formalisms dedicated to modeling design patterns and the way how to reuse them in the automation of software development. The solution envisaged here is based on combining metamodeling techniques and formal methods to represent security patterns at two levels of abstraction to fostering reuse. The goal of the paper is to advance the state of the art in model and pattern-based security for software and systems engineering in three relevant areas: (1) develop a modeling language to support the definition of security patterns using metamodeling techniques; (2) provide a formal representation and its associated validation mechanisms for the verification of security properties; and (3) derive a set of guidelines for the modeling of security patterns within the integration of these two kinds of representations.

Safety lifecycle development process modeling for embedded systems - example of railway domain

Nowadays, many practitioners express their worries about current software engineering practices. New recommendations should be considered to ground software engineering on solid theory and on proven principles. We took such an approach towards software engineering process modeling for embedded system applications with security and dependability requirements, focusing on the problem of integrating safety during the process design to clarify assessment of this kind of applications. In this paper, we propose a safety-oriented process metamodel to support all the requirements of safety processes. The resulting modeling framework serves primarily to capture the basic concepts of concerns related to safety development of embedded systems based on the clear separation between the development process, the system and their properties. Subsequently, the safety property model of the process is defined. The feasibility of the approach is evaluated with a case study from the railway domain.