Confidential Computing Transparency
Ceren Kocaoğullar Tina Marjanov Ivan Petrov Ben Laurie Al Cutter Christoph Kern Alice Hutchings Alastair R. Beresford





1]Ceren Kocaoğullar
1]Tina Marjanov
2]Ivan Petrov
2]Ben Laurie
2]Al Cutter
2]Christoph Kern
1]
Alice Hutchings
1]Alastair R. Beresford
[1]University of Cambridge
[2]Google
Confidential Computing Transparency
    [
    5th September 2024
===================================




§ ABSTRACT 
Confidential Computing is a security paradigm designed to protect data in-use by leveraging hardware-based Trusted Execution Environments (TEEs). 
While TEEs offer significant security benefits, the need for user trust remains a challenge, as attestation alone cannot guarantee the absence of vulnerabilities or backdoors. 
To address this, we propose a Confidential Computing Transparency framework with progressive levels of transparency.
This framework goes beyond current measures like open-source code and audits by incorporating accountability for reviewers and robust technical safeguards, creating a comprehensive trust chain.
Our tiered approach provides a practical pathway to achieving transparency in complex, real-world systems. 
Through a user study with 400 participants, we demonstrate that higher levels of transparency are associated with increased user comfort, particularly for sensitive data types.
 




§ INTRODUCTION


Confidential Computing is a security approach that aims to protect data while it is in-use.
This relatively new approach extends the long-standing ability of protecting data at-rest using encryption, and in-transit, using cryptographic protocols, such as TLS.
Confidential Computing uses hardware-based Trusted Execution Environments (TEEs) to achieve this level of privacy.
Several TEE implementations are available from prominent hardware providers, such as Intel SGX <cit.> and TDX <cit.>, AMD SEV-SNP <cit.>, and Arm CCA <cit.>.
Commercial cloud platforms, including Google Cloud <cit.>, Microsoft Azure <cit.>, and Amazon Web Services <cit.> have made Confidential Computing widely available.

Using TEEs provides Confidential Computing distinctive properties compared to other privacy-preserving computation techniques like homomorphic encryption and secure multiparty computation. 
Specifically, TEEs provide confidentiality for both data and code in execution   through techniques like hardware isolation and memory encryption.
TEEs also protect the integrity of data and code throughout execution.
With these unique security and privacy properties, Confidential Computing serves as a versatile tool that can be used independently or complement other privacy methods, such as homomorphic encryption. 
Therefore, Confidential Computing is an esssential component for building a foundation for comprehensive private computation.

To provide Confidential Computing, a TEE must be attestable <cit.>.
In the realm of Confidential Computing, attestation refers to gaining information about the authenticity, integrity and certain runtime properties of a TEE through validating a hardware-signed attestation.
The attestation evidence contains relevant measurements of the Trusted Computing Base (TCB) <cit.>, which is the collection of firmware and software that the security of a system depends on <cit.>.
However, while attestation verifies that the intended software is running on an intended TEE, it does not guarantee the absence of vulnerabilities or backdoors within a Confidential Computing system. 
Therefore, unless the user builds and installs the entire software stack that runs on top of the TEE by themselves, and the hardware is correct and reviewable, attestation alone does not provide enough evidence to the user that they can trust a Confidential Computing system (<ref>).

To address this trust gap, TEE providers are progressively adopting transparency measures.
Critical software components are increasingly open-source, including AMD SEV firmware <cit.>, Intel TDX modules <cit.>, and ARM Trusted Firmware <cit.>.
The AWS Nitro architecture also underwent a recent audit, the findings of which have been made public <cit.>.
While open-source code and professional audits contribute to reduced need for user trust, they are not sufficient on their own. 
Additional transparency mechanisms are essential to hold those who write or review the source code accountable. 
These mechanisms should also allow users to practically verify that a specific version of a piece of software source code matches its corresponding binary. 
Such transparency mechanisms provide users with information about trustworthiness of a binary.
Attestation can serve as the final link in the trust chain, allowing users to verify that the trusted binary runs on a certain machine.

Although transparency does not ensure security, as evidenced by significant vulnerabilities found in open-source software <cit.>, it offers significant improvement over the alternative of naive trust. 
Transparency allows for community scrutiny, which typically leads to quicker detection and resolution of issues, thereby promoting greater accountability. 
Transparency is not limited to source code:
Certificate Transparency is now the standard method for monitoring TLS certification <cit.>, inspiring similar initiatives such as Key Transparency <cit.> and Binary Transparency <cit.>.

In this paper, we propose a transparency framework for Confidential Computing systems which systematises the landscape of possible solutions and considers a diverse range of possible methods, including open-source code, reproducible builds and provenance or endorsement statements by first- and third-party and community reviews processes. 
These methods are underpinned by digital certificates and verifiable transparency logs to permit remote attestation of these steps to users.
Our framework supports a hierarchy of transparency where each level builds on the previous one (<ref>). 
This layered approach supports a clear pathway of improvement for Confidential Computing systems to follow as time and technology allows.
While the focus of this paper is on Confidential Computing Transparency, the proposed ideas may also be applied to hardware and binary transparency in a wider context.

It is essential to understand how these advancements impact user trust. 
To explore this, we conducted a user study targeting non-expert computer users who were recruited via Prolific.
We presented 400 participants with information on how data is processed by a variety of Confidential Computing systems (<ref>) to assess perceptions of trustworthiness when processing personal information. 
The study focused on two key aspects: (1) how different levels of transparency affect end-user trust in Confidential Computing, and (2) what types of data end-users are willing to share with Confidential Computing systems at different transparency levels. 
Our results indicate that end-users of computer systems largely recognise the benefits of increased transparency, and the trust they placed in Confidential Computing systems correlated positively with the levels assigned by our framework. 
We also found that greater transparency is especially valued when it concerns data that users consider sensitive.

Our main contributions are summarised as follows:

    
  * We establish key concepts related to transparency in Confidential Computing, covering its definition, significance, scope, beneficiaries and facilitators (<ref>).
    
  * We propose the Confidential Computing Transparency framework, bridging technical security in TEEs and user trust through reviewer accountability and a robust trust chain (<ref>).
    Our framework offers tiered transparency levels, adaptable for complex needs and limitations of real-world systems.
    
  * We conduct the first user study to empirically study end-user trust in Confidential Computing with 400 participants (<ref>).
    Results show that increased transparency positively impacts trust, especially for sensitive data.



§ DEFINING TRANSPARENCY


In this section, we answer five important questions about transparency in Confidential Computing: what is it and why is it important (<ref>), what is subject to transparency (<ref>), who stands to benefit from it (<ref>), and who facilitates it (<ref>). 
We defer answering the question of how transparency can be achieved to <ref>.



 §.§ Necessity of transparency

Attestation is a process that provides insights into the trustworthiness of a TEE.
It often involves a hardware-signed proof about some information about the origin and current state of a TEE <cit.>.
There are three types of claims that may be derived from this signed proof:


    
  * Authenticity: 
    Attestation allows users to verify the origin of the TEE and the workload running inside it.
    It involves verifying that the TEE has been produced by the expected manufacturer, and that it runs the expected workload.
    
  * Integrity: 
    Attestation can also provide users with claims about whether the software components, such as the firmware, bootloader, operating system, and workload, have been tampered with.
    
  * Runtime status: Attestation can additionally provide partial insights into the runtime status of the current state of the TEE, such as the execution mode.


Although attestation plays a pivotal role in building trust in the authenticity and integrity of a TEE <cit.>, it has limitations in providing comprehensive security assurance. 
Most significantly, attestation cannot guarantee the absence of vulnerabilities or backdoors within the attested components. 
For example, if firmware or hardware in the Trusted Computing Base (TCB) of the TEE contains a hidden backdoor granting unauthorised access to user data, attestation may still succeed. 
This is because the backdoor does not compromise the measurable authenticity or integrity of the TEE, and the runtime-related data included in the attestation evidence is restricted in scope.

A transparent approach with thorough review processes is crucial for uncovering vulnerabilities or backdoors. 
Such reviews can include inspecting the source code of critical binaries, evaluating the tools used in generating the binaries from the source code, and conducting comprehensive assessments of the system's architecture (<ref>). 
Embracing this kind of transparency can mitigate hidden threats, empower users and stakeholders to make informed decisions, and ultimately provide a high level of assurance about the security of a Confidential Computing system. 



 §.§ Scope of transparency

When discussing transparency in Confidential Computing, it is crucial to extend our perspective beyond the TEE. 
Communication channels with a TEE, where users load private data and code, must be secured, for example, by using a cryptographic protocol. 
Similarly, when multiple TEEs, such as those on a CPU and a GPU, collaborate to process sensitive data, the communication between them must also be secure. 
Therefore, we consider the entire end-to-end Confidential Computing systems rather than focusing only on TEEs.

In an end-to-end Confidential Computing system, we classify the components that could jeopardise the confidentiality or integrity of user data if they are compromised or malicious as sensitive components.
These include the TEE TCB for security and integrity (e.g. the components that process plaintext user data, generate or store keys), as well as endpoints and protocols used in TEE-to-user or TEE-to-TEE communication.
While transparency should ideally apply to all sensitive components, not all benefit equally.
We identify three prerequisites for benefiting from transparency in this specific context:


    
  * Reviewability: 
    It should be possible to gain meaningful information about the security of a component through inspecting it.
    This goal is inherently subjective and must be considered on a case-by-case basis.
    For example, the ideal approach to achieve reviewability for a software component is granting reviewers access to the source code.
    However, even with source code access, nuances arise <cit.>; access to the documentation, architecture, reference manuals, or expert guidance might impact the reviewability of a large and complicated code base.
    The same applies to granting access to the commit history versus a snapshot of source code. 
    In situations where providing source code access is not feasible, other forms of reviewability can also be achieved, for example by executing a binary within a confined environment and analysing its behaviour.    
    While the highest level of reviewability should always be the primary goal, practical constraints may call for a best-effort approach.
    
  * Certifiability: 
    It should be possible to generate and publish a digitally signed statement for a reviewed component.
    The ability to provide a validation of a review is crucial for maintaining the integrity and transparency of the review process, enhancing the quality of reviews, aiding in compliance with legal and regulatory requirements, providing evidence in disputes, etc.
    Certifiability can take different forms.
    For instance, one can produce a signed statement for some source code that has been reviewed.
    On the other hand, when dealing with a machine learning model that is pre-trained but undergoes frequent fine-tuning for different users, certifying the model's architecture rather than its weights might be a suitable option.
    
  * Attestability:
    While transparency is necessary for addressing the limitations of attestation in providing security assurance, attestability itself serves as a prerequisite for transparency.
    This paradoxical need stems from the fact that attestation provides authenticity and integrity verification (<ref>). 
    If a component lacks attestability, users cannot confirm whether a specific instance corresponds to a reviewed version of a component, and certifiers cannot be unequivocally held accountable for their assessments.
    As a result, if the component is not attestable, making it transparent cannot enhance its security assurance in an externally verifiable way.


We call the sensitive components that meet all three criteria as transparency-enhanced sensitive components.
Hardware transparency
A notable category of sensitive components that may not fit the transparency-enhanced description is hardware. 
While hardware designs can be open-sourced, like OpenTitan <cit.>, reviewed, and even formally verified <cit.>, there appears no scalable method for verifying that any piece of hardware matches a particular design, with the same technical guarantees as software. 

Methods like supply chain auditing and monitoring can provide some level of insight into hardware integrity.
Apple's Private Cloud Compute counters targeted hardware attacks by using high-resolution imaging in the manufacturing chain, and auditing hardware at the data centers under third-party oversight <cit.>.
Another approach can be inspecting random hardware samples to verify that they correctly correspond to the design.
However, these methods fall short of the certainty provided by reproducible software builds.
As a result, reviewability and certifiability of hardware components present significant challenges.
The same applies to attestability, as current attestation protocols mainly focus on software elements like firmware and drivers, offering little or no assurance about hardware.

These challenges are so fundamental that they hinder the user's ability to assess whether the hardware can support Confidential Computing; let alone its correctness.
Given these complexities, in this paper we focus on the software components of Confidential Computing systems.
Nevertheless, if the above challenges are resolved, our transparency framework can be used for hardware as well.
Until then, the security properties gained by the transparency framework we propose rest on the correctness of the Confidential Computing hardware.

Non-sensitive components
Addressing the transparency of non-sensitive components, which do not jeopardise the confidentiality or integrity of user data if compromised, requires establishing a well-defined trust boundary. 
This trust boundary essentially assumes the role of a sensitive component, safeguarding the integrity and confidentiality of data.
Transparency can then be used to externally validate that this trust boundary prevents the non-sensitive components from accessing sensitive memory regions or otherwise compromising confidentiality and integrity of data. 
Assurance in this context can be achieved through various means, such as hardware isolation or memory encryption.
If the trust boundary is transparency-enhanced, then non-sensitive components do not need to be included in the transparency discussions.
Otherwise, non-sensitive components should also be treated as sensitive and be included in the transparency efforts.



 §.§ Agents of transparency

A Confidential Computing system achieves transparency when its users can directly review its sensitive components, or delegate this responsibility to others.
The reviewing entity must remain accountable and directly answerable to the users for their evaluations and decisions.
This accountability is achieved by issuing review certificates, which uniquely identify the reviewed component and bear the signature of the reviewer.
Therefore, we refer to the accountable reviewers who serve as the agents of transparency as the certifiers.

Traits: Each certifier has traits relating to their methodology and motivation. 

In terms of methodology, certifiers can be either reporting or alerting.
A certifier's methodology affects the content of the certificate they issue.

Reporting certifiers adopt a methodology that involves uncovering both the strengths and shortcomings of the component under review.
They issue certificates that are similar to security assessment reports, which include the scope and findings of the review.
The number and content of reporting certificates, as well as the credibility of the certifiers all play into signalling trust about a component.
Users may choose their own trusted reviewers, similar to the open-source Rust code review system  <cit.>. 
Alternatively, rather than relying on a fixed set of trusted parties users might form a web of trust, in the same way as  <cit.>, another Rust review system.
Also similar to  <cit.>, users can define policies to ensure that their trusted reviewers assess the code according to specific criteria. 
To provide guidance to reporting certifiers or achieve some coherence in structure among different reporting certifiers, the code owner may provide a signed public review plan as well.

Alerting certifiers have a methodology focused on finding bugs and vulnerabilities in the component under review.
They issue certificates detailing the discovered bug or vulnerability, including information such as the vulnerability type, root cause, impact description, and public references–similar to CVE records <cit.>.
These certificates are useful for urging the code owner to fix the issues and holding them accountable if they fail to do so.
Once the bug or vulnerability is fixed, an alerting certifier must assess the fix and issue a follow-up certificate that includes their opinion on the solution. 
The number and content of alerting certificates, credibility of the certifiers, the promptness and effectiveness of the code owner's response to these certificates may serve as trust signals.



In terms of motivation, certifiers can either be independent, or they may be affiliated to the code owner.
Independent certifiers do not have vested interests in the code owner's outcomes and are not responsible to them.
They may have a greater commitment to ensuring the component's quality and security.
However, they may also be driven by self-interest, such as an independent researcher aiming to publish a paper about a vulnerability in the reviewed component, an open-source contributor who wants to gain experience, or individuals affiliated with competing organisations who aim to highlight weaknesses in the code owner’s product.
Similarly, a bug bounty hunter, motivated by financial rewards, seeks to find bugs without bearing any responsibilities toward or having vested interests in the code owner.

Affiliated certifiers share a formal or informal association with the code owner.
This affiliation may arise from contractual agreements, employment, partnerships, or having financial ties with the code owner. 
While the affiliation introduces potential impact on their assessments, they are incentivised to maintain high standards due to accountability for their certificates and the risk to their reputation.
A structured reputation system tracking review quality, consistency, and peer feedback can further encourage thorough and truthful assessments.

Categories:
We categorise certifiers into three groups based on their access methods to the reviewed components, namely first-party, third-party, and community certifiers.
As Figure <ref> shows, the categories of reviewers are orthogonal to their traits.

First-party certifiers are internal to the entity responsible for producing the reviewed component, which we refer as the code owner. 
These certifiers are usually either included in the component's development or they oversee it.
They should have the authority to directly make or otherwise invoke changes to the reviewed component if they notice a problem with it.
All first-party certifiers are affiliated, and most likely reporting in methodology.
However, there are also examples of alerting first-party certifiers.
For example, first-party security research teams like Google Project Zero <cit.>, Microsoft Security Response Center (MSRC) <cit.>, and IBM X-Force <cit.> search for and publicise vulnerabilities in their own closed-source <cit.> or open-source <cit.> software.

Third-party certifiers are granted exclusive access to the components for review. 
The ideal third-party certifiers are independent experts.
This may include regulators, and to some degree, customer companies. 
For instance, a cloud computing platform purchasing hardware might seek to review the firmware and drivers. 
Similarly, a company outsourcing software development might want to review the components to ensure the quality of the work.
Customer companies might not be fully independent due to intricate business dynamics, such as financial investments, loyalty due to long-term partnerships, concerns about the performance impact on purchased components, etc.
Third-party certifiers may also be affiliated, such as auditors or consultants paid by the code owner.
It is worth noting that third-party certifiers might be obligated to create their certificates in such a way that does not expose any confidential information about the reviewed component.

Community certifiers have access to the code through open-sourcing.
These certifiers are individuals or groups of volunteers from the broader community, often with expertise to review the relevant components.
This includes academics, independent researchers, bug bounty hunters, and external adopters who want to use the open-source code in their own projects.
Notable community certification programmes are  <cit.> and  <cit.>, collaborative code review projects for verifying security and reliability of Rust dependencies.
Professional research teams such as Google Project Zero <cit.>, MSRC <cit.>, and IBM X-Force <cit.> also act as alerting community certifiers when reviewing code produced by other code owners <cit.>.



 §.§ Beneficiaries of transparency


We identify four types of users who may benefit from transparency:

    End users have their data processed within a Confidential Computing system, whether on a remote resource, such as a cloud infrastructure, or their own devices. 
    These users' primary concern revolves around ensuring the privacy and integrity of their data.
    Application developers execute code within Confidential Computing systems, where their priority may be protecting the confidentiality of their code, their customers' data, or both.
    This category of users includes the application developers using cloud-based services such as Google Cloud Confidential Computing <cit.>, Microsoft Azure Confidential Computing <cit.>, and AWS Nitro <cit.>.
    It also includes users who leverage hardware of end-devices to execute their code, be it an operating system, a hypervisor, or other lower-level components. 
    Application providers execute third-party code, i.e. code they have not authored, within Confidential Computing systems.
    Their primary concern is ensuring the security and trustworthiness of the code they run.
    Platform providers include cloud providers, software-as-a-service providers, CPU manufacturers as platform providers for executing code in enclaves, Android with Private Compute Core <cit.> or Android Virtualisation Framework (AVF) <cit.>, and other entities offering infrastructure or services for Confidential Computing. 
    Their main objective is to establish and maintain a trustworthy Confidential Computing system for end users and application developers, ensuring the integrity and security of the systems and services they provide.






§ CONFIDENTIAL COMPUTING TRANSPARENCY


Following the reasoning and discussions we provide in <ref>, we define Confidential Computing Transparency as follows.


Transparency in Confidential Computing is the practice of allowing certifiers (as categorised in <ref>) to examine the security properties of the sensitive, reviewable, certifiable, and attestable (as defined in <ref>) components of a Confidential Computing system.
These certifiers should be able to certify their comprehensive assessments in a manner that is publicly verifiable.


In this section, we present a framework to answer the question of how this transparency can be achieved in Confidential Computing.
Our framework acknowledges the diverse transparency needs, limitations, and risk profiles of various system components. 
For instance, some transparency-enhanced sensitive components might not allow open-sourcing or third-party certification due to IP restrictions or proprietary information.
This complexity is more pronounced in real-world systems involving multiple stakeholders and components from different vendors.
For example, even a setup that consists of a single TEE can include microcontroller units from different vendors, each with dedicated firmware and drivers.

To address complex requirements and challenges, our framework adopts a layered approach, defining three transparency levels, each incorporating a certifier category described in <ref> and a set of trust-building blocks.
As shown in Figure <ref>, each level builds on the previous one by adding more trust-building blocks and integrating an additional certifier category.
Based on needs and limitations, system designers can apply different transparency levels to different components, though we strongly advise aiming for the highest transparency level achievable.



 §.§ Level 1 (L1)


Requirements 
The foundational level of transparency is achieved through engaging first-party certifiers as accountable reviewers.
This level relies on the following trust-building blocks to ensure transparency:

    
  Endorsement statement is a digitally signed statement by affiliated and reporting first-party certifiers, including a unique identifier of a binary (e.g. hash), as defined and used by Google's open-source project Oak <cit.>.
  It can also include the time of issuance and the validity period.
  By issuing an endorsement statement for a specific binary, the certifier confirms that the binary was generated from specific source code and endorses its use in production for the validity period. 
  The certifier also implicitly vouches for additional checks that are not explicitly captured in the endorsement statement, such as ensuring that the build and release pipelines work correctly.
  After the validity period, the certifier may issue a new statement or passively revoke the existing one by taking no action (see <ref>).
    
    
  Verifiable transparency log is defined as a publicly available append-only ledger maintained on a trusted infrastructure by an independent party, separate from the code owner or the certifiers <cit.>. 
    Transparency logs do not inherently guarantee truthful and accurate operations, so additional measures are required to ensure their integrity and consistency, as we discuss in <ref>.



Process
At this transparency level, the review and certification must happen prior to the binary's release.
There is one exception to this rule: if first-party researchers identify a vulnerability in the binary after its release, they may issue alerting certificates.
The first transparency level is achieved through the following steps.

    
  * First-party certifiers review the security of the source code associated with the sensitive components, and approve it for release.
    
  * The code owner builds a binary from the source code. 
    To ensure the integrity of the build process, it is essential that both the code owner and the first-party certifiers have established trust in the build toolchain and infrastructure used. 
    This trust is ideally built through direct review of the tools and processes. 
    If direct review is not feasible, it may be reasonable to implicitly trust open-source tools, or tools widely used across the company and maintained by a dedicated team.
    The code owner can then release the binary, e.g. by distributing it to cloud servers, end devices, or publishing it to an app store.
    
  * 
    First-party certifiers generate an endorsement statement that they sign with their private signing keys (separately or using a multisignature scheme <cit.>).
    They publish this endorsement statement on a transparency log.
    
  * 
    If first-party researchers discover a vulnerability after the binary's release, they generate a signed alerting certificate as described in <ref>, and publish it on the transparency log.
    
  * 
    After receiving a binary, the user must verify that the transparency log contains a valid endorsement statement. 
    This involves: (I) confirming the endorsement's binary hash[If the binary is running on a server where the user as the client (as opposed to the user's end-device) the user must obtain the attestation evidence of the binary to retrieve the correct hash value.] and validity period, and (II) verifying the endorsement's signature(s) using the certifiers' public keys, unless relying on third-party monitors (<ref>).
    
    In Binary Transparency, this verification is typically done by an auditor, usually represented as client-side software <cit.>. 
    Inclusion proofs can be used for efficiently verifying that an endorsement statement is added to the transparency log (<ref>). 
    The user (or auditor) must also periodically check the log for any alerting certificates, which may prompt them to discontinue using the binary.


