↓ Skip to main content
Le Site de François
  1. Index/

TLS (Transport Layer Security)

Security Cryptography Networking Tls Pki Protocol

TLS (Transport Layer Security) is the protocol that establishes an encrypted, integrity-protected, and authenticated channel between two parties over an untrusted network. It is the successor to SSL (which is deprecated and broken) and the mechanism behind HTTPS, gRPC, LDAPS, SMTPS, database connections, and most other encrypted transport in modern infrastructure. The current version is TLS 1.3 (RFC 8446, 2018); TLS 1.2 remains in wide use but TLS 1.0 and 1.1 are deprecated by RFC 8996. The fundamental security properties TLS provides are: confidentiality (a passive observer cannot read the session content), integrity (an active attacker cannot modify session content without detection), and server authentication (the client can verify it is talking to the intended server rather than an impersonator). Client authentication is optional in standard TLS and is provided by mTLS.

A TLS connection begins with a handshake that negotiates session parameters and establishes a shared secret. In TLS 1.3, the handshake is significantly simplified over 1.2: the client sends a ClientHello containing supported cipher suites and a key share (a Diffie-Hellman or ML-KEM public key value in PQC-hybrid deployments); the server responds with a ServerHello selecting the cipher suite, its own key share, and its X.509 certificate; both sides derive the session keys from the combined DH output; the server immediately sends a Finished message authenticated with those keys, and the handshake is complete in one round trip (1-RTT), with session resumption possible at 0-RTT for returning clients. The server’s certificate is signed by a CA in the client’s trust store, proving server identity; the client checks that the server’s hostname matches a SAN in the certificate and that the certificate chain validates to a trusted root and is not expired or revoked. After the handshake, all data is encrypted with AEAD (Authenticated Encryption with Associated Data) ciphers — in TLS 1.3, either AES-256-GCM or ChaCha20-Poly1305 — which simultaneously provide confidentiality and integrity, making separate MAC computation unnecessary. Forward secrecy is mandatory in TLS 1.3: the ephemeral DH key exchange means that even if the server’s long-term private key is later compromised, previously recorded sessions cannot be decrypted, since the session key was never persisted.

TLS is the transport layer on which the rest of the security stack in this glossary is composed. mTLS extends it with client certificates for mutual authentication. SPIFFE/SPIRE uses X.509-SVIDs in TLS handshakes to provide workload-to-workload mTLS with zero static secrets. Vault exposes its API over TLS and issues short-lived TLS certificates via its PKI engine. Trustee and the KBS use attested TLS (aTLS) — a variant where the server’s TLS certificate is bound to a TEE attestation report, so the client simultaneously establishes an encrypted channel and verifies it is talking to a genuine TDX or SEV-SNP guest. The PQC transition affects TLS at the key exchange and authentication layers: ML-KEM replaces ECDH for key establishment (already deployed in hybrid form in Chrome and OpenSSL 3.4+), and ML-DSA replaces ECDSA for certificate signatures in the server’s X.509 certificate chain — addressing both the HNDL threat to confidentiality (via key exchange) and the long-term threat to server authentication (via certificate signatures).

Related

PKI (Public Key Infrastructure)

Security Cryptography Certificates Identity Tls Pki
Public Key Infrastructure (PKI) is the framework that makes asymmetric cryptography operationally useful at scale. Asymmetric cryptography provides a mathematical relationship between a public key and a private key, but by itself it cannot answer the question a relying party cares about: whose public key is this? PKI answers that question by introducing a trusted third party — the Certificate Authority (CA) — that cryptographically binds a public key to an identity (a hostname, an organisation name, an email address, a SPIFFE ID) by signing a certificate. A relying party that trusts the CA can therefore trust any certificate the CA signs, without needing to know the subject directly. The chain of trust extends recursively: a Root CA signs Intermediate CA certificates, which sign end-entity certificates (also called leaf certificates). Root CA private keys are kept offline in HSMs and used rarely; intermediate CAs handle day-to-day issuance and can be revoked without rotating the root. The set of root CA certificates a system trusts is its trust store — browsers and operating systems ship with a pre-populated trust store of publicly-trusted roots, while private PKIs use custom roots distributed by administrators.

PQC (Post-Quantum Cryptography)

Security Cryptography Standards Pki Tls Nist
Post-Quantum Cryptography (PQC) is the set of cryptographic algorithms designed to resist attacks from a Cryptographically Relevant Quantum Computer (CRQC) — a quantum computer large and stable enough to run Shor’s algorithm at scale. Shor’s algorithm can solve the integer factorisation and discrete logarithm problems that underpin RSA, ECDSA, and ECDH in polynomial time, meaning that every asymmetric algorithm in wide use today — TLS key exchange, X.509 certificate signatures, SSH host keys, code signing, and encrypted email — becomes trivially breakable by a CRQC. Symmetric algorithms (AES, SHA-256) are substantially less affected: Grover’s algorithm provides only a quadratic speedup against them, which is mitigated by doubling key lengths (AES-256 remains appropriate). PQC replaces the asymmetric primitives only, on hard mathematical problems for which no efficient quantum algorithm is known: structured lattices (the Learning With Errors and Module-LWE problems), hash functions (the security of SHA-3 family variants), and error-correcting codes.

SSH (Secure Shell)

Security Networking Cryptography Remote-Access Linux Pki
SSH (Secure Shell) is a cryptographic protocol, standardised in RFC 4251–4254, that provides a secure channel over an unsecured network for remote login, remote command execution, file transfer (via SFTP and SCP), and general TCP port forwarding. It replaced the plaintext protocols it was designed to obsolete — Telnet, rlogin, rsh, rcp — by providing mutual authentication and full session encryption. SSH is the universal administrative access mechanism for Linux servers, network devices, and embedded systems, and the transport layer for Git over SSH, Ansible, Fabric, and most configuration management tooling. The protocol stack has three layers: SSH-TRANS (the transport layer — handles the initial key exchange, server authentication, and establishes the encrypted channel), SSH-AUTH (the authentication protocol — authenticates the client to the server using one of several methods), and SSH-CONN (the connection protocol — multiplexes the encrypted channel into multiple logical channels for sessions, port forwards, and X11 forwarding).