| Internet-Draft | ACME Workload Identity | November 2026 |
| Rasmussen | Expires 20 May 2027 | [Page] |
Enterprises hold large certificate inventories, yet few of their certificates are managed through ACME. Many workloads, such as CI/CD jobs, containers, virtual machines, cloud services and the automation that manages appliances, cannot complete ACME's challenges. Certification Authorities (CAs) and Certificate Lifecycle Management (CLM) systems that serve them fall back to External Account Binding (EAB) with long-lived shared secrets, or to proprietary APIs.¶
OpenID Connect (OIDC) provides a short-lived cryptographically verified identity token to the workload. This document lets an ACME client send that token with each newOrder request. The token can be bound to the request's nonce and account key through its audience claim, so identity providers need no changes. The CA/CLM verifies the token and, under its own policy, may pre-authorize the identifier in the order, as RFC 8555 already allows. This replaces the EAB secret with a fresh, per-order proof of workload identity. It does not change how CAs validate control of identifiers.¶
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.¶
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.¶
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."¶
This Internet-Draft will expire on 20 May 2027.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License.¶
ACME [RFC8555] automates issuance for web public facing web servers, but much of an enterprise's certificate inventory cannot respond to either a DNS or HTTP challenge.¶
The workloads involved include CI/CD pipelines, containers, cloud functions, virtual machines, cloud services such as key management services, and automation such as Ansible that obtains certificates for network devices, databases and other appliances that cannot run ACME themselves. Many keep no state between runs and are deliberately given no long-lived secrets. Many need certificates that no challenge helps with, such as X.509 client certificates for mutual TLS or for SSH authentication.¶
For these workloads, each existing ACME mechanism has a cost:¶
dns-01 requires the workload, or a service acting for it, to hold credentials that can change DNS. Giving many workloads write access to DNS is an operational risk, since a mistake can cause an outage; and a security risk, since a compromised workload can alter DNS and move laterally.¶
http-01 requires the CA to reach the workload over HTTP. That is often impossible: the workload is not an HTTP server; inbound traffic is restricted by IP allowlists, mutual TLS or geo-blocking; or the network allows no ingress at all, as is common in regulated environments.¶
dns-persist-01 [I-D.ietf-acme-dns-persist] removes DNS changes at issuance, but binds each authorization to a persistent ACME account. Each workload must keep that account's key, which is a long-lived credential to store, rotate and inventory.¶
Subscribers whose organization and domains a CA has already validated, such as OV and EV customers, need no challenge at all. CAs link their accounts using External Account Binding (EAB, Section 7.3.4 of [RFC8555]) and pre-authorize the names the Subscriber is allowed (Section 7.1.3 of [RFC8555]).¶
The EAB MAC key is a long-lived shared secret. A Subscriber either holds many of them, one per workload, each of which must be created, distributed, stored, rotated and inventoried; or holds a few, each of which lets anyone who obtains it get certificates for every name the Subscriber is allowed. The keys tend to end up in configuration files and command lines.¶
Where ACME does not fit, Subscribers integrate with each CA's or CLM's proprietary API, separately for every combination of CA, CLM and workload environment.¶
These workloads already have a better credential. Their platform (GitHub Actions, GitLab CI/CD, Kubernetes, SPIFFE, AWS, Azure, Google Cloud and others) issues them a short-lived JSON Web Token [RFC7519], signed with a key the platform publishes. Accepting such a token is commonly called workload identity federation (WIF). This document lets an ACME client use the platform's token in place of a stored credential.¶
This document defines:¶
a "wifToken" field in the newOrder request (Section 4), carrying the workload's platform token; and¶
an audience binding (Section 3) that ties the token to the nonce and account key of that one request, using only the token's existing "aud" claim; and¶
a static audience mode (Section 3.1) that a CA may permit, by policy, for identity providers that cannot vary the audience per request.¶
The CA verifies the token and finds the policy entry it satisfies (Section 7). That entry tells the CA which Subscriber the workload belongs to and which identifiers it may have. The CA may then pre-authorize those identifiers for this order. Identifiers it does not pre-authorize are validated per normal process (HTTP, DNS).¶
A workload therefore needs no secret. It creates an ephemeral account from a freshly generated key, sends its platform token with each order, and the CA checks its identity on every order rather than once when the account was created.¶
This document does not define a new way to validate control of an identifier. Pre-authorization based on a token is CA policy, exactly as pre-authorization based on EAB is today (Section 10.1). This document also does not define a policy language.¶
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.¶
Software that needs a certificate, such as a CI/CD job, a container or a virtual machine.¶
The platform service that issues identity tokens to workloads. It has no relationship with the CA and does not know ACME is in use.¶
A JWT [RFC7519] that an IdP issues to a workload, signed with an asymmetric algorithm and verifiable with a key the IdP publishes.¶
A service that manages certificates for a Subscriber and obtains them from one or more CAs. A CLM can act as the ACME server. In this document, "CA" and "server" include a CLM in that role.¶
The organization that obtains certificates from the CA and configures the CA's policy for its workloads.¶
CA configuration, set up by a Subscriber, that names an accepted issuer, a rule over that issuer's token claims, the identifiers a matching workload may be pre-authorized for, and whether it accepts tokens in static audience mode (Section 7).¶
The value a workload places in the "aud" claim of its WIF Token (Section 3).¶
Terms from [RFC8555], [RFC7515] and [RFC7519] are used as defined there.¶
Before any of this, the Subscriber configures one or more Policy Entries at the CA. Each says which workload tokens may be pre-authorized for which identifiers.¶
The WIF Token must be usable only by the account that requested it, and only once. Identity providers can let the workload choose the "aud" claim. This document therefore carries the binding in the audience.¶
The Audience Binding Value is:¶
ABV = "urn:ietf:params:acme:wif:" ||
base64url(SHA-256(ASCII(nonce || "." || thumbprint)))
¶
where:¶
nonce is the value of the "nonce" header parameter in the JWS protected header of the newOrder request that carries the token (Section 6.5 of [RFC8555]);¶
thumbprint is the base64url-encoded JWK SHA-256 Thumbprint [RFC7638] of the account key that signs that request; and¶
ACME nonces are single-use, so the ABV is unique to one request. The thumbprint ties it to one account key, so a leaked token is useless to anyone who does not hold that key. Hashing keeps the value at a fixed 68 characters, which every surveyed IdP accepts, and keeps the nonce from the IdP.¶
A server supporting this document MUST generate nonces containing at least 128 bits of entropy.¶
Some IdPs cannot put a per-request value in "aud". A CA/CLM MAY accept their tokens in static audience mode (Section 3.1), which is weaker and is available only where the CA/CLM policy enables it.¶
Some IdPs fix the audience when the token is issued or when the workload is configured. Azure managed identities accept only a pre-registered application ID URI. GitLab CI/CD issues ID tokens when a job starts, with the audience written in the pipeline definition. Kubernetes projected token volumes fix the audience when the pod starts (Appendix A). These tokens cannot carry an ABV.¶
A CA/CLM MAY accept such tokens, as a matter of its own policy, in static audience mode. Static audience mode MUST be disabled unless the CA/CLM configuration enables it, and a CA/CLM SHOULD enable it per Policy Entry rather than per issuer. In this mode:¶
The CA/CLM configures one or more static audience values for the issuer, for example an application ID URI that the Subscriber registered for the CA. The workload requests its token with one of them. A static audience SHOULD identify this CA/CLM alone, so that tokens a workload obtains for other services are not accepted. The values are agreed out of band and are not listed in the directory.¶
A token in this mode is accepted only by a Policy Entry that explicitly permits static audience tokens (Section 7).¶
The server MUST accept each such token at most once. It MUST record a value that identifies the token until the token's "exp", and reject a token it has already recorded with "wifTokenReplayed". The value is the "jti" claim where the CA's configuration says the issuer guarantees "jti" to be unique, and otherwise the SHA-256 hash of the whole token. A server with several instances must share this record among them.¶
The server SHOULD set a maximum token lifetime for the issuer that is no longer than its workloads need.¶
A static audience token is not bound to an account key or a nonce. Anyone who obtains it before it is used can present it with their own account, and the first presentation succeeds (Section 10.3). A CA/CLM that permits this mode accepts that risk, for the Policy Entries it enables it on, in return for supporting these IdPs. The choice can differ between Policy Entries. For example, a CA/CLM might permit it for a private CA's short-lived client certificates but not for names in publicly trusted certificates.¶
A client MUST NOT send "wifToken" unless the server's directory contains the "wif" metadata object (Section 6). [RFC8555] does not require servers to ignore unrecognized fields in a newOrder request, so a server that does not support this document might reject the request.¶
To place an order with a WIF Token, the client:¶
obtains a fresh nonce, from a newNonce request or from the Replay-Nonce header of an earlier response;¶
computes the ABV (Section 3) from that nonce and its account key;¶
requests a WIF Token from its IdP with the ABV as the audience (Appendix A), asking for the shortest lifetime the platform allows; and¶
sends a newOrder request (Section 7.4 of [RFC8555]) signed with the same account key and using that nonce, with the token in a "wifToken" field.¶
POST /acme/new-order HTTP/1.1
Host: ca.example
Content-Type: application/jose+json
{
"protected": base64url({
"alg": "ES256",
"kid": "https://ca.example/acme/acct/evOfKhNU60wg",
"nonce": "5XJ1L3lEkMG7tR6pA00clA",
"url": "https://ca.example/acme/new-order"
}),
"payload": base64url({
"identifiers": [
{ "type": "dns", "value": "gateway.internal.example.com" }
],
"wifToken": "eyJhbGciOiJSUzI1NiIsImtpZCI6IjFGMkFCM..."
}),
"signature": "H6ZXtGjTZyUnPeKn...wEA4TklBdh3e454g"
}
In static audience mode (Section 3.1), the client instead requests its token with the agreed static audience, which it may do before obtaining the nonce, and omits step 2.¶
If the server rejects the request with "badNonce", the client must start again from step 1 with a new nonce and, unless it is in static audience mode, a new token.¶
The client needs a new token for every order. It MUST NOT store a WIF Token or write it to a log.¶
When a newOrder request contains "wifToken", the server performs these steps before creating the order. If any step fails, the server rejects the request with an error from Section 4.6 and creates no order.¶
Parse "wifToken" as a JWS in Compact Serialization [RFC7515].¶
Check "alg". Reject "none" and all MAC algorithms. Accept only algorithms configured for the issuer selected in step 3; never take the algorithm from the token alone.¶
Check that "iss" exactly matches an issuer the server accepts, using simple string comparison (Section 6.2.1 of [RFC3986]). Prefix, suffix and subdomain matches are not allowed.¶
Select the verification key from the issuer's key set (Section 4.5) using "kid". Reject the token if "kid" names no key in the set. A server SHOULD reject a token without "kid".¶
Verify the signature.¶
Check that "exp" is in the future and that "nbf" and "iat", if present, are not, allowing at most 60 seconds of clock skew. Reject the token if its remaining lifetime exceeds the server's maximum for the issuer.¶
Compute the expected ABV from the nonce in this request's protected header and the thumbprint of the key that signed it. Check that "aud" equals it (if a string) or contains it (if an array), comparing octet for octet. If it does not, and static audience mode (Section 3.1) is enabled for this issuer, check in the same way whether "aud" is one of the issuer's static audience values. If it is, the token is in static audience mode. Otherwise, reject with "wifAudienceMismatch".¶
Find the Policy Entries whose issuer is this token's issuer and whose rule the token's claims satisfy (Section 7). For a token in static audience mode, consider only Policy Entries that permit that mode. If there are none, reject with "wifPolicyDenied".¶
For a token in static audience mode, check that it has not been accepted before, and record it (Section 3.1). If it has been, reject with "wifTokenReplayed".¶
The server never includes "wifToken" in the order object it returns or stores.¶
After validation, the server creates the order. For each identifier in the order, the server either:¶
pre-authorizes it, if a matching Policy Entry permits that identifier and the CA's own validation requirements allow it (Section 7.1.3 of [RFC8555]). The authorization is created with status "valid" and no challenges need to be completed; or¶
handles it exactly as it would without a token: by offering challenges, by reusing an existing validation, or by rejecting it.¶
The token identifies the Subscriber. Anything a CA would do for accounts linked to that Subscriber by EAB, such as reusing that Subscriber's earlier domain validations within the period its rules allow, it MAY do here.¶
An authorization pre-authorized on the basis of a WIF Token:¶
MUST have an "expires" no later than the token's "exp", and the server MUST NOT extend it; and¶
MUST NOT be used to satisfy any order other than the one whose request carried the token.¶
Together these mean a token authorizes one order and nothing after it. Each new order needs a new token, so the workload's identity is checked every time.¶
A WIF Token could instead be sent once, with the newAccount request, in place of EAB. The account would then hold the Subscriber's authority until it was deactivated, long after the token had expired and regardless of later changes to the workload. Sending the token with each order keeps authority tied to a fresh, short-lived proof of identity, leaves account registration unchanged, and lets ephemeral workloads discard their accounts freely.¶
The server obtains an issuer's JWK Set [RFC7517] from the "jwks_uri" in its OpenID Provider Metadata [OIDC-DISCOVERY], or from keys configured directly. The metadata URL MUST come from the server's own configuration, never from a token's "iss" claim (Section 10.7).¶
Servers SHOULD cache key sets, and SHOULD refresh one when they see an unknown "kid", rate-limiting those refreshes.¶
| Type | Meaning |
|---|---|
| badWifToken | The token is malformed, has a bad signature or algorithm, or is outside its validity period |
| wifIssuerNotAccepted | The token's issuer is not accepted |
| wifAudienceMismatch | "aud" does not contain the expected ABV |
| wifPolicyDenied | The token is valid, but no Policy Entry accepts it |
| wifTokenReplayed | A token in static audience mode has already been used |
With "wifPolicyDenied", a server SHOULD say which claims it evaluated and the values the token carried, so operators can fix the problem. It MUST NOT reveal the values the policy expected (Section 7).¶
A workload creates an ordinary account from a freshly generated key, with no "externalAccountBinding". The account carries no authority of its own; what a workload may obtain is decided per order, from its token and the Policy Entries. EAB is therefore not needed.¶
A CA/CLM that requires EAB for other reasons, such as billing, can either set "externalAccountRequired" to false or serve WIF Tokens from a separate directory. See Section 12.¶
Workloads often create a new account on every run. Servers SHOULD allow this, SHOULD apply rate limits by Policy Entry rather than by account, and SHOULD discard accounts that have been idle for a long time.¶
A server supporting this document SHOULD include a "wif" object in the "meta" field of its directory, with these fields:¶
The issuers the server accepts.¶
The longest remaining token lifetime, in seconds, that the server accepts.¶
If true, the server rejects any newOrder request without a "wifToken" with the error type "unauthorized". Defaults to false.¶
"meta": {
"wif": {
"issuers": ["https://token.actions.githubusercontent.com"],
"maxTokenLifetime": 300,
"required": true
}
}
¶
Setting "required" to true turns away every client that does not implement this document, as "externalAccountRequired" does for clients without EAB. A CA that also serves other clients SHOULD give workload clients a separate directory.¶
Clients MUST ignore members of the "wif" object they do not recognize. A CA that does not want to reveal which platforms its Subscribers use may give an empty "issuers" array.¶
A Policy Entry associates:¶
an accepted issuer;¶
a rule over that issuer's token claims;¶
the identifiers a matching workload may be pre-authorized for; and¶
whether it accepts tokens in static audience mode (Section 3.1), which is off unless set explicitly.¶
For example:¶
issuer: https://token.actions.githubusercontent.com require: repository_owner_id = 1234567 repository_id = 89012345 ref = refs/heads/main permit: dns:gateway.internal.example.com¶
A Subscriber configures its Policy Entries out of band, before any request arrives. The CA is responsible for checking that the Subscriber is entitled to the identifiers it lists, as it is when it sets up EAB pre-authorization today.¶
This document does not define a policy language, but every policy:¶
MUST name an explicit issuer and an explicit rule over claims. "Any token from this issuer" MUST NOT be expressible, because shared platforms such as GitHub issue tokens to every tenant from one issuer (Section 10.4);¶
SHOULD match claims that are not reassigned, such as numeric IDs, rather than names (Section 10.5);¶
SHOULD, for important identifiers, constrain where the workload ran, such as the branch, environment or namespace; and¶
SHOULD list identifiers exactly. A pattern that matches more names than intended grants all of them. Where names are generated at run time, as in an ephemeral test environment, a Policy Entry can instead permit names under a subdomain reserved for that workload.¶
The server does not tell clients which claim values a policy expects. Clients cannot choose their claims anyway, and the values describe the Subscriber's internal structure. The values are not secret, though. Security rests on the IdP issuing tokens for a subject only to that subject, and on the audience binding. It does not rest on anyone not knowing the policy.¶
A CA operator SHOULD accept an IdP only if it:¶
signs tokens with an asymmetric algorithm from [RFC7518], or a successor, of at least 128-bit strength;¶
publishes its keys through OpenID Connect Discovery [OIDC-DISCOVERY], or lets the CA obtain them through another trustworthy channel;¶
lets the workload set "aud" to an arbitrary string on each request. An IdP that cannot do this can be accepted only in static audience mode (Section 3.1), and only where the CA's policy permits it;¶
includes "exp" and supports short token lifetimes; and¶
issues claims that identify the workload precisely and stably, and never issues a token for a subject to anyone but that subject.¶
IANA is requested to add this entry to the "ACME Order Object Fields" registry:¶
| Field Name | Field Type | Configurable | Reference |
|---|---|---|---|
| wifToken | string | true | This document |
The field appears only in newOrder requests. Servers never return it in an order object (Section 4.2).¶
IANA is requested to add these entries to the "ACME Error Types" registry, each with the prefix "urn:ietf:params:acme:error:":¶
| Type | Description | Reference |
|---|---|---|
| badWifToken | The WIF Token is malformed, unverifiable or not currently valid | This document |
| wifIssuerNotAccepted | The token issuer is not accepted | This document |
| wifAudienceMismatch | The token audience does not contain the expected binding value | This document |
| wifPolicyDenied | No policy accepts this workload | This document |
| wifTokenReplayed | A static audience token has already been used | This document |
IANA is requested to add this entry to the "ACME Directory Metadata Fields" registry:¶
| Field Name | Field Type | Reference |
|---|---|---|
| wif | object | This document |
The ABV uses the prefix "urn:ietf:params:acme:wif:" within the namespace registered by Section 9.6 of [RFC8555]. No registry exists for labels in that namespace, so no IANA action is requested. See Section 12.¶
A valid "wifToken" shows that the requester held the account key and a fresh token, issued by an accepted IdP, whose claims satisfy a Policy Entry. It identifies the workload, and through the Policy Entry, the Subscriber.¶
It proves nothing about control of any identifier. Pre-authorization on the basis of a token is a CA policy decision, with the same standing as pre-authorization on the basis of EAB. A CA MUST apply its own validation requirements before pre-authorizing an identifier. In particular, a publicly trusted CA pre-authorizes a name only where its rules already allow it, for example by reusing a recent validation of that name for the same Subscriber.¶
WIF Tokens leak in practice, for example into build logs. A leaked token is harmless only because its audience commits to one account key and one single-use nonce, which the server recomputes (Section 3). A token whose audience is a fixed value would be a usable bearer credential for its whole lifetime. That is why the bound audience is the default, and why static audience mode is off unless a CA enables it.¶
Because the audience changes on every request, an IdP or tenant administrator cannot restrict which audiences a workload may request. That control must come instead from the IdP's controls over which workloads get tokens, and from Policy Entries. The "urn:ietf:params:acme:wif:" prefix only makes the value recognizable; it carries no security weight.¶
A token in static audience mode (Section 3.1) is a bearer credential until it is used or expires. Single-use enforcement stops a leaked token from being used after the workload has used it, but not before. An attacker who reads the token, for example from a log while the job is still running, can race the workload. Short token lifetimes, never logging tokens, and narrow Policy Entries limit the risk. A CA deciding whether to permit this mode should weigh the value of the identifiers involved. The mode suits short-lived certificates from a private CA better than names in publicly trusted certificates.¶
Every GitHub repository gets tokens from the same issuer. A policy that accepts any token from that issuer accepts a token from any GitHub user, including an attacker who signed up minutes earlier. Policy Entries therefore MUST constrain claims that identify the Subscriber's own workloads (Section 7), and implementations SHOULD refuse to load a rule that does not constrain the subject.¶
Some claims look stable but are not. A renamed or transferred GitHub repository frees its name for someone else, but its "repository_id" is never reused. A Kubernetes service account can be deleted and recreated with the same name, and an AWS IAM role can be recreated with the same ARN. Some platforms also let administrators change the format of "sub". Policies SHOULD match numeric or unique identifiers and individual claims, rather than names or patterns over "sub".¶
A token shows which workload identity ran, not which code ran. Anyone who can change a workflow, for example by pushing to a branch or through a compromised dependency, can obtain a token for that identity. Policies for important identifiers SHOULD require a specific branch, environment or namespace, and SHOULD use platform approval gates where available.¶
Fetching issuer metadata from a URL taken from a token would let attackers make the CA send requests to arbitrary hosts. Servers MUST build these URLs from configuration (Section 4.5). They SHOULD also refuse non-public addresses unless configured for a private issuer, limit response size and redirects, and time out quickly.¶
Verifying a token costs more than processing an ordinary newOrder request. Servers SHOULD reject malformed or oversized tokens before verifying them, and SHOULD rate-limit newOrder requests carrying tokens by account and by Policy Entry. Servers SHOULD keep using cached keys for a bounded period when an IdP is unreachable.¶
Servers MUST keep a list of accepted algorithms per issuer and MUST NOT let the token's header choose the verification algorithm (step 2 of Section 4.2).¶
A WIF Token reveals internal details to the CA, such as repository, organization, cluster, namespace and branch names, and cloud account numbers. CAs SHOULD keep only the claims their policy and audit duties need, and SHOULD NOT keep tokens.¶
Servers MUST NOT copy token claims into certificates. Claims routinely contain internal names, and publicly trusted certificates are logged in Certificate Transparency [RFC6962].¶
The directory's "issuers" list shows which platforms a CA's Subscribers use (Section 6). The IdP learns only that a workload asked for a token with an ACME audience, not which CA, account or identifier was involved.¶
This section is to be removed before publication.¶
Names. Is "wifToken" the right field name, and "wif" the right metadata and URN label?¶
Static audience mode (Section 3.1) lets a CA accept tokens from IdPs that cannot vary the audience per request, such as Azure managed identities and GitLab CI/CD, at the cost of a token that is a bearer credential until it is used. Should this document define the mode, or leave it entirely to CA policy? Should the directory say which issuers permit it? Should the working group instead ask IdPs to support a per-request audience?¶
Some relying parties, such as mTLS gateways, may want the certificate to name the workload itself. A later extension could define an identifier type derived from the token's "iss" and "sub". Client-authentication certificates for mutual TLS and SSH, a main use case, depend on it. Should it be in this document?¶
CAs that need EAB for billing still need a pre-shared secret. Could a WIF Token be exchanged for EAB credentials, for example using OAuth 2.0 Token Exchange [RFC8693], and should that be specified here or elsewhere?¶
The "urn:ietf:params:acme:wif:" prefix has no registry to record it. Should one be created?¶
This appendix is informative. Platform details change, so check current documentation.¶
Issuer "https://token.actions.githubusercontent.com". The job needs the "id-token: write" permission. The audience is chosen per request, for example with "core.getIDToken(audience)". Match "repository_owner_id" and "repository_id" rather than names, and constrain "ref" or "environment".¶
The issuer is per cluster. Use the TokenRequest API, which takes the audience per request. Projected token volumes fix the audience when the pod starts, so their tokens can be used only in static audience mode (Section 3.1). "sub" is "system:serviceaccount:NAMESPACE:NAME". Match the service account UID where available.¶
The JWT-SVID API takes the audience per request [SPIFFE-ID]. "sub" is the SPIFFE ID.¶
The issuer is the GitLab instance URL. ID tokens are declared with "id_tokens" in the pipeline definition and issued when the job starts, so their audience cannot include a nonce. They can be used only in static audience mode. A job gets one token per declared ID token, so it can place only that many orders. Match "project_id" and "namespace_id" rather than paths, and constrain "ref" and "ref_protected".¶
The STS "GetWebIdentityToken" action, on a regional endpoint, takes up to ten audiences and a lifetime of 60 to 3600 seconds (default 300). "sub" is the caller's IAM principal ARN. Caller-supplied tags MUST NOT be trusted by policy.¶
AKS workload identity works as Kubernetes. Managed identity tokens, such as those from the Instance Metadata Service, carry a pre-registered application ID URI as their audience, which cannot vary per request. They can be used only in static audience mode, with an application ID URI the Subscriber registers for the CA. These tokens may lack "jti", so the server keys replay detection on a hash of the token. The platform caches tokens and may return the same one to repeated requests, which the server then rejects as replayed, so a workload may be limited to about one order per token lifetime.¶
Identity tokens from the metadata server take the audience per request.¶
Example Corp runs a private CA. Its GitHub Actions deployment job for repository "example-corp/gateway" needs a certificate for "gateway.internal.example.com". Example Corp configured this Policy Entry once:¶
issuer: https://token.actions.githubusercontent.com require: repository_owner_id = 1234567 repository_id = 89012345 ref = refs/heads/main permit: dns:gateway.internal.example.com¶
The job holds no credential for the CA. It:¶
generates an account key and creates an account with no EAB, keeping the Replay-Nonce from the response;¶
computes the ABV from that nonce and its account key, and requests a GitHub token with that audience;¶
sends newOrder for "gateway.internal.example.com" with the token in "wifToken", using that nonce; and¶
finalizes the order.¶
The CA verifies the token against GitHub's keys, checks its lifetime, recomputes the ABV from the request's nonce and key, and finds that "repository_owner_id", "repository_id" and "ref" match the entry. The entry permits the name, so the CA returns the order with its authorization already valid, expiring with the token. The job finalizes immediately.¶
A job from a fork, a different branch or another repository presents a valid token whose claims do not match, and is refused with "wifPolicyDenied".¶
This section is to be removed before publication.¶
Replaced the "wif-01" challenge with a "wifToken" field in the newOrder request. List feedback pointed out that a challenge on a "dns" or "ip" authorization would act as an alternative proof of control, which a platform token cannot provide. The token now supports pre-authorization by CA policy, as EAB does, and the document says plainly that it is not proof of control.¶
The audience binding now uses the request's nonce in place of the challenge token.¶
A token authorizes only the order it was sent with.¶
Added the "required" directory metadata field.¶
Removed the challenge object and the per-challenge "issuers" field.¶
Added static audience mode, off by default and enabled by CA policy per Policy Entry, for IdPs that cannot vary the audience, such as Azure managed identities and GitLab CI/CD. Tokens in this mode are single use, and the "wifTokenReplayed" error applies only to them.¶
Expanded the problem statement: why dns-01, http-01, dns-persist-01 and EAB do not serve many enterprise workloads; certificates that name a workload; and CLM systems acting as ACME servers.¶
Rewrote the whole document to be shorter and plainer.¶
Thanks to Aaron Gable, Mike Ounsworth, Geng Feng, Seo Suchan, Mike Kushner and Sven Rajala for their review of -00 on the ACME list. The authors of [I-D.ietf-acme-openid-federation] advised keeping this work within ACME's existing extension points.¶
Parts of this document were drafted with the help of a large language model (Claude, from Anthropic). The author has reviewed all of the text and is responsible for it.¶