Discussion
At this transparency level (L1), beneficiaries cannot directly see the attested components, but generating and publishing endorsement statements holds the code owner accountable for their released binaries. 
This ensures the code owner cannot disown a particular release.
Furthermore, this transparency level ensures that any insider or outsider attacks on the released binary do not go unnoticed, as new transparency log entries or their absence are detectable.
This achieves `Signature Transparency', a concept implemented by Sigstore's Rekor <cit.> and Sigsum <cit.>.

L1 also guards against covert targeted attacks, where an attacker serves a specific user a targeted malicious binary by allowing users to verify they are served the same binary as everyone else. 
However, this system is not immune to more overt, coordinated attacks. 
Even if the transparency log operations are monitored for correctness as described in <ref>, an adversary can manipulate the timing of population updates. 
For instance, the adversary might delay visibility of transparency log updates for certain IPs or intentionally cause out-of-band checks for update availability to fail for specific IPs. 
This way, the adversary can potentially create split-view release streams with `good' and `bad' binary versions. 
Even so, this transparency level can alert vigilant observers to anomalous activities like unusual release patterns or duplicate version numbers, serving as a deterrent and early warning mechanism against targeted attacks.

As all first-party certifiers are affiliated (see <ref>), reviewers in this transparency level are limited to the first and second quadrants of the certifier diagram (Figure <ref>).
In other words, there is no variety of motivation among certifiers at this transparency level.



 §.§ Level 2 (L2)


