Encrypted Spaces
An architecture for collaborative applications where data is encrypted and operations are cryptographically verifiable.
Encrypted Spaces are part of a research effort to explore collaboration tools where servers store data but are able to inspect and process only the data that we choose.
The cloud has transformed collaboration.
Tools that were once private, local, and single-user (e.g., word processors, spreadsheets, and design editors) are now multi-user systems built on centralized backends. Centralized, cloud-accessible servers make collaboration easy, but force users to trust the servers that store and manipulate sensitive data.
Exposure
Anything held in plaintext on a server can be read by an attacker who breaks in, by an insider with access they shouldn't have, or by a party who compels its disclosure.
Loss of control
Policies for data sharing and retention are decided by servers, not users. Policies may change over time, deletion is rarely as final as it appears, and what was shared with a small group can become input to external algorithms for recommendation, ranking, or model training.
Self-censorship
Because users cannot know how a server will handle private data, they often hold back what they would otherwise share. Sensitive conversations move to other channels, or do not happen at all.
For journalists, activists, patients, and social-service organizations, these risks are not theoretical—they shape what can safely be said, shared, or built.
A trustworthy collaborative application can run on untrusted servers. Through careful use of cryptography, the application can ensure confidentiality and let users verify that servers act correctly. Through careful application design, neither users nor developers need to be exposed to low-level cryptographic details.
An encrypted space is a shared, persistent data system where:
- 01The server acts as a centralized data store and synchronization point, but is not trusted with plaintext user data.
- 02An application data schema defines what is encrypted, and what the server can see to support rich queries.
- 03Users verify cryptographic proofs to ensure that servers behave properly.
- 04The system enforces membership and access control, and handles key management and encryption.
- 05Participants know who can read and modify data, and all changes are attributed to their author.
Change logs and zero-knowledge proofs.
Encrypted Spaces keeps a change log — a record of every change to encrypted data that the users make over time. […] Encrypted Spaces can use a kind of “roll-up” property of zero-knowledge proofs to ensure that every user has the latest version of their group’s data without actually applying every change in the whole change log.
A sync engine designed for untrusted infrastructure.
To demonstrate the practicality of applications using encrypted spaces, we are prototyping a sync engine (like Firebase or Supabase) that stores data in an encrypted space. The low-level space code handles verifiable inserts, updates, and deletions of shared encrypted data.
The sync engine provides implementations of higher-level data structures to applications (e.g., Tables, Lists, and TextAreas). To clients, those structures appear like local data, but behind the scenes, the sync engine backs the structures with an encrypted space, and coordinates updates to provide clients with a shared, synchronized view.
use encrypted_spaces_sdk::Space;
use serde::{
Deserialize, Serialize,
};
#[derive(Serialize, Deserialize)]
struct Project {
id: Option<i64>,
name: String,
}
// Open a Space.
let space =
Space::new(transport).await?;
let projects = space
.table::<Project>("projects");
// Write a row.
let id = projects
.insert(&Project {
id: None,
name: "Internal Tools"
.into(),
})?
.execute()
.await?;
// Read it back.
let new_projects = projects
.select()
.where_gt("id", known_id)
.all()
.await?;
use encrypted_spaces_sdk::Space;
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize)]
struct Project {
id: Option<i64>,
name: String,
}
// Open a Space.
let space = Space::new(transport).await?;
let projects = space.table::<Project>("projects");
// Write a row.
let id = projects
.insert(&Project {
id: None,
name: "Internal Tools".into(),
})?
.execute()
.await?;
// Read it back for any app in the space.
let new_projects = projects
.select()
.where_gt("id", known_id)
.all()
.await?;
A read/write against a space — the same SDK surface a Firebase or Supabase developer expects, with verification underneath.
Encrypted Spaces is developed by a small group of researchers and engineers.
Michele Orrù
CNRSAssistant Professor at CNRS in Paris, working on cryptography and privacy-preserving systems that reduce long-term storage of personal data. In the past, he has contributed to several open-source projects including arkworks, Python, Debian, and Tor.
Trevor Perrin
IndependentCryptography engineer working on applied cryptography and protocol design. Co-creator of the Signal Protocol, and author of the Noise Protocol Framework.
Nora Trapp
Harvard UniversityEngineer and applied cryptographer at the Berkman Klein Center, focused on usable cryptography and protocol design. Former technical lead at the Signal Foundation, designing and implementing core systems including usernames and groups, and founding engineer at Juicebox, developing practical approaches to cryptographic key recovery.
Greg Zaverucha
Microsoft ResearchCryptographer and software engineer in the Cryptography Group at Microsoft Research. Co-author of the Signal Private Group System and co-inventor of the KZG polynomial commitment scheme, widely used in modern zero-knowledge systems and verifiable computation.
This work has been developed with close collaboration and support from the Cryptography Group at Microsoft Research and the Applied Social Media Lab at Harvard’s Berkman Klein Center for Internet & Society.
Encrypted Spaces is active research, not a finished system.
Read the whitepaper, try the prototype, or get in touch if you want to work on this with us. We’re building a broader constellation of research around these ideas.
For collaboration, questions, and other inquiries, reach us directly.
