CompTIA Security+ SY0-701: Cryptography and PKI
When a certificate is renewed but a service still fails, the answer is rarely “add more encryption.” The problem may be a broken trust chain, the wrong service name, a key that no longer belongs to the expected identity, or a protocol that protects only part of the connection. This guide explains how to tell those failures apart and select a defensible remedy.
An API team has replaced a server certificate that was about to expire. Browsers connect, but a production client rejects the service. The private key is present, the certificate is within its validity period, and the application has not changed its password. What should the team investigate next?
A certificate is not a general-purpose stamp marked “secure.” It is one piece of a system that binds an identity to a public key, checks who issued that binding and decides what the key is permitted to do. A valid signature on a certificate is necessary for some of those decisions but not sufficient for all of them. The client's trusted roots, the chain of intermediate certificates, the service name and the intended use still matter.
That distinction runs throughout CompTIA Security+ SY0-701 Objective 1.4, which covers choosing suitable cryptographic solutions. The important skill is not memorizing a list of tools. It is recognizing what needs protecting, what an attacker can change and which security property a chosen mechanism actually supplies. The wider SY0-701 exam domains establish the context; here, the focus is the cryptographic decision itself.
Start by naming the failure you need to prevent. Confidentiality means an unauthorized party cannot read protected content. Integrity means an unexpected alteration can be detected. Origin authentication offers evidence about which verified key or entity was involved. Availability means protected data and keys can still be used by authorized systems when required. Those properties can overlap, but they are not interchangeable.
Consider a confidential report sent to a partner. Encrypting the file protects its contents from readers who lack the decryption key. An attached cryptographic hash can help a recipient compare the bytes with a trustworthy expected digest; the hash alone does not prove who supplied that reference. A verified digital signature adds evidence of integrity and control of the signing private key, assuming the verifier already trusts the link between the signer's identity and public key. If the only decryption key is destroyed, none of these controls solves the resulting availability problem.
A sound decision therefore separates the goal from the dependency. “Protect the report in transit” is incomplete until you also ask whether the connection must authenticate the remote endpoint, detect tampering and remain protected after a reverse proxy terminates TLS. “Keep the certificate trusted” is incomplete until you identify the trust store, certificate path and revocation policy of the relying application.
Some cases call for controls at multiple layers. A signed document can travel over a properly authenticated, encrypted channel without either mechanism becoming redundant: the channel protects the conversation between endpoints, while the signature can be verified later by someone who did not participate in the original TLS session. Neither automatically establishes that a named human personally authored every sentence in the document.
With symmetric encryption, the participants use shared secret key material for encrypting and decrypting data. It is efficient for protecting sizeable files, backups and streams, but efficiency does not answer the key-distribution question. If an attacker obtains the key, strong encryption algorithms do not prevent that attacker from decrypting ciphertext that was protected with it.
Asymmetric cryptography uses related public and private keys. The public half can be distributed, while the private half must remain under appropriate control. Public-key encryption can let a sender encrypt a short secret for the holder of the corresponding private key; digital signature algorithms use a private signing key to create signatures that a public key can verify. Key agreement is another public-key technique, but it is not simply “asymmetric encryption.” Algorithm purpose and permitted key usage matter.
Modern TLS illustrates why these distinctions matter. In a typical authenticated TLS 1.3 handshake, the peers negotiate cryptographic parameters, use a key-establishment mechanism such as ephemeral (EC)DHE to derive shared secrets, and authenticate the server through the appropriate certificate and signature checks. The resulting traffic keys drive symmetric authenticated encryption, for example AES-GCM or ChaCha20-Poly1305, which protects records efficiently. The certificate does not itself encrypt every application record, and the public key is not a substitute for verifying which server controls it.
The term hybrid cryptography describes this combination of asymmetric operations for authentication and/or key establishment with symmetric protection for data. It does not excuse weak endpoint authentication. Unauthenticated key exchange can create a shared secret with the wrong peer when an active attacker substitutes key shares. Likewise, choosing a stronger cipher does not repair a server name that fails certificate validation.
If an exam scenario asks which mechanism is fastest for encrypting a large existing database when an approved secret key is already available, symmetric encryption is a strong answer. If the scenario instead describes verifiable signing or establishing a secret with a previously unknown remote endpoint, look for the precise public-key operation rather than automatically selecting encryption. The important word in the stem is usually the requirement, not the presence of the word “key.”
A cryptographic hash produces a digest from input data; approved algorithms such as SHA-256 produce a fixed-length output. A team can recompute a software package's hash and compare it with a known-good digest stored through a trusted channel. That detects unexpected changes with high confidence under the assumptions of the hash function and the integrity of the reference value. If an attacker can replace both the software and its published checksum, hashing alone cannot establish authenticity.
A digital signature helps address that problem when the verifier has a trusted public key and can verify a signature covering the relevant bytes. It can identify that the corresponding private signing key was used and that the signed content has not been altered without detection. But it cannot independently prove a particular employee wrote the content or that the signing key was never stolen. Certificate validation, key custody, authorization and incident history determine how much weight the organization should place on the signature.
Password storage is a different use of hashing. A salt is normally unique per stored password and makes precomputed attacks against reused hashes less effective; it need not be secret. A password-hashing scheme should also impose an appropriate computational or memory cost so offline guessing is harder. A fast general-purpose digest with an appended salt is not equivalent to a deliberately designed password hash or key-derivation function. Security+ candidates should be able to explain why salting, a work factor and strong password policy solve related but distinct problems.
One useful test is to ask whether the recipient is checking bytes against a trusted reference, proving a signing key participated, deriving a password verifier or keeping data unreadable. Each question leads to a different cryptographic operation. Describing every one of them as “encryption” loses exactly the distinction that decides the correct control.
A public-key certificate states a relationship between identity information and a public key. A certificate authority (CA) signs that statement under an issuance policy. For a relying client, the question is not merely whether the certificate has a signature. It is whether the client can establish an acceptable chain from the presented certificate through any required intermediates to a trust anchor that the client already accepts.
A service might present a leaf certificate issued by an intermediate CA. That intermediate was itself authorized by a root CA. The client may keep the root's public-key trust information in an operating-system or application trust store. The root is a starting assumption under local policy, not a conclusion produced by checking that its certificate signed itself. A self-signed certificate can be useful as a private trust anchor when its public key is deliberately distributed and trusted, but self-signature alone does not make an arbitrary certificate trustworthy.
Path validation also applies constraints. A verifier examines issuer-to-subject relationships and signatures, validity times, whether a CA is permitted to issue subordinate certificates, and applicable policies. The application must also check the intended service identity and key use. For a server reached as api.example.net, a trusted certificate issued for another hostname is not automatically acceptable merely because its chain is cryptographically correct. A certificate issued for a signing purpose should not silently be accepted for an unrelated TLS server role.
A certificate signing request (CSR) typically carries a public key, subject information and proof that the requester controls the corresponding private key. The CA's independent validation of the requested identity is a separate decision. Generating a CSR does not create a valid server certificate, and possessing the matching private key does not let an operator skip certificate issuance, policy or trust-store requirements.
Wildcard names illustrate why exact matching matters. Under modern TLS service-identity rules, a certificate matching *.example.net can cover api.example.net and shop.example.net, but it does not by that wildcard alone cover example.net or a.b.example.net. An administrator who sees “wildcard” and assumes unlimited nested hostnames can deploy a fully signed certificate that still fails an application’s identity check. Broadly sharing a wildcard private key also concentrates risk if one service is compromised.
Private PKI makes the trust decision especially visible. An internal root is acceptable to an application only after an authorized administrator has distributed or enrolled its public-key trust information by a controlled process. An operating system, browser and language runtime may use different trust stores, so a successful connection in one program proves little about another. For each client, ask what identity it requested, which leaf and intermediates were presented, what anchor its policy accepts and which key usages and revocation conditions apply.
A certificate has a validity window. Outside that window a client can reject it on time grounds, without needing proof that the CA revoked it. Revocation addresses a different problem: a CA may announce that a previously issued certificate should no longer be relied upon before its normal expiration, for example after a private-key compromise or issuance error. A local trust-store administrator can also remove trust in a CA, but that local policy action is not the same thing as finding a leaf certificate on a CA's revocation list.
A certificate revocation list (CRL) is signed status information published by a CA or authorized CRL issuer. A verifier needs the correct issuer, relevant scope and suitably fresh information. A cached CRL that never updates is a weak answer to a newly compromised key; a CRL belonging to a different issuer does not establish the status of this certificate.
Online Certificate Status Protocol (OCSP) provides a different status-distribution method. A request identifies a particular certificate; a responder may report good, revoked or unknown and provide time fields describing the response's validity. “Good” is narrower than “valid in every respect.” Under RFC 6960, it does not necessarily mean the certificate was ever issued, nor does it certify the hostname, chain, policy or allowed key usage. OCSP information also needs an authorized responder, correct signature and suitable freshness.
Neither protocol is a replacement for the rest of path validation. The security outcome additionally depends on how the client behaves when revocation data is unavailable, which varies by application and policy. A high-assurance internal service may need a stricter revocation-failure response than a general public browser. Do not claim that every browser always blocks or always proceeds under an unreachable OCSP service; the relevant implementation and trust policy must be examined.
Certificate pinning is another policy layer. An application might require a particular service key or pinned identity in addition to ordinary CA validation. That can limit some types of unexpected interception but can also disrupt legitimate rotation. When a pinned application fails just after a service key changes, the right fix is a planned pin update and verified new binding—not permanently disabling server-certificate validation.
Choosing AES, RSA or an elliptic-curve algorithm is only one piece of cryptographic engineering. Key creation, access rules, storage, monitoring, rotation, revocation, backup and destruction can matter more to the outcome. An excellent cipher cannot save a system that commits its decryption key to public source control.
A Trusted Platform Module (TPM) can protect selected keys on a device and support measured-boot or attestation workflows. The TPM does not make the surrounding operating system invulnerable, and attestation requires a verifier that understands the measurement evidence. A secure enclave likewise separates sensitive operations from a normal execution environment, but its exact guarantees depend on the platform and implementation.
A hardware security module (HSM) is intended for controlled cryptographic operations with important keys, such as a CA signing key or sensitive payment-processing key. A key management system (KMS) orchestrates lifecycle operations across applications: access control, creation, use, rotation, disabling and auditability. Some KMS deployments use HSM-backed hardware, but the service and the hardware device are not interchangeable terms.
Key escrow can support exceptional recovery of encrypted records after an employee leaves or a recovery key is lost. That availability benefit creates a concentrated security responsibility. Recovery should be limited to suitable encryption key material, gated by documented authorization and recorded through audit controls; casually escrowing a personal signing key can undermine the exclusivity that signature assurance depends upon.
For a Security+ decision scenario, work backwards from the risk: a stolen laptop that was powered off suggests properly managed full-disk encryption and recovery-key custody; a cloud application distributing many encryption keys suggests policy-controlled KMS; a protected enterprise certificate authority suggests strong restricted-use signing-key storage. The highest-value answer is the control whose assurance matches the failure, not whichever product name sounds most sophisticated.
A company rotates the certificate on api.example.net. The public browser on one administrator's workstation opens the endpoint, but a Java-based billing service begins reporting a certificate-path error. The replacement certificate is not expired. The server operator initially proposes copying the private key to the billing service “so it can decrypt correctly.” That would be the wrong response to a trust-path failure and would distribute secret material to a client that should not need it.
First separate what is known from what is assumed. Confirm the actual hostname and port the billing service uses, whether its client sends the expected TLS Server Name Indication (SNI), and which certificate the server returns for that name. Inspect the leaf certificate's subject alternative names (SANs), its validity window, allowed TLS-server usage and signature chain. A browser succeeds against one endpoint configuration while another application connects to a different virtual host; the two observations are not necessarily contradictory.
Next examine the chain as that particular Java client sees it. Suppose the replacement leaf was issued by a newer intermediate CA, but the server sends only the leaf. The browser may already have the intermediate cached or retrieve it through another facility. The billing client may not. Its trust store might contain the expected root but lack a complete path to the leaf. If so, the server should present the correct intermediate chain, not expose the private key or tell the client to ignore all certificate errors.
Now test the distinct failure branches. If the correct chain is present but the SAN does not include api.example.net, replace the certificate with one issued for the intended name. If the intermediate chains only to a root the client does not trust, determine whether that root is legitimately approved and distribute it through a verified trust-store update if policy allows. If revocation followed exposure of the server's private key, generate a fresh key pair and obtain a replacement certificate under incident procedures; reinstalling the same compromised key is not recovery. An OCSP “good” response for one certificate does not cure a hostname mismatch or untrusted root.
Finally, retest from the actual application runtime after the controlled repair, recording the presented chain, the validated identity and the agreed TLS session. Do not treat the workaround “disable certificate verification” as a resolution. It merely removes the assurance that the billing service is connected to the intended API, leaving room for interception even if the channel continues to show encrypted traffic.
This case is primarily about public-key identity and path validation, not about whether a cipher can encrypt bytes. The correct answer changes with the failed condition: missing intermediate, wrong name, untrusted anchor or revoked certificate each requires a different remedy. At fleet scale, certificate lifecycle operations also determine whether renewal reaches every deployment, whether the service activates the new certificate and whether client-side failures are detected before an outage.
An organization runs a client-to-edge HTTPS gateway in front of a back-office API. The browser shows a valid certificate and negotiates TLS 1.3 with the edge. The gateway then forwards requests to the internal API over ordinary HTTP across a shared network segment. Someone concludes that “the entire service uses TLS, so confidentiality and integrity are covered.” That conclusion extends the channel's properties beyond the endpoint at which they stop.
Map the connections, not just the page URL. Connection A is client to edge; it has an authenticated TLS handshake and authenticated record encryption. Connection B is edge to API; unless a separate protection mechanism exists, it is not encrypted or integrity-protected merely because Connection A used TLS. An adversary with access to the internal segment could read or alter traffic on B. The external browser's padlock cannot test this internal hop.
A defensible repair is to establish an independently validated TLS connection from the edge to the API, with correct API service identity, suitable key custody, and authorization between the services. Where client identity is also needed, mutual TLS can provide cryptographic certificate-based client authentication under a managed service policy; it does not replace application-level authorization or careful mapping of which user initiated the request.
Within each TLS 1.3 channel, authenticated encryption with associated data (AEAD) provides record confidentiality and tamper detection. If a record's authentication check fails, the recipient does not get a valid plaintext record from that ciphertext. But records decrypted by the edge become plaintext in the edge's processing environment, so they can be logged, mishandled or forwarded unprotected after that point. TLS protects a particular session, not the entire future life of its data.
Consider also what the edge is allowed to do. If it is an authorized TLS termination point, the security objective may be satisfied by protecting both hops and restricting gateway access. If the requirement is that even the gateway cannot read the payload, two independently terminated TLS connections do not meet it; the system needs application-layer end-to-end content encryption, with keys held by the true intended recipients. This is an architectural distinction, not a TLS configuration checkbox.
A team enabling TLS 1.3 early data (0-RTT) must also account for possible replay of that early application data. It is not automatically appropriate for state-changing requests such as payment initiation. The safest decision depends on whether the endpoint can tolerate replay and whether the application's anti-replay protections are adequate. A faster handshake is not a blanket authorization to accept every transaction before ordinary confirmation has completed.
The important insight is to identify the exact trust boundary that a mechanism covers. In the first case, the cryptography is intact but identity validation fails. In the second, a TLS channel can be sound while sensitive data crosses an unprotected downstream boundary. Both examples may include certificates and encryption, yet the correction is different.
A signed certificate is not automatically a trusted certificate. The relying party must have an appropriate trust anchor and validate the path and intended service identity. A self-signed root becomes a trust anchor through controlled policy and distribution, not through its own signature alone.
Encryption does not automatically prove origin or integrity. For transport, specify a properly authenticated protocol with integrity-protected records. For stored artifacts, decide whether a signed hash or authenticated encryption is needed in addition to confidentiality.
An OCSP “good” result is not a universal certificate-validity verdict. A separate name check, trusted issuance path, valid time, acceptable usages and a suitable revocation policy still apply. Similarly, an expired certificate is not necessarily revoked, and a local distrusted root is not the same thing as a leaf appearing on a CRL.
A wildcard does not cover every level of a domain. A single-label wildcard under modern TLS service-identity matching covers names such as api.example.net, not every nested host and not automatically the bare apex.
A stronger algorithm does not substitute for control of its keys. A compromised HSM administrator, a leaked service secret or an unchecked recovery process can defeat otherwise appropriate cryptographic choices. Identify the key owner, allowed purpose, recovery path and observability before treating the control as complete.
After reading a certificate failure, try to explain the likely cause without naming a tool first. Which name was requested? Which key was presented? What trust anchor does the client possess? Has the issuer revoked the credential? Which remedy preserves verification rather than bypassing it? If two candidate fixes address different problems, make the original requirement more precise.
For a communication design, draw each encrypted segment and mark where decryption occurs. State whether the protocol authenticates one or both peers, where keys are established, who has plaintext access and how record tampering is detected. If the path contains a proxy or inspection gateway, do not describe the connection as end-to-end merely because its first hop is encrypted.
Then return to the SY0-701 study plan with concrete missed decisions, not a tally of definitions memorized. Cryptography and PKI become manageable when you can work from a failure observation to a verifiable cause, reject plausible but irrelevant controls, and explain which security property the eventual repair restores.