Requirements
The second transparency level is achieved by introducing third-party certifiers as accountable certifiers.
First-party certifiers also participate at this level, performing reviews and issuing certificates similarly to how they operate in L1. 
This ensures that code owners remain accountable for the binaries they release. 
In addition to the trust-building blocks used in the first transparency level, the second level introduces the following ones. 

    
  Reproducible builds refers to a collection of tools and techniques that are used to ensure that every build for the same source code consistently generates the same bit-exact binary output <cit.>. 
    
  Provenance statement includes all the necessary configuration details for building the source code into a specific binary, such as what toolchain, commands and flags to use <cit.>.
    It is provided by the code owner to certifiers alongside the component under review.


Process
The build, release, and first-party review process of the binary happens as described in L1 (<ref>). 
To attain L2 transparency, the following additional steps must be followed.
At this transparency level, the review and certification can happen before or after the binary's release.


    
  * Third-party certifiers review the source code of the sensitive components.
    The source code must be reproducibly buildable to allow each certifier to build it by themselves, and verify that the source code and the resulting binary is the same as the ones reviewed and built by the other certifiers (see <ref> for the alternative).
    
  * 
    Each certifier uses the provenance statement to learn the build configurations for the component and independently compiles the source code into a binary on trusted infrastructure. 
    Certifiers must establish trust in the build toolchain instructed by the provenance statement, which can be achieved by applying transparency principles to the toolchain itself (see <ref>).
    
  * 
    Each third-party certifier generates a signed certificate (either reporting or alerting as described in <ref>) for the self-built binary, and publishes it on a transparency log.
    
  * 
    Once the binary is received on an end-device (or the attestation evidence if the binary runs on a server), the user should check if a valid endorsement statement for it exists on a transparency log, as in L1 Step <ref>.
    Unlike endorsement statements the existence and validity of certificates from third-party certifiers is not enough to provide trust to the beneficiaries; the content of the certificates also matter (<ref>).


