PI: Vasia Kalavri (BU)

Project Description  

Graph Neural Networks (GNNs) have recently delivered breakthrough performance in several large-scale, real-world applications, such as recommendation, online advertising, and fraud detection [1, 2]. These successes highlight GNNs’ unique ability to integrate structural and feature information to efficiently learn complex, multi-hop patterns of large-scale graphs. In this proposal, we aim to investigate how graph-ML advances could be leveraged to enable security monitoring in cloud-native microservice environments. We believe that GNNs can provide stronger defenses by capturing complex attacks that go beyond established signature-oriented intrusion detection and offline analysis on graph snapshots. 

We propose developing a real-time GNN inference system for detecting anomalous inter-service behaviors of microservice applications as they occur. Our system will model the evolving mesh of RPC/HTTP calls between containers as a dynamic graph, where nodes represent pods or services and edges represent communication events, and augment pre-trained GNNs with real-time multi-hop context. Our hypothesis is that an attacker who attempts to reach sensitive data creates structural fingerprints, such as unusual two- or three-hop paths and bursts of calls to rarely accessed endpoints. While conventional per-flow rules or statistical monitors may not easily detect such anomalies, GNNs excel at modeling and classifying such traversal patterns. Scoring the resulting request subgraphs in real time will enable automatic detection of compromised components, preventing attackers from escalating privileges or exfiltrating data. 

Approach/Research Methods

Microservice architectures naturally form graphs whose structure and attributes encode both normal application logic and adversarial activity. A service dependency graph encodes application structure and communication patterns between services. When deployed on a service mesh, like Istio, telemetry data can be used to construct a corresponding temporal request graph that captures timestamped messages as they flow from one service to another. If services are instrumented with tracing tools, we can further retrieve the causal execution graph, containing precise activity durations, delays, and effects.  

A core technical challenge lies in efficiently constructing context-rich request graphs for accurate inference from diverse sources, such as telemetry collectors, message buses, and graph databases. For example, envoy sidecars may emit spans into Kafka, a Flink job writes calls into a graph DB, another job samples neighborhoods and pushes feature vectors into a feature store, and a PyG cluster pulls those vectors for GNN-based inference. While such a pipeline is straightforward to assemble from existing components, each hand-off introduces serialization and network overhead, while cross-system result freshness is difficult to maintain. Consequently, end-to-end inference latency can stretch into seconds or more, which is inadequate for isolating a compromised pod before it causes harm. 

To realize sub-second anomaly scoring on dynamic microservice-call graphs, we will implement the entire GNN inference flow, from raw telemetry to anomaly score, as a single stateful streaming dataflow pipeline. Every incoming RPC or HTTP event directly updates the underlying graph representation and triggers on-demand k-hop neighborhood fetches. Each sampled subgraph is then immediately fed into a lightweight inductive GNN operator that has access to the latest model parameters. By owning every layer of the stack, we can guarantee that multi-hop neighborhoods are fetched with low latency, inference requests can be grouped into adaptive micro-batches to fully utilize GPU workers, and model updates and graph updates are coordinated transactionally with event-time watermarks, so no event is ever scored against a stale model or missing edge.  

Our proposed solution delivers three key benefits: (i) it collapses multi-system orchestration into a single, easy-to-deploy pipeline, dramatically reducing maintenance and integration cost, (ii) it leverages streaming features, such as watermarks, windowing, and fault-tolerant state, to ensure that anomaly scores always reflect the latest graph structure and traffic patterns, even in the face of network delays or failures, and (iii), it ensures truly real-time defense: as soon as a container deviates from its learned communication neighborhood, the system can quarantine it in milliseconds, shrinking the attack window.  

Milestones for the current proposed year

The goal for the first year is to establish infrastructure, complete a reference implementation, and conduct a feasibility study. Milestones are organized into four quarterly phases: 

• Q1: Deploy an instrumented Kubernetes testbed with benchmark microservice applications; set up automated telemetry collection under normal and synthetically injected attack workloads.  
• Q2: Implement core streaming dataflow operators: temporal graph construction, k-hop neighborhood sampling, and streaming GNN inference with GPU micro-batching.
• Q3: Integrate and evaluate the end-to-end pipeline on collected data and public datasets; target sub-second anomaly scoring.
• Q4: Release open-source prototype with deployment scripts; publish technical report. 

