In this paper, we investigate how attackers can discover sensitive information embedded within databases by exploiting inference rules. We demonstrate the inadequacy of naively applied existing state of the art differential privacy (DP) models in safeguarding against such attacks. We introduce ontology aware differential privacy (Onto-DP), a novel extension of differential privacy paradigms built on top of any classical DP model by enriching it with semantic awareness. We show that this extension is a sufficient condition to adequately protect against attackers aware of inference rules.

We propose a system for marking sensitive or copyrighted texts to detect their use in fine-tuning large language models (LLMs) under black-box access with statistical guarantees. Our method builds digital "marks" using invisible Unicode characters organized into ("cue", "reply") pairs. During an audit, prompts containing only "cue" fragments are issued to trigger regurgitation of the corresponding "reply", indicating document usage. To control false positives, we compare against held-out counterfactual marks and apply a ranking test, yielding a verifiable bound on the false positive rate. The approach is minimally invasive, scalable across many sources, robust to standard processing pipelines, and achieves high detection power even when marked data is a small fraction of the fine-tuning corpus.

The advanced inference capabilities of Large Language Models (LLMs) pose a significant threat to the privacy of individuals by enabling third parties to accurately infer certain personal attributes (such as gender, age, location, religion, and political opinions) from their writings. Paradoxically, LLMs can also be used to protect individuals by helping them to modify their textual output from certain unwanted inferences, opening the way to new tools. Examples include sanitising online reviews (e.g., of hotels, movies), or sanitising CVs and cover letters. However, how can we avoid miss estimating the risks of inference for LLM-based text sanitisers? Can the protection offered be overestimated? Is the original purpose of the produced text preserved? To the best of authors knowledge, no previous work has tackled these questions. Thus, in this paper four design rules (collectively referred to as reteLLMe) are proposed to minimise these potential issues. We validate these rules and quantify the benefits obtained in a given use case – sanitising hotel reviews. We show that up to 76

Due to the rapid proliferation of data online, an important quantity of private or sensitive informations is being stored as linked data in graph databases (e.g., represented as RDF). For such databases to be shared without jeopardizing privacy, they must first undergo a process known as database sanitization. During this process, databases are transformed following graph transformations that are usually described informally or through ad-hoc processes. However, a more thourough formalization of these transformations would aid in analysing the sanitization process, ensuring its correctness, and demonstrating the resulting privacy guarantees. This paper is an effort toward bridging the gap between the rigorous graph rewriting approaches and graph sanitization. We propose a graph transformation language to serve as a basis for constructing various sanitization mechanisms. This language relies on a set of elementary transformation operators formalized using a generic algebraic graph rewriting approach. Our language takes into account semantic and supports the equivalent of WHERE and EXCEPT clauses. As a proof of concept, we use these operators to implement two mechanisms from the literature, one generic (Local Differential Privacy) and one specifically introduced for semantic graph databases (sensitive attribute masking through anatomization). We propose an open-sourced tool implementing the elementary operators and the privacy mechanisms we derive from them relying on the Attributed Graph Grammar System (AGG) and its java API, providing a concrete tool implementing formal graph rewriting mechanisms to sanitize semantic graph databases. We present experimental results on this implementation regarding both proposed schemes and discuss its efficiency and scalability.

The rise of Large Language Models (LLMs) has triggered legal and ethical concerns, especially regarding the unauthorized use of copyrighted materials in their training datasets. This has led to lawsuits against tech companies accused of using protected content without permission. Membership Inference Attacks (MIAs) aim to detect whether specific documents were used in a given LLM pretraining, but their effectiveness is undermined by biases such as time-shifts and n-gram overlaps. This paper addresses the evaluation of MIAs on LLMs with partially inferable training sets, under the ex-post hypothesis, which acknowledges inherent distributional biases between members and non-members datasets. We propose and validate algorithms to create "non-biased" and "non-classifiable" datasets for fairer MIA assessment. Experiments using the Gutenberg dataset on OpenLLaMA and Pythia show that neutralizing known biases alone is insufficient. Our methods produce non-biased ex-post datasets on which MIAs achieve AUC-ROC scores comparable to those previously obtained on genuinely random datasets, validating our approach. Globally, MIAs yield results close to random, with only one Meta-Classifier-based MIA being effective on both random and our datasets, but its performance decreases when bias is removed.

This paper studies how privacy guarantees on relational databases (RDBs) with foreign key constraints can be transposed to Semantic Web (RDF) databases and vice versa. Thus, we consider a Differentially Private (DP) model for RDB related to cascade deletion and demonstrate that it is sometimes similar to an existing DP graph privacy model, but inconsistently so. Consequently, we tweak this model in the relational world to propose a new model called restrict deletion. We show that it is equivalent to an existing DP graph privacy model, facilitating the comprehension, design and implementation of DP mechanisms when mapping of RDB to RDF.