Discussion
The second transparency level (L2) significantly improves trust by incorporating both affiliated and independent third-party reviewers, unlocking the third quadrant and expanding the diversity of reviewer motivations (Figure <ref>).

From a practical standpoint, incorporating third-party certifiers may introduce potential delays in the review process, particularly in dynamic production environments where code updates are frequent. 
This creates a trust dilemma, especially in scenarios where a vulnerability is detected. 
The code owner may need to decide whether to quickly implement a patch without waiting for certification, or follow the full review process and delay until certification is received.

To mitigate these time-related challenges, one potential solution might be implementing a transparent source control mechanism to allow certifiers to review only the code changes.
An alternative approach is issuing certificates after the binary is released.
Although this might mean users are not immediately assured that third-party certifiers have vetted the binary processing their data, this mechanism disincentivises the code owner from releasing malicious or subpar code.
To implement this approach, the code owner should include an explicit promise in the endorsement statement at Step <ref> that there will be a third-party audit certificate to follow. 
This promise may also specify a timeline for certification, e.g. .
Having a signed explicit promise like this eliminates ambiguity and allows for more automated verification of the promise at Step <ref>.

Making the source code reproducibly buildable can be challenging, or the reviewers might find it impractical to build the binary themselves. 
An alternative approach is using a trusted builder (see <ref>).
However, this option comes with certain caveats, such as the need for the certifiers and beneficiaries of transparency to trust the builder. 
    


 §.§ Level 3 (L3)


Requirements
The third and highest level of transparency employs community certifiers as accountable reviewers. 
As in L2, community certifiers do not replace the first-party and third-party certifiers from the previous levels.
L3 must include first-party certifiers, and ideally, it should also incorporate third-party certifiers.
In addition to the trust-building blocks used by the other levels, this transparency level introduces a new one:

    
  Open sourcing in this context refers to making the source code of a component publicly accessible on a platform, which the user does not need to trust.


Process
In this level, each community certifier follows the same process described in L2 (<ref>).

Discussion
This level of transparency significantly improves openness and accountability, driven by principles of public accessibility and community involvement. 
It allows anyone with the neccessary skills and time to be able to review the source code.

It is important to recognise that open-sourcing, while a powerful tool for transparency, does not guarantee that all security issues will be detected immediately, as evidenced by past vulnerabilities in large-scale open-source projects with extensive communities including Heartbleed <cit.>, POODLE <cit.>, Log4Shell <cit.>, and Shellshock <cit.>.

