Rania Mzid

IKM -- An Identity based Key Management Scheme for Heterogeneous Sensor Networks

Wireless sensor networks applications are growing and so are their security needs. However, due to severe memory, computing and communication limitations, wireless sensor networks security presents tremendous challenges. Central to any security service, key management is a fundamental cryptographic primitive to provide other security operations. In this paper, we propose IKM, an identity based key management scheme designed for heterogeneous sensor networks. This scheme provides a high level of security as it is based on a variant of public key cryptography named pairing identity based cryptography. The IKM scheme supports the establishment of two types of keys, pairwise key to enable point to point communication between pairs of neighbouring nodes, and cluster key to make in-network processing feasible in each cluster of nodes. IKM also supports the addition of new nodes and re-keying mechanism. A security analysis is presented to prove the scheme resilience against several types of attacks especially the node compromise attack. We also perform an overhead analysis of the proposed scheme in terms of storage, communication, and computation requirements. To demonstrate the feasibility of this scheme, we present implementation and performance evaluation of the proposed scheme on Crossbow TelosB motes running TinyOS. The results indicate that it can be deployed efficiently in resource-constrained sensor networks that need a high level of security.

Adapting TLS handshake protocol for heterogenous IP-based WSN using identity based cryptography

IP-based Wireless Sensor Networks (IP-based WSNs) combine IPv6 technology with WSNs to create a global sensor network infrastructure. However, wireless radio access and Internet connectivity make end-to-end security urgently needed by security critical WSN applications. Transport Layer Security (TLS) is considered as a suitable solution to ensure such security. However, the certificate-based mechanism used by the TLS handshake protocol has a complex certificate management overhead and long handshake latency. Identity Based Cryptography (IBC) provides a viable alternative to the use of certificates. In this paper, we propose two improved TLS handshake protocols for IP-based WSNs using IBC. The first uses IBC and Elliptic curve Diffie Hellman (ECDH) protocol for key exchange and agreement while the second uses a variant of IBC based on Elliptic Curve Cryptography (ECC) and bilinear pairing. Security analysis shows that improved TLS ensures security requirements for IP-based WSN. AVISPA tool is used to validate the proposed improvements. In addition, performance analysis shows that TLS handshake protocol using IBC gives better performance in terms of latency and energy consumption.

DPMP: a software pattern for real-time tasks merge

In a model-driven development context, the refinement of the architectural model of a real-time application to a Real Time Operating System (RTOS) specific model is a challenging task. Indeed, the different design choices made to guarantee the application timing properties are not always implementable on the target RTOS. In particular, when the number of distinct priority levels used at the design level exceeds the number allowed by the RTOS for the considered application, this refinement becomes not possible. In this paper, we propose a software pattern called Distinct Priority Merge Pattern (DPMP) that automatically perform the re-factoring of the architectural model when this problem occurs. First, we give an heuristic algorithm describing this pattern and we show that this method is not always effective. Then, to address the limitations of the first method, we propose a MILP formulation of the DPMP pattern that allows to check whether a solution exists and gives the optimal one. The evaluation of the second method, allows to estimate a cost in terms of processor utilization increase during the deployment of an application on a given RTOS family characterized by the number of distinct priority levels that it offers.

A MDD Approach for RTOS Integration on Valid Real-Time Design Model

The transition from the design model to the implementation model is a critical phase in Real-Time Embedded Systems development process. Indeed, this model must conserve functional and non-functional requirements of the design model on the target execution platform. In this paper, we propose a two-steps approach based on an explicit description of two types of platform: the abstract platform used at the design level to validate the different design choices, and the concrete execution platform. The first step consists in feasibility tests whose role is to help the designer detecting the potential refinement problems. The second step is a mapping step that ensures the compliance of the implementation model with the design model taking into consideration the characteristics of the target execution platform.

Real-time design models to RTOS-specific models refinement verification

One key point of Real-Time Embedded Systems development is to ensure that functional and non-functional properties (NFPs) are satisfied by the implementation. For early detection of errors, the verification of NFPs is realized at the design level. Then the design model is implemented on a Real-Time Operating System (RTOS). However, the design model could be not implementable on the target RTOS. In this paper, we propose to integrate between the design and the implementation phases, a feasibility tests step to verify whether the design model is implementable on the target RTOS and a mapping step to generate the appropriate RTOS-specific model. This two-steps approach is based on an explicit description of the platform used for verification and the RTOS which is the implementation platform. Moreover an additional verification step is needed to ensure the conformity of the implementation model to the design model with regard to NFPs.

