Public Key Infrastructure uses certificate hierarchies to establish chain-of-trust verification, connecting root certificates through intermediate certificates down to end-entity certificates used by websites and services. This process allows clients to cryptographically verify that they are communicating with a legitimate, trusted source.
PKI Certificate Hierarchy
When it comes to public key infrastructure, we apply those trust models. We are going to look into what those trust models look like when it comes to certificates, and how we create this hierarchy of certificates.
I'm going to start out with just a brief overview of that third-party trust and hierarchy trust. Then we're going to get into certificates and what those certificates look like: the root certificate, the intermediary certificates, and the end entity certificate.
If two entities want to communicate back and forth and establish some sort of trust, a third-party trust would be some sort of third party that would help in that process of verification, of creating that trust. And as long as one user trusts, in this case, the certificate authority, and that certificate authority trusts these servers right here, then this user will trust those servers.
Public key infrastructure also utilizes a hierarchy trust. That is, there is some sort of top level trust, and that trust gets passed down from entity to entity. And so we're going to actually apply that to public key infrastructure.
So let's take a look at different certificates. First of all, we have a root certificate. The root certificate sits at the top. That becomes the anchor of trust that proves everything else. And so here is the root certificate. The root certificate really is key to all of the trust that happens within this hierarchy right here. So we really want to put some safeguards in place.
And one way that we might want to do that is by creating intermediate certificates instead. It can create an extra layer of security, but also with it, this could be a separate entity. And so if this certificate authority wanted to pass on some of its trust to another entity, then you would need something like an intermediate certificate. But it wouldn't necessarily need to be a separate entity either. There could be the same certificate authority that wants to create an intermediate certificate in order to create that level of security.
So how can we trust this intermediate certificate? How can we verify that it's to be trusted? Well, if the public key can decrypt this fingerprint accurately, then we know that this certificate is good, and therefore we can trust this intermediate certificate.
Then there's an end entity certificate. The end entity certificate is what we're going to actually use on the service. So in this example right here, we're going to apply this end entity certificate for the TechKnowSurge website, and then that's going to be what's used on that website to verify that it's coming from the correct source.
So what does the verification process look like for this? Well, what's going to happen is, if we can use the public key from the root certificate to decrypt the fingerprint from the intermediate certificate, then we know that the intermediate certificate is valid. Then we can take the public key of the intermediate certificate and decrypt the fingerprint of the end entity certificate, and if that does that correctly, then we know that this certificate is valid.
So let's take a look at what that looks like in application. Now, here at the top we have our root certificate authority. The certificate authority that's at the top, it has a private key, that it also has a matching public key on a certificate that's already installed on the user's machine. From there, an intermediary certificate was generated for this intermediary certificate authority right here, and we also call that a subordinate. So this is a subordinate right here that has its own private key right there. All these private keys are kept private.
Same thing, the TechKnowSurge website also has its own private key and has submitted a CSR to get a certificate that has specifically for the techknowsurge.com, that has the public key on it. When the TechKnowSurge website downloaded the certificate and installed it on the machine, it also installed the intermediate certificate as well. So it has two certificates that are on it.
Now what happens is, when the user goes and connects to this machine, it will actually download both the intermediate and the TechKnowSurge certificate. Now that user has both of those certificates plus the root certificate. It can use the root certificate public key to verify the fingerprint by decrypting that fingerprint and verifying the intermediate certificate, and using that public key to decrypt the fingerprint of the techknowsurge.com certificate. And therefore now it knows that this techknowsurge.com certificate is verified, and can use the public key now to decrypt information coming from the official techknowsurge.com website.
One thing to note is that there are three levels with our example right here, but we could actually have multiple intermediate sites. So this could actually extend beyond just three levels.
We started out with just a quick review around a third-party trust and a hierarchy trust, and really we applied those then to the certificates: what is a root certificate, what is an intermediary certificate, and then what is an end entity certificate. And we use all of this for verifying each step along the way, to make sure that when we're getting to the end entity — or techknowsurge.com was our example — when we get to it, we can verify the source to make sure that we're getting the accurate information from the correct source.
TechKnowSurge builds IT and cybersecurity professionals through hands-on, concept-first training built around real understanding — not memorization. Free interactive tools, structured programs, and 25+ years of real-world experience, all in one place.
Explore free tools and programs →