Confidentiality and Verifiability
Last updated
Last updated
Ensuring the correctness and trustworthiness of computations in a decentralized environment is crucial.
To ensure that the Vistara network’s hardware virtualization approach is robust, we can draw several points from the figure below (NVIDIA CC paper) representing the chain of trust i.e. Hardware Validity.
The chain of trust describes the process of validating the trustworthiness of a system step-by-step until you reach the final authority that can be inherently trusted.
Kind of like a verifiable paper trail where at any point you can inspect and ensure the validity of the system's trustworthiness. For instance, the proof of silicon by CPU vendors for specific OEMs, the motherboard vendors for their coprocessors, and the associated firmware-based components like BIOS, UEFI, or BMC Code. Each step in this chain validates the integrity and security of the previous layer, culminating in a robust, secure system.
Let’s see the Infrastructure Stack Layers and their significance:
Compute layer
Data Persistence
Hypervisor and Operating System
Data management
Application/Middleware
App with secure UI
By understanding and implementing security measures at each layer of the infrastructure stack, we can ensure a comprehensive and robust security posture. This layered approach not only enhances the trustworthiness of the system but also makes it resilient against various threats, thereby providing a secure foundation for deploying and managing applications, AI, AVSs, etc. in decentralized networks.
Let’s try to see different levels.
Ensuring that the computations performed by nodes are correct and consistent with the specified algorithms. Mechanisms:
Formal Verification: Using mathematical proofs and models to verify the correctness of code and algorithms.
Reproducible Builds: Ensuring that the same source code always compiles to the same binary, which can be independently verified.
Remote Attestation: Verifying the integrity of computations by validating the environment in which they run (e.g., using Intel SGX). Example: Verifying that a machine learning model trained on one node produces the same results when trained on another node.
Ensuring that the resources allocated to a workload are as claimed and are being used appropriately. Mechanisms:
Trusted Platform Modules (TPMs): Providing hardware-based attestation of resource configurations.
Benchmarking: Regularly running performance benchmarks to ensure resources are as specified. Example: Verifying that a node claiming to provide 8 CPU cores and 32 GB of RAM is indeed allocating and utilizing those resources correctly.
Ensuring that the data processed and stored within the network is not tampered with and remains consistent, this is common and techniques like structuring data in a merkle tree are already being used.
Nodes in the network should not need to trust each other; instead, they rely on cryptographic proofs and consensus mechanisms. Mechanisms:
Consensus Algorithms: Ensuring that the majority of nodes agree on the state of the network (e.g., using Byzantine Fault Tolerance).
Ensuring that the execution environment itself does not need to be trusted; instead, trust is placed in the attestation and verification mechanisms. Mechanisms:
Enclave Technologies (e.g., Intel SGX): Running sensitive computations in hardware-enforced isolated environments.
Remote Attestation: Providing cryptographic proof that a piece of software is running in a secure enclave. Example: Running confidential AI workload in a trusted execution environment that can be verified by any participant in the network.
Ensuring that data remains private and encrypted, accessible only to authorized parties.
Mechanisms:
End-to-End Encryption: Encrypting data at rest and in transit.
Homomorphic Encryption: Allowing computations on encrypted data without decrypting it. Example: Ensuring that personal data used in a computation remains encrypted and confidential throughout the process.
Ensuring that the logic and processes within computations are not exposed to unauthorized parties.
Mechanisms:
Confidential VMs (e.g., using AMD SEV): Running VMs where the memory is encrypted and not accessible to the hypervisor.
Secure Multi-Party Computation (MPC): Allowing parties to jointly compute a function over their inputs while keeping those inputs private. Example: Ensuring that a trading algorithm running on Vistara cannot be reverse-engineered by other nodes or operators.
Utilize hardware security modules such as TPMs or technologies like Intel SGX and AMD SEV to provide strong guarantees about the integrity and confidentiality of the computation environment.
Provide cryptographic proof that the hardware and initial software states are as expected.
Enable secure provisioning and operation within a trusted execution environment, isolated from the host operating system.
Merkle Trees and Cryptographic Proofs: Use Merkle trees to create verifiable proofs of the computation outputs. Validators or other network participants can use these proofs to verify computation outcomes without needing to rerun the entire computation.
Zero-Knowledge Proofs (ZKPs): Implement ZKPs to enable verification of the correctness of computations without revealing the underlying data or computation details, enhancing privacy and security.
Multi-party Computation (MPC): In scenarios where inputs need to be kept secret from other collaborating parties, MPC can be used to ensure that computations are correct and private.
Redundant Computation: Run the same computation on multiple, independently operated nodes and use a consensus mechanism to agree on the result. This can be particularly effective against malicious actors if the cost of coordination exceeds the potential gain from cheating.
Employ formal methods to verify the correctness of the critical software components involved in the computation, especially those that orchestrate and manage execution environments and resource allocation.
Implementing continuous monitoring and anomaly detection tools that can identify unexpected behavior or results from microVMs or containers, which might indicate a breach or misconfiguration.
We outlined approaches for verifiability, trustlessness, and confidential computing.
Vistara, through Hypercore and Spacecore, aims to create a flexible, unopinionated platform that allows for a variety of approaches to verifiability, trustlessness, and confidential computing.
Let's look at how each approach can integrate with Vistara:
Level 1 Verifiability:
Implement foundational security measures to establish initial trust.
Level 2 Verifiability:
Ensure that all data within the network is tamper-proof. Enhance reliability and confidentiality.
Level 3 Verifiability:
Protect sensitive computations and data.
Level 4 Verifiability:
Guarantee the correctness of critical computations through distributed consensus.
Level 5 Verifiability:
Ensure reproducibility and verifiability of results.
Let's refine it.
In terms of Verifiability in Vistara's decentralized network, let's define them in categories based on their complexity, scope, and security guarantees.
Secure Boot and Remote Attestation:
Secure Boot: Ensures the hardware and initial software states are trusted by verifying the integrity of the boot process.
Remote Attestation: Verifies the integrity of the running software stack through attestation reports, providing a foundation of trust.
Cryptographic Techniques:
Merkle Trees: Provide tamper-proof data structures that ensure data integrity.
Zero-Knowledge Proofs (ZKPs): Enable confidential computations by allowing verification without revealing underlying data.
Replication of Computation:
Multi-Party Computation (MPC): Facilitates confidential data processing by distributing computation tasks across multiple parties without revealing inputs.
Redundant Computation: Enhances reliability by performing the same computation on multiple nodes and comparing results.
Consensus-Based Verification:
Consensus Mechanisms: Ensure the correctness of computation results through mechanisms like Byzantine Fault Tolerance, which rely on agreement among nodes.
Deterministic Computation:
Reproducible Results: Guarantees that computations produce the same output given the same input and initial state, enabling easy verification across nodes.
