Taming Distrust in the Decentralized Internet with PIXIU

TL;DR

This paper addresses the challenge of mutual distrust in decentralized Internet systems by analyzing distrust properties and proposing PIXIU, a framework that employs trust-λ and decentralized execution to enable trustworthy task completion.

Contribution

It introduces PIXIU, a novel framework that mitigates distrust among nodes in decentralized Internet through trust-λ and decentralized execution mechanisms.

Findings

Analyzed distrust properties in decentralized systems

Designed trust-λ and decentralized executor components

Demonstrated improved trustworthiness in task execution

Abstract

Decentralized Internet is booming. People are fascinated by its promise that users can truly own their data. However, in a decentralized Internet, completing a task usually involves multiple nodes with mutual distrust. Such distrust might eventually become a major obstacle for the growth of the decentralized Internet. In this paper, we analyze the distrust using a simple model and highlight the properties required to faithfully accomplish one task in a decentralized Internet. We also introduce our draft solution -- PIXIU, a framework to mitigate the distrust among different nodes. In PIXIU, we design and utilize trust-{\lambda} and decentralized executor to achieve the above-needed properties.

Full text

1 Introduction

Surveys and reports suggest that current Internet is highly centralized [1, 2]. In a centralized Internet, as users, our (private) data are collected and stored in some centralized data silos, which are out of our control. This misplacement of ownership might lead to catastrophic consequences—data abuse [6], data manipulation [14, 13], data breach [3] and so on.

Users should be in control of and be empowered to monetize their own data. In order to achieve this goal, decentralized Internet has been proposed. Though immature, decentralized Internet is able to offer most of the functionalities that nowadays centralized Internet provides, including websites [15], online marketplace [10], social network [4], online collaboration [7], video sharing [5] and more [9, 12, 11].

Different from current centralized architecture, decentralized Internet is, by design, a peer-to-peer network which allows individual users to truly own their data. In a decentralized Internet, user data are stored in PODs [11] (Personal Online Datastores) which are controlled by users themselves. And, users can choose to run applications in their own PODs for fun and profit.

However, there are trust issues in such decentralized Internet. Instead of trusting a few giant tech companies, a user now has to trust many (if not all) nodes in the peer-to-peer network, which she may or may not know. Indeed, a user can choose which nodes to collaborate with. But, the question still remains—how can a user make sure that the nodes, which have been granted the read permission, will not stealthily leak the data, or alter the application, or—even—how to ascertain that they actually do anything instead of returning an arbitrary result?

We believe such distrust is deep-seated in the nature of decentralization and it might eventually become the major obstacle for the growth of the decentralized Internet. In this paper, we introduce a simple model to systematically analyse different types of distrust. And, in order to tackle these problems, we design Pixiu, a framework to mitigate the distrust in the decentralized Internet.

In our distrust model, multiple PODs and one data consumer together want to finish one task. An executor takes the data from PODs and the task from the data consumer as inputs, and produces the result. All the participants mutually distrust each other. There are concerns about the data counterfeit, data stealing, task stealing, execution corruption, and so on.

Pixiu is designed to mitigate the above distrust. In its core are trust-$\lambda$ and the decentralized executor. In Pixiu, we split one task (e.g., a query, a machine learning training) into steps, execute each step separately in a trust-$\lambda$, and chain the trust-$\lambda$s chronologically as one decentralized executor. Each trust-$\lambda$ consists of several trusted execution environments (TEE), so that no data nor the execution leak outside the decentralized executor.

Pixiu’s ethos is pragmatic. It assumes TEE can provide both confidentiality and integrity, which—in reality—is not always true [39, 8]. However, we argue that, in practice, the violations of such assumption can be restricted by (i) extra security techniques to solidify the TEE and, more importantly, (ii) thanks to the fine-granularity of each step, the attacks would be economically insufficient.

2 Distrust model

In this section, we are going to introduce our distrust model in the decentralized Internet. We assume that the users’ data have already been stored in their PODs. How to collect data into PODs is out of the topic of this paper.

Figure 1 depicts an abstract workflow of a task in the decentralized Internet. A data consumer starts a task which includes a piece of code and a specification of what data should be its inputs. Some PODs have the data needed by this task and (suppose) they allow such a task to access these data.

An executor takes the task from the data consumer and the corresponding data from PODs as inputs, executes the task’s code, and outputs the result to the data consumer. In addition, the executor generates an execution proof for both sides to verify this procedure. Note that the executor is an abstract entity that might locate in one or multiple nodes in the decentralized Internet.

In the above workflow, we have three participants with mutual distrust: the data consumer, PODs, and the executor. PODs are responsible for providing genuine data, but are fear of either executor or data consumer stealing their data. On the other hand, the data consumer worries that the PODs may provide fake data, and the task code are stolen or not faithfully executed by the executor. In a decentralized network, the participants can be anyone in the world, hence they naturally distrust each other.

