Trusted Execution Environment (TEE)

The TEE establishes a secure enclave that is cryptographically isolated from the rest of the system, including the host operating system, hypervisor, and other applications. This is achieved via processor extensions like Intel SGX (Software Guard Extensions) or ARM TrustZone. Code and data within the enclave reside in a protected region of memory, with access controlled by the CPU's memory management unit. Even a compromised OS with root privileges cannot read or tamper with the enclave's contents, providing a root of trust anchored in silicon.

Attestation is the cryptographic process that allows a remote party (e.g., a federated learning server) to verify the identity and integrity of a TEE. It proves:

• The code is running inside a genuine TEE on authentic hardware.
• The exact software (e.g., secure aggregation logic) loaded into the enclave is correct and has not been altered.
• The enclave's initial state is known and trusted. This creates a chain of trust, enabling clients in a federated network to confidently submit encrypted model updates, knowing they will only be processed by the verified, intended secure code.

Sealing is the TEE's mechanism for persistent, secure storage. Sensitive data (e.g., intermediate model states, encryption keys) can be encrypted by the enclave using a key derived from the hardware and the enclave's identity. This sealed data can only be decrypted and accessed by the same enclave (or a designated successor) on the same platform after a successful restart. This guarantees data confidentiality at rest and is crucial for maintaining state across sessions in a continual learning pipeline without exposing secrets to the untrusted host disk.

Code execution inside the TEE is guaranteed to be tamper-proof. The CPU ensures that instructions are executed as authored, preventing runtime attacks like code injection or control flow manipulation. Memory integrity is protected, often using Memory Encryption Engines (e.g., Intel TME/MKTME, AMD SME) that transparently encrypt data leaving the CPU die. This ensures that even an attacker with physical memory access sees only ciphertext. For federated learning, this means the core aggregation algorithm runs deterministically and securely, producing a verifiably correct result.

A core security principle of a TEE is the minimization of its Trusted Computing Base—the amount of software and hardware that must be trusted for the system's security to hold. The TEE's TCB is typically limited to the enclave application itself and a small, auditable enclave runtime library. It explicitly excludes the vast, complex host OS, drivers, and other applications. This reduces the attack surface dramatically. In federated learning, a bug in the client's OS does not compromise the security of the secure aggregation process running inside the TEE.

In Federated Learning, TEEs enable Secure Aggregation without relying solely on cryptographic protocols like MPC. The workflow is:

1. Each client encrypts its model update with the TEE's public key, attested by the server.
2. The server routes encrypted updates to an aggregation enclave.
3. Inside the TEE, updates are decrypted, summed, and the aggregate is re-encrypted for the server.
4. The server receives only the final, encrypted aggregate model. This ensures the server never sees individual client contributions, providing strong privacy even against a honest-but-curious server. It is a foundational primitive for Federated Continual Learning (FCL) where privacy must be maintained across sequential learning rounds.

A specific cryptographic protocol, often using MPC or masking techniques, that allows a federated learning server to compute the sum of client model updates without inspecting any individual update. This protects client data from the central server.

• TEE Implementation: A TEE can act as the trusted third party that receives encrypted updates from clients, decrypts them inside its secure enclave, performs the aggregation, and outputs only the final averaged update. This architecture removes the need for complex multi-party cryptographic protocols among the clients themselves.

The property of a distributed system (like a federated learning server) to tolerate a fraction of malicious or faulty clients that submit arbitrary, incorrect updates. Defenses include robust aggregation rules (e.g., median, trimmed mean) that filter out outliers.

• TEE's Role: While TEEs guarantee code integrity and data confidentiality, they do not inherently provide Byzantine robustness. A malicious client with a compromised local dataset can still generate a harmful update from within a valid TEE. Therefore, Byzantine-robust aggregation algorithms must still be executed, potentially inside the TEE for added assurance.