Similar to L2 (<ref>), this transparency level may not always guarantee real-time verification. 
Nonetheless, open-sourcing remains a crucial step towards minimising the need for user trust.
Moreover, unlike traditional open-sourcing, this transparency level requires reviewers to certify their assessments, serving as an additional trust signal (<ref>).

Availability of source code substantially improves the ability of independent alerting certifiers to analyze code for defects (<ref>), fully unlocking the last and fourth quadrant of the certifier diagram (Figure <ref>).
To incentivise such certifiers, the code owner may set up bug bounty programmes.
The code owner may also set up coordinated vulnerability disclosure mechanisms to allow the alerting reviewers to report issues to the code owner and giving it some time before issuing a public certificate.
In this case, if the issue is fixed before it is disclosed to the public, the certifiers may still issue their certificate after a patch has been released, similar to how first-party security research teams file CVE records after patch releases.



 §.§ Revocation

Revocation is an essential part of the transparency framework, as the majority of software is ultimately revoked. 
There are two main reasons to revoke an endorsement statement or a binary:


    
  *  The code owner or a certifier finds a vulnerability in the endorsed binary. 
    
  *  A monitor, witness (<ref>), or auditor (<ref>) identifies an anomaly in the transparency log or endorsement statements.


In both of these cases, there are decisions to make about who will make the revocation decision and how will the revocation be carried out.

When the reason <ref> applies, and the code owner or a certifier discovers a vulnerability, the code owner can revoke the endorsement statement.
One way to achieve this is through passive revocation by issuing short-lived endorsement statements and simply not issuing a new endorsement statement for the affected binary. This allows users to detect the issue and stop using the binary. 
Alternatively, code owner can actively revoke a statement by publishing its unique identifier on a publicly accessible certificate revocation list (CRL) <cit.>.

For both revocation reasons <ref> and <ref> above, users can independently choose to stop using a binary based on information they receive from auditors, monitors, or witnesses. 
One way to implement this is through a policy in the client-side auditor software <cit.>, similar to the policies in Rust  <cit.>.
This policy can alert the client about inconsistencies on a transparency log or the existence of alerting certificates about a binary.
Alternatively, monitors or witnesses can collectively issue global revocation statements, which they can then publish on CRLs.


§ ADDITIONAL CONSIDERATIONS

In this section, we describe optimisations and other modifications that can be applied to our transparency framework to accommodate different needs and constraints.



 §.§ Monitoring transparency logs

Publicly available transparency logs do not inherently ensure truthful and accurate operations. 
Monitors can watch logs for correct behavior, such as ensuring the log is append-only, hashes are valid, and the log does not present split views to different observers <cit.>.
To avoid split views, monitors can share their current and previous views of tranpsarency logs via gossiping
<cit.>, gaining a comprehensive understanding of the log's state and prevent propagation of inaccuracies.
Approaches like collective signatures from witnesses have been proposed to mitigate potential attacks on gossiping <cit.>.

Even if the transparency log behaves correctly, the mere presence of an endorsement statement in a log does not confirm its validity; it only means that the information is discoverable.
Without validating the endorsement statement, the trust relies on the expectation that someone will eventually detect any inaccuracies and raise an alarm.
So far, we have described this validity check as a client-side responsibility (see L1 Step <ref> and L2/L3 Step <ref>), which may be impractical due to resource constraints, technical expertise, or the large volume of data in transparency logs. 
Additionally, clients would need certifier public keys, which can be challenging to manage.

Beneficiaries of transparency can instead delegate this validation responsibility to monitors, who can verify the correctness of statements and certificate signatures within the transparency log <cit.>.
Ideally, the code owner should offer an open-source monitoring mechanism, enabling individuals to scrutinise its source code and deploy them on their trusted machines.
The trustworthiness of the monitor code itself can be increased by using our transparency framework.



 §.§ Inclusion proofs

When a user receives a binary or attestation evidence for a binary, they should verify the presence of a corresponding valid endorsement statement in a transparency log (see L1 Step <ref> and L2/L3 Step <ref>).
This can be efficiently done using inclusion proofs, similar to how they are used in Certificate Transparency to verify the inclusion of a certificate on a transparency log <cit.>. 

To be able to have inclusion proofs, the transparency log is constructed as a Merkle tree <cit.>, where the tree head is signed by the log operator <cit.>.
An inclusion proof contains the shortest list of hashes needed to compute the tree head given a leaf node. 
With an inclusion proof and the hash of an endorsement statement (as the leaf node), if the client can compute the tree head hash and also verify the signature of the tree head, this confirms that the endorsement statement has indeed been included in the transparency log (conditional upon the client having the correct public key to verify the signature).
To keep inclusion proofs scalable, the log operator periodically issues a signed commitment to the state of the log, sometimes called a checkpoint, which can be used instead of the original tree head <cit.>. 
This approach reduces the verification complexity from linear to logarithmic in the number of certificates.

Certificate Transparency uses inclusion promises, signed commitments from log maintainers guaranteeing future entry addition, to address merge delays. 
Unlike inclusion proofs, these promises require full trust in the log and additional monitoring <cit.>. 
In Confidential Computing Transparency, where some latency at publish time is likely tolerable, we do not recommend inclusion promises to be used.
Alternative transparency log designs like Sunlight <cit.> can help reduce merge delays.



 §.§ Trusted builders

In L2 and L3 (<ref> and <ref>), the certifiers are responsible for building the binary to ensure the binary they issue a certificate for is generated from the source code they have reviewed.
Alternatively, a trusted builder, a dedicated tool for building binaries, can take on this task.
Using a trusted builder presents an important tradeoff: the certifiers are relieved from the responsibility of building the binary themselves, but they need to trust the builder.
Despite this tradeoff, a trusted builder can be helpful especially in L3, where community reviewers may lack resources.
Moreover, using a trusted builder removes the requirement for the source code to be reproducibly buildable, which can be a difficult task for the code owner to achieve and maintain.
However, ideally, the source code should still be reproducibly buildable to allow independent verification. 

A key difference with using a builder is that for each build, the trusted builder should generate a signed provenance statement and post it on a transparency log. 
This statement is a verifiable and attributable claim that the binary was built honestly on a trusted, uncompromised platform, allowing the certifiers to gain insight into the build environment.
This is especially important since the code does not have to be reproducibly buildable, and the certifiers might not be able to build the binary themselves to compare it with the binary that the trusted builder produced.

To establish trust in a builder, users must first trust the build toolchain. 
This can be achieved by using an open-source build toolchain and applying the transparency principles to it (also see <ref>).
Second, the toolchain must also operate on trusted infrastructure, ideally controlled by an actor unlikely to collude with the code owner.
For instance, Google's open-source Confidential Computing project Oak <cit.> has a trusted builder that uses the open-source SLSA build stack <cit.> and runs on GitHub, which is currently owned by Microsoft. 
The level of assurance can be further increased by involving multiple independent builders. 
For example, Oak runs a trusted builder instance on Google Cloud in addition to GitHub. 
Another way of increasing the trustworthiness of a builder is to run the build toolchain’s TCB inside a TEE that is different from the one under scrutiny.
Using a hardened build platform with strong isolation and protection for the provenance signing key can also increase trust on the builder.
This idea is used in SLSA V1.0 as well <cit.>.