In the following, we summarize the properties required by the decentralized Internet to mitigate the distrust.

• •

Data privacy. PODs distrust the data consumers that they may steal the data, or the executor might leak the data. Data privacy requires that only a bounded amount of user data can be revealed (i.e., differential privacy) to the data consumer and the executor.

• •

Data authenticity. \xmakefirstucdata consumers worry that the PODs may sabotage the task by sending fake data as inputs. Data authenticity requires that the input data can be authenticated, otherwise, should be explicitly tagged as alleged.

• •

Task privacy. The task may contain some confidential logic of data consumers’ (e.g., the architecture of a neural network, ranking algorithm) that the executor should not know. Task privacy requires that the executor learns nothing about the task logic.

• •

Execution integrity. \xmakefirstucdata consumers concern that the result might be bogus, as the task’s code is not faithfully executed. Execution integrity requires that the code runs as written by the executor.

• •

Accountability. Inevitably, executing a task in a distributed setup will encounter failures, errors, bugs, misconfigurations, and so on. Accountability requires that, for one failed task, all the participants are able to pinpoint and agree on where went wrong.

• •

Traceability. When users need some processed data (e.g., some statitics, a trained machine learning model), they want to understand how the data were generated. Traceability requires that one can find and verify the history of any piece of data generated within the decentralized Internet.

3 A draft solution: Pixiu

In order to fulfill the requires in previous section, we design Pixiu. Pixiu is a framework built on top of a decentralized Internet, where all the participating nodes are treated equally in a peer-to-peer manner. Each node can play one or multiple roles—PODs, data consumers, or the executor—within each task. And, Pixiu, as the framework, organizes and coordinates these roles to finish the tasks.

In this section, we are going to introduce the basic building block of Pixiu named trust-$\lambda$ (§3.1) which provides execution integrity and task privacy; then, we describe decentralized executor (§3.2), the key to achieve the data privacy and data authenticity; finally, we will justify our assumption in §3.3.

Due to the space limit, we have to skip other pieces of Pixiu which are also indispensable. In specific, we make the following assumptions, which should have been achieved by other components of Pixiu.

• •

We assume a fixed peer-to-peer network with all nodes equipped with TEE.

• •

We assume all PODs are willing to expose their data (i.e., grant read permission) under the guarantee of data privacy.

• •

We assume that, for one task, both PODs and the data consumer have agreed, beforehand, how to split this task into trust-$\lambda$s.

• •

We assume that Pixiu can always find the relevant data from PODs and qualified nodes as executors.

3.1 Properties of trust-$\lambda$

A trust-$\lambda$ is the basic execution unit in our system. A task can be divided into multiple trust-$\lambda$s. Each trust-$\lambda$ has three properties: first, it has only one entry point and one exit point for data; second, the privacy of code and data within one trust-$\lambda$ is protected; third, the execution of logic cannot be tampered with.

The properties of trust-$\lambda$ are enforced by a software and hardware co-design. Figure 2 shows the process of one trust-$\lambda$. Each trust-$\lambda$ is composed of three components: one data validator, one sandbox and one proof generator. The data validator is the one component that accepts outside data. It checks the input data using proof (described below), and then passes the data to the sandbox. The sandbox ensures that the function running inside cannot send data out by disabling all I/O and restricting access to memory out of enclave.

The third component generates a proof of execution to show that the output data are indeed generated from the input data and algorithm. A proof contains sufficient information of the data flow, but no sensitive data that may reveal user’s personal information. A typical proof only has hashes of the input data and the function. The proof generator will sign the proof with its own private key. The private key is initialized when the node joins the Pixiu network.

All of the three components are running within hardware enclaves, so that they can attest each other, offer attestation to outsiders and protect both integrity and privacy of the code and data. They run on the same node so that their secure channels are based on shared memory buffers.

3.2 \xmakefirstucdecentralized executor

A decentralized executor is an instantiation of the executor in a decentralized Internet, which consists of a set of trust-$\lambda$s. Figure 3 depicts the architecture of a decentralized executor.

In this example, the whole task has been split into multiple trust-$\lambda$s with different purposes: data prover, task execution, and differential privacy. First, the input data flow from PODs into the data prover, in which the program authenticates the input data. If valid, the data flows into the task execution to finish the essential task the data consumer provides. The result, instead of directly returning to the data consumer, has to go through another differential privacy trust-$\lambda$, which guarantees that the sensitive personal data would not be leaked. Finally, the result is delivered to the data consumer.

All these procedures are executed within trust-$\lambda$s, which, because of trust-$\lambda$’s properties, are faithfully executed with confidentiality. And, each of the trust-$\lambda$ commits an execution proof to a public storage, which PODs and the data consumer can examine.

