How to Disable Puppet Autosign and Audit Agent Certificates
Puppet autosign without verification lets anyone get a trusted agent certificate. How to disable it, use policy-based signing and audit issued certs.
Puppet autosign controls whether the Puppet CA signs agent certificate requests without a human approving them. With autosign = true, or an autosign.conf allowlist, anyone who can reach port 8140 can obtain a certificate your Puppet Server trusts. CVE-2026-115731 turned that trust into remote code execution. This guide shows how to check the setting, disable it or replace it with policy-based signing, and audit every certificate the CA has already issued.
Why autosign matters right now
Puppet agents authenticate with X.509 certificates signed by the Puppet CA. Every endpoint an agent can call, including the report upload at PUT /puppet/v3/report, trusts any certificate that CA signed. The CVE record for CVE-2026-115731 states that where the certificate authority autosigns requests without strong verification, an unauthenticated network attacker can obtain a certificate and then exploit the deserialization flaw. The patch fixes the deserializer. Autosign is what decides whether a stranger counts as an agent in the first place, and the next bug in an agent-facing endpoint will have the same precondition. Our coverage of the Puppet Enterprise CVE-2026-115731 KEV listing has the version table and the timeline.
What is Puppet autosign?
Puppet autosign is a setting in the server section of the CA server's main configuration file. It tells the CA whether to sign incoming certificate signing requests automatically, and if so, by what rule.
The setting is named autosign and lives in the [server] section of puppet.conf. It has three modes, documented by Puppet:
- Naive:
autosign = true. Every request is signed. Any host that can reach the CA becomes a trusted agent. - Basic:
autosignpoints to a non-executable file, by default$confdir/autosign.conf. The file is a line-separated list of certnames or domain globs such as*.scratch.example.com. Puppet's documentation says this mode is insecure, because any host can provide any certname when it requests a certificate. A glob that matches your production domain is functionally the same as naive autosigning. - Policy-based:
autosignpoints to an executable. The CA runs it for each request, passes the requested certname as the only argument and the PEM-encoded CSR on standard input. Exit 0 signs the certificate. Any non-zero exit leaves it for manual review.
Only the third mode can verify anything beyond the name the requester chose for itself. Note the gotcha in Puppet's documentation: if the file named by autosign is executable by the Puppet user, Puppet treats it as a policy script even if it contains a valid allowlist. The reverse is also a trap. A policy script that lost its executable bit silently becomes an allowlist that matches nothing.
How do you check whether autosign is enabled?
You check autosign by reading the autosign value in the server section of the CA server's configuration file and, if it names a file, inspecting that file's contents and permissions. The setting is only relevant on the server that acts as the CA.
Open puppet.conf on the CA server and find the [server] section. If there is no autosign line, Puppet uses the default path $confdir/autosign.conf, and an empty or missing file means nothing is autosigned. If the file exists, read it. Any line that is a glob covering your real hostnames is a problem. Then check whether the file is executable. If it is, you are running a policy script; read it and confirm it verifies something a stranger could not supply.
Puppet Enterprise and OpenVox use the same setting. Older documentation refers to a [master] section instead of [server]; the behavior is the same.
How to disable autosign
If you can tolerate approving new nodes by hand, this is the safest option and takes one line.
- On the CA server, edit
puppet.conf. - In the
[server]section, set:
autosign = false
- Restart the
puppetserverservice.
Puppet's documentation confirms that autosign = false disables autosigning even when an autosign.conf or policy executable exists. From now on, new agents will submit a request that waits until an administrator signs it. Ostorlab's write-up on CVE-2026-115731 recommends this as the interim step while patching, with one caveat they state plainly: the workaround does not fix the flaw. A stolen or forged agent certificate still reaches the vulnerable deserializer on an unpatched server. Disable autosign and patch; do not choose.
How to move to policy-based autosigning
Manual signing does not scale for autoscaling groups or frequent rebuilds. Policy-based autosigning keeps automation while making the requester prove something.
The approach Puppet documents is to embed additional information in the CSR when the node is provisioned, since a plain CSR contains only the certname and the public key. The common patterns are a pre-shared key that the policy script compares against a known value, or a cloud instance identifier that the script verifies against the provider's API. Puppet's own warning applies: your autosigning security is as good as your handling of the keys. A PSK baked into a golden image that every employee can download is not a secret.
To enable it:
- Write the policy executable. It receives the certname as its single argument and the CSR on stdin. It must exit 0 only when verification succeeds.
- Make it executable by the user Puppet Server runs as, and by nobody else writable.
- Set
autosignin the[server]section ofpuppet.confto the script's full path. - Restart
puppetserver. - Test with a deliberately bad request and confirm it is left pending, not signed.
Puppet notes that the server process blocks while the executable runs, so a slow script (for example one that calls a cloud API with a long timeout) can tie up all server threads. Keep the check fast and cache where you can.
How to audit the certificates already issued
Changing the setting stops future abuse. It does nothing about certificates an attacker already obtained while autosign was open. Ostorlab's detection guidance for CVE-2026-115731 starts here.
- List every certificate. Run
puppetserver ca list --allon the CA server. This prints signed, requested and revoked certificates with their names. - Reconcile against inventory. Compare the signed list with your CMDB, cloud inventory or DNS. Every certname should map to a machine you own. Pay attention to names that look like yours with a character added or removed: CVE-2026-115732, fixed in the same release, lets a certificate whose name extends or shortens an authorized hostname be treated as that host.
- Check the access log. Search Puppet Server's access log for
PUT /puppet/v3/reportrequests from certificate names that are not in your inventory. A legitimate agent sends one report per run, so a certname that appears only in report uploads and never in catalog requests is suspicious. - Revoke what you cannot explain. Revoke the unknown certificate and clean it from the CA, then investigate the host or network it came from.
- Decide whether the CA is burned. If an unknown certificate was signed while the server was unpatched, assume the attacker could have reached the deserializer. Ostorlab's advice is to treat the CA as compromised: rebuild the server, rotate the CA and reissue every agent certificate. This is painful. It is also the only way to be sure, because an attacker with code execution on the CA server can read the signing key and mint certificates that pass every check above.
Keep the fix in place
Add a check to your monitoring that reads the autosign setting on the CA server and alerts if it is true or points to a non-executable file with glob entries. Treat the policy script like any other credential-handling code: in version control, reviewed, with its secret rotated when staff leave. And put the Puppet CA on the same patching and access-control footing as a domain controller, because a configuration management server is a Tier 0 asset whether or not your asset register says so. For the bug class that made this urgent, see what insecure deserialization (CWE-502) is.