Skip to content
Crypto.world

Research

Verifiable Computation with Trusted Execution Environments and On-Chain Digital Rights Tokens

Today's data infrastructures reward whoever holds data rather than whoever creates it, because sharing typically means handing over a raw copy that the recipient can then copy, combine or repurpose…

Verifiable Computation with Trusted Execution Environments and On-Chain Digital Rights Tokens
arXiv
2609.21728
Published
2026-09-18
Authors
Bingle Stegmann Kruger, Co-Pierre Georg

AI summary

Overview

Research area: Cryptography and Security (arXiv category cs.CR), at the intersection of Trusted Execution Environments (TEEs), verifiable computation, blockchain-based data governance, and digital rights management.

Technical level: Intermediate to Advanced. The paper is readable by a motivated newcomer, but it assumes working familiarity with remote attestation, sealing keys, smart contracts and token standards.

Scope (one sentence): The paper specifies and prototypes an architecture in which data owners pool private data inside Intel SGX enclaves and sell narrowly scoped, on-chain "Digital Rights Tokens" that entitle third-party analysts to run one specific, hash-pinned open-source program over that data and receive only the result.

What This Paper Is About

Today's data infrastructures reward whoever holds data rather than whoever creates it, because sharing typically means handing over a raw copy that the recipient can then copy, combine or repurpose beyond the original agreement. The authors argue that watermarking or contractual licences cannot fix this, since a single unauthorised use can already cause harm. Their goal is an information infrastructure in which creators keep ex ante control over how their data is processed — which computations are allowed, by whom, at what price and with what output shape — even after the data has been combined with other people's data.

Key Contributions

  1. Digital rights formalised as a K-dimensional rights vector and instantiated as Digital Rights Tokens (DRTs). Each DRT encodes a per-computation licence over one sealed data pool, carrying fields for the right type ("append", or a "wasm"/"python" execution runtime), mintAddress (Base58), managingPoolAddress, poolName, supply and cost (nonnegative integers), githubUrl, and codeHash. Because a DRT is a transferable token, secondary markets become possible without exposing any data beyond what the authorised computation permits.

  2. A five-component information infrastructure with a "redeem-to-execute" path. The components are a frontend application with a blockchain SDK, an enclave deployment service, execution enclaves (one per pool), a smart contract and blockchain network, and oracle nodes. A redeemed DRT is bound to a specific auditable program (open-source code plus its expected hash) and to an attested TEE; RA-TLS channels and per-pool sealing keys keep raw data inside the enclave.

  3. Governance properties enforced by the mechanism rather than by policy. DRTs are freely resellable, but redeeming one burns it, so the total number of executions on a pool equals the supply fixed at pool creation; each non-append DRT names an open-source program and the hash of its compiled artefact, and the enclave refuses to run on a hash mismatch; and output is bounded per redemption by the referenced code and across redemptions by the burning supply.

  4. An open-source proof-of-concept implementation. Licensed GNU AGPL v3 with Zenodo deposits for the core library and the enclave deployment service, it demonstrates DRT issuance and redemption as Solana SPL tokens on the Solana testnet and in-enclave execution of WASM and Python jobs over sealed pools.