Database sanitization allows to share and publish open (linked) data without jeopardizing privacy. During their sanitization, graph databases are transformed following graph transformations that are usually described informally or through ad-hoc processes. This paper is a first effort toward bridging the gap between the rigorous graph rewriting approaches and graph sanitization by providing basic generic graph rewriting operators to serve as a basis for the construction of sanitization mechanisms. As a proof of concept, we formalize two operators, blank node creation and weighted relation randomization, using an algebraic graph rewriting approach that takes into account semantic through the equivalent of WHERE and EXCEPT clauses. We show that these operators can be used to achieve pseudonymity and local differential privacy. Both operators and all related rewriting rules are implemented using the Attributed Graph Grammar System (AGG), providing a concrete tool implementing formal graph rewriting mechanisms to sanitize semantic graph databases.

Summary Modeling and specifying correct software systems is a challenging task that can be supported by providing appropriate modeling abstractions. This article proposes an approach for graphical multiscale modeling of such systems using model transformation techniques. The approach is founded on a guided rule‐based iterative modeling process ensuring controlled transition from a coarse‐grained description to a fine‐grained description. It provides also user‐friendly graphical descriptions by extension of UML notations, hence preserving the common practices from software architectures design. The iterative design process is supported by a set of model transformation rules. The rules manage the refinement process (by adding or removing subsystems or by adding or removing details on a given subsystem) as a model transformation. Our approach is supported by a rule‐based generator that implements the automatic transformation of UML diagrams into Event‐B specifications allowing formal verification of their correctness properties, and relieving software architects of mastering formal techniques. To experiment and validate our approach, we consider a case study dedicated to the smart cities.

Differential privacy is one of the most popular and prevalent definitions of privacy, providing a robust and mathematically rigid definition of privacy. In the last decade, adaptation of DP to graph data has received growing attention. Most efforts have been dedicated to unlabeled homogeneous graphs, while labeled graphs with an underlying semantic (e.g. RDF) have been mildly addressed. In this paper, we present a new approach based on graph projection to adapt differential privacy to RDF graphs, while reducing query sensitivity. We propose an edge-addition based graph projection method that transforms the original RDF graph into a graph with bounded typed-out-degree. We demonstrate that this projection preserves neighborhood, allowing to construct a differentially private mechanism on graphs given a similar mechanism on graphs with bounded typed-out degree. Experimental and analytical evaluation through a realistic twitter use-case show that this provide up to two orders of magnitude of utility improvement.

Purpose Graph rewriting concerns the technique of transforming a graph; it is thus natural to conceive its application in the evolution of graph databases. This paper aims to propose a two-step framework where rewriting rules formalize instance or schema changes, ensuring graph’s consistency with respect to constraints, and updates are managed by ensuring rule applicability through the generation of side effects: new updates which guarantee that rule application conditions hold. Design/methodology/approach This paper proposes Schema Evolution Through UPdates, optimized version (SetUp OPT ), a theoretical and applied framework for the management of resource description framework (RDF)/S database evolution on the basis of graph rewriting rules. The framework is an improvement of SetUp which avoids the computation of superfluous side effects and proposes, via SetUpoptND , a flexible and extensible package of solutions to deal with non-determinism. Findings This paper shows graph rewriting into a practical and useful application which ensures consistent evolution of RDF databases. It introduces an optimised approach for dealing with side effects and a flexible and customizable way of dealing with non-determinism. Experimental evaluation of SetUpoptND demonstrates the importance of the proposed optimisations as they significantly reduce side-effect generation and limit data degradation. Originality/value SetUp originality lies in the use of graph rewriting techniques under the closed world assumption to set an updating system which preserves database consistency. Efficiency is ensured by avoiding the generation of superfluous side effects. Flexibility is guaranteed by offering different solutions for non-determinism and allowing the integration of customized choice functions.

This paper introduces SetUp, a theoretical and applied framework for the management of RDF/S database evolution on the basis of graph rewriting rules. Rewriting rules formalize instance or schema changes, ensuring graph's consistency with respect to given constraints. Constraints considered in this paper are a well known variant of RDF/S semantic, but the approach can be adapted to user-defined constraints. Furthermore, SetUp manages updates by ensuring rule applicability through the generation of side-effects: new updates which guarantee that rule application conditions hold. We provide herein formal validation and experimental evaluation of SetUp.

Industry includes more and more IoT components to have a better control on production and logistic processes.Unfortunately, growing network openness in a formerly isolated world induces major security risks which are especially critical in an industrial context. These risks are exacerbated by the highly fragmented nature of the industrial IoT market which imposes interoperability management and challenges security.We propose an approach to enable end-to-end data security within a heterogeneous IoT deployment. Interoperability is ensured by a central network powered by oneM2M interacting with various tier protocols. In this paper, we focus on secure communication with ZigBee and discuss how it can be transposed to other protocols, namely Z-Wave and Thread.