One decentralized executor usually has a chain of trust-$\lambda$s. The integrity of the decentralized executor is ensured by encryption and key management. Specifically, the data consumer acts as a dispatcher. It first recrutes several instances that runs the trust-$\lambda$ it needs, then sends the list to the data owner. The data owner first attests each instance. After that, it will generate keys and send them to each instance in a way that the output of one trust-$\lambda$ can only be decrypted by the next trust-$\lambda$.

In the following, we’re going to describe several common components in a decentralized executor.

Data prover is responsible for providing data authenticity in the decentralized executor. Depending on the type of data, there are multiple ways to authenticate a piece of data. If the data have been signed by the hardware (e.g., camera [27]), the validation can be as simple as verifying a signature. Similar case applies to the data signed by their source organization (e.g., health data [28]).

Another type of data, which have machine-checkable sources (e.g., shopping record, search history), can be authenticated by logging into the corresponding website and verifying that the provided data entry does exist. TEE technique [35] is able to guarantee that user’s login is secure, as well as the validation is faithful.

Admittedly, there are cases that it is hard or even impossible to authenticate the data. Pixiu requires that these data should be tagged as “alleged” and the data consumers should take their own risks to trust these data.

Differential privacy guarantees the data privacy in Pixiu. Differential privacy [25] is a statistical technique that aims to protect privacy of individual users while still allowing statistical queries to these data. Previous systems demonstrate that differential privacy can be applied transparently to a lot of tasks (e.g., machine learning [16], statistic analysis [26], SQL query [33]). Hence, Pixiu can leverage these systems to build our differential privacy trust-$\lambda$. Investigating what tasks can (or cannot) use differential privacy and how to achieve them in practice is our future work.

Execution proofs empower Pixiu with the accountability and traceability. Any participant in one task is able to verify the whole chain of trust-$\lambda$s via examining (checking the signature and comparing the hashes) the series of execution proofs on the public storage. Since execution proofs are signed by trust-$\lambda$s, they cannot be forged.

Specifically, PODs can ensure that their data flow through a differential privacy trust-$\lambda$, so that data privacy is enforced. And data consumers can ascertain that the input data have been authenticated by a data prover trust-$\lambda$. As for the data generated within Pixiu, anyone can track the history of the processing and find the original data sources.

3.3 Justify Pixiu’s assumption

Pixiu assumes that TEE can provide both execution integrity and confidentiality. However, in reality, attacks, like side channel [39] and L1TF [8], may successfully steal data from enclaves. In the following, we try to argue that the violation of such assumption can be restricted by the two schemes below.

One way to reduce the attacking surface, besides applying Intel’s latest patch, is to restrict the software stack underneath enclaves with trusted hardware like TPM (Trusted Platform Module) and Intel TXT (Trusted eXecution Technology). The execution nodes may have different security levels. For examle, a node depending entirely on Intel SGX (Software Guard eXtension) is considered as mid-level security, which could be vulnerable to side channel attacks. A more secure node can run a formally verified kernel and use SGX as well, and nothing else to minimize the attacking surface.

On the other hand, our methodology of dividing a task into multiple trust-$\lambda$ can increase the cost of an attack, as well as decrease its gain, making it economically insufficient. Since trust-$\lambda$s are isolated with each other, the data leaked in a single trust-$\lambda$ can be very limited and an attacker may need to compromise many nodes before achieving one sucessful attack. Further, the functions that are considered as more important can be deployed to the nodes with higher security level.

4 Real-world use cases

In this section, we are going to present several real-world use cases of Pixiu.

4.1 Case 1: advertisements

In this application scenario, advertisers are data consumers. They want to run their advertisement recommendation algorithms on users’ PODs and deliver the advertisements about their products to the potential buyers. Clearly, users do not want their data to be leaked to the advertisers, and (perhaps) the advertisers also want their recommendation algorithms to be secret.

With Pixiu, an advertiser can send its advertisement to the target users without learning who they are. The advertiser can filter out the non-target users by setting conditions in the task. For example, as a video game seller, it can specify that its advertisements will only send to those who have a purchase record of a Nintendo Switch. The advertiser can check the advertisement delivery by examining the execution proofs committed by each trust-$\lambda$. PODs can also make sure that their personal data (e.g., whether have a Nintendo Switch) have not been leaked to the advertiser, in the same way.

4.2 Case 2: financial data query

Some organizations (e.g., banks, financial companies) and individuals have many financial records. Other companies, researchers, or individuals may try to understand some statistics about the overall financial status, or the financial condition of a particular group of people. However, nowadays, the data owners are unwilling to share their data, and the queriers are afraid of that their queries will be leaked.

