It Takes Two to #MeToo - Using Enclaves to Build Autonomous Trusted Systems

Danny Harnik, Paula Ta-Shma, Eliad Tsfadia

Introduction

The "privileged user" threat remains a significant vulnerability in modern cybersecurity. Traditional systems often rely on IT administrators who possess nearly unlimited access to data. While encryption provides a layer of defense, the human element—administrators managing keys or infrastructure—can be compromised through malice, coercion, or external hacking.

This risk is particularly acute for sensitive reporting services, such as those used in the #MeToo movement (e.g., Callisto). These systems typically employ "threshold-based" reporting, where a victim's complaint is only released to authorities if a matching complaint is filed against the same perpetrator. Currently, such systems require "blind trust" in service operators. This paper introduces EConfidante, a system designed to replace human trust with autonomous data management. By leveraging hardware-enforced rules, EConfidante ensures that no human—not even a system administrator—can access raw data unless specific programmatic conditions are met.

System Architecture

EConfidante is built upon three primary pillars designed to ensure data integrity and confidentiality:

  1. Intel SGX (Software Guard Extensions): This technology enables the creation of "Enclaves"—isolated memory regions within the CPU. These enclaves act as "black boxes" where even the operating system or root users cannot inspect the internal state or execution.
  2. Remote Attestation: This process allows the hardware to provide cryptographic proof to users that a specific, untampered version of the code is running within a genuine Intel SGX enclave.
  3. Immutable Ledger (HyperLedger Fabric): To address the "stateless" nature of SGX enclaves (which lose memory upon reboot) and prevent "rollback attacks," the system utilizes a blockchain framework. This ensures that once a complaint is recorded, it cannot be deleted or ignored by an administrator.
Figure 2: The EConfidante system architecture, illustrating the relationship between administrators, the enclave cluster, and the immutable ledger.

To further secure the system, EConfidante implements a Lease Mechanism. To prevent a rogue administrator from launching "shadow" enclaves, the system requires a quorum ($k$ out of $n$ administrators) to issue digital leases. An enclave will only function if it possesses a valid, current lease from the required number of administrators.

Operational Workflow

The authors describe EConfidante as a "truthful robot." It is autonomous, meaning it cannot be influenced by external parties, and robotic, meaning it executes its programmed logic without discretion.

Figure 1: High-level workflow of the EConfidante system, showing record submission and the matching process within secure enclaves.

In the #MeToo use case, the workflow follows these steps:

  • Submission: A user submits a record to a "Submit records" enclave.
  • Storage: The record is encrypted and stored on the immutable ledger.
  • Matching: A "Scanner Agent" inside a separate enclave periodically scans the ledger. If two independent complaints match the same perpetrator, the enclave releases the information.
  • Privacy by Design: To prevent traffic analysis, the scanner produces a fixed-size report regardless of whether a match was found, ensuring observers cannot infer activity from network patterns.

Performance and Results

The authors developed a Proof of Concept (PoC) with a compact, auditable codebase of approximately 1,700 lines within the trusted enclave. Performance benchmarks indicate that the system is practical for sensitive reporting:

  • Setup and Attestation: Takes approximately 3 seconds (one-time cost).
  • Complaint Submission: Latency is roughly 2.8 seconds, which is acceptable for infrequent, high-sensitivity reporting.
  • Matching Scan: A ledger GET request takes about 0.3 seconds.

The system maintains data secrecy even if all administrators are malicious, provided the underlying Intel SGX hardware remains secure.

Limitations and Future Work

While EConfidante significantly reduces the need for human trust, several challenges remain:

  • Hardware Vulnerabilities: SGX has been subject to side-channel attacks (e.g., Spectre). EConfidante is intended as an additional defense layer rather than a total replacement for traditional security.
  • Trusted Time Dependencies: The current lease mechanism relies on Intel's "Platform Services" for trusted time, which is not supported on all CPU models (e.g., certain Xeon E3 processors).
  • Scalability: As the volume of complaints increases, the enclave's memory limits (128MB SGX cache) may lead to performance degradation due to paging.
  • Social Trust: The system protects data but does not eliminate the "first reporter" risk—the social barrier where the first victim must trust that a second will eventually come forward.

Summary updated

Abstract

We provide enhanced security against insider attacks in services that manage extremely sensitive data. One example is a #MeToo use case where sexual harassment complaints are reported but only revealed when another complaint is filed against the same perpetrator. Such a service places tremendous trust on service operators which our work aims to relieve. To this end we introduce a new autonomous data management concept which transfers responsibility for the sensitive data from administrators to secure and verifiable hardware. The main idea is to manage all data access via a cluster of autonomous computation agents running inside Intel SGX enclaves. These EConfidante agents share a secret data key which is unknown to any external entity, including the data service administrators, thus eliminating many opportunities for data exposure. In this paper we describe a detailed design of the EConfidante system, its flow and how it is managed and implemented. Our #MeToo design also uses an immutable distributed ledger which is built using components from a Blockchain framework. We implemented a proof of concept of our system for the #MeToo use case and analyze its security properties and implementation details.
BibTeX
@misc{harnik2018it,
  author = {Danny Harnik and Paula Ta-Shma and Eliad Tsfadia},
  title = {{It Takes Two to \#MeToo - Using Enclaves to Build Autonomous Trusted Systems}},
  year = {2018},
  eprint = {1808.02708},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/1808.02708},
}
Figure