Multiobjective Optimization Approach for a Portable Development of Reconfigurable Real-Time Systems: From Specification to Implementation

This paper deals with the reconfigurable real-time systems that should be adapted to their environment under real-time constraints. The reconfiguration allows moving from one implementation to another by adding/removing/modifying parameters of real-time software tasks which should meet related deadlines. Implementing those systems as threads generates a complex system code due to the large number of threads, which may lead to a reconfiguration time overhead as well as the energy consumption and the memory allocation increase. Thus this paper proposes a multiobjective optimization approach for reconfigurable systems called MO2R2S for the development of a reconfigurable real-time system. Given a specification, the proposed approach aims to produce an optimal design while ensuring the system feasibility. We focus on three optimization criteria: 1) response time; 2) memory allocation; and 3) energy consumption. To address the portability issue, the optimal design is then transformed to an abstract code that may in turn be transformed to a concrete code which is specific to a procedural programming (i.e., POSIX) or an object-oriented language (i.e., RT-Java). The MO2R2S approach allows reducing the number of threads by minimizing the redundancy between the implementation sets. By an experimental study, such optimization permits to decrease the memory allocation by 28.89%, the energy consumption by 40.2%, and the response time by 61.32%.

SRMP: a software pattern for deadlocks prevention inreal-time concurrency models

Model-based approaches for the development of software intensive real-time embedded systems allow early verification of timing properties at the design phase. At this phase, the Real-Time Operating System (RTOS) may not be chosen, hence some assumptions on the software platform are made to achieve timing verifications such as schedulability analysis of tasks describing the application. Among these assumptions, the synchronization protocol which is used to manage the concurrent access to resources that are shared between tasks. A classical solution is to consider the Priority Ceiling Protocol (PCP) synchronization protocol to avoid deadlocks. However, when this protocol is not provided by the target RTOS on which the application will be deployed, the concurrency model becomes not implementable and a new synchronization protocol must be considered. In this paper, we propose the Shared Resource Merge Pattern (SRMP) which aims to prevent deadlocks when the use of PCP protocol is not allowed by the target RTOS. The application of this pattern on the concurrency model must guarantee that the timing properties of the real-time application are still met.

A New Approach for Optimal Implementation of Multi-core Reconfigurable Real-time Systems.

This paper deals with a multi-core reconfigurable real-time system specified with a set of implementations, each of which is raised under a predefined condition and executes multiple functions which are in turns executed by threads. The implementation as threads generates a complex system code. This is due to the huge number of threads and the redundancy between the different implementations which may lead to an increase in the energy consumption. Thus we aim in this paper to optimize the system code by avoiding the redundancy between implementations and reducing the number of threads while meeting all related real-time constraints. The proposed approach adopts mixed integer linear programming (MILP) techniques in the exploration phase in order to provide a feasible task model. An optimal reconfigurable POSIX-based code of the system is manually generated as an output of this technique. An application to a case study and performance evaluation confirm and validate the expected results.

MILP-based Approach for Optimal Implementation of Reconfigurable Real-time Systems

This paper deals with the design and implementation of reconfigurable uniprocessor real-time embedded systems. A reconfiguration is a run-time operation allowing the addition-removal of real-time tasks or the update of their parameters. The system is implemented then by different sets of tasks such that only one is executed at a particular time after a corresponding reconfiguration scenario according to user requirements. The problem is to optimize the system code while meeting all related real-time constraints and avoiding any redundancy between the implementation sets. Based on the Linear Programming (MILP), we propose a multi-objective optimization technique allowing the minimization of the number of tasks and their response times. An optimal reconfigurable POSIX-based code of the system is manually generated as an output of this technique. We apply the paper’s contribution to the study of the performance evaluation.

A New Approach for Automatic Development of Reconfigurable Real-Time Systems

In the industry, reconfigurable real-time systems are specified as a set of implementations and tasks with timing constraints. The reconfiguration allows to move from one implementation to another by adding/removing real-time tasks. Implementing those systems as threads generates a complex system code due to the large number of threads and the redundancy between the implementation sets. This paper shows an approach for software synthesis in reconfigurable uniprocessor real-time embedded systems. Starting from the specification to a program source code, this approach aims at minimizing the number of threads and the redundancy between the implementation sets while preserving the system feasibility. The proposed approach adopts Mixed Integer Linear Programming (MILP) techniques in the exploration phase in order to provide feasible and optimal task model. An optimal reconfigurable POSIX-based code of the system is manually generated as an output of this technique. An application to a case study and performance evaluation show the effectiveness of the proposed approach.