Main Findings

  • End-to-end feasibility demonstrated, not benchmarked. The prototype supports pool instantiation, token issuance and redemption, code verification, and in-enclave execution of WASM and Python jobs; the authors present it as evidence that control-centric verifiable computation is technically feasible. No execution-time, throughput, gas-cost or scalability measurements are reported — a systematic performance evaluation is explicitly deferred to future work.
  • Enclave initialisation is the main practical inhibitor. The time required to initialise a new enclave for each data pool is described as a key inhibitor in the current implementation, though the authors note this is an infrequent operation amortised over the pool's lifetime.
  • Test workloads were deliberately simple and small. Initial tests rely on small datasets and simplistic DRT-authorised code, such as computing mean or median values; throughput under varying pool sizes is stated as requiring further investigation.
  • Privacy is reframed as control, not secrecy. Because results are returned, users necessarily cede some privacy; the argument is that the chosen computation (the DRT) bounds the scope of leakage and determines who receives it. This trade-off is made explicit and enforceable rather than hidden in policy statements.
  • Trust is split into two layers. A platform layer (TEE plus remote attestation) guarantees code authenticity, runtime integrity and confidentiality of data in use; an authorisation layer (on-chain rules) decides which code may run on which pool. Under assumption T1 (hardware faithfully executes the loaded image and attestation binds its measurement to a verifiable quote) and T2 (creators choose and contributors accept a set of computations whose outputs they will release), a malicious code authorisation is a T2 governance failure, not a hardware break.
  • The oracle is a liveness, not a safety, dependency. With a single oracle in the prototype, a malicious or faulty oracle can delay, censor or omit an execution, but should not cause a correctly implemented enclave to run an unauthorised computation, provided redemptions are checked against authenticated ledger state rather than trusted as oracle assertions.
  • Five recurring engineering challenges were surfaced (C1–C5): binding on-chain rights to off-chain execution (exactly one execution per redemption, plus liveness); reconciling code identity (any source change yields a different hash and invalidates the DRT until reverted); operational hygiene of attestation (expiring collateral, key rotation, microcode advisories — re-attestation on restart and daily is recommended, and deterministic builds of the SDK are called essential); schema evolution (changing a sealed schema requires opening a new pool, losing the historical contributor base); and the fact that attestation can prove which program ran but not that it is benign.
  • Residual leakage risks are acknowledged. Output resale cannot be prevented by the protocol, since computation is governed and not downstream handling of derived artefacts; supply-bounded DRTs and creator-chosen output policies limit the damage. Compositional reconstruction is possible if a creator admits a sufficiently expressive DRT set, which is why the full DRT set, code references and supplies are public on-chain before any contribution.
  • Known TEE weaknesses apply. Intel SGX side-channel vulnerabilities are explicitly in scope for the prototype; physical attacks and microarchitectural side channels are treated as out of scope. The prototype runs on Azure DCsv3 confidential VMs, and the design is described as TEE-agnostic with AMD SEV-SNP, Intel TDX and ARM CCA named as viable alternatives.
  • Explicit non-goals: no multi-oracle consensus (though the design supports k-of-n), no GPU TEEs, no advanced output-privacy mechanisms beyond limiting the number of DRTs (rate limiting, aggregation-only schemas or differential-privacy wrappers are named as absent), and runtime failures of redeemed DRTs are not yet handled gracefully.

Methodology in Plain English

The authors start from theory and work toward a working system. They first survey competing legal notions of privacy — the right to be let alone, limited access to the self, secrecy, and control over personal information — and adopt the control-based view, leaning on Westin's definition and Demsetz's notion of ownership as control over a bundle of rights. They then write three definitions: information ownership as control over a bundle of rights, information co-ownership as joint control over that bundle, and digital privacy as a user's control over information they created. A Unix file permission scheme (read, write, execute for three classes of user) serves as the intuition for encoding rights as a vector of bits, which is then generalised to K rights and tokenised as DRTs.

They design the system around five components and four data-lifecycle phases — pool creation, contribution, redemption and execution, and settlement — and give pseudocode for each (Algorithms 1–4). A data pool is defined as a tuple of a schema, a vector of permitted rights realised as DRT mints, an append-only multiset of contributor records, a sealing key held only inside the pool's enclave, and a Solana program-derived address anchoring the rights to the pool. Data contributors buy and redeem an AppendDRT and upload schema-conformant records over an encrypted channel, receiving contributor tokens that track pool ownership and revenue shares; analysts buy and redeem an ExecuteDRT, the oracle relays the redemption to the enclave, the enclave recomputes the code hash, checks it against the on-chain record, unseals the pool, runs the job, and returns only the policy-approved result. Royalties are split on-chain pro rata to contributor-token holders without revealing which contributor supplied which record.