This paper investigates the use of graph rewriting rules to model updates-instance or schema changes-on RDF/S databases which are expected to satisfy RDF intrinsic semantic constraints. Such databases being modeled as knowledge graphs, we propose graph rewriting rules formalizing atomic updates whose application transforms the graph and necessarily preserves its consistency. If an update has to be applied when the application conditions of the corresponding rule do not hold, side-effects are generated: they engender new updates in order to ensure the rule applicability. Our system, SetUp, implements our updating approach for RDF/S data and offers a theoretical and applied framework for ensuring consistency when a RDF knowledge graph evolves.

The goal of the SENDUP project is to propose anonymisation mechanisms for data organized as graphs with an underlying semantic. Such mechanisms trig- gers updates on the database. This deliverable presents the update approach and side-effect management techniques defined in SENDUP. We focus on updates -instance or schema changes- on RDF/S databases which are expected to satisfy RDF intrinsic semantic constraints. We model RDF/S databases as type graphs and use graph rewriting rules to formalize updates. Such rules define both the effect of a graph transformation and its applicability conditions. We propose 19 rules modelling atomic updates and prove that their application necessarily preserves the database’s consistency. If an update has to be applied when the application conditions of the corre- sponding rule do not hold, side-effects are generated: they engender new updates in order to ensure the rule applicability. These techniques are implemented in a dedicated software module S1 called SetUp. This deliverable also presents a preliminary experimental validation and evaluation of SetUp.

Industry 4.0 proposes the inclusion of IoT components in industrial contexts to have a better control on production and logistic processes.Unfortunately, growing connectivity in a formerly isolated world induces major security risks which are especially critical in an industrial context. Furthermore, the highly fragmented nature of the industrial IoT market imposes interoperability management. Interoperability and heterogeneity generally poses security challenges, exacerbating these risks.oneM2M is a promising standard that can enable interoperability and ensure communication with various tier protocols. The interface between oneM2M and tiers protocols has however to be trusted, which is undesirable. In this paper, we focus on the first phase of an approach to enable end-to-end encryption between oneM2M and Zigbee devices: secure key exchange. We fully define an exchange protocol taking place during the enrolment of a Zigbee device within oneM2M. We provide and discuss an implementation of this protocol, demonstrating its technical feasibility.

The amount of data produced by individuals and corporations has dramatically increased during the last decades. This generalized gathering of data brings opportunities but also new privacy challenges. Nowadays, data are often organized as graphs with an underlying semantic to allow efficient querying and support inference engines. Such is the case in, for example, linked data and semantic web typically relying on RDF. The SEmantic Networks of Data: Utility and Privacy (SEND UP) project focuses on such databases and will follow two main goals: (1) prevent illegitimate use of private data while querying semantic data graphs and (2) publish useful sensitive semantic data graphs while preserving privacy. Context and goals More and more private information collected: threatening privacy yet useful ⇒ needs for privacy guarantees and utility preservation.

Specifying correct software-intensive Systems of Systems architectures is a challenging research direction requiring new modeling abstractions and techniques. For this purpose, we provide a refinement-based approach for multi-scale description of software architectures. We define an incremental process starting from a coarse-grained description, and leading to a fine-grained description. The refinement process involves both system-independent structural features ensuring the model correctness, and specific features related to the expected behavior of the modeled domain. In this paper, we propose a formal method to represent structural as well as behavioral features of multi-scale architectures. We elaborate a set of refinement rules to build correct-by-design architectures. Features and rules are specified formally in Event-B specifications. We implement these specifications under the Rodin platform and we use the ProB theorem prover to prove specification consistency. In order to illustrate and validate our solution, we experiment our approach with a case study dedicated to the Smart Home System of Systems (SoS).

Specifying correct software-intensive Systems of Systems architectures is a challenging research direction requiring new modeling abstractions and techniques. For this purpose, we provide a refinement-based approach for multi-scale description of software architectures. We define an incremental process starting from a coarse-grained description, and leading to a fine-grained description. The refinement process involves both system-independent structural features ensuring the model correctness, and specific features related to the expected behavior of the modeled domain. In this paper, we propose a formal method to represent structural as well as behavioral features of multi-scale architectures. We elaborate a set of refinement rules to build correct-by-design architectures. Features and rules are specified formally in Event-B specifications. We implement these specifications under the Rodin platform and we use the ProB theorem prover to prove specification consistency. In order to illustrate and validate our solution, we experiment our approach with a case study dedicated to the Smart Home System of Systems (SoS).