Building a Certificate Inventory: Find Certs Before They Find You
Ask an IT team how many certificates the organization has and you get a silence. Not roughly. Exactly: where each one is, when it expires, and who renews it. If you can answer that, you can skip this guide. If your honest answer is "the website one, the mail one, and probably some others", you are in good company. In that case, you have just found the real cause of certificate outages. Nobody is taken down by the certificate they were watching. The outage comes from the one they forgot they had.
An inventory sounds like paperwork, and paperwork sounds skippable. It is not. Every other certificate discipline stands on a list of what exists: expiry monitoring, renewal automation, a calm incident response. A monitoring system can only watch addresses you point it at. An automation rollout can only cover certificates somebody wrote down. The list comes first, always. I have built this list twice, and the first attempt stopped at the certificates I could remember, which is not an inventory. It is a memory test.
This guide shows you how to build that list for real. It covers the surprising places certificates hide and four practical ways to discover them. It covers the fields a useful register needs (hint: "expiry date" is not even the most important one). And it covers the habits that keep the register alive instead of letting it rot into a historical document. You can get a first honest version done in a week of spare moments.
In this guide
- Why the inventory comes first
- Where certificates hide
- Four ways to find them
- The register: fields that earn their place
- Keeping it current
- Domain names belong in the same register
- Where to go next
Why the inventory comes first
The classic expiry outage — walked through step by step in why certificate outages keep happening — almost never involves a certificate anyone was tracking. It involves the VPN portal certificate installed three admins ago, or the one on the load balancer that fronts a service everyone thought was decommissioned. The certificates you remember are, by definition, the ones least likely to hurt you.
The instinct is to start by setting up expiry alerts for the certificates you know about, because that feels like progress. Do that too; it takes an hour and it is a genuinely good hour. But understand that you have protected yourself against the outage you were already least likely to have. The larger, slower, more valuable job is hunting down everything else. That is because the danger of a certificate is inversely proportional to how well it is remembered. An inventory is how an organization converts "unknown unknowns" into a boring list of dated entries, and boring lists are where outages go to die.
Before hunting, define what counts. For the register, a "certificate" is anything with an expiry date whose lapse would hurt. That includes every certificate your systems present to others (servers, devices, services). It includes every certificate your systems hold in order to be a client. Examples are a client certificate a partner's API demands, or a certificate your backup agent authenticates with. It also includes the certificates everything else depends on — the intermediate and root certificates of any internal authority you operate. That last category feels abstract until you read about the meta-expiry problem in running an internal CA. For now, just know that CA certificates get register rows too.
Where certificates hide
Certificates accumulate wherever anything encrypts or authenticates, which on a modern network is nearly everywhere. Walk through this tour with your own network in mind and keep a tally of the ones you had not thought about this morning.
| Hiding place | Typical certificate | Who notices first when it expires |
|---|---|---|
| Public websites | Public CA cert on the site or its load balancer | Customers, loudly, with screenshots |
| Internal web apps | Internal CA or self-signed on intranet, wiki, HR portal | Staff, via a wave of "is this safe to click?" tickets |
| Mail servers | Certs on the message transfer and mailbox services | Remote users whose mail clients start throwing warnings |
| VPN gateways | Cert the VPN presents to connecting clients | Everyone working remotely, all at once, before breakfast |
| RADIUS / authentication servers | Cert the server shows during secure Wi-Fi logins | The whole office, when wireless logins silently fail |
| Device management pages | Self-signed or internal certs on switches, firewalls, storage | You, mid-emergency, when the admin page refuses to load cleanly |
| Load balancers / reverse proxies | The front-door cert, plus certs on the back-end hops | Everyone behind that front door simultaneously |
| Printers | A self-signed cert nobody has ever looked at | Honestly? Possibly no one, ever. Inventory it anyway |
| Code signing | Cert that signs your installers, packages, or scripts | Whoever ships the next release and finds it untrusted |
| Service-to-service | Certs between apps, databases, queues, agents | An application team, via a 2 AM cascade of vague errors |
A few of these deserve a closer look, because they are the ones that ambush people. The RADIUS server is the service that checks credentials when laptops and phones join secure Wi-Fi. It presents a certificate to every connecting device. When that certificate expires, devices across the whole building quietly refuse to reconnect. The guide to monitoring RADIUS covers that particular flavor of bad morning in depth. Load balancers are sneaky in the other direction. People remember the certificate on the front, then forget that the load balancer often talks TLS to the back-end servers too. Each back-end server presents its own certificate that can expire independently. And some load balancers check those back-end certificates strictly.
Service-to-service certificates are the fastest-growing category and the hardest to see. Applications increasingly encrypt their internal conversations: web app to database, service to message queue, monitoring agent to collector, backup client to backup server. Those certificates never appear in a browser, so no human ever glances at a padlock for them. Their expiry shows up as an application error at a confusing distance from the cause — a batch job "cannot connect," a queue "times out." This can burn hours before someone thinks to check a certificate date. And do not skip code signing. A certificate that signs software does not take a service down when it lapses, but it can block your next deployment at the least convenient moment. That is its own kind of outage.
Tip: yes, the printers really do have certificates. And yes, they are almost always self-signed and long-expired. And no, nobody has ever been paged about one. Put them in the inventory anyway with the blast radius honestly recorded as "cosmetic warning on the admin page." The point of a register is that you decided a certificate does not matter — instead of discovering one mattered after all.
Four ways to find them
No single discovery method finds everything, so run all four. They overlap, and the overlap is a feature. A certificate found twice is confirmation, while a certificate found only by one method tells you which blind spot it was living in.
1. Scan your own address space for TLS listeners
The most productive single step is to take the subnets from your IP plan. For each address, attempt a TLS connection on the ports where encrypted services usually live. These are the web ports, mail ports, directory and VPN ports, and the high ports admin interfaces favor. Whenever something answers, read the certificate it presents and record the names on it, the issuer, and the expiry date. Any TLS-aware scanning tool or a modest script can do this. What matters is that it is your tool reading what is actually served, not what documentation claims. The output of a first scan is reliably humbling, in a useful way:
10.20.4.15:443 CN=intranet.corp.example expires in 210 days issuer: Internal Issuing CA 10.20.4.31:8443 CN=nas-admin.corp.example expires in 12 days issuer: self-signed 10.20.6.9:636 CN=dc1.corp.example expires in 402 days issuer: Internal Issuing CA 10.20.8.40:443 CN=printer-3f.corp.example expires in -8 days issuer: self-signed
That second line — an admin interface nobody mentioned, twelve days from expiry — is the entire argument for scanning. Rescan on a schedule and compare against the register. Anything new that appears is either a system someone forgot to tell you about or a surprise you want to investigate. Either way, you want the diff.
Harbourview Clinic kept a spreadsheet of nine certificates, and all nine had been renewed on time for years. The first address-space scan found forty-one. The other thirty-two included the patient check-in kiosks and the RADIUS server that let every laptop onto the wireless. They also included a pathology results feed. Its certificate had been renewed by hand from a contractor's laptop until the contractor left. Eleven of the forty-one had already expired, all self-signed, all on admin pages that people had been clicking past for months. The spreadsheet had been right about every one of its nine rows, which turned out not to be the same thing as being right.
2. Export from the places that hold them
Scanning sees what is served right now; exports see what is installed, including certificates that only matter occasionally. Pull lists from the certificate stores on your servers (Windows keeps one per machine that can be enumerated centrally). Pull them from load balancer and reverse proxy configurations, and from web and mail server config files. Also pull them from the issuance history in your CA accounts. That means both the vendor portals where certificates were bought and your internal CA's log if you run one. For certificates on your public domain names, there is a bonus source. Public CAs record what they issue in openly searchable transparency logs. So you can look up every certificate ever publicly issued for your domains — including ones requested by departments that never told IT.
3. Ask the humans
Some certificates are invisible to both scans and exports. Examples are the code-signing certificate on a build server and the client certificate a partner requires for their API. Another is the certificate inside an appliance that only presents it during a failover. Those live in people's heads, so ask. A short message to application owners and team leads catches things no tool will. Ask "what certificates does your system depend on, and who renews them?" Ask purchasing, too: invoices from certificate vendors are a surprisingly complete record of what someone once thought was worth paying for.
4. Harvest the complaints
Every ticket that contains a browser-warning screenshot is a free discovery event: a real certificate, at a real address, that real users encounter. Search the helpdesk history for "certificate," "not secure," "not private," and "warning," and mine the results for register entries. Then make it a standing habit. From now on, any certificate warning that reaches the helpdesk gets two actions. Fix the user's problem, and confirm the certificate is in the register. The complaint stream is discovery that runs itself. Check the register every time, without exception. The printer does not get an exemption.
Expect the four methods to disagree with each other, and treat every disagreement as information. When the same certificate turns up at several addresses, that is one certificate with several deployment locations. In that case, record it as one row with every host:port listed. Come renewal day you must replace it in all of those places. The forgotten copy is a classic way to "fix" an expiry and still be broken. When an export shows a certificate installed on a server but no scan ever sees it served, find out why. It may protect a service that only listens during failover, or it may be debris worth cleaning up. The reconciliation is tedious exactly once; after that, the rescan diff keeps it small.
The register: fields that earn their place
Where the register lives matters far less than what it records. A spreadsheet is a perfectly respectable start; a small database or your documentation system works too. What separates a register that prevents outages from a list of certificates is a handful of fields, each answering a question you will one day ask urgently.
| Field | What it records | The urgent question it answers |
|---|---|---|
| What / where | Names on the certificate, plus every host:port where it is served | "What exactly breaks, and where do I go to fix it?" |
| Expiry date | The date after which everything stops | "How long do we have?" |
| Issuer | Public CA (and which account), internal CA, or self-signed | "Who do we renew through, and can we log in there?" |
| Owner | A named person and a team — never just a mailbox | "Who is acting on this alert?" |
| Renewal method | Auto-renewed, scripted, manual portal purchase, vendor paperwork | "How much lead time does this need?" |
| Blast radius | What fails when it expires, and who feels it | "How hard do we escalate?" |
| Last verified | When a human or scan last confirmed this entry matches reality | "Can I trust this row at all?" |
Two of these are routinely skipped and are the two that matter most. Owner must be a person with a name, plus a team as backup. The register is where you fix the "renewal reminders went to a dead mailbox" failure permanently. A distribution list nobody reads is just a dead mailbox with more members. Renewal method is what turns the register into a monitoring plan. A certificate that renews itself needs a short warning window, while one that requires a purchase order and a change window needs months. That mapping is exactly how alert timing gets chosen in monitoring certificate expiry. And record where the private key lives for anything renewed manually. Mid-incident is a bad time to learn that the only copy was on the old admin's laptop.
Keeping it current
A register decays the moment you stop feeding it, and a stale register is worse than none — it radiates false confidence. Three habits keep it honest, and none of them takes long.
- Intake: every new system that arrives on the network brings its certificates into the register the same week. Make it a line on the same intake checklist that gets new systems monitored at all, as described in bringing new systems into monitoring.
- Rescan and diff: re-run the address-space scan on a schedule and compare against the register. New listener with no register entry: create one and find its owner. Register entry that no longer answers: confirm the system is truly gone, then retire the row instead of letting ghosts accumulate.
- Re-verify on people changes: when someone leaves or changes roles, search the register for their name the same week. Every row they owned gets a new named owner. And check the vendor accounts and reminder addresses tied to those rows while you are there. That is exactly where the classic outage incubates.
Give the "last verified" field teeth by treating its age as a warning of its own. Any row nobody has confirmed in a couple of rescan cycles is due a five-minute check. The goal is not a beautiful document. The goal is that the next time a certificate question comes up, the register answers it in under a minute and turns out to be right. That applies whether the question is routine or an emergency. A good register needs three things: rows, owners, and at least one reader who is not currently in an incident.
Domain names belong in the same register
While you are building this, add a short and disproportionately important section: your domain name registrations. A domain expiring outranks any certificate expiring, and it is not close. When a domain lapses, its DNS stops resolving. That takes down the websites and the mail flow. In a grim little irony, it also takes down the ability to renew certificates for that domain or receive the reminder emails about any of it. The first symptom is usually "everything is failing and nothing makes sense," which is why it can take a while to diagnose. The DNS troubleshooting guides show just how many directions that failure radiates. Let a domain lapse long enough and someone else can even register it out from under you, which converts an outage into a genuine crisis.
Domains fail through exactly the dead-mailbox pattern certificates do. In that pattern, they were registered years ago by someone who left, on a card that has since been reissued. Their reminders go to an address nobody reads. So give each domain a register row with the same fields. Use registrar and account instead of issuer, and auto-renew status as the renewal method. Include owner, expiry, and a blast radius that honestly reads "everything on this name." Turn registrar auto-renew on, keep the payment method and contact address current, and monitor the expiry date anyway as a backstop. It is a five-row addition to the register that removes one of the few failure modes genuinely worse than a certificate outage.
Warning: only ever scan address space you own or have explicit written permission to scan. Keep the rate polite, and give your helpdesk a heads-up before the first run. A TLS discovery scan is harmless read-only behavior, but fragile old devices occasionally react badly to unexpected connections, and surprises travel faster than explanations.
Where to go next
Run the four discovery methods, put the results in a register with owners and renewal methods, add the domains, and schedule the rescan. That is a complete, honest inventory, and everything else in this topic stands on it. The next step is making the register active. That means wiring each row to an expiry check with a warning window matched to its renewal effort. That is what Monitoring Certificate Expiry: Checks That Fire in Time covers. The rest of the Certificate & Expiry Monitoring guides continue from there to automation and internal CAs. Do the scan this week. The certificate you forgot you had is not waiting for a convenient time.
Put this into practice with SysPeep Monitor
A certificate inventory starts with knowing what is on the network at all — and that part does not have to be manual. SysPeep Monitor auto-discovers the devices and interfaces on your network from a single Windows machine. That gives you a live starting list to hunt certificates from. SysPeep Monitor also has dashboards and alerting to keep watch once the register exists. The free trial is a quick download.
Download Free TrialLearn About SysPeep