Finally, they build the prototype: Solana SPL tokens for the rights, Intel SGX enclaves for execution, RA-TLS for attested channels, and a single oracle node, tested with small datasets and simple statistical jobs.

Why This Matters

Impact on research. The paper reframes data privacy from secrecy (cryptographic hiding) to enforceable control over use, and shows how three usually separate strands — privacy-preserving computation (secure multiparty computation, homomorphic encryption, differential privacy), TEE-based confidential computing, and tokenised blockchain data governance — can be composed. Prior blockchain data-market work, the authors argue, emphasises access rights, licensing or accountability but not enforceable control over which computations run on the underlying data; the DRT-plus-attestation binding is the distinctive move. It also gives a concrete design vocabulary (rights vectors, DRT fields, redemption semantics) that others can critique or extend.

Real-world applications:

  • Clinical and biomedical data pools — multiple hospitals contribute patient records under a shared schema, and researchers buy the right to run a specific, hash-verified analysis script, receiving aggregate statistics rather than records.
  • Financial and transaction data consortia — banks or payment providers combine fraud or credit signals so that only pre-approved models (for example mean or median style aggregates) can be computed, with royalties flowing back to contributors.
  • Personal data vaults and data unions — individuals pool browsing, mobility or sensor data and license narrowly scoped computations, tracking revenue shares through contributor tokens.
  • AI and model training on sensitive corpora — hash-pinned training or evaluation code executed inside an enclave, with supply-bounded DRTs capping how many times a corpus can be queried.

Industry relevance. The architecture speaks directly to confidential-computing cloud offerings (the prototype uses Azure DCsv3), to blockchain platforms seeking regulated data-market use cases (Solana SPL tokens here), and to data-governance and compliance teams who need auditable, tamper-evident records of who computed what, on which dataset, under which approved code. The honest catalogue of limitations — oracle trust, side channels, enclave start-up cost, output resale — is itself useful for practitioners deciding whether the pattern is deployable.

Future Directions

  1. Systematic performance evaluation. The authors explicitly defer measurement of execution overhead and the scalability of DRT issuance on-chain; throughput under varying pool sizes is untested, and the enclave-initialisation bottleneck needs quantifying.
  2. Stronger trust and privacy primitives. Extending to GPU-enabled TEEs, incorporating multiple oracle nodes (the design already supports k-of-n, with the open problem of deduplicating forwarded events inside the enclave), and integrating differential privacy, aggregation-only schemas or query-set auditing for compositional reconstruction risk.
  3. Robustness of the redemption lifecycle. Runtime failures of redeemed DRTs are not yet handled gracefully, and the C1 safety/liveness question — how to verify minimal evidence of a redemption inside the enclave without importing a full blockchain client into the trusted computing base — remains open.
  4. Governance and incentive design. Analysing incentive and governance models for data contributors and data analysts is named as future work, alongside open problems in schema migration (C4), versioning of code bound to attestation policies (C2), and how contributors can be protected from socially engineered admission of malicious DRTs (C5).

Target Audience

Researchers and graduate students in applied cryptography, confidential computing and blockchain systems; system architects and engineers building privacy-preserving data markets or data clean rooms; policy and legal scholars interested in operationalising control-based definitions of data ownership and co-ownership; and standards or compliance practitioners who need enforceable, auditable mechanisms rather than contractual promises. Readers seeking quantitative benchmarks should look elsewhere, since this paper offers architecture, definitions, pseudocode and a feasibility prototype rather than measurements.

Authors’ abstract

We present an architecture that enables data owners to combine private data into data pools using Trusted Execution Environments (TEEs) and manage these pools by issuing narrowly scoped computational rights, encoded as Digital Rights Tokens (DRTs), to third-party data analysts. Each DRT binds specific open-source code to a pool and is issued and redeemed on a distributed ledger. Data analysts can obtain the right to execute open-source code on the combined sealed data inside…

The full abstract on arXiv
Read the original paper