What public-key mechanisms establish
Public-key systems use corresponding private and public keys, but they do not all perform one generic operation called public-key encryption. A signature authenticates a statement using a private key and can be checked with the public key. Key agreement derives a shared secret through a different mechanism. A typical certificate-authenticated TLS 1.3 connection combines these roles rather than encrypting all application data with the certificate key. Public keys are meant to be public, but a secure connection still needs a trustworthy binding between the key and the intended peer.
A certificate signature is not the whole check
A certificate binds a public key to names and other attributes through an issuer’s signature. A client checks a path to an accepted trust anchor, signatures, validity periods, permitted usage and the requested service identity. A correctly signed certificate for one name is not automatically valid for another name. Nor should finding a self-signed certificate automatically create a new trusted root. The decision about which anchors to trust is distinct from validating the peer’s presented chain. A successful signature check supplies one necessary fact, not every fact needed for server authentication.
Trace a TLS 1.3 handshake
The peers negotiate parameters and typically derive traffic keys from an ephemeral key agreement. The server presents a certificate and signs the handshake context to demonstrate possession of the corresponding private key. Finished messages authenticate the handshake transcript with derived key material. Application records then use symmetric authenticated encryption. This sequence connects server identity, negotiated parameters and the current connection; it is more than sending a certificate file. Forward-secrecy claims depend on the chosen handshake mode and appropriate handling of ephemeral secrets, so they should not be inferred from the presence of any certificate alone.
What a protected channel does not guarantee
TLS addresses interception and modification in transit, not whether the endpoint application behaves honestly or returns a correct answer. A malicious service can hold a valid certificate, and compromised endpoints can expose plaintext after decryption. Ignoring name, expiry or trust-path errors defeats important authentication checks. TLS 1.3 early data also has replay considerations, so an operation with nonrepeatable side effects needs additional application safeguards. Describe the attacker and handshake mode when stating a security guarantee, and keep authorization, input validation and endpoint security within the surrounding application design.
Exercise: separate path and service identity
Connect to api.example with a leaf and intermediate certificate supplied by the server. The client has independently configured trust anchors. Arranging certificates into a candidate chain does not establish a validated path. Check signatures, validity, CA constraints and intended usage for the candidate. Separately apply the relevant service-identity rules to the reference name and certificate identifiers.
Case A has matching signatures but no path to an accepted trust anchor. Case B has a valid path but the wrong service name. Case C has the right name but an expired certificate. None is rescued by one other successful check. The model answer names each failed condition. An implementation reporting its first error does not establish that all remaining checks succeeded.
| Case | Successful observation | Blocking condition |
|---|---|---|
| A | Presented signatures connect | No accepted trust anchor |
| B | Path and validity | Wrong name for api.example |
| C | Name matches | Expired at verification time |
| D | Path, validity and name | Required usage not permitted |
Return from an error to its condition
Adding a missing intermediate and registering a new trust anchor change different boundaries. Do not turn a self-signed certificate sent by the peer into a trusted authority on the strength of that presentation. For a name mismatch, inspect the intended reference name and issued identifiers while retaining verification.
Record the verification time when clock error is possible. Investigate usage, CA constraints and revocation handling against the selected implementation and policy. The table classifies failures; it does not prescribe every product's check order or revocation-information policy. Retain the error, presented certificates and independent trust configuration so the proposed correction has an identifiable reason.
Choose the lab by the question
Use the TLS certificate-chain lab to vary trust settings and intermediate availability. Use the certificate-hostname-validation lab to change the reference name under the same trust configuration. Success in one experiment does not establish the property examined by the other.
Written task: fixing a path error reveals a name error. Did security get worse? A model answer is that the implementation may now reach a later failing check; the changed message alone cannot establish deterioration. Inspect each required condition and accept only when they all hold. This extension is a classification exercise, with no need to change certificates or configuration on an external service.