Success criterion: A working end-to-end pipeline achieving sub-second GNN-based anomaly scoring on a real Kubernetes testbed. 

Anticipated Deliverables

Year 1: Reference implementation, testbed data collection infrastructure, open-source release, and evaluation report on latency and detection accuracy. 

Year 2: GNN models trained on real testbed data; collaboration with industry partners to simulate and characterize attack patterns not covered by public datasets; continual learning extensions; paper submission to a top systems or security venue. 

Year 3: Full evaluation including detection accuracy, false-positive rates, and adversarial robustness; production validation with member companies; complete open-source release; paper submission; collaboration with industry partners to validate the system in or near production-like Kubernetes and service-mesh environments. 

Research areas of expertise needed for project success

Prior work and PI qualifications. The PI’s expertise lies in performance optimization for graph processing systems [3-6], and in designing and building large-scale stream processing systems [7-9]. This project bridges these two areas and additionally builds on our recently published work on scalable GNN sampling [10, 11], streaming GNN inference and continual training [12, 13], and streaming graph partitioning via GNNs [14]. The PI has long experience with technology transfer and has been an active contributor to open-source projects, including serving as a committer and PMC member of Apache Flink since 2015. Some of her contributions include leading the development of Flink’s graph processing library as part of her PhD thesis work, prototyping Flink’s streaming SQL query optimizer and API, developing the DS2 controller model, which underpins Flink’s Kubernetes auto-scaling operator, and co-authoring the “Stream Processing with Apache Flink” book [15].  

Project viability. This proposal builds on our ongoing research effort to develop HoloStream, a next-generation stream processing engine tailored to stateful AI applications, such as GNN and LLM inference pipelines, which require multi-hop context retrieval at inference time. HoloStream, developed in Go from the ground up, introduces two unique capabilities: (i) efficient multi-hop and multi-source context retrieval at inference time, supporting neighborhood structure and feature lookups for GNNs, and (ii) transparent computation offloading to hardware accelerators. In contrast to existing stream processing systems, like Apache Flink, which couple KV state with local compute, HoloStream’s state abstraction enables workload-aware customization and targeted specialization. This proposal will extend HoloStream to natively support real-time GNN inference for graph anomaly detection, by adding temporal neighborhood sampling, feature retrieval operators, and seamless Kubernetes integration. 

Potential Member Company Benefits

If successful, the project has the potential to enable detection of sophisticated threats that evade existing rule-based approaches, not only improving detection accuracy and responsiveness, but also serving as a foundation for next-generation graph-based analytics workflows.  

For industry partners, the project has the potential to deliver the following concrete benefits: 

• Early access to advanced threat detection: Identify sophisticated, multi-hop attacks that evade existing rule-based and signature-based approaches. 
• Native integration with production infrastructure: The system will be designed for Kubernetes and service-mesh environments, making it directly applicable to managed platforms and security offerings.
• Independent hardware benchmarks: As a natural byproduct of system evaluation, partners will gain independent benchmark data on GPU and storage performance under real AI-driven security workloads. 

It is our key objective to establish a long-term collaboration with the industry partners, leading to joint publications, research visits, and student internships. 

References 

[1] Zheng, D., Song, X., Zhu, Q., Zhang, J., Vasiloudis, T., Ma, R., Zhang, H., Wang, Z., Adeshina, S., Nisa, I. and Mottini, A., 2024, August. GraphStorm: all-in-one graph machine learning framework for industry applications. In Proceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining (pp. 6356-6367). 

[2] Dwivedi, V.P., Joshi, C.K., Luu, A.T., Laurent, T., Bengio, Y. and Bresson, X., 2023. Benchmarking graph neural networks. Journal of Machine Learning Research, 24(43), pp.1-48. 

[3] Abbas, Z., Kalavri, V., Carbone, P. and Vlassov, V., 2018. Streaming graph partitioning: an experimental study. Proceedings of the VLDB Endowment, 11(11), pp.1590-1603. 

[4] Besta, M., Fischer, M., Kalavri, V., Kapralov, M. and Hoefler, T., 2019. Practice of streaming processing of dynamic graphs: Concepts, models, and systems. arXiv preprint arXiv:1912.12740. 

[5] Kalavri, V., Vlassov, V. and Haridi, S., 2017. High-level programming abstractions for distributed graph processing. IEEE Transactions on Knowledge and Data Engineering, 30(2), pp.305-324. 