In this scenario, data providers need to ensure no data leakage, and for the queriers, they need to keep their queries private. With Pixiu, a PIR (Private Information Retrieve) trust-$\lambda$ can be inserted into the task to protect the query processing from the data providers. The query will be encrypted and executed by the PODs of data provider without revealing which data have been touched. Since the data providers do not trust any query, they will also leverage differential privacy to ensure no personal information will be leaked through the result.

4.3 Case 3: machine learning training

Machine learning brings convenience to people’s lives: machine translation, autocorrect, auto captioning, etc. Most of these machine learning algorithms require training on substantial data. And some personalization functionalities require the peeking of user’s own data. People have been forced to choose between convenience and privacy. Pixiu can make this dilemma obsolete.

With Pixiu, people can opt in to volunteer their data for machine learning tasks, without the worry of losing privacy. These machine learning tasks can in turn be used for their own benefits, such as personal assistant, search personalization, etc.

Imagine a researcher wants to train a language model of modern day Americans, and she is interested in making use of the abundance of training data lying in people’sPODs. In this case she would be a data consumer, who specifies the task and gets the word out. Some users that store their text messages in their PODs may now sign up. Data consumer starts the job in an enclave (consumer enclave), which updates the global model. She then sends algorithm to user’s PODs which will run as trust-$\lambda$.

The learning process involves several rounds of communcation between consumer enclave and user enclaves. In each round, the consumer enclave distributes the global model. Each user enclave updates the global model with local data using stochastic gradient descent, encrypts parameters, and sends it back to the consumer enclave. The consumer enclave then collects the encrypted parameters, which it cannot decrypt. But it can aggregate the parameters and then decrypt the result. After a few rounds of updates, the global model stablizes, and training is done.

4.4 Case 4: secure polls and surveys

Polls and surveys can be done on Pixiu. Survey conductors need integrity of the result, and survey takers need discretion.

Say a company is trying to conduct a customer survey, to learn about how a product is received by the market. In this case, it would be the data consumer. Participating users can authenticate their legitimacy throught an identity verification protocal (e.g., cryptographic proof of membership). The demographic data can be filled out automatically using the data in PODs. Then the user can communicate their encrypted answers securely to the executor. The executor then generates survey results, without revealing the raw data. Eventually, a secure polling system may lead to a secure voting system.

5 Related work

Decentralized system.

There are multiple decentralized systems [34, 21, 22] designed to give back the control of data to users. Solid [34], a decentralized platform for social web applications, defines a series of rich protocols and suggests the creation of a POD, which is owned by individual users and stores their data. Amber [21] and Oort [22] provide global queries to efficiently collect and monitor relevant data created by all the users, which enables cross-user data applications. Instead of providing more functionalities in a decentralized setup, Pixiu focuses on taming the distrust within these functionalities.

TEE.

Many previous works leverage TEE to protect execution in untrusted environment [19, 18, 32, 23, 37]. Ryoan [32] proposes a distributed sandbox mechanism that enables a user to process her private data (e.g., gene) by multiple untrusted algorithms on different platforms. Our design is inspired by Ryoan but targets a different problem: the data owner is not the consumer, which leads to a totally different threat model. For example, Ryoan does not need to consider the fake data problem or privacy leakage between data owner and consumer, while Pixiu considers both.

Cryptographic tools.

There is another thread of systems [30, 29, 38, 17] that leverage model cryptographic tools, such as FHE (Fully-Homomorphic Encryption), MPC (secure Multi-Party Computation), PIR (Private Information Retrieval), to completely get rid of the trust among participants. Pixiu is complementary to them. Meanwhile, these methods can be implemented within trust-$\lambda$ as a replacement of TEE. However, as far as we know, adopting these techniques usually imposes significant overheads, hence we choose to use TEE as our current option.

Privacy-preserving machine learning.

Federated learning [36] is a learning scheme that allows a model to be trained on remote and decentralized data. This protects privacy to some extend because data stay where they are. Cryptographic tools have been used to prevent adversarial inference of individual data [20]. It is worth mentioning that multiple attacks on federated learning have been proposed [31].

Another line of efforts has been on acheving differential privacy with random noise mechanisms [24, 16]. They are pertinent on particular machine learning algorithms, and proved differential privacy parameters. Pixiu can seamlessly accomodate these designs.

6 Conclusion

Decentralization is not just about data (e.g., PODs) and execution (e.g., distributed computing), it is also about trust. The decoupling of three roles: data owner, data consumer and executor, brings new challenges to the trust model as well as the system design. Pixiu proposes a decentralized execution framework, where each step of execution goes with proofs of data and code. Multiple steps can be connected to run various tasks with code and data from different roles. Currently, Pixiu leverages hardware TEE to achieve better practicability. It can also use cryptographic tools including MPC and FHE according to different scenarios.