The digitalization of public and private services has led to more sophisticated and serious cybersecurity threats. Among them, SQL injection attacks leverage user inputs to remotely execute malicious actions on a database, such as data exfiltration and deletion, or privilege escalation. They are regularly classified as one of the most prominent threats to web services. Intrusion detection systems are widely used to detect such injection attacks and react to them, but it is difficult to assess their actual effectiveness and compare them because of a lack of high-quality datasets. Current SQL injection detection datasets lack diversity, are poorly documented, and the generated samples are not representative of real-world infrastructures. This article presents a new dataset (The dataset is available at: https://zenodo.org/records/17086037 ). Whose design is structured around four quality dimensions: realism, diversity, benchmarking capabilities and the presence of good documentation. We examine the dataset diversity using lexical, syntactic and semantic metrics, and demonstrate that its size is sufficient to evaluate data-intensive detectors. Finally, we provide nine classical and state-of-the art SQL injection detection pipelines as baselines for future works.

Intrusion Detection Systems (IDS) are common security tools for protecting modern information systems, yet their effectiveness at detecting application-layer attacks is often limited by the semantic gap between low-level host or network observations and the actual behavior of applications. Existing work overlooks the data collection phase and typically focuses on designing complex decision engines and preprocessing functions such as embedding-based representations. Unfortunately, these approaches incur significant computational overhead at inference time and remain brittle against adversarial inputs. In this paper, we present a parser-based instrumentation approach for application-level intrusion detection that provides lexical, syntactic and explicit semantic observation with minimal overhead. We introduce gaur, an implementation for instrumenting parsers, it produces observations during parsing by associating semantic tags to grammar rules, eliminating the need for runtime natural language processing. Our evaluation demonstrates the low overhead and collection time of our data collector. Furthermore, empirical results show that incorporating explicit semantic information into decision engines not only improves detection performance over traditional mechanisms but also enables faster inference and greater robustness than approaches relying on implicit semantic representations.

Cyberattacks are becoming increasingly frequent and sophisticated, often exploiting the software supply chain (SSC) as an attack vector. Attack graphs provide a detailed representation of the sequence of events and vulnerabilities that could lead to a successful security breach in a system. MulVal is a widely used open-source tool for logical attack graph generation in networked systems. However, its current lack of support for capturing and reasoning about SSC threat propagation makes it unsuitable for addressing modern SSC attacks, such as the XZ compromise or the 3CX double SSC attack. To address this limitation, we propose an extension to MulVal that integrates SSC threat propagation analysis with existing network-based threat analysis. This extension introduces a new set of predicates within the familiar MulVal syntax, enabling seamless integration. The new facts and interaction rules model SSC assets, their dependencies, interactions, compromises, additional security mechanisms, initial system states, and known threats. We explain how this integration operates in both directions and demonstrate the practical application of the extension.

Energy-harvesting embedded systems, like sensors and medical implants, must satisfy real-time constraints under strict energy limitations. Traditional schedulers, which prioritize timing over energy, often fail to produce valid schedules, particularly for non-preemptive task models. We introduce HELIOS, a lightweight, table-driven scheduler that treats timing and energy as joint first-class constraints while supporting limited-preemptive execution. HELIOS introduces energy readiness, ensuring jobs execute only when both temporal and energy conditions are met. The scheduling problem is formulated as an integer linear programming (ILP) problem, jointly optimizing task ordering, preemption points, and execution under energy constraints. By leveraging non-preemption and energy readiness, HELIOS maintains complexity proportional to job count. A key innovation is the use of worst-case energy footprints to guarantee safe execution via an energy readiness threshold. The table-driven runtime ensures compatibility with resource-constrained kernels. Experiments demonstrate that HELIOS achieves higher schedulability than priority-based baselines.

Developers gain productivity by reusing readily available Free and Open Source Software (FOSS) components. Such practices also bring some difficulties, such as managing licensing, components and related security. One approach to handle those difficulties is to use Software Bill of Materials (SBOMs). While there have been studies on the readiness of practitioners to embrace SBOMs and on the SBOM tools ecosystem, a large scale study on SBOM practices based on SBOM files produced in the wild is still lacking. A starting point for such a study is a large dataset of SBOM files found in the wild. We introduce such a dataset, consisting of over 78 thousand unique SBOM files, deduplicated from those found in over 94 million repositories. We include metadata that contains the standard and format used, quality score generated by the tool sbomqs, number of revisions, filenames and provenance information. Finally, we give suggestions and examples of research that could bring new insights on assessing and improving SBOM real practices.

Intrusion Detection Systems (IDS) are essential tools to protect network security from malicious traffic. IDS have recently made significant advancements in their detection capabilities through deep learning algorithms compared to conventional approaches. However, these algorithms are vulnerable to meta-attacks, also known as adversarial evasion attacks, which are attacks that improve already existing attacks, specifically their ability to evade detection. Deep learning-based IDS, in particular, are particularly susceptible to adversarial evasion attacks that use Generative Adversarial Networks (GAN). Nonetheless, well-known strategies have been proposed to cope with this threat. However, these countermeasures lack robustness and predictability, and their performance can be either remarkable or poor. Such robustness issues have been identified even without adversarial evasion attacks, and mitigation strategies have been provided. This paper identifies and formalizes threats to the robustness of IDSs against adversarial evasion attacks. These threats are enabled by flaws in the dataset’s structure and content rather than its representativeness. In addition, we propose a method for enhancing the performance of adversarial training by directing it to focus on the best evasion candidates samples within a dataset. We find that GAN adversarial attack evasion capabilities are significantly reduced when our method is used to strengthen the IDS.

The use of free and open source software (FOSS) components in all software systems is estimated to be above 90%. With such high usage and because of the heterogeneity of FOSS tools, repositories, developers and ecosystem, the level of complexity of managing software development has also increased. This has amplified both the attack surface for malicious actors and the difficulty of making sure that the software products are free from threats. The rise of security incidents involving high profile attacks is evidence that there is still much to be done to safeguard software products and the FOSS supply chain.Software Composition Analysis (SCA) tools and the study of attack trees help with improving security. However, they still lack the ability to comprehensively address how interactions within the software supply chain may impact security.This work presents a novel approach of assessing threat levels in FOSS supply chains with the log model. This model provides information capture and threat propagation analysis that not only account for security risks that may be caused by attacks and the usage of vulnerable software, but also how they interact with the other elements to affect the threat level for any element in the model.

Intrusion Detection Systems (IDS) are essential tools to protect network security from malicious traffic. IDS have recently made significant advancements in their detection capabilities through deep learning algorithms compared to conventional approaches. However, these algorithms are susceptible to new types of adversarial evasion attacks. Deep learning-based IDS, in particular, are vulnerable to adversarial attacks based on Generative Adversarial Networks (GAN). First, this paper identifies the main threats to the robustness of IDS against adversarial sample attacks that aim at evading IDS detection by focusing on potential weaknesses in the structure and content of the dataset rather than on its representativeness. In addition, we propose an approach to improve the performance of adversarial training by driving it to focus on the best evasion candidates samples in the dataset. We find that GAN adversarial attack evasion capabilities are significantly reduced when our method is used to strengthen the IDS.

Deep neural network-based Intrusion Detection Systems (IDSs) are gaining popularity to improve anomaly detection accuracy and robustness. Yet, Deep neural network (DNN) models have been shown to be vulnerable to adversarial attacks. An attacker can use a generator, here a Generative Adversarial Network, to alter an attack so that the IDS model misclassify it as normal network traffic. There is a race between adversarial attacks and mechanisms to make robust IDSs, like Adversarial Training. To our knowledge, no study thoroughly assesses how attack generators or IDS training is sensitive to parameters controlling resources spent during training. Such results provide insights on how much to spend on IDS training. This paper presents the outcome of this assessment for GANs vs adversarial training. Interestingly, it shows that GANs’ evasion capabilities are either very good or poor, with almost no average cases. Resources impact the likelihood of obtaining an efficient generator.

Global static scheduling for Mixed Criticality (MC) systems demonstrates excellent results in terms of acceptance ratio and number of preemptions. But, no practical implementation and empirical evaluation have been presented yet for multi-processors systems. Moreover, the new kernel mechanisms it would require have not been studied. In this paper, we present two contributions on the implementation of global static schedulers For MC systems: G-RES, a global table-driven reservations LITMUSRT plugin, and G-MCRES, another LITMUSRT plugin scheduling MC tasks with global table-driven reservations and enforcing safe criticality mode changes. These contributions aim to solve the problems of instantaneous migrations and simultaneous mode changes in the context of global static schedulers. We based our experiments on scheduling tables generated off-line by GMHMC-DAG, a meta-heuristic to schedule multiprocessor systems composed of multi-periodic Directed Acyclic Graphs of Mixed Criticality tasks with multiple criticality levels. The performances are very good w.r.t those of LITMUSRT and consistent with our temporal complexity evaluations.

Recent works on mixed--criticality (MC) scheduling algorithms have produced impressive results in terms of schedulability performances but at the expense of a large number of preemptions. Besides, not all MC scheduling algorithms can handle more than two criticality levels. Thus, current MC scheduling algorithms perform well in one of these three criteria but poorly in the others. For instance, our recent contribution, MxC-RUN, entails a limited number of preemptions but provides average schedulability performances and cannot handle systems with more than two criticality levels. In this paper, we present GMC-RUN, an approach that deeply revisits the main principles of MxC-RUN to address these three criteria. Comparisons with other scheduling algorithms show that GMC-RUN exhibits very good performances concerning schedulability ratio but also impressively low numbers of preemptions. Thanks to the notion of criticality level reduction, GMC-RUN successfully handles systems with any number of criticality levels.

Mixed-criticality systems emerged with the aim of reconciling safety requirements and efficient use of multi-processor or uniprocessor platforms. On multi-processors, recent works on mixed-criticality have produced impressive results in terms of speed-up factor. But these solutions, based on Pfair-like scheduling algorithms, entail too many preemptions and migrations to be effectively used in real systems. As RUN is an optimal scheduling algorithm that is known to limit this problem, we propose MxC-RUN, an adaptation of RUN to mixed-criticality systems. We redefine RUN's primal servers as modal servers that allocate the overestimated time budget of their higher criticality tasks to execute lower criticality ones. These servers can be handled by RUN without any modification and preserve its performances in terms of preemptions and migrations. MxC-RUN earns a speed-up factor smaller than other multi-processors EDF-based mixed-criticality scheduling algorithms.

ARINC 653 systems have to comply with strong requirements with respect to time determinism and resource consumption. However, interacting processes may introduce significant overheads and induce pessimism in schedulability analysis. In this paper, we restrict the ARINC 653 execution and communication models so that a message is delivered as if it was sent at the sender deadline. We take advantage of dedicated inter-partition buffers to provide predictable and efficient implementations for kernel and application suppliers.

The design of hard real-time embedded systems has to comply with strong requirements with respect to time determinism and resource consumption. However, interacting tasks may induce pessimism in schedulability analysis or introduce significant overheads in memory usage. In this paper, we restrict the execution and communication models to enforce an efficient and predictable implementation. To ensure determinism, a message sent by an emitting task is delivered at its deadline. We take advantage of a wait-free specialized message queues to provide predictable and efficient implementation. The integration of such mechanisms is assisted by a model driven engineering framework 1 .

Multicore processors are now considered as relevant candidates for the next generation of Integrated Modular Avionics (IMA) systems. One expected benefit of multicore introduction inside IMA platforms is an increase of the number of avionic applications hosted on a single platform. This can be achieved by deploying several ARINC 653 partitions simultaneously on different cores. However to be certifiable, such an architecture must fulfill many dependability requirements. In this paper we focus on the problem of Worst Case Execution Time (WCET) computation of embedded partitions under the Robust Partitioning constraint. Today's multicore processors internal features make those requirements fulfillment difficult to ensure on the platform for any set of hosted partitions. That comes from the difficulty to characterize with a satisfying confidence the processor behavior when several unknown applications use simultaneously shared hardware resources, such as the main memory. We present in this paper a generic software solution that constrains the use of shared resources to remain inside predefined usage domains for which the processor has a deterministic behavior. We illustrate this approach with a case study based on a COTS processor from the Freescale QorIQ series.

Robust partitioning enforcement is a mandatory requirement in IMA(1) systems. In this paper, we refine this requirement in the context of multicore processors and discuss a strategy to ensure it. We focus on a scenario in which several ARINC 653 partitions hosted on the same platform are executed at the same time on different cores.When this scenario is deployed on modern COTS2 hardware, robust partitioning may be impaired by inter-core conflicts sequences. The issue with such a deployment strategy lies in the isolated parallel execution of several partitions. The approach presented here aims at identifying conditions that entail inter-core conflicts with a sufficient level of detail. This representation helps identifying robust partitioning failure causes. Such information is a first step towards an acceptation of true parallelism in partitioned systems, i.e. deployment on multicores.

AADL is an architecture description language intended for model-based engineering of high-integrity systems. The AADL Behavior Annex is an extension allowing the refinement of behavioral aspects described through AADL. When implementing Distributed Real-time Embedded system, fault tolerance concerns are integrated by applying replication patterns. We considered a simplified design of the primary backup replication pattern to express the modeling capabilities of AADL and its annex. Our contribution intends to give accurate description of the synchronization mechanisms integrated in this example.

AADL is an architecture description language intended for model-based engineering of high-integrity distributed systems. The AADL Behavior Annex (AADL-BA) is an extension allowing the refinement of behavioral aspects described through an AADL architectural description. When implementing Distributed Real-time Embedded system (DRE), fault tolerance concerns are integrated by applying replication patterns. We considered a simplified design of the primary backup replication pattern as a running example to analyze the modeling capabilities of AADL and its annex. Our contribution lies in the identification of the drawbacks and benefits of this modeling language for accurate description of the synchronization mechanisms integrated in this example.

Real-time software applications are in charge of maintaining a timely and predictable interaction with their environment, being it hardware devices, or other software entities. In this paper, we illustrate the use of early error detectors (that we previously described in [1]), generated from timed automata based specifications, in a recovery block-like design pattern. This design pattern is enhanced with our Early Error Detection service that allows triggering as soon as possible error recovery mechanisms.