Home › Topics › Certificate & Expiry Monitoring › Internal CA Basics

Running an Internal CA Without Scaring Yourself


Every growing network reaches the same point. Half its certificates protect things the public internet will never see: management pages, internal apps, the directory server, the connections between services. Getting certificates for those from a public vendor is somewhere between awkward and impossible. The standard answer is an internal certificate authority: a passport office you run yourself, issuing certificates that only your own devices trust. It is a good answer, used everywhere, and it tends to terrify whoever is asked to set it up. That is because "certificate authority" sounds like a job for a bank vault and a security team of twelve.


Replace the fear with respect. Day to day, an internal CA is not hard to run; directory-integrated CA services and modern open tooling have made issuance nearly push-button. What it demands is a clear mental model (what did I just create, and what can it do?), a short list of protective habits, and monitoring. A CA adds a handful of quiet single points of failure to your network. They include the most spectacular expiry problem in this whole topic: the CA certificate's own expiry. That takes down everything it ever signed at once. I have watched a team learn that it ran a CA on the day the CA stopped. That is not the recommended way to find out.


This guide gives you that model in plain language. It covers why internal CAs exist, the trust deal you are making, and root versus issuing CA. It also covers how trust gets onto your clients, what to monitor, and the habits that keep issuance safe. It includes the honest cases where you do not need a CA at all and a self-signed certificate is perfectly fine.


In this guide

  • Why internal CAs exist
  • The trust deal you are making
  • Root and issuing CA, in plain language
  • Getting clients to trust it
  • Monitoring the CA itself
  • Operational habits that keep it safe
  • When self-signed is honestly fine
  • Where to go next

Why internal CAs exist


Three reasons, and the first is a hard constraint. A public CA will only issue a certificate for a name after verifying control of it on the public internet. Internal names cannot pass that test. The public system simply has no way to vouch for switch-core.corp.local or a bare private address like 10.20.0.1. Public CAs will not issue for names the world cannot verify. If you want the management page on your core switch to stop showing warnings, somebody you control has to do the vouching. That somebody is an internal CA.


The second reason is volume. Even where public certificates are free, the operational overhead of obtaining and rotating them is not. An organization can easily need certificates on hundreds of internal endpoints. These include every device management page, every internal app, and the RADIUS server that authenticates the wireless network. (See monitoring RADIUS for why that one certificate matters so much). They also include agents, printers, and appliances. An internal CA turns each of those into a quick internal issuance instead of a public transaction.


The third is control. You set the issuance rules: which names are allowed, what lifetimes make sense for internal purposes, which uses a certificate may serve. That flexibility is real power — and one honest caution comes with it. Freed from public lifetime limits, teams are tempted to issue internal certificates that last a decade so they "never have to deal with it again." (Someone will deal with it again. Just not them.) That sentence is how the forgotten-certificate outage from why certificate outages keep happening gets built with a longer fuse and higher stakes. Choose lifetimes long enough to be practical, short enough that renewal remains a living process. And put every internal certificate in the same register and monitoring as the public ones.


The trust deal you are making


Here is the part to internalize before anything gets installed. Making your devices trust your CA means adding your CA's root certificate to their trust stores, right alongside the big public authorities. From that moment, every one of those devices will believe any certificate your CA signs — for any name. Not just internal names: anything.


Read that back, because it defines the protection level. If someone hostile obtains your CA's private key, they can mint a certificate for any website in the world. Your fleet will accept that certificate without a murmur. That is a perfect disguise kit for impersonating banks, mail providers, or your own intranet to every machine that trusts you. Nothing on the network makes a better target. So the deal is: the CA gives you the power to vouch. In exchange, its private keys must be guarded at least as carefully as your top-level admin credentials. A CA compromise roughly equals a compromise of those credentials. That is not a reason to avoid running one. It is the reason the rest of this guide keeps circling back to protection, monitoring, and restraint.


Root and issuing CA, in plain language


Mature CA setups split themselves in two, and the split makes sense the moment you see the job description of each half. The root CA is the locked-away signature: the certificate your devices actually trust. It does almost nothing — its one recurring job is signing the certificate of the next layer down, which happens rarely. Because it acts so rarely, it can be kept offline. That could be on a machine that is powered off, disconnected, or even a virtual machine archived to encrypted storage in a safe. An attacker cannot steal keys from a box that is not running.


The issuing CA (in public-web language, an intermediate) is the daily worker. It is an online service, signed by the root, that handles the actual stream of certificate requests. That means devices enrolling, servers renewing, templates being applied. It holds its own private key, and because it is online and busy, that key lives at more risk than the root's. That is precisely the point of the split. If the daily worker is ever compromised or simply needs replacing, the root — safe in its vault — signs a replacement. The old issuing certificate is then revoked. In that case, your devices never need to be touched, because the thing they trust never changed. Think of the root as the company seal in the safe and the issuing CA as the front-desk stamp. Losing the stamp is a bad week; losing the seal means re-establishing trust with every device you own, one trust store at a time.