[6] Kalavri, V., Simas, T. and Logothetis, D., 2016. The shortest path is not always a straight line: leveraging semi-metricity in graph analysis. Proceedings of the VLDB Endowment, 9(9), pp.672-683.

 [7] Mei, Y., Xia, R., Lan, Z., Hu, K., Huang, L., Carbone, P., Lei, Y., Kalavri, V., Yin, H. and Wang, F., 2025. Disaggregated State Management in Apache Flink® 2.0. Proceedings of the VLDB Endowment, 18(12), pp.4846-4859. 

[8] Kalavri, V., Liagouris, J., Hoffmann, M., Dimitrova, D., Forshaw, M. and Roscoe, T., 2018. Three steps is all you need: fast, accurate, automatic scaling decisions for distributed streaming dataflows. In 13th USENIX Symposium on Operating Systems Design and Implementation (OSDI 18) (pp. 783-798). 

[9] Wang, Y., Huang, L., Wang, Z., Kalavri, V. and Matta, I., 2025, March. CAPSys: Contention-aware task placement for data stream processing. In Proceedings of the Twentieth European Conference on Computer Systems (pp. 654-670). 

[10] Chen, Q., Song, Y., Martinez, M. and Kalavri, V., 2025, July. RingSampler: GNN sampling on large-scale graphs with io_uring. In Proceedings of the 17th ACM Workshop on Hot Topics in Storage and File Systems (pp. 52-60). 

[11] Song, Y., Chen, P.H., Lu, Y., Abrar, N. and Kalavri, V., 2024, June. In situ neighborhood sampling for large-scale GNN training. In Proceedings of the 20th International Workshop on Data Management on New Hardware (pp. 1-5). 

[12] Perini, M., Ramponi, G., Carbone, P. and Kalavri, V., 2022, April. Learning on streaming graphs with experience replay. In Proceedings of the 37th ACM/SIGAPP symposium on applied computing (pp. 470-478). 

[13] Shami, N.A. and Kalavri, V., 2025, June. Bridging GNN Inference and Dataflow Stream Processing: Challenges and Opportunities. In Proceedings of the 8th Joint Workshop on Graph Data Management Experiences & Systems (GRADES) and Network Data Analytics (NDA) (pp. 1-10).

 [14] Zwolak, M., Abbas, Z., Horchidan, S., Carbone, P. and Kalavri, V., 2022, June. GCNSplit: bounding the state of streaming graph partitioning. In Proceedings of the Fifth International Workshop on Exploiting Artificial Intelligence Techniques for Data Management (pp. 1-12). 

[15] Hueske, F. and Kalavri, V., 2019. Stream processing with Apache Flink: fundamentals, implementation, and operation of

PI: Manuel Egele (BU) & William Robertson (NEU)

Project Description (including goals and objectives): 

A system’s Unified Extensible Firmware Interface (UEFI) code is executed immediately upon startup. Replacing much of the legacy BIOS functionality, UEFI’s execution model comprises a number of phases including the Driver Execution Environment (DXE) and Run Time (RT) phases. Since UEFI code, particularly DXE modules, execute before the operating system kernel is launched, these components execute with high privilege (ring -2 on x86). The same applies to SMI handling code that executes during the runtime phase. Therefore, bugs and vulnerabilities in UEFI code give rise to powerful security exploits that have the capability to undermine the integrity of any security layers built on top including secure boot (e.g., CVE-2021-3971 & CVE-2021-3972) and OS-provided security mechanisms (e.g., unprivileged user-space applications). 

To shore up the security foundations that UEFI provides in modern systems, we propose the DARE (DXE Attack-surface Reduction and Emulation) project which comprises the research and development thrusts necessary to improve the security of UEFI firmware along two complementary and synergistic axes – vulnerability prevention and vulnerability detection. 

In the first thrust, a static analysis approach will identify modules and functions that are not necessary for the correct operation of a given system and remove that code from the UEFI firmware image. This reduces the attack surface that adversaries can exploit, reducing the trusted computing base, and therefore increases the bar for attackers. In short; vulnerabilities in code that no longer exists on the target are by definition not exploitable. 

