ACME Working Group S. Rasmussen Internet-Draft Independent Intended status: Standards Track 16 November 2026 Expires: 20 May 2027 Workload Identity Tokens in Automated Certificate Management Environment (ACME) Orders draft-rasmussen-acme-wif-01 Abstract 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. Status of This Memo 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. Rasmussen Expires 20 May 2027 [Page 1] Internet-Draft ACME Workload Identity November 2026 Copyright Notice 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. Table of Contents 1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 3 1.1. Problem . . . . . . . . . . . . . . . . . . . . . . . . . 3 1.2. This Document . . . . . . . . . . . . . . . . . . . . . . 4 1.3. Terminology . . . . . . . . . . . . . . . . . . . . . . . 5 2. Overview . . . . . . . . . . . . . . . . . . . . . . . . . . 6 3. The Audience Binding Value . . . . . . . . . . . . . . . . . 6 3.1. Static Audience Mode . . . . . . . . . . . . . . . . . . 7 4. The "wifToken" Order Field . . . . . . . . . . . . . . . . . 8 4.1. Client Behaviour . . . . . . . . . . . . . . . . . . . . 8 4.2. Server Validation . . . . . . . . . . . . . . . . . . . . 9 4.3. Pre-authorization . . . . . . . . . . . . . . . . . . . . 10 4.4. Why the Token Is Sent with Each Order . . . . . . . . . . 11 4.5. Issuer Keys . . . . . . . . . . . . . . . . . . . . . . . 11 4.6. Errors . . . . . . . . . . . . . . . . . . . . . . . . . 11 5. Accounts . . . . . . . . . . . . . . . . . . . . . . . . . . 12 6. Directory Metadata . . . . . . . . . . . . . . . . . . . . . 12 7. Authorization Policy . . . . . . . . . . . . . . . . . . . . 13 8. Identity Provider Requirements . . . . . . . . . . . . . . . 14 9. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 14 9.1. ACME Order Object Fields . . . . . . . . . . . . . . . . 15 9.2. ACME Error Types . . . . . . . . . . . . . . . . . . . . 15 9.3. ACME Directory Metadata Fields . . . . . . . . . . . . . 15 9.4. URN Label . . . . . . . . . . . . . . . . . . . . . . . . 16 10. Security Considerations . . . . . . . . . . . . . . . . . . . 16 10.1. What a WIF Token Proves . . . . . . . . . . . . . . . . 16 10.2. The Audience Binding . . . . . . . . . . . . . . . . . . 16 10.3. Static Audience Tokens . . . . . . . . . . . . . . . . . 17 10.4. Issuer Allowlisting Is Not Authorization . . . . . . . . 17 10.5. Mutable and Reassignable Claims . . . . . . . . . . . . 17 10.6. Execution Context . . . . . . . . . . . . . . . . . . . 17 10.7. Server-Side Request Forgery . . . . . . . . . . . . . . 17 10.8. Denial of Service . . . . . . . . . . . . . . . . . . . 18 Rasmussen Expires 20 May 2027 [Page 2] Internet-Draft ACME Workload Identity November 2026 10.9. Algorithm Confusion . . . . . . . . . . . . . . . . . . 18 11. Privacy Considerations . . . . . . . . . . . . . . . . . . . 18 12. Open Issues . . . . . . . . . . . . . . . . . . . . . . . . . 18 13. Related Work . . . . . . . . . . . . . . . . . . . . . . . . 19 14. References . . . . . . . . . . . . . . . . . . . . . . . . . 19 14.1. Normative References . . . . . . . . . . . . . . . . . . 19 14.2. Informative References . . . . . . . . . . . . . . . . . 20 Appendix A. Provider Profiles . . . . . . . . . . . . . . . . . 22 Appendix B. Example . . . . . . . . . . . . . . . . . . . . . . 23 Changes Since -00 . . . . . . . . . . . . . . . . . . . . . . . . 24 Acknowledgements . . . . . . . . . . . . . . . . . . . . . . . . 25 Use of Generative AI . . . . . . . . . . . . . . . . . . . . . . 25 Author's Address . . . . . . . . . . . . . . . . . . . . . . . . 25 1. Introduction 1.1. Problem 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. Rasmussen Expires 20 May 2027 [Page 3] Internet-Draft ACME Workload Identity November 2026 * 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. 1.2. This Document 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. Rasmussen Expires 20 May 2027 [Page 4] Internet-Draft ACME Workload Identity November 2026 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. 1.3. Terminology 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. Workload: Software that needs a certificate, such as a CI/CD job, a container or a virtual machine. Identity Provider (IdP): The platform service that issues identity tokens to workloads. It has no relationship with the CA and does not know ACME is in use. WIF Token: A JWT [RFC7519] that an IdP issues to a workload, signed with an asymmetric algorithm and verifiable with a key the IdP publishes. Certificate Lifecycle Management (CLM) system: 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. Subscriber: The organization that obtains certificates from the CA and configures the CA's policy for its workloads. Policy Entry: 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). Rasmussen Expires 20 May 2027 [Page 5] Internet-Draft ACME Workload Identity November 2026 Audience Binding Value (ABV): 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. 2. Overview Client ACME Server IdP | | | |-- newAccount (fresh key) ----->| | |<-- Replay-Nonce: N ------------| | | | | | ABV from N and account key | | |-- request token (aud = ABV) ------------------------------->| |<-- WIF Token -----------------------------------------------| | | | |-- newOrder (nonce N) --------->| | | {identifiers, wifToken} |-- fetch JWKS (cached) ---->| | | verify signature, expiry, | | | aud = ABV, policy entry | |<-- order, authzs pre- | | | authorized per policy ------| | |-- finalize ------------------->| | Figure 1: Ordering a certificate with a WIF Token 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. 3. The Audience Binding Value 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]); Rasmussen Expires 20 May 2027 [Page 6] Internet-Draft ACME Workload Identity November 2026 * thumbprint is the base64url-encoded JWK SHA-256 Thumbprint [RFC7638] of the account key that signs that request; and * base64url is without padding [RFC4648]. 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. 3.1. Static Audience Mode 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). Rasmussen Expires 20 May 2027 [Page 7] Internet-Draft ACME Workload Identity November 2026 * 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. 4. The "wifToken" Order Field 4.1. Client Behaviour 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: 1. obtains a fresh nonce, from a newNonce request or from the Replay-Nonce header of an earlier response; 2. computes the ABV (Section 3) from that nonce and its account key; 3. requests a WIF Token from its IdP with the ABV as the audience (Appendix A), asking for the shortest lifetime the platform allows; and 4. 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. Rasmussen Expires 20 May 2027 [Page 8] Internet-Draft ACME Workload Identity November 2026 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" } Figure 2: A newOrder request carrying a WIF Token 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. 4.2. Server Validation 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. 1. Parse "wifToken" as a JWS in Compact Serialization [RFC7515]. 2. 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. Rasmussen Expires 20 May 2027 [Page 9] Internet-Draft ACME Workload Identity November 2026 3. 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. 4. 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". 5. Verify the signature. 6. 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. 7. 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". 8. 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". 9. 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. 4.3. Pre-authorization 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. Rasmussen Expires 20 May 2027 [Page 10] Internet-Draft ACME Workload Identity November 2026 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. 4.4. Why the Token Is Sent with Each Order 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. 4.5. Issuer Keys 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. 4.6. Errors +======================+================================+ | 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 | Rasmussen Expires 20 May 2027 [Page 11] Internet-Draft ACME Workload Identity November 2026 +----------------------+--------------------------------+ | 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 | +----------------------+--------------------------------+ Table 1: Error types 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). 5. Accounts 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. 6. Directory Metadata A server supporting this document SHOULD include a "wif" object in the "meta" field of its directory, with these fields: issuers (required, array of string): The issuers the server accepts. maxTokenLifetime (optional, number): The longest remaining token lifetime, in seconds, that the server accepts. required (optional, boolean): If true, the server rejects any newOrder request without a "wifToken" with the error type "unauthorized". Defaults to false. Rasmussen Expires 20 May 2027 [Page 12] Internet-Draft ACME Workload Identity November 2026 "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. 7. Authorization Policy 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: Rasmussen Expires 20 May 2027 [Page 13] Internet-Draft ACME Workload Identity November 2026 * 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. 8. Identity Provider Requirements A CA operator SHOULD accept an IdP only if it: 1. signs tokens with an asymmetric algorithm from [RFC7518], or a successor, of at least 128-bit strength; 2. publishes its keys through OpenID Connect Discovery [OIDC-DISCOVERY], or lets the CA obtain them through another trustworthy channel; 3. 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; 4. includes "exp" and supports short token lifetimes; and 5. issues claims that identify the workload precisely and stably, and never issues a token for a subject to anyone but that subject. 9. IANA Considerations Rasmussen Expires 20 May 2027 [Page 14] Internet-Draft ACME Workload Identity November 2026 9.1. ACME Order Object Fields 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 | +------------+------------+--------------+---------------+ Table 2 The field appears only in newOrder requests. Servers never return it in an order object (Section 4.2). 9.2. ACME Error Types 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 | This | | | malformed, unverifiable | document | | | or not currently valid | | +----------------------+-------------------------+-----------+ | wifIssuerNotAccepted | The token issuer is not | This | | | accepted | document | +----------------------+-------------------------+-----------+ | wifAudienceMismatch | The token audience does | This | | | not contain the | document | | | expected binding value | | +----------------------+-------------------------+-----------+ | wifPolicyDenied | No policy accepts this | This | | | workload | document | +----------------------+-------------------------+-----------+ | wifTokenReplayed | A static audience token | This | | | has already been used | document | +----------------------+-------------------------+-----------+ Table 3 9.3. ACME Directory Metadata Fields IANA is requested to add this entry to the "ACME Directory Metadata Fields" registry: Rasmussen Expires 20 May 2027 [Page 15] Internet-Draft ACME Workload Identity November 2026 +============+============+===============+ | Field Name | Field Type | Reference | +============+============+===============+ | wif | object | This document | +------------+------------+---------------+ Table 4 9.4. URN Label 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. 10. Security Considerations 10.1. What a WIF Token Proves 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. 10.2. The Audience Binding 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. Rasmussen Expires 20 May 2027 [Page 16] Internet-Draft ACME Workload Identity November 2026 10.3. Static Audience Tokens 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. 10.4. Issuer Allowlisting Is Not Authorization 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. 10.5. Mutable and Reassignable Claims 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". 10.6. Execution Context 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. 10.7. Server-Side Request Forgery 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. Rasmussen Expires 20 May 2027 [Page 17] Internet-Draft ACME Workload Identity November 2026 10.8. Denial of Service 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. 10.9. Algorithm Confusion 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). 11. Privacy Considerations 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. 12. Open Issues This section is to be removed before publication. 1. Names. Is "wifToken" the right field name, and "wif" the right metadata and URN label? 2. 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? 3. 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 Rasmussen Expires 20 May 2027 [Page 18] Internet-Draft ACME Workload Identity November 2026 "sub". Client-authentication certificates for mutual TLS and SSH, a main use case, depend on it. Should it be in this document? 4. 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? 5. The "urn:ietf:params:acme:wif:" prefix has no registry to record it. Should one be created? 13. Related Work External Account Binding (Section 7.3.4 of [RFC8555]) links an account to a Subscriber using a shared secret, once, at account creation. This document links each order to a Subscriber using a platform-issued token. The two can coexist. ACME Authority Token [RFC9447] validates identifiers using a JWT. It requires the token to carry an "atc" claim containing the ACME account key's fingerprint, which only a token issuer built for ACME can do. General-purpose platform IdPs cannot, which is why this document carries the binding in "aud" instead. ACME Remote Attestation [I-D.ietf-acme-rats] conveys evidence about a platform's state. A CA could require both that and a WIF Token. ACME with OpenID Federation [I-D.ietf-acme-openid-federation] establishes trust through OpenID Federation trust chains. This document uses no federation metadata; the CA trusts each IdP's keys directly. WIMSE Workload Credentials [I-D.ietf-wimse-workload-creds] defines workload credential formats but leaves out how to obtain them. This document is one way for a workload to obtain a certificate. 14. References 14.1. Normative References [OIDC-DISCOVERY] Sakimura, N., Bradley, J., Jones, M., and E. Jay, "OpenID Connect Discovery 1.0 incorporating errata set 2", 15 December 2023, . Rasmussen Expires 20 May 2027 [Page 19] Internet-Draft ACME Workload Identity November 2026 [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, March 1997, . [RFC3986] Berners-Lee, T., Fielding, R., and L. Masinter, "Uniform Resource Identifier (URI): Generic Syntax", STD 66, RFC 3986, DOI 10.17487/RFC3986, January 2005, . [RFC4648] Josefsson, S., "The Base16, Base32, and Base64 Data Encodings", RFC 4648, DOI 10.17487/RFC4648, October 2006, . [RFC7515] Jones, M., Bradley, J., and N. Sakimura, "JSON Web Signature (JWS)", RFC 7515, DOI 10.17487/RFC7515, May 2015, . [RFC7517] Jones, M., "JSON Web Key (JWK)", RFC 7517, DOI 10.17487/RFC7517, May 2015, . [RFC7518] Jones, M., "JSON Web Algorithms (JWA)", RFC 7518, DOI 10.17487/RFC7518, May 2015, . [RFC7519] Jones, M., Bradley, J., and N. Sakimura, "JSON Web Token (JWT)", RFC 7519, DOI 10.17487/RFC7519, May 2015, . [RFC7638] Jones, M. and N. Sakimura, "JSON Web Key (JWK) Thumbprint", RFC 7638, DOI 10.17487/RFC7638, September 2015, . [RFC8174] Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, May 2017, . [RFC8555] Barnes, R., Hoffman-Andrews, J., McCarney, D., and J. Kasten, "Automatic Certificate Management Environment (ACME)", RFC 8555, DOI 10.17487/RFC8555, March 2019, . 14.2. Informative References Rasmussen Expires 20 May 2027 [Page 20] Internet-Draft ACME Workload Identity November 2026 [AWS-GWIT] "GetWebIdentityToken, AWS Security Token Service API Reference", 2026, . [AZURE-IMDS] "Azure Instance Metadata Service token acquisition", 2026, . [GITHUB-OIDC] "OpenID Connect reference (GitHub Actions)", 2026, . [GITLAB-OIDC] "OpenID Connect (OIDC) Authentication Using ID Tokens (GitLab CI/CD)", 2026, . [I-D.ietf-acme-dns-persist] Heurich, S., Birge-Lee, H., and M. Slaughter, "Automated Certificate Management Environment (ACME) Challenge for Persistent DNS TXT Record Validation", Work in Progress, Internet-Draft, draft-ietf-acme-dns-persist-03, 15 November 2026, . [I-D.ietf-acme-openid-federation] De Marco, G., Pitman, B., Geoghegan, T., Cook, D., and J. Jones, "Automatic Certificate Management Environment (ACME) with OpenID Federation 1.0", Work in Progress, Internet-Draft, draft-ietf-acme-openid-federation-00, 16 December 2025, . [I-D.ietf-acme-rats] Liu, P. C., Ounsworth, M., Richardson, M., Mallaya, G., and S. Rajala, "Automated Certificate Management Environment (ACME) Remote Attestation Identifier and Challenge Type", Work in Progress, Internet-Draft, draft- ietf-acme-rats-03, 28 October 2026, . Rasmussen Expires 20 May 2027 [Page 21] Internet-Draft ACME Workload Identity November 2026 [I-D.ietf-wimse-workload-creds] Campbell, B., Salowey, J. A., Schwenkschuster, A., Sheffer, Y., and Y. Rosomakho, "WIMSE Workload Credentials", Work in Progress, Internet-Draft, draft- ietf-wimse-workload-creds-03, 30 October 2026, . [K8S-TOKENREQUEST] "Managing Service Accounts: bound service account tokens", 2026, . [RFC6962] Laurie, B., Langley, A., and E. Kasper, "Certificate Transparency", RFC 6962, DOI 10.17487/RFC6962, June 2013, . [RFC8693] Jones, M., Nadalin, A., Campbell, B., Ed., Bradley, J., and C. Mortimore, "OAuth 2.0 Token Exchange", RFC 8693, DOI 10.17487/RFC8693, January 2020, . [RFC9447] Peterson, J., Barnes, M., Hancock, D., and C. Wendt, "Automated Certificate Management Environment (ACME) Challenges Using an Authority Token", RFC 9447, DOI 10.17487/RFC9447, September 2023, . [SPIFFE-ID] "SPIFFE ID and JWT-SVID specification", 2024, . Appendix A. Provider Profiles This appendix is informative. Platform details change, so check current documentation. GitHub Actions [GITHUB-OIDC]: 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". Kubernetes [K8S-TOKENREQUEST], including EKS and AKS: The issuer is Rasmussen Expires 20 May 2027 [Page 22] Internet-Draft ACME Workload Identity November 2026 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. SPIFFE: The JWT-SVID API takes the audience per request [SPIFFE-ID]. "sub" is the SPIFFE ID. GitLab CI/CD [GITLAB-OIDC]: 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". AWS [AWS-GWIT]: 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. Azure [AZURE-IMDS]: 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. Google Cloud: Identity tokens from the metadata server take the audience per request. Appendix B. Example 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: Rasmussen Expires 20 May 2027 [Page 23] Internet-Draft ACME Workload Identity November 2026 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: 1. generates an account key and creates an account with no EAB, keeping the Replay-Nonce from the response; 2. computes the ABV from that nonce and its account key, and requests a GitHub token with that audience; 3. sends newOrder for "gateway.internal.example.com" with the token in "wifToken", using that nonce; and 4. 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". Changes Since -00 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. Rasmussen Expires 20 May 2027 [Page 24] Internet-Draft ACME Workload Identity November 2026 * 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. Acknowledgements 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. Use of Generative AI 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. Author's Address Scott Rasmussen Independent Email: scott@zaita.com Rasmussen Expires 20 May 2027 [Page 25]