Modern systems rely on numerous third-party software components from various vendors and open-source repositories. To secure their software supply chain, Software Bill of Materials (SBOM) has emerged as an inventory of third-party components, hence enabling the identification of vulnerable software components among those integrated in the systems. This identification is a prerequisite for the systems designers to mitigate vulnerabilities brought by the components. However, current SBOM techniques are not enough to trace dependencies from the source code scaling up to the service-oriented level, nor from the design to the operation phases. These limitations prevent discovering potential vulnerability propagation and operational impact analysis in a System-of-Systems (SoS) context, nor lateral movement analysis, e.g., on the deployment configuration. To overcome these limitations, we propose an original combination of three dependency graphs: (1) a call-level, static dependency graph, following recent state of the art to reduce false positives over package-level graphs; (2) a deployment dependency graph, to enable lateral movement analysis; and (3) an observed runtime interaction graph, to deal with the service-oriented scale. To illustrate our proposal, we executed a case study on a real-life infrastructure for Capture The Flag challenges. Our approach successfully reconstructed the system architecture, then it correctly reported the exploitability of a zip-slip vulnerability.

International audience

To fix bugs or to enhance a software system without service disruption, one has to update it dynamically during execution. Most prior dynamic software updating techniques require that the code to be changed is not running at the time of the update. However, this restriction precludes any change to the outermost loops of servers, OS scheduling loops and recursive functions. Permitting a dynamic update to more generally manipulate the program's execution state, including the runtime stack, alleviates this restriction but increases the likelihood of type errors. In this paper we present ReCaml, a language for writing dynamic updates to running programs that views execution state as a delimited continuation. ReCaml includes a novel feature for introspecting continuations called match_cont which is sufficiently powerful to implement a variety of updating policies. We have formalized the core of ReCaml and proved it sound (using the Coq proof assistant), thus ensuring that state-manipulating updates preserve type-safe execution of the updated program. We have implemented ReCaml as an extension to the Caml bytecode interpreter and used it for several examples.

In most reflective systems, the model of reflection objects often mirrors (a part of) the metamodel of the system. As a result, reflection is commonly tightly bound to the rest of the system. In this paper, we investigate the loosening of that coupling. With the rise of domain-specific modeling the need for separation of concerns and reuse when designing metamodels become critical. Therefore, we advocate the use of general design patterns abstracting the details of modeling languages when working on cross-cutting concerns (such as reflection) of a metamodel. Once the abstract patterns for reflection are built, they are mapped onto concrete modeling languages thanks to model engineering tools. In this paper, we apply this approach to the fractal component model. Following this process, reflection mechanisms built at the abstract level are straightforwardly reused and the resulting reflection system gains modularity.

In large-scale distributed execution environments such as multicluster systems and grids, resource availability may vary due to resource failures and because resources may be added to or withdrawn from such environments at any time. In addition, single sites in such systems may have to deal with workloads originating from both local users and from many other sources. As a result, application malleability, that is, the property of applications to deal with a varying amount of resources during their execution, may be very beneficial for performance. In this paper we present the design of the support of and scheduling policies for malleability in our Koala multicluster scheduler with the help of our Dynaco framework for application malleability. In addition, we show the results of experiments with scheduling malleable workloads with Koala in our DAS multicluster testbed.

Since the concept of grid computing has emerged; one of the major challenges consists in making applications able to benefit efficiently from the huge amount of resources with out burdening the developer. Observing that grid computing environments are dynamic, adaptability has been proposed as a way to tackle this problem. Adaptability is in deed the ability of applications to modify themselves according to their actual environment. It guarantees that they continuously behave in the best possible way despite environmental changes. In the context of grid computing, environmental changes concern mostly processor and network availability because of resource sharing between applications, administrative tasks and failures

As grid architectures provide execution environments that are distributed, parallel and dynamic, applications require to be not only parallel and distributed, but also able to adapt themselves to their execution environment. This article presents a model for designing self-adaptable parallel components that can be assembled to build applications for grid. This model includes the definition of a consistency criterion for the dynamic adaptation of SPMD components. We propose a solution to implement this criterion. It has been evaluated on both synthetic and real codes to exhibit the behavior of the several proposed strategies