If a trusted builder is used in  L2 or L3, the release process for the binary is revised as follows:

    
  * The code owner initiates a build of the source code using a trusted builder. 
    
  *  The trusted builder generates a signed provenance statement about the binary and the build process, publishes it on a transparency log, builds the code into a binary and returns it to the code owner. 
    If there are multiple trusted builders, then all builders do the same.
    
  * The code owner verifies the signature of the provenance statement, and confirms that the information it contains about the build process is correct. 
    If there are multiple trusted builders, the code owner does these checks for each build. 
    If the binary is reproducibly buildable, the code owner also checks that all binaries are identical.
    
  * If the checks about the build are successful, the code owner generates an endorsement statement about the binary. 
    If the code is not reproducibly buildable and there are multiple trusted builders, the code owner generates an endorsement statement for each unique binary.
    These endorsement statements include a unique pointer to the provenance statement generated and published by the trusted builder in Step <ref>. 


Following this build and release process, the third-party or community certifier in L2 or L3 review the source code. 
If the source code is not reproducibly buildable, Step <ref> of L2 and L3 is replaced by the certifier verifying that a certain binary correctly corresponds to the reviewed source code.
To do so, the certifier gets the endorsement statement for that particular binary version from the transparency log, and checks that the signatures on both the endorsement and provenance statements are valid. 
The certifier also checks if endorsement statement includes the correct binary hash.
If the source code is reproducibly buildable, the certifier can additionally build it on its own trusted infrastructure, as in Step <ref> of L2 and L3.



 §.§ Automated certifiers

A certifier can be replaced by automated processes, introducing a fourth certifier category, which we call automated certifiers.
An automated certifier can be constructed by building a transparent mechanism that generates formal proofs of security properties of the component.
The transparency of the generation mechanism gives assurance to the beneficiaries (<ref>) that the proofs are generated correctly.
This alternative certifier type can be used for achieving transparency in a similar way in L2 and L3, also using a trusted builder as we describe in <ref>.
The level of transparency provided depends on the assurance of the generated proof.
This alternative certifier type can both be seen as an optimisation, since automated proofs may work more efficiently than human reviewers, and as a privacy enhancement, as the code owner can potentially generate proofs that do not reveal proprietary information, e.g. by using zero-knowledge proofs <cit.>.


§ USER STUDY


We conducted a user study to examine how varying levels of transparency within the Confidential Computing Transparency framework affect end users' perceptions of trust and confidentiality. 
Given that end users often view certain types of data as more sensitive than others <cit.>, we anticipated that these perceptions might influence their preferences for transparency.
Therefore, we included different data types as a factor in our study.



 §.§ Research questions and method


We aim to answer two main research questions: 


    
  *  How do different transparency levels of the Confidential Computing Transparency framework shape end users’ sense of trust?
    
  *  What types of personal data are end users willing to share at different transparency levels?