Can a small shop run a single-tier CA, where one online box is both root and issuer? People do, and it works — until the day that box is compromised or its certificate must change. At that point, the recovery is the touch-every-device scenario. The two-tier design costs one extra afternoon at setup. It is the cheapest insurance in this guide.


Getting clients to trust it


A CA nobody trusts issues expensive warnings. Distribution of the root certificate to your clients is what makes the whole scheme work. How hard it is depends entirely on how managed the device is.


  • Managed computers are the easy case. Directory policy on a Windows domain can push the root into every domain machine's trust store automatically. Equivalent central management exists for other platforms. Trust arrives silently, fleet-wide, and stays current.
  • Phones and tablets take the same trick via mobile device management: the root rides in as part of the device profile.
  • Servers, appliances, and applications are the gotcha layer. Some applications ignore the operating system's trust store and keep their own private list. Certain runtimes, containers, and appliances all do this. The symptom is a classic head-scratcher: the browser on the server accepts an internal certificate happily while the application on the same server rejects it. When that happens, ask "which trust store is this app actually reading?" before anything else.
  • Unmanaged devices — guest laptops, contractors, personal phones — are the honesty checkpoint. They do not trust your CA. You should think hard before asking their owners to install your root. Installing your root grants you (and anyone who compromises you) sweeping power over their device's trust. The cleaner answer is to give genuinely public-facing things a public certificate and let internal certificates protect internal things.

Verify the distribution instead of assuming it. Spot-check a few machines from each platform for the root's presence. Treat helpdesk tickets about internal certificate warnings as a monitoring signal. A warning on an internal site from a managed device means either the site's certificate is wrong or that device never received the root. Both are worth knowing this week rather than during an incident. New device types joining the network (a new phone platform, a new appliance line) are the moments trust distribution silently develops gaps. So add "does it trust our CA?" to the intake questions you already ask when bringing new systems into monitoring.


Warning: never train users to click through certificate warnings "because it's just the internal cert." Every click-through rehearses the exact behavior an attacker needs from them later. If a system your people use daily shows warnings, fix the trust or fix the certificate. The warning fatigue is genuinely more dangerous than the missing padlock.


Monitoring the CA itself


Running a CA quietly adds a few services to the short list of things everything else depends on, and each earns a check. A CA never announces that it has become critical infrastructure; it simply is, from the first certificate onward. The table is the summary; the paragraphs after it explain the two entries that surprise people.


What to watchWhySuggested window
Issuing service availabilityEnrollment and renewals fail quietly while it is down; the damage surfaces days later as certificates that never renewedAlert within minutes, like any core service
Revocation endpoints reachableClients that cannot check revocation behave unpredictably — hangs, slow logins, hard failuresAlert within minutes
Revocation data freshnessPublished revocation lists carry their own expiry; a stale list is treated as invalidWarn well before the list's next-update time passes
Issuing CA certificate expiryThe meta-expiry: everything it signed fails with it, and it stops being able to issueWarn a year out; treat replacement as a project
Root CA certificate expiryThe same, one level up, plus redistributing trust to every deviceWarn even earlier; plan in years
Issuance volume and log reviewA burst of unexpected certificates is a security signal, not a performance onePeriodic human review

The revocation endpoints need a word of explanation. Revocation is how a CA takes a certificate back before its expiry — because a key leaked, a server was rebuilt, an admin left. Clients learn about it two generic ways. They can download a published list of revoked certificates that the CA signs and refreshes on a schedule. Or they can ask an online responder about one certificate at a time. Both arrive over plain web URLs baked into every certificate the CA issues. If those URLs stop answering, client behavior gets genuinely weird, because every vendor chose differently. In that situation, some clients fail open (accept without checking — quietly less secure). Some fail closed (refuse — sudden mystery outage). And some stall for long timeouts (logins and connections turn painfully slow for no visible reason). Slow smart-card logins and VPN handshakes that hang are classic symptoms of an unreachable revocation endpoint. Monitor the URLs like any web check — and monitor freshness too. The published list carries its own next-update deadline, and going stale is equivalent to going dark.


The issuing service row hides a similar delayed-fuse quality. When enrollment breaks — the service is down, a permission changed, a template was edited carelessly — nothing visible fails at that moment. Devices and servers simply stop obtaining and renewing certificates. The damage surfaces days or weeks later as a scatter of expiries that your expiry monitoring suddenly starts announcing. An availability check on the issuing service, plus a glance at issuance volume, catches the breakage while it is still one problem instead of forty. A normal week has a heartbeat of renewals; a silent week is a symptom.


Then there is the meta-expiry. CA certificates expire like any other. When an issuing CA's certificate lapses, every certificate it signed stops validating at that same moment — the entire population, at once. The CA can then no longer issue replacements. There is also a subtle shrinking-runway effect long before that day. Issuance is generally constrained so a certificate does not outlive its issuer. So as the CA certificate ages, the lifetimes it can grant quietly compress toward zero. Renewing or replacing a CA certificate is not an afternoon task. It can mean re-signing the issuing tier, republishing trust, and re-issuing down the tree. That is why the warning windows in the table are measured in years. The response to the alert is "open a project," not "log in and click renew." Every CA certificate belongs in the register from building a certificate inventory with exactly that noted in the renewal-method field. And since a CA is also a clock-driven signer, keep its time disciplined. A CA with a skewed clock mints certificates that are "not valid yet" and breaks things in advance. NTP monitoring is part of CA hygiene too.


Ashgrove Housing had run a single-tier CA since before anyone on the current team joined. It had issued the certificates for the intranet, the wireless RADIUS server, and every switch management page. It had never once needed attention, which is why nobody knew it was there. Its certificate expired at midnight on a Saturday. By Monday the wireless would not authenticate laptops, and the intranet warned on every page. By then, the switches could only be managed over a console cable. The three tickets were assigned to three different people. The CA was found on Tuesday, on a virtual machine named after an admin who had left, in a folder called "temp". The replacement took the rest of the month, one trust store at a time.


Operational habits that keep it safe


None of these habits is hard. Together they are most of the difference between a CA that quietly serves for years and one that stars in an incident report.


  • 1. Log every issuance, and read the log. Who requested, what name, which template, when. A periodic skim answers the only question that matters: did we issue anything I cannot explain? An unexplained certificate for a sensitive name is a five-alarm finding precisely because of the trust deal above.
  • 2. Keep template discipline. Templates define what a certificate may claim — names, lifetime, allowed uses. Keep them few and narrow. Server certs should not be able to sign other certs, and user certs should not be able to impersonate servers. No template should hand out decade lifetimes or wildcard names to anyone who asks. Broad templates are how CAs get used against their owners.
  • 3. Keep the list of people who may issue short and current. Named individuals, reviewed when roles change, removed the week someone leaves. "The whole IT group" is not a list.
  • 4. Guard the keys physically and logically. Root offline, always. Issuing CA on a hardened, patched, minimal box — not cohabiting with the intranet server — with its private key non-exportable where the platform supports it.
  • 5. Back up the CA and rehearse the restore. Keys, database, configuration — encrypted, offline, tested. A CA you cannot restore converts every certificate it issued into a countdown with no renewal path.
  • 6. Write down the CA's own renewal plan. Future-you, or your successor, should find the meta-expiry dates, the replacement procedure, and the trust redistribution steps in documentation. They should not discover them from the alert.

When self-signed is honestly fine


A self-signed certificate is one that vouches for itself — the same kind of document, signed by its own key, with no authority behind it. Browsers warn about them because a self-made ID proves nothing to a stranger. But not every connection involves strangers, and pretending otherwise leads to over-engineering. Self-signed is honestly fine when the trusting side can verify the certificate directly instead of through an authority. One case is a lab or test bench that will be rebuilt next month. Another is a pair of appliances that talk only to each other and are configured to pin each other's exact certificates. Pinning means explicitly remembering and requiring those certificates. Another is a single service with one or two clients whose trust you set once, by hand, on purpose.


What you give up is everything an authority automates: no central revocation, no shared trust. Every client needs individual convincing, and every renewal means re-convincing them all. That workload is the tell for when self-signed stops being fine. The cases include more than a handful of clients or anything users touch with a browser. They also include anything that must rotate on a schedule or anything security will ever audit. The moment you find yourself copying certificate fingerprints to a fourth machine, or writing instructions that include "click past the warning" — stop. Not "after this one". Stop. That is the signpost pointing back to the top of this guide. And either way, self-signed certificates expire too, so they live in the register and get checks like everything else, per monitoring certificate expiry.


Where to go next


An internal CA is a passport office you run. It has a locked-away root, a hard-working issuing layer, and trust pushed to the fleet by policy. It also has revocation endpoints that must stay reachable and a meta-expiry that gets project-level lead time. Put its certificates and services in the same inventory and monitoring as everything else, and follow the six habits. And it will be one of the most boring, dependable things you run. From here, automating renewals shows how an internal CA becomes the engine of zero-touch certificate management. The rest of the Certificate & Expiry Monitoring guides cover the inventory and expiry checks this all plugs into. It does not need a bank vault or a security team of twelve. It needs a register row, a monitoring check, and one person who remembers it exists.


Put this into practice with SysPeep Monitor

A CA adds a few services to the list of things that must simply never be down. These are the issuing service, the revocation endpoints, and the box they live on. SysPeep Monitor watches servers and services like these from one Windows machine. It provides availability checks, health metrics over SNMP and WMI, and alert rules that tell the right person the moment something goes quiet. The free trial sets up in minutes.

Download Free TrialLearn About SysPeep