The second thrust develops novel dynamic program analysis capabilities that allow us to analyze UEFI code for bugs and vulnerabilities in an automated manner. Leveraging fuzzing and concolic execution paradigms DARE’s bug and vulnerability finding capabilities enable developers to pro-actively identify and fix bugs and vulnerabilities in their UEFI firmware modules. 

The synergistic nature of this design becomes apparent through the interactions that these two thrusts enable. For example, the static analysis can inform the fuzzer which areas of code to focus on and the fuzzer can help further narrow down the code that is actually required in a given deployment. 

In summary, by combining vulnerability prevention and vulnerability detection approaches, DARE will improve the security of the critical high-privilege UEFI software framework.

Approach/Research Methods: 

To execute the vulnerability prevention thrust, DARE takes a given UEFI firmware image and a target system deployment profile as inputs to perform static program analysis, with the goal to eliminate unneeded code at the function level. DARE first constructs a call graph for each DXE module, identifying the function pointers installed for each protocol and defining these entry points as “root nodes.” Following this intra-module analysis, we perform a reachability analysis to identify all code reachable from these root nodes. By establishing directed edges between “consumer” module function nodes (which request a specific UEFI protocol) and their respective “provider” root nodes (which supply and implement those protocols), we construct a global Consumer-Provider Graph (CPG) that captures the interconnected execution flow of the DXE modules. The novelty of this approach is in its fine-grained, function-level granularity and its scalable, static nature. Current state-of-the-art methods rely on unscalable, trial-and-error module removal and dynamic boot testing, and operate with coarse module granularity. DARE leverages the CPG and the deployment profile to statically identify the necessary root nodes and required code for a given hardware configuration. Subsequently, DARE disables extraneous code by overwriting it with invalid instructions. The output is a functionally equivalent UEFI firmware image with a reduced code footprint, smaller attack surface, and trusted computing base (TCB), and the guarantee that vulnerabilities in removed code can no longer be exploited by adversaries. 

For the vulnerability detection thrust, DARE proposes a full DXE phase emulation framework enabling dynamic program analysis. Current SOTA approaches attempt to emulate modules in isolation, which is misaligned with the DXE phase’s interactive consumer-provider architecture. Because a module’s execution crucially relies on protocols provided by other modules, DARE will identify and resolve module dependencies by loading modules in the correct order. To this end, DARE introduces the novel capability of full DXE phase emulation. Specifically, DARE will advance SOTA emulation capabilities by developing a framework equipped with a custom DXE dispatcher. Given a firmware image as input, DARE will load and initialize the DXE modules in their correct order, mirroring the physical boot process. By managing the UEFI system table and corresponding underlying data structures, DARE will expose the DXE phase to security research, enabling the effective application of coverage-guided fuzzing and concolic execution for DXE modules. As a demonstration of this full-system emulation capability, DARE will target Non-Volatile Random-Access Memory (NVRAM) variables. NVRAM is an attractive attack surface as prior work already identified numerous vulnerabilities in (stand-alone) DXE modules that parse and interpret NVRAM values insecurely. By combining inter-module analysis with NVRAM access, DARE can fuzz multiple DXE modules that form complex execution paths. Ultimately, the output of this dynamic analysis—reproducible crashes and identified vulnerabilities—will be reported directly to platform vendors (e.g., Lenovo, Cisco), system integrators (e.g., SHI), and other relevant entities for remediation. 

Milestones for the current proposed year: 

• Obtain UEFI firmware images (min 10) & extract DXE modules 
• Create analysis capability to annotate DXE modules as Producers & Consumers with protocols 
• Generate CPG & analysis capability to determine reachability
• Prototype for DXE module loader & dispatcher in fuzzing setup 

Anticipated Deliverables:

• Y1: Automated static analysis capability that, based on a UEFI Firmware image, creates a CPG and determines code reachability rooted at each protocol-handler (i.e., provider)
• Y1: Attack surface reduction based on expert-provided deployment profiles
• Y1: Initial fuzzing prototype supporting DXE module dependencies and loading, ideally a small number of bugs and vulnerabilities arising from early NVRAM fuzzing campaigns
• Y2: Infer deployment profile semi-automatically. Instead of relying on experts, collect necessary information from the running system
• Y2: Scale fuzzing to large-scale, and design and incorporate concolic execution (CE) capability
• Y3: Fully automated end-to-end attack surface reduction capability evaluated at scale
• Y3: Create feedback mechanisms between CE and fuzzer, and between the dynamic and static analysis capabilities 