In the study, we first introduced participants to Confidential Computing through a script presented as both an animated and narrated video[<https://www.dropbox.com/scl/fi/9swys6bkypg5n16mgrjvm/transparency_short.mp4?rlkey=ws2o90lw3v5zr3jrhxqwycrvk   st=zvytmn3x   dl=0>] and text (Appendix <ref>). 
The script described Confidential Computing as a system that protects user data from app developers, emphasising that its trustworthiness depends on secure design and implementation.
This was illustrated with a vault analogy, emphasising that trust depends on confidence that the keypad does not secretly record PINs or have hidden mechanisms to bypass security.
The script also introduces the concept of transparency through reviews and certification, noting that these certifiers can be held accountable if their assessments prove faulty.
Participants' comprehension of key concepts was assessed with three true or false questions.

In the core phase of the study, we presented the participants with a series of imaginary virtual assistant apps running on Confidential Computing systems.
Each app required access to a different type of personal data, which we categorised into (1) social-economic, (2) lifestyle-behaviour, (3) tracking, (4) financial, (5) authenticating, and (6) medical-health data, drawing from the work of Chua et al. <cit.>.
We selected virtual assistant apps, as they represent a single app type that may require access to any of the six chosen data types.
Each app was randomly assigned a specific transparency level L1, L2, or L3, or no transparency at all.
We carefully described each transparency level using neutral language and labelled all certifier types as experts to avoid implying any hierarchy.
Exact descriptions are provided in Appendix <ref>.
While our framework incorporates first-party certifiers across all transparency levels, we omitted this detail from the study to maintain clear distinctions between levels, avoiding potential confusion and to not imply any hierarchy.
For each app, we also included an animated GIF illustrating the corresponding transparency level, taken from the informative video.
Participants rated their comfort level using each app, and their confidence in the app's ability to protect their data.

In the final phase of the study, participants rated their comfort level using a virtual assistant app reviewed under different transparency options (L1, L2, L3 and no transparency), regardless of data type. 
They also evaluated their level of concern if their data were leaked or tampered with across various data types, without reference to transparency. 
This question aimed to assess how privacy concerns are tied to perceptions of risk associated with specific data types.
We also collected information on participants' openness to adopting new technologies and their current habits of using virtual assistant apps to determine how general distrust or familiarity might influence privacy concerns.
We provide the full study script as well as a more detailed analysis and a breakdown of demographics in the Appendices <ref> and <ref>. 
Additionally, we make the user study artefacts publicly available (see Appendix <ref>).

We ran the survey using Qualtrics and recruited participants via the Prolific academic platform <cit.>, as recommended by relevant research <cit.>. 
We obtained ethics approval from the University of Cambridge review board (see Appendix <ref> for additional information).
We recruited 400 participants in small batches between 1 August 2024 and 20 August 2024. 
The survey took on average ∼12 minutes, the participants were compensated at a fixed rate of £3 or ∼£15/h. 
Participants that did not complete the study or were identified as bots were excluded and automatically replaced by Prolific.
Those who answered any of the comprehension questions incorrectly more than twice were removed from the study.
This filtered out random clickers, as the remaining participants demonstrated a clear understanding of at least one question.
Our final analysis after the removals was performed on 369 participants. 
Each participant answered questions about the six data type / transparency level combinations of the app, resulting in 2,214 main observations.



 §.§ Quantitative results


To address <ref>, we evaluate two key metrics: (I) participants' comfort levels in the core phase of the study, aggregated across all data types (see Figure <ref>), and (II) comfort with the virtual assistant app under given transparency options, irrespective of data type, which we gather from the last phase of the study (see Figure <ref>).



We find a similar distinct pattern in both cases, indicating a strong effect of transparency on comfort levels. 
Participants reported the lowest comfort levels in the absence of transparency, a trend particularly pronounced when no specific data type was involved. 
A significant increase in comfort was observed when any form of transparency was introduced. 
Among the transparency levels, participants expressed the highest comfort with L2, followed by L3 and L1. 
A broader variation in comfort levels was observed when participants were exposed to different data types, revealing a multimodal distribution, particularly for L1 and L3.
This variation is largely driven by considerable differences in comfort across various data and transparency combinations. 
Conversely, when data types were not specified (see Figure <ref>), the variability in comfort levels decreased, with L2 and L3 yielding almost indistinguishable results. 
We explore these trends further in <ref>.

We formally confirm the significant effect of transparency on participants' comfort through an ANOVA analysis, and we reject the null hypothesis that all transparency group means are equal (ANOVA, F = 159.992, p < 0.001, N = 2,214). 



We additionally examine the effect of data type on participants' comfort regardless of the transparency level.
Our findings on participants' baseline concern about different data types largely align with Chua et al. <cit.>. 
Participants express highest concern (and lowest comfort with sharing) about their financial and authentication data, followed by tracking and medical data. 
They are least concerned about, and most willing to share, socioeconomic and lifestyle-behavior data.

Upon establishing a baseline, we investigate interaction effects between transparency and data type to answer <ref> (see Figure <ref>).
While L2 and L3 seem similar on aggregate level, more nuanced patterns emerge across data types. 
Specifically, participants show a preference for L3 in apps handling financial and tracking data; two categories that evoke higher levels of baseline concern. 
In contrast, L2 is favoured for apps involving lifestyle, social, medical, and, to a lesser extent, authentication data.
Despite these observed trends, the interaction effects are not statistically significant (ANOVA, F=0.801, p=0.6, N=2214). 
Additionally, the consistent gap between least and most preferred transparency options across data types suggests a uniform increase in comfort from the baseline.

Demographic analysis reveals several correlations in comfort levels for data sharing. 
There are weak correlations with gender and age: women express slightly higher comfort levels than men, and younger participants tend to be more comfortable sharing data compared to older individuals. 
There is also a positive correlation between participants' willingness to explore new technology and their willingness to share data.

Our analysis covers four main regions: the Americas (144 participants), Europe (143), the Middle East and Africa (66), and Asia and the Pacific (14). 
While region does not significantly affect overall comfort levels, two patterns emerge.
First, European and American participants exhibit higher baseline concern for their data, particularly regarding lifestyle, social, tracking, and medical data.
Second, these participants also report lower comfort levels with no transparency and L1.
However, the comfort levels for L2 and L3 are largely consistent for all regions.

Education and work field do not yield statistically significant patterns, but some trends are notable. 
High school or trade school graduates tend to prefer L2 transparency, while university graduates favour L3. 
Field-related patterns reveal that economists (54 participants) are indifferent to transparency levels. 
Participants in arts/humanities (34), social sciences (28), STEM (108), and trades (21) prefer increasing transparency, with comfort levels rising from L1 to L3. 
Health workers (34) and those in `other' fields (71) uniquely favour L2 transparency, being the only groups whose comfort levels decrease from L2 to L3.



 §.§ User perceptions

In addition to quantitative data, we aimed to gain a deeper understanding of participants' perceptions and beliefs about the transparency levels. 
To achieve this, we included an open-ended question asking participants to elaborate on their rationale behind their choices, allowing them to discuss any or all of the transparency levels freely.
We manually analysed the answers to the open-ended question by first removing non-informative answers that do not address the question (e.g.“I was honest”, “Personal experience”) or do not provide reasoning relating to any specific transparency level (e.g. “All seem very safe”, “I would rather trust my data to machines than to people”). 
We started with 369 answers; after removing 185 empty or non-informative answers, we manually annotated the remaining 184 answers to extract the main themes. 
We used an iterative inductive approach, allowing themes to emerge from the data until saturation is achieved and no new themes are identified. 
Finally, two annotators independently classified the participants' answers into the theme classes. 
The Cohen's κ agreement score was 0.82 (almost perfect agreement), with any disagreements later discussed and resolved. 

Participant responses supported the quantitative results, expressing a strong dislike for no transparency (49 answers), believing that unreviewed systems can have vulnerabilities or that the app developer might hide something. 
No answers defended unreviewed systems, however several responses noted reviewing is imperfect as humans make mistakes. 

While the consensus is clear for no transparency, the same cannot be said for L1, L2 and L3. 
The main theme emergeing from the data is that of objectivity and impartiality (90 answers). 
Specifically, participants believe first-party certifiers cannot be objective and trusted due to conflict of interest, possible pressure from their employer, self-interest and bias. 
External certifiers, on the other hand, are considered more neutral and trustworthy because they are not perceived as being influenced by pressure from the app developer.
Many participants express such views for both community and third-party certifiers (70); however, a smaller portion believes that only community certifiers can be truly independent (20). 

Participants expressed a range of concerns, sometimes conflicting, in addition to their focus on objectivity. 
Some participants believe first-party certifiers have a better understanding of the app, giving them an advantage in the reviewing process (4 answers). 
On the other hand, others feel that third-party certifiers are more precise, and are true experts in the field specialised in reviewing (9). 
Similarly, some participants exclusively addressed third-party certifiers as experts, or perceived them to have better and more exclusive access to the sensitive components, especially when compared to community certifiers (16).
In contrast, some participants are sceptical about third-party certifiers, believing they might still try to satisfy or be pressured by the app developer (10), albeit in smaller numbers compared to first-party certifiers. 

Regarding community certifiers, some participants recognised the value of more diverse perspectives, `out of the box' thinking and potential to offer unique solutions (10 answers). 
Additionally, a number of participants valued the increased likelihood of spotting problems due to more reviewers (17).
In direct contrast, some participants felt uncomfortable with having the code available to anyone to see as this might include malicious actors (16). This potentially explains the small dip in user's aggregate comfort for L3. 

Finally, we identified a number of misconceptions among participants. 
Despite highlighting otherwise in the introduction script (see <ref> and Appendix <ref>) and as included in our comprehension questions, a significant number of participants still believed that certifiers have access to participants' personal data or are able to tamper with it (26).


§ RELATED WORK


The security of our HTTPS connections relies on domains sending their X.509 certificates to browsers, which then verify if the certificate is issued by an authorised Certificate Authority (CA). 
This mechanism inherently trusts CAs, creating a risk where compromised CAs could issue false certificates, leading to man-in-the-middle attacks <cit.>. 
To counter this, Google launched Certificate Transparency in 2013 <cit.>, which is currently mandatory in all major browsers <cit.>.
Certificate Transparency allows public verification through three steps: CAs submit data to a transparency log, receive a signed inclusion proof, and incorporate it into the final certificate <cit.>.
Monitors (<ref>) check these logs for anomalies and trigger revocation if needed.

In end-to-end encrypted communication, a similar issue arises with key directory servers.
CONIKS <cit.>, inspired by Certificate Transparency, first introduced the concept of Key Transparency to ensure users receive the correct keys while protecting privacy.
Key Transparency has since evolved and found real-world applications including Google's open-source Key Transparency project <cit.>, along with implementations by WhatsApp and Apple <cit.>.


Binary Transparency <cit.>, addresses similar concerns in software supply chains to ensure accountability for software originating from central repositories and to counter targeted attacks.
It is actively used in Google Pixel binaries <cit.> and Go modules <cit.>.
Sigstore <cit.> is a collaborative project automating logging, signing, and monitoring for Binary Transparency. Similarly, Contour <cit.>, MADT <cit.>, and CHAINIAC <cit.> focus on software integrity through these methods.

Supply-chain Levels for Software Artifacts (SLSA) <cit.> is a framework incorporating Binary Transparency concepts to counter software supply chain threats. 
It uses a tiered structure like ours, and can complement our approach to enhance the resilience of Confidential Computing systems. 
Our L2 and L3 aligns with SLSA v0.1 L4, emphasising reproducible builds and having a two-person review requirement through affiliated reporting first-party certifiers (Figure <ref>, quadrant II).
Implementing our framework's L2 and L3 with hardened trusted builders (<ref>) achieves SLSA v1.0 L3.
Therefore, with specific implementation choices, our transparency framework can provide high levels of supply-chain security.


§ CONCLUSIONS

This paper introduces the Confidential Computing Transparency framework bridging the gap between the technical security offered by Trusted Execution Environments (TEEs) and user trust (<ref>). 
Our framework offers progressive transparency levels involving first- and third-party, as well as open-source reviewers.
It extends beyond existing industry practices by adding reviewer accountability and a robust trust chain with verifiable transparency logs, signed statements, and reproducible builds.
The tiered approach offers a practical solution for implementing trustworthy Confidential Computing systems across diverse scenarios.
We also address key questions about transparency in Confidential Computing, including its definition, importance, scope, beneficiaries, and facilitators (<ref>). 
Our user study highlights the critical role of transparency in building user trust (<ref>), with participants favouring higher transparency over unreviewed systems. 
However, misconceptions about open sourcing underline the need for clear communication and education.

While focused on Confidential Computing due to the unique attestability of TEEs (<ref>), our transparency framework applies to various Binary Transparency scenarios.
For binaries in remote TEEs, attestation ensures integrity, while in controlled environments users can directly validate binaries via signature checks and transparency log inclusion proofs. 
Our framework, while described through software, is also applicable to hardware within our transparency scope (<ref>).

Our levelled transparency framework allows system designers to tailor transparency based on needs and limitations. 
For example, an open-source SPDM <cit.> driver may easily align with L3, while an IP-sensitive compiler might be more suitable for L2. 
We recommend the highest feasible transparency level, while minimising the transparency surface by reducing sensitive components (<ref>).





plain







§ APPENDIX




 §.§ Ethical considerations

Ethics approval was obtained from the University of Cambridge review board prior to research. Given that our study involved human participants, several important ethical considerations were addressed:


    
  * Informed consent: We obtained informed consent from all users, with the option to withdraw from the study at any point or not answer any or all questions. We also provided direct contact with the researchers for any questions or concerns. 
    
  * Confidentiality and anonymity: The data was anonymised and as such no single individual can be identified. We collected minimal demographics information, with all data analysed on an aggregate level.
    
  * Data Security: All data was stored in electronic form on encrypted disks or a secure server. Only researchers involved in the project have direct access to raw data. Any publicly released data is anonymised and aggregated.
    
  * Compensation: The participants were compensated for their time at the rate slightly greater than the UK living wage per hour. The payment was made directly to the participant using the Prolific platform.
    
  * Risks to participants or researchers: We did not foresee any risks or harms to either participants or the researchers involved in the study, or the greater public. 




 §.§ User study script
 



 §.§ Welcome screen

Thank you for participating in this study by the University of Cambridge. Through this study we hope to learn more about people's preferences surrounding data sharing in different transparency scenarios. You will receive a payment of £3 for participating. The study is expected to take approximately 10 minutes.

Your participation is confidential and your identity will not be stored with your data. You will not be asked to provide any personally identifying information. Your answers will be used only for research purposes and in ways that will not reveal who you are. The results will be reported in aggregate form only, and cannot be identified individually. Any information that could identify you will be removed before data is shared with other researchers or results are made public. We will keep the raw data for the duration of the study and delete it by April 2025. For reproducibility, we may release a public appendix containing some aggregate and processed data.

You must be at least 18 years old to participate. By participating in this study, you consent to the data being used for this purpose. Your participation in this research is entirely voluntary and you have the right to withdraw consent at any time by closing your browser. For any questions during or after the study, please contact Ceren Kocaogullar on ck596@cam.ac.uk and Tina Marjanov on tm794@cam.ac.uk.



 §.§ Consent

If you do not wish to participate in this study, please return your submission on Prolific by selecting the `Stop without Completing'. Are you happy to continue? (Note: Participant chooses between “Continue with the study” and “Stop without completing”.)



 §.§ Background information

Please watch the following informational video[footnote]. 
If you cannot watch it, click on the button below to see the text. 
You can proceed after the video finishes playing. 



  §.§.§ Instructional script (written and video)

In this study, you will be presented with a number of imaginary apps. 
These apps run on a Confidential Computing system that aims to protect your data in such a way that even the app developer should not be able to see your data. 
However, this Confidential Computing system can only be trusted if it has been designed and built securely.

Imagine this system like a safe where your data is stored. 
The safe has a keypad, where you can enter your PIN to lock and unlock it. 
In order to trust the safe with protecting your data, you should trust that the keypad does not secretly record your PIN or have a special mechanism that opens the safe.

Sometimes, the Confidential Computing system can be checked by reviewers who certify that the product is safe to use. 
If their certification turns out to be faulty the reviewers can be held accountable.
The reviewers can be:

    
  * experts working for the app developer company
    
  * experts who are granted exclusive access to the code for reviewing it. They may include consultants and auditors hired by the developer company, as well as regulatory authorities.
    
  * experts from the broader software engineering community. The system is made publicly available for reviewing by academics, independent researchers, individuals who get rewards for finding bugs, or anyone who is interested in reviewing the code.

 
Or the system may not be reviewed at all. 

Remember: reviewers only look at the Confidential Computing system and do not see users’ personal data.



 §.§ Comprehension


Please answer the following questions. (Note: The answers are multiple choice between True / False)




    
  * A Confidential Computing system claiming to be secure is always secure, regardless of how it was built.
    
  * Reviewers who certify the system's safety can be held accountable if their certification is faulty.
    
  * Reviewers get access to the full system, including users' personal data.
 



 §.§ Instructions


You will now be presented with a number of different multi-purpose virtual assistant apps that help you with your everyday tasks. 
To operate efficiently, each app requires access to different types of your data. 
Each app runs on the previously described Confidential Computing system. 
The apps have been developed by a startup and are just about to be released.

For each of the scenarios, you will be asked about your comfort and confidence using the app under the specified conditions.



 §.§ Core study

(Note: Six versions of the following screen are presented to the participants, varying the data types and transparency level descriptions as listed after the questions.)

Virtual assistant app  requires permission from you to access your . This includes ].

In order to assess if the Confidential Computing system is designed and built securely, the system was .




(Note: Participants answer each question using a slider ranging from 0 to 100.)


    
  * How comfortable would you feel using this app?
    
  * How confident would you feel about this app’s ability to keep your  data safe?








 §.§ Additional questions

Note: Participants answer each question using a slider ranging from 0 to 100.


    
  * How would you best describe your approach to purchasing or experimenting with new technology?
    
  * How likely are you to use a multi-purpose virtual assistant app (e.g. Siri, Alexa, Google Assistant)?
    
  * How concerned are you about other people getting access to your data without your consent?    
    
  * Imagine your data was leaked or tampered with. How worried would you be for each of the data types listed below? 
    
  * Regardless of the data type, how comfortable would you feel with the virtual assistant app being reviewed with each of the following options?




Note: The following is an open-ended question with a text box for the response.


    
  * Please explain how you assigned the scores to the review options. 




 §.§ Demographics

Note: We collect the following information: age, gender, level of schooling, field of work/study and country in which the participants lived the longes. 
We omit the full demographics questions in the interest of space.



 §.§ End of survey and payment

Thank you for taking part in this study. 
Please click on the `Finish' button below to be redirected back to Prolific and register your submission.
(Note: Upon clicking the `Finish' button, the participants are redirected to Prolific platform and payment is made.)



 §.§ User study demographics
 








