Secure Channel

Confidentiality ensures that transmitted data is kept secret from all parties except the intended sender and receiver. It is achieved through symmetric encryption algorithms like AES-GCM or ChaCha20-Poly1305, which scramble the plaintext message into ciphertext using a shared secret key. Without the correct key, an eavesdropper intercepting the ciphertext gains no usable information about the original message. This property protects against passive network sniffing and man-in-the-middle attacks aiming to read sensitive data.

Integrity guarantees that data is not altered—accidentally or maliciously—during transmission. It is enforced using cryptographic mechanisms like Message Authentication Codes (MACs) or authenticated encryption modes. These algorithms generate a unique tag for the message based on its content and a secret key. The receiver recalculates this tag; any mismatch indicates the data was tampered with in transit, and the message is rejected. This protects against active attackers who might modify packets to inject malicious code or corrupt model updates in a federated learning round.

Authentication verifies the identities of the communicating parties. It answers the critical question: "Am I talking to the correct server/client, or an impostor?" This is typically achieved through asymmetric cryptography and digital certificates. A trusted Certificate Authority (CA) cryptographically signs a server's public key, creating a certificate. The client verifies this signature chain to authenticate the server. Mutual TLS (mTLS) extends this to authenticate clients as well. Without authentication, confidentiality and integrity are vulnerable to man-in-the-middle attacks.

Forward Secrecy (or Perfect Forward Secrecy - PFS) is an enhanced property ensuring that the compromise of a party's long-term private key does not allow an attacker to decrypt past recorded communications. It is achieved by using ephemeral key exchange protocols like Diffie-Hellman (DHE) or Elliptic Curve Diffie-Hellman (ECDHE). These protocols generate a unique, temporary session key for each connection. Even if the server's main private key is stolen later, all previous sessions encrypted with their unique ephemeral keys remain secure. This is a critical defense for long-lived systems where key compromise is a realistic threat.

Replay Protection prevents an adversary from capturing valid, encrypted data packets and re-transmitting them later to cause unintended effects. Secure channels implement this using sequence numbers, timestamps, or nonces within the protocol. Each message includes a unique, monotonically increasing identifier. The receiver checks this identifier and rejects any message that has already been seen or is out of sequence. Without replay protection, an attacker could, for example, re-send a legitimate "transfer funds" command or a specific model update in a federated learning system, disrupting the protocol's state.

A cryptographic protocol that allows a central server in federated learning to compute the sum of client model updates without learning any individual client's contribution. This is the primary application for which secure channels are established.

• Core Mechanism: Clients often use pairwise masking; each client adds a secret mask shared with another client. When all masked updates are summed, the masks cancel out, revealing only the aggregate.
• Key Property: Provides confidentiality of individual updates while enabling the global model to improve. It is robust to client dropouts, ensuring the aggregate can still be computed if some clients fail to respond.

A cryptographic subfield that enables multiple parties to jointly compute a function over their private inputs while revealing only the final output. Secure channels are the communication layer that enables MPC protocols.

• Broader Framework: Secure aggregation is a specific instance of MPC where the function is a sum. General MPC can compute arbitrary functions (e.g., averages, comparisons) on distributed, private data.
• Security Models: Protocols are designed for different threat models, including the honest-but-curious adversary (follows protocol but tries to learn secrets) and the stronger malicious adversary (can deviate arbitrarily).

A form of encryption that allows computations to be performed directly on ciphertext. When decrypted, the result matches the outcome of operations performed on the plaintext. This can create a secure channel where data is never decrypted during processing.

• Types: Partially Homomorphic Encryption (PHE), like the Paillier cryptosystem, supports only addition or multiplication. Fully Homomorphic Encryption (FHE) supports arbitrary computations but is computationally intensive.
• Use in FL: Clients can encrypt their model updates before sending them. The server can homomorphically sum the encrypted vectors without decrypting them, achieving secure aggregation.

A rigorous mathematical framework for quantifying and limiting privacy loss. It ensures that the inclusion or exclusion of any single individual's data has a negligible effect on the algorithm's output. Often used in conjunction with secure channels.

• Mechanisms: Achieved by injecting calibrated noise, such as via the Gaussian mechanism or Laplace mechanism, into computations.
• Privacy Budget: Measured by epsilon (ε); a smaller ε denotes stronger privacy guarantees. In federated learning, Local Differential Privacy (LDP) applies noise at the client device before any data leaves, providing a strong, trust-minimized guarantee.

A secure, isolated area within a main processor (e.g., Intel SGX enclaves) that guarantees the confidentiality and integrity of code and data loaded inside it, even from a compromised operating system or hypervisor.

• Alternative to Cryptography: Provides a hardware-rooted secure channel for computation. Sensitive code (like aggregation logic) runs within the TEE, and remote clients can attest that they are communicating with a genuine, secure enclave.
• Use Case: Can be used to run a secure aggregation server where plaintext model updates are decrypted and processed only inside the protected enclave, shielding them from the server operator.

A cryptographic protocol where one party (the prover) can prove to another (the verifier) that a statement is true without revealing any information beyond the validity of the statement itself. Used to verify properties over data transmitted via secure channels.

• Application: In federated learning, a client could use a ZKP to prove that their local model update was computed correctly on valid data, without revealing the data or the model weights. zk-SNARKs are a highly efficient, non-interactive form of ZKP.
• Enhances Integrity: Complements secure channels (which provide confidentiality) by adding verifiable computation, ensuring participants are not submitting malicious or malformed updates.