Research areas of expertise needed for project success:

• Software & Systems security
• Program analysis (static and dynamic)
• Software reverse engineering (UEFI code is frequently binary-only)
• Computer systems 

Potential Member Company Benefits: 

Customers of platform vendors (e.g., Lenovo, CISCO) and system integrators (SHI) expect that the purchased products satisfy security requirements and that vendors offer and perform security maintenance. The attack surface reduction aspects of DARE result in UEFI-images that are custom-tailored to a given system deployment. This obviates the need to fix and address security vulnerabilities in code that got removed during the analysis, reducing vendor time and effort to create, maintain, and install patched UEFI firmware on large fleets of systems. Similarly, the vulnerability detection capabilities within DARE allow vendors to proactively look for and fix identified bugs and security vulnerabilities. This allows vendors to stay a step ahead of attackers that seek to exploit vulnerabilities for their nefarious purposes.

PI: Manos Athanassoulis (BU)

Project Description (including goals and objectives): 

Modern cloud storage is built around immutability: data is written once, compacted periodically, and never updated in place. This design, embodied by LSM-based storage engines deployed at datacenter scale, is highly efficient for ingestion; however, it treats deletion as an afterthought. When a record is deleted, a tombstone is inserted to logically invalidate it, but the underlying bytes persist indefinitely, waiting for a compaction event that may never arrive on any predictable schedule. At scale, this creates three compounding problems: wasted storage capacity, increased write amplification as invalid data is repeatedly recompacted, and degraded read performance as queries must filter growing volumes of stale entries. Most critically, it creates a privacy and compliance debt: deleted data is not persistently purged on any guaranteed timeline, directly conflicting with regulations such as GDPR, CCPA, and a growing body of US state privacy laws that mandate persistent deletion within fixed windows (typically 30–60 days).

This project proposes a QoS-driven deletion stack for cloud storage that treats deletion as a first-class system contract rather than a background side effect. We will develop new compaction routines that enforce multiple deletion service classes, for example, “purge within 1 hour / 24 hours / 7 days”, while minimizing disruption to read and write performance. We will build the first end-to-end system offering deletion observability and compliance-by-design by: (1) extending SQL with retention and deletion deadline semantics; (2) building storage engine and catalog integration to track and enforce these contracts throughout the system; and (3) co-designing delete-aware compaction with the filesystem and device layer, including TRIM, Zoned Namespace (ZNS) SSDs, and Flexible Data Placement (FDP), where managing deletion deadlines in tandem with zone resets and data placement decisions can eliminate redundant data movement and dramatically reduce garbage collection overhead.

The outcome is a cloud storage stack where applications can declare deletion SLAs, the storage engine enforces them, compliance can be audited at every layer, and the underlying hardware is used more efficiently. Beyond regulatory compliance, this approach improves resource utilization and system performance under delete-heavy workloads, benefiting any data-intensive deployment at cloud scale.

Approach/Research Methods: (These thrusts correspond to the full duration of three years)                                               

Thrust 1: Delete-Aware Compaction with Multiple Service Classes. We will augment tombstone metadata to carry explicit deletion deadlines and extend file-level metadata so every file tracks all deadlines it must satisfy. Compaction scheduling will be driven by both level saturation and imminent deadline expiration, prioritizing files with time-critical tombstones without triggering unnecessary full-tree compactions. We will also extend this framework to range tombstones, which present additional complexity in deadline tracking across key ranges. We will also systematically address the well-known read performance penalty of tombstone-heavy workloads, developing tombstone-aware filter management and compaction policies that reduce the overhead imposed by non-negligible delete fractions.

Thrust 2: End-to-End Compliance Infrastructure and Observability. We will extend SQL parsers to support deletion timeliness semantics (associating deadlines with DELETE statements and retention durations with INSERT statements) and integrate these contracts into the database catalog and storage engine. A core contribution is deletion observability through structured logging: we record the time each tombstone enters the system and the time it reaches the last LSM level and physically purges all matching data. This log provides a provable, auditable compliance record that no current production system offers. We will build an end-to-end prototype targeting PostgreSQL and RocksDB/MyRocks and evaluate it along two dimensions: (a) performance analysis measuring delete persistence latency, throughput, and space/write amplification; and (b) a user study assessing the usability and expressiveness of the proposed SQL extensions with database developers and administrators.

Thrust 3: Retention-Based Deletion. Retention-based deletion requires a different approach from on-demand deletion. When arbitrary per-row retention durations are permitted, we physically organize data by expiration timestamp, clustering entries that expire together into contiguous pages so that large fractions of expired data can be dropped without reading. When retention is uniform across groups of rows, we propose a partitioned compaction strategy that organizes each LSM level in a weaved fashion on both the sort key and the expiration attribute, enabling entire pages or files to be dropped at retention expiry without rewriting their contents.

Thrust 4: Hardware-Conscious Deletion via ZNS and FDP Co-Design. We will co-design deletion-aware compaction with zone management on Zoned Namespace (ZNS) SSDs and Flexible Data Placement (FDP) devices. Files containing tombstones with imminent deadlines will be directed to dedicated zones that reset together once all tombstones are persisted, avoiding rewriting of valid data alongside expired data. Under FDP, placement hints derived from deletion deadlines will direct data with similar expiration profiles to the same placement groups, reducing cross-placement garbage collection. The result is a system in which the database’s deletion schedule and the device’s zone management operate in concert, minimizing redundant data movement and device wear.

 Milestones for the current proposed year: 

• Design tombstone support for multiple deadlines by identifying the minimal metadata needed
• Implement and validate deadline-driven compaction scheduling for both point tombstones
• Extend the MySQL SQL parser for timely deletion threshold (and build infrastructure for retention)
• Implement structured logging for tombstones in RocksDB to enable auditable guarantees
• Benchmark with data management and cloud benchmarks augmented with deletes
• Interact with industry partners to evaluate the current challenges and needs regarding deletion
• Perform a user-stury on the proposed SQL extensions
• Submit a paper to a top venue (e.g., ACM SIGMOD, VLDB)

Anticipated Deliverables: 

• Open-source implementation of deletion-aware compaction policies in RocksDB
• Open-source extension of MyRocks SQL parser to support expressive deletion requirements
• Open-source LSM/ZMS co-design through the ConfZNS++ storage emulator 
• A structured compliance framework that is applicable to all LSM systems
• An augmented benchmark that targets workloads with deletion

Research areas of expertise needed for project success: 

• Storage engine internals (LSM-trees, B+-trees, compaction); 
• database query language design and parsing; 
• SSD/flash storage architecture; 
• data privacy regulation analysis; 
• systems benchmarking and workload characterization.

Potential Member Company Benefits: 

• Everpure (formerly Pure Storage) must meet growing customer demand for GDPR/CCPA-compliant data lifecycle management, and has recently expanded its mission from storage hardware toward data management and governance. Research on SSD-conscious and device-level deletion maps directly onto Everpure’s goals for reducing write amplification and extending device lifetime while enabling verifiable compliance guarantees for customers. 
• Cisco is contractually obligated under its Data Processing Agreements to persistently delete customer data on demand. Cisco’s own 2025 Data Privacy Benchmark Study found that 96% of organizations believe privacy investment returns outweigh costs. Deletion-aware storage engine techniques and SQL extensions developed here are directly relevant to the database infrastructure underpinning Cisco’s cloud services. 
• Red Hat officially packages and supports MySQL and PostgreSQL across RHEL 8, 9, and 10, and provides certified PostgreSQL operators for OpenShift. Deletion-compliant storage engine improvements developed here translate directly into hardened, regulation-ready versions of these supported database offerings, strengthening Red Hat’s OpenShift data management platform for regulated enterprise customers.
• G-Research operates under UK/EU GDPR and other regulations and has massive time-series and market data workloads, thus, faces retention-based deletion. The proposed research directly addresses the need to purge aged financial datasets efficiently without full-database reorganizations or latency spikes.
• Lenovo, as a major server and storage manufacturer, stands to benefit from research that co-designs SSD garbage collection with database-level compaction, reducing unnecessary writes, extending flash device lifetime, and enabling Lenovo to offer storage platforms with built-in deletion compliance properties. 
• SHI serves customers in healthcare, finance, and government sectors with stringent deletion compliance requirements. This research will produce deletion-compliant database components and design guidelines that directly inform SHI’s advice to customers navigating privacy and deletion regulations.

PI: Ari Trachtenberg (BU)

Project Description (including goals and objectives): 

This project investigates security vulnerabilities arising from shared resources in modern containerized computing environments. Platforms such as Docker and Kubernetes improve efficiency by enabling multiple tenants to share kernel resources, particularly the filesystem page cache. While this design significantly enhances performance and resource utilization, it introduces subtle cross-tenant side-channel and covert-channel attack surfaces that can undermine isolation guarantees.

Prior work by the PI has demonstrated the feasibility of such attacks, but their real-world impact remains unexplored. Current defenses often rely on disabling resource sharing—incurring significant performance and cost overhead.

This project systematically quantifies these risks and develops practical, low-overhead mitigations. Specifically, it will:

• Probe high-bandwidth, noise-resilient covert and side-channel attacks. 
• Assess their effectiveness across workloads, container platforms, and storage systems. 
• Gauge tradeoffs among performance, resource efficiency, and security. 
• Engineer deployable mitigations that strengthen isolation while preserving performance.

Approach/Research Methods: 

• The project integrates systems experimentation, attack design, and performance analysis in realistic deployments:
• Characterize shared page-cache behavior across workloads, configurations, and container platforms. 
• Adapt attack techniques to remain robust under eviction dynamics and system noise. 
• Compare behavior across runtimes, orchestration systems, and storage backends. 
• Harden systems via prototype mitigations (cache partitioning, eviction control, access obfuscation). 
• Evaluate scalability and reliability in multi-tenant environments. 
• Study security–performance tradeoffs to guide practical deployment.

 Milestones for the current proposed year: 

• Increase covert-channel bandwidth and robustness under realistic conditions.
• Expand side-channel attacks to a broader range of applications and workloads.
• Perform cross-platform evaluation of shared-resource vulnerabilities.
• Initiate development of mitigation techniques.

Anticipated Deliverables: 

• Demonstration of high-bandwidth covert channels and fine-grained side-channel attacks.
• Comprehensive evaluation of cross-tenant leakage across platforms.
• Prototype mitigation strategies with quantified performance overhead.
• Deployment guidelines for secure configuration of shared resources.
• Publications in leading security and systems venues.

Research areas of expertise needed for project success: 

• Systems security 
• Operating systems 
• Cloud computing and virtualization 
• Filesystems and storage systems

Potential Member Company Benefits: 

• More clarity on cross-tenant information leakage risks in shared-resource environments.
• Optimized mitigation strategies that improve isolation without significantly degrading performance.
• Near-term practical solutions compatible with existing container platforms and infrastructure.
• Enhanced guidance for balancing efficiency and security in multi-tenant system design.
• Yielding improved trust in containerized and cloud-native infrastructures.

PI: Peter Desnoyers (NEU)

Project Description (including goals and objectives): 

High-efficiency approaches to basic data storage abstractions (object, virtual disk, file) to deliver NVMe-level performance to user applications at acceptable capital cost.

Continuation of prior work [Socc25] using light-weight communication for consistency and coordination on top of direct access to single-device backend logs.

Approach/Research Methods: 

I/O and message efficiency: existing highly-layered approaches result in (a) high I/O amplification (up to 17x [Lee17]), wasting device IOPS, and (b) high message counts and resulting CPU overhead

Separation of coordination and storage: independent per-device logs eliminate overhead due to serialization of storage operations; lightweight (e.g. eRPC) communication allows in-memory ordering/consistency in real-time; logged metadata allows recovery when necessary.

NVMe-oF: all internal storage operations use NVMe-oF with functional extensions added in SPDK-based NVMe-oF to PCIe target bridge.

Milestones for the current proposed year: 

• Shared log extensions to SPDK NVMe-oF target (“ZNS-ish”)
• HW, SW testbed establishment
• Performance validation of selected HW/SW and design choices
• Demonstration, benchmarking of prototype

Anticipated Deliverables: 

• Virtual disk proof-of-concept; goals:
  • Performance – comparable to low-end local NVMe
  • Efficiency – total CPU < high-IOPS application
  • Memory << application
• Specific deliverables subject to IAB guidance

Research areas of expertise needed for project success: 

• General domain expertise (use cases and requirements)
• SPDK, DPDK, NVMe-oF
• Consistency semantics

Potential Member Company Benefits: 

• Open strategies and algorithms for high-performance storage systems
• I/O acceleration on general-purpose compute without dedicated special-purpose hardware