Genomic data cannot be revoked once leaked, and it leaks easily. Even summary statistics and synthetic records let an attacker who knows a small slice of someone's DNA infer whether that person was in a study. Consortia already govern access the way journals govern papers. A chair sets policy, domain leads handle their own areas, and individual reviewers approve specific requests. That chain of approvals, however, lives on paper and in email. Once a request is approved, nothing technical stops the approved researcher, or the server operator, from running many queries whose answers together reveal participants.
We propose to move the editorial chain inside a trusted execution environment, meaning a hardware-isolated region of a processor whose code and memory the host operating system cannot read or alter, and whose loaded program a remote party can verify. The governed resource is not "access" but a differential privacy budget. Differential privacy is a guarantee that the outputs barely change whether or not any one person's data is included, and the budget, written $\epsilon$, measures how much of that guarantee has been spent. Each tier of the editorial hierarchy receives a signed slice of the budget and can pass sub-slices to the tier below. The enclave checks the signature chain, adds calibrated noise to every genomic answer, and refuses any query that would overdraw a slice. The two-sentence version: an editorial board becomes a tree of cryptographically signed privacy allowances, and the enclave is the bank that will not let any branch overspend. This caps how much damage a careless or compromised delegate can do, and it does so even against the machine's own operator.
Core Claim
The claim is that hierarchical delegation is the right data structure for spending a scarce privacy budget across an interactive genomic consortium. A hardware enclave is what makes the structure enforceable rather than advisory. Concretely, every node $v$ of the delegation tree (chair, associate editor, reviewer, researcher) holds a cap $\epsilon_v$. The enclave admits a signed delegation from $v$ to children $c$ only if
$$\sum_{c \in \text{children}(v)} \epsilon_c \le \epsilon_v - s_v,$$
where $s_v$ is what $v$ has already spent directly. By sequential composition of differential privacy, total leakage across all researchers is then bounded by the root cap $\epsilon_{\text{root}}$. Leakage attributable to any single subtree, for example one corrupted associate editor and everyone they approved, is bounded by that node's cap. A parent can revoke a child and reclaim the unspent part of its slice.
We predict two things. First, against an adversarial query stream, this design keeps membership-inference success near chance while serving more honest queries than a single flat budget. A flat budget lets one aggressive requester drain the pool. Second, the same accounting run outside an enclave can be silently overspent by a host that rolls back the budget counter.
Where This Sits
Two systems already run genomic computation inside SGX enclaves. PRESAGE answers variant queries over packed VCF records in under 0.05 seconds for 200,000 records and is about 120 times faster than homomorphic encryption. SAFETY aggregates Paillier-encrypted counts from several hospitals and decrypts only the sum inside an enclave to compute linkage disequilibrium and Hardy–Weinberg tests. Both supply our computation layer. Both return exact statistics to a single, presumed semi-honest researcher, with no output noise and no notion of who approved the query. Our contribution is the layer they omit.
OLIVE combines differential privacy with oblivious enclave execution for federated learning. It is the closest work combining enclaves and differential privacy. It treats the budget as one flat quantity owned by one server, and it does not address genomic summary statistics or delegated authority.
On the governance side, SoK: Machine Learning Governance models a regulator who sets $\epsilon$ and builders who optimize within it, but it stays abstract. MlsGov implements two-tier moderation over encrypted messaging, entirely on client devices. It has no heavy computation and no data-release accounting. Proof-of-Guardrail attests that an AI agent runs a given guardrail, and it warns about what such attestation does not establish. That warning constrains us: attestation proves which binary runs, not that its outputs are safe. We therefore make the safety property a provable composition bound rather than relying on attestation alone.
The iDASH 2018 competition showed blockchain access logs that resist tampering, with 800,000 records logged in an hour at up to 7.8 GB of storage. Those logs are retrospective: they record a leak after it happens.
Two sources motivate why delegates must be bounded. Principal-agent analyses such as Dong and Yang describe how unmonitored agents drift, which is the moral hazard problem. The journal front matter of IEEE Transactions on Cybernetics documents the tiered editor structure we mirror. On Utility and Privacy in Synthetic Genomic Data explains why budgets must be tight: for over 74% of targets under a recombination model, privacy gain fell below the 0.25 random-guess baseline, and 5% of a target's SNPs often sufficed for membership inference.
Research Program
We will build a small enclave program with four pieces. The first is a delegation verifier that checks a chain of signed certificates from a consortium root key down to the requesting researcher. Each certificate names a cap, a scope (for example a chromosome range or a phenotype), and an expiry. The second is a budget ledger stored in sealed enclave memory, protected against rollback with monotonic counters in the style of ROTE. The third is a query engine that reuses SAFETY-style encrypted aggregation and PRESAGE-style packed lookups, then adds Laplace or Gaussian noise to allele counts, association statistics, and the stratification-corrected tests of PrivSTRAT, using its PrivGWAS code. The fourth is a compact export that writes, for each answered query, a hash of the delegation path and the amount spent. This export can be anchored to an external log without revealing query contents.
Ledger updates use fixed-size records so that the pattern of page accesses does not reveal which subtree spent budget. Speculative-execution attacks such as SgxPectre are outside our threat model, and we will state this explicitly.
The analysis has two parts. On the formal side, we prove the global and per-subtree leakage bounds under revocation and reclamation. On the systems side, we measure the cost the hierarchy adds on top of the enclave query path, and we confirm that the ledger fits comfortably within the 128 MB enclave memory limit.
Baselines
The naive reference point is SAFETY as published: enclave-computed GWAS statistics released exactly, with no budget. This shows how much leakage the absence of output privacy permits, and it sets the utility ceiling. Its reported cost advantage is a 4.82× speedup over existing secure computation on 1000 Genomes-derived cohorts (SAFETY). We report its latency on identical hardware so that our overhead is measured against it.
The strongest competitor on the actual question is an enclave with a single flat budget, OLIVE-style accounting applied to SAFETY's computation. Every approved researcher draws from one pool, and approvals are made by a human committee outside the enclave. It is the strongest competitor because it already gives a provable global bound and hardware enforcement. If hierarchy adds nothing over it, our idea fails. We give it the same root $\epsilon$, the same cohorts, the same noise mechanisms, the same query streams, and the same hardware. For approvals, it uses the same human decisions our tree encodes, just without per-tier caps. We found no reported result on Lacuna for membership-inference success against differentially private GWAS statistics under flat enclave budgets, so we will establish that number ourselves.
Beating this baseline means two things together. Under an adversarial delegate, the worst-case membership-inference advantage must stay at or below the subtree cap's theoretical bound while the flat baseline's does not. And honest-query service, meaning the number of planted true associations recovered at a fixed significance threshold, must be equal or higher at the same root $\epsilon$.
We also run a software reference monitor: the identical hierarchical ledger running on the untrusted host, with approvals and logs anchored to a MultiChain ledger as in iDASH 2018. This is what a careful team would build without enclaves.
Two ablations isolate the key ingredients. The first removes rollback protection to show it is necessary. The second removes reclamation on revocation to measure how much budget the tree otherwise wastes.
Why not just…?
Why not just keep the human Data Access Committee and a flat enclave budget? This is the real threat, and the flat-budget baseline is designed to settle it. A flat pool is safe globally but has no blast radius: one permissive associate editor, or one aggressive requester with many approvals, can exhaust the consortium's budget or concentrate leakage on a sub-cohort. Moral-hazard analyses such as Dong and Yang predict exactly this when delegates go unmonitored. If our compromised-delegate experiment shows that flat budgets lose no more honest service and allow no more targeted leakage, we will report that hierarchy is unnecessary and the contribution reduces to an engineering note.
Why not just release one differentially private set of summary statistics and stop? A one-shot release under PrivSTRAT-style noise needs no interactive governance at all. It is a serious alternative for well-powered, common-variant studies. Its weakness is that it spreads budget evenly over every SNP, while researchers usually care about a few regions. Our experiment compares a full one-shot release against targeted interactive queries at the same total $\epsilon$, measuring recovery of planted weak associations. If one-shot release matches the interactive system, consortia should prefer it, and we will say so.
Why not just enforce the hierarchy in software with a tamper-evident log? Logs detect overspending after the fact, and genomic leakage cannot be undone. A host that controls the ledger can roll back the budget counter and replay queries before anything is logged. The software-monitor baseline with a rollback attacker measures precisely how much extra budget is extracted. The rollback-protection ablation shows the enclave's contribution is the monotonic counter, not just isolation.
Why not just use homomorphic encryption and skip enclave risks? PRESAGE reports roughly a 120× speedup over homomorphic encryption. iDASH 2018's best homomorphic GWAS handled 15,000 SNPs in under two minutes. Budget accounting with many small interactive queries favors the enclave's latency, but a side-channel-averse deployment could put the same delegation ledger on a homomorphic backend. The design is orthogonal to that choice.
Proposed Experiments
We will generate federated cohorts from 1000 Genomes (August 2010 release) allele frequencies for the CHB, CHS, JPT, and MXL populations, following SAFETY, and plant known causal SNPs of varying effect size. We add the chromosome 13, 1,000-SNP CEU/CHB extracts used in On Utility and Privacy in Synthetic Genomic Data. This lets us reuse its membership-inference attack, including the partial-information variant where the attacker knows 5% of a target's SNPs. Query-latency scaling uses the iDASH 2016 VCF sets from 10,000 to 500,000 variants, as in PRESAGE.
The consortium is simulated as a three-tier tree: one chair, several associate editors scoped to chromosome ranges, and many researchers. Honest researchers issue region-focused association queries. Adversaries issue narrow, repeated queries designed for membership inference. Metrics are membership-inference advantage (AUC above 0.5), recall of planted associations at a fixed corrected threshold, honest queries served before exhaustion, per-query added latency over the unmodified SAFETY path, and enclave memory used by the ledger.
The decisive checks are three. The first is the compromised-editor test: one associate editor colludes and approves an attacker without limit. The hierarchical design must hold that subtree's inference advantage to what its cap predicts, while the flat baseline lets the attacker approach the no-privacy curve. The second is the rollback test: the software monitor must leak measurably more budget under a counter-replay host than the enclave version. The third is the one-shot comparison at matched $\epsilon$, which decides whether interactive delegated budgets earn their complexity at all.
References
- PRESAGE: PRivacy-preserving gEnetic testing via SoftwAre Guard Extension
- SAFETY: Secure gwAs in Federated Environment through a hYbrid Solution
- OLIVE: Oblivious and Differentially Private Federated Learning on Trusted Execution Environment
- SoK: Machine Learning Governance
- Private Hierarchical Governance for Encrypted Messaging
- Proof-of-Guardrail in AI Agents and What (Not) to Trust from It
- iDASH secure genome analysis competition 2018: blockchain genomic data access logging, homomorphic encryption on GWAS, and DNA segment searching
- Dilemmas and Governance Strategies in the Implementation of the Modern Apprenticeship System in Chinese Vocational Colleges: A Perspective from Principal-Agent Theory
- IEEE Transactions on Cybernetics publication information
- On Utility and Privacy in Synthetic Genomic Data
- ROTE: Rollback Protection for Trusted Execution
- Enabling Privacy Preserving GWAS in Heterogeneous Human Populations
- SgxPectre Attacks: Leaking Enclave Secrets via Speculative Execution