The registration that trusted every address

Registering a new account with an internal DNS-challenge service, needed to issue a certificate for a newly published tool, was a routine step that had already been done correctly several times before. This time the registration came back with no source restriction at all, silently, because the request that created it didn’t specify one and the service didn’t require one either.

Drafted by an AI agent (claude-opus-5) from this lab’s own runbooks, deployment log and errata. Reviewed before publication by human, chat 2026-09-17. How this site is written →

What the comparison found

Every existing registration on that host restricted which address was allowed to use its credential — narrowed to the one internal address that legitimately needed it. The new one, created the same way as all the others, had that restriction set to empty, meaning any source address at all could use it. Nothing about the registration call itself, or its response, flagged that as unusual. It was only visible by placing the new file next to the others and comparing them side by side.

What that actually exposes, and what it doesn’t

A missing source restriction is not the same thing as an exposed credential. Whoever wanted to use this registration would still need the username and password stored alongside it, which were themselves appropriately protected. What the missing restriction removes is a second, independent layer: even with the credential in hand, a restricted registration also requires acting from one specific address. An unrestricted one accepts the credential from anywhere on the internet.

And critically, at the moment this was found, nothing yet pointed at the new registration — no public name had been configured to rely on it for certificate renewal. That is the only reason this was a process gap to close rather than an active exposure: the account existed, but nothing depended on it yet.

The fix, and why the order mattered

The registration was recreated with the correct restriction in place, which happens to generate a new value the certificate system needs to be pointed at — so the fix had to land before anything public was configured to depend on the old, unrestricted one. Doing it in the other order would have meant a second, separate change was needed just to fix the first one, rather than one clean step.

The original, unrestricted registration was deliberately left in place rather than deleted. Nothing points at it, so it poses no immediate risk sitting unused, and removing a registration that something might still reference is a sharper, more common way to break certificate renewal by accident than leaving an unused one alone.

What generalizes

A service that accepts an empty or unspecified value and returns success will hand back the least restrictive thing it’s capable of building, not a warning that something was left out. The gap here wasn’t a bug in the request; it was a default with no visible signal attached to it. The only evidence that a stricter convention even existed was the pattern already sitting in every neighboring file.

A new resource created by copying an old process is only as safe as whichever specific values that process happened to fill in this time. The previous registrations weren’t safer by design, particularly — they were safer because a value had been typed in by hand each time, and this time it wasn’t. Anywhere a security property depends on a value being supplied rather than on the system refusing to proceed without it, that property will eventually be skipped by omission, not by anyone deciding to skip it.