<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE rfc [
  <!ENTITY nbsp    "&#160;">
  <!ENTITY zwsp   "&#8203;">
  <!ENTITY nbhy   "&#8209;">
  <!ENTITY wj     "&#8288;">
]>
<!-- name="GENERATOR" content="github.com/mmarkdown/mmark Mmark Markdown Processor - mmark.miek.nl" -->
<rfc xmlns:xi="http://www.w3.org/2001/XInclude" version="3" ipr="trust200902" docName="draft-gco-oauth-delegate-sd-jwt-00" submissionType="IETF" category="std" xml:lang="en" indexInclude="true">

<front>
<title>Delegate SD-JWT</title><seriesInfo value="draft-gco-oauth-delegate-sd-jwt-00" stream="IETF" status="standard" name="Internet-Draft"/>
<author initials="G." surname="Oliver" fullname="Gareth Oliver"><organization>Google</organization><address><postal><street/>
</postal><email>gco@google.com</email>
</address></author><date/>
<area>Security</area>
<workgroup>Web Authorization Protocol</workgroup>
<keyword>sd-jwt</keyword>
<keyword>delegate sd-jwt</keyword>

<abstract>
<t>This document specifies an extension to Selective Disclosure JSON Web Tokens to support further delegation from the Holder to a Delegate Holder. This is done by allowing the Key Binding JWT to also be an SD-JWT, optionally with its own Key Binding. This has particular applicability to Agentic systems.</t>
</abstract>

</front>

<middle>

<section anchor="introduction"><name>Introduction</name>
<t>This is an extension to SD-JWTs <xref target="RFC9901"/>, to allow for the creation and delegation of new credentials using an existing SD-JWT+KB.</t>
<t>SD-JWT provides a mechanism for ensuring minimal disclosure in a three party model. This allows an intermediary party (the Holder) to choose to remove claims when only a subset is needed by a verifier. Additionally SD-JWT+KB allows for proof of possession by the Holder using the <tt>cnf</tt> claim. The Verifier need only trust the Issuer and its policy regarding the <tt>cnf</tt> key to trust the resulting presentation.</t>
<t>This is achieved using a composite structure of an Issuer-Signed JWT containing salted hashes and associated optional disclosures that can be omitted by the Holder. An optional KB-JWT containing transaction-specific data and signed by the private key <tt>cnf</tt> key is used to provide cryptographic key binding.</t>
<t>While it is possible for a Verifier to forward and further down-scope a SD-JWT, it is not able to prove that it was the recipient of the original SD-JWT+KB presentation, nor is it able to downscope parts of the transaction data, which may be relevant for privacy reasons.</t>
<t>This capability is useful for a ‘delegation’ model, where the Holder delegates further presentations of the SD-JWT+KB to a Delegate Holder. Additionally, the Holder should be able to provide additional (optionally disclosable) claims as part of the Delegation.</t>
<t>One example usecase is to delegate to an AI agent the ability to perform purchases on the users behalf, along with constraints on valid fulfillment conditions. The AI Agent can then prove to a merchant that it has been authorized to perform a purchase at this merchant on a Holders behalf, without revealing what other merchants may have been able to fulfill this purchase.</t>
<t>The approach taken here is to extend te KB-JWT so that it can be used as the start of a new SD-JWT or SD-JWT+KB, linking the resulting SD-JWT to the original one.</t>

<section anchor="feature-summary"><name>Feature Summary</name>
<t>This specification defines extensions to the SD-JWT and SD-JWT+KB formats:</t>

<ol spacing="compact">
<li><t>dSD-JWT which is a composite structure consisting of an SD-JWT and a Key Binding SD-JWT. The KB-SD-JWT signs over a delegate JSON Payload with zero or more disclosures.</t>

<ul spacing="compact">
<li>This includes an alternative format for a KB-JWT (called a KB-SD-JWT) to secure a nested, selectively disclosable JSON object. This is achieved by making the KB-JWT an SD-JWT.</li>
<li>A format for extending the SD-JWT+KB Compact Serialization to include a KB-SD-JWT.</li>
<li>An alternative format to do the same for the SD-JWT JSON Serialization format.</li>
</ul></li>
<li><t>dSD-JWT+KB which extends dSD-JWT to include Key Binding, allowing the Delegate Holder to prove proof of possession.</t>

<ul spacing="compact">
<li>This re-uses the KB-JWT mechanism specified by SD-JWT+KB for associating and presenting a proof of possession of a key pair.</li>
<li>This also allows for further delegation of the dSD-JWT+KB with the use of additional KB-SD-JWTs.</li>
</ul></li>
</ol>
</section>
</section>

<section anchor="conventions-and-definitions"><name>Conventions and Definitions</name>

<section anchor="requirements-notation-and-conventions"><name>Requirements Notation and Conventions</name>
<t>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 RFC 2119 <xref target="RFC2119"/>.</t>
</section>

<section anchor="terms-and-definitions"><name>Terms and Definitions</name>
<t>This specification uses the terms "Disclosure", "Selectively Disclosable JWT (SD-JWT)", "Key Binding",
"Key Binding JWT (KB-JWT)", "Selectively Disclosable JWT with Key Binding (SD-JWT+KB)" defined by
<xref target="RFC9901"/>.</t>
<t><em>Delegated SD-JWT(dSD-JWT)</em>: A composite structure consisting of an SD-JWT and a Key Binding SD-JWT (KB-SD-JWT). It acts as a chain of SD-JWTs where the Key Binding of the previous SD-JWT is used to sign the new one, allowing the Verifier to link presentations back to the initial Issuer.</t>
<t><em>Delegated SD-JWT with Key Binding (dSD-JWT+KB)</em>: An extension of the dSD-JWT that includes a final Key Binding JWT (KB-JWT). This allows the Delegate Holder to demonstrate proof of possession of the dSD-JWT.</t>
<t><em>Key Binding SD-JWT (KB-SD-JWT)</em>: An alternative format for a KB-JWT used to secure a nested, selectively disclosable JSON object (the Delegate Payload). It serves as the KB-JWT for the preceding SD-JWT in a chain.</t>
<t><em>Key Binding SD-JWT+KB (KB-SD-JWT+KB)</em>: A specific type of KB-SD-JWT where the <tt>typ</tt> parameter is set to "kb+sd-jwt+kb". This type requires the Delegate Payload to include a <tt>cnf</tt> claim.</t>
<t><em>Delegate Payload</em>: A JSON object (which may be nested and selectively disclosable) over which the KB-SD-JWT signs. In a dSD-JWT+KB, this payload MUST include a <tt>cnf</tt> claim to establish the Delegate Holder's key.</t>
<t><em>Issuer</em>: An entity that creates the initial SD-JWT.</t>
<t><em>Holder</em>: An entity that receives the initial SD-JWT from the Issuer and has control of it. They may present the SD-JWT to a Verifier directly or delegate it to a Delegate Holder.</t>
<t><em>Delegate Holder</em>: An intermediary entity to whom the original Holder delegates the SD-JWT. The Delegate Holder can perform further presentations or delegations of the SD-JWT.</t>
<t><em>Verifier</em>: An entity that requests, checks and extracts the claims of the SD-JWT or dSD-JWT.</t>
<t><em>Delegation</em>: Delegation in this document refers to a Holder or Delegate Holder presenting a credential to a Delegate Holder for the purpose of further presentation.</t>
</section>
</section>

<section anchor="flow-diagram"><name>Flow Diagram</name>
<figure><name>Delegate SD-JWT Issuance, Delegation and Presentation.
</name>
<sourcecode type="ascii-art"><![CDATA[+----------------------------------------+
|                                        |
|                Issuer                  |
|                                        |
+----------------------------------------+
                  |
          Issues SD-JWT+KB and
             all Disclosures
                  |
                  v
+----------------------------------------+
|                                        |
|                Holder                  |
|                                        |
+----------------------------------------+
                  |
          Delegates SD-JWT+KB,
        selected Disclosures and
          Payload to create a
         dSD-JWT or dSD-JWT+KB,
      including all new disclosures
                  |
                  v
+----------------------------------------+
|                                        |
|         Delegate Holder(s)             |
|                                        |
+--+-------------------------------------+
   |   |          |
   +---+---+-----------------------------+
       |          |
       +---+-----------------------------+
                  |
           Presents dSD-JWT or
        dSD-JWT+KB and selected
            Disclosures
                  |
                  v
+----------------------------------------+
|                                        |
|              Verifier(s)               |
|                                        |
+--+-------------------------------------+
   |   |   |
   +---+---+-----------------------------+
       |   |
       +---+-----------------------------+
]]></sourcecode>
</figure>
</section>

<section anchor="concepts"><name>Concepts</name>
<t>At a high level, a dSD-JWT acts as a chain of SD-JWTs where the KB-JWT in the proceeding SD-JWT+KB fulfills the role of the Issuer-JWT for the next. This allows the Verifier to know the full chain that the dSD-JWT went through and link the presentations back to the initial Issuer while preserving the principles of Data Minimization.</t>

<section anchor="selective-disclosure"><name>Selective Disclosure</name>
<t>An dSD-JWT has two different sets of Selective Disclosures:</t>

<ul spacing="compact">
<li>Selective Disclosures from the original SD-JWT</li>
<li>Selective Disclosures from the new Delegate Payload</li>
</ul>
<t>A Delegate Holder may always choose to include or omit selective disclosures from the Delegate Payload. If the Holder wishes to allow the Delegate Holder to omit selective disclosures from the proceeding SD-JWT it MUST omit the <tt>sd_hash</tt> claim from the KB-JWT and include the <tt>issuer_jwt_hash</tt> claim instead.</t>
</section>

<section anchor="optional-key-binding"><name>Optional Key Binding</name>
<t>Keybinding is required for the initial SD-JWTs and all KB-SD-JWTs except the final one. It is optional for key binding to be used for the final KB-SD-JWT. When it is used, the Delegate Holder’s public key information is included in the Delegate Payload of the final KB-SD-JWT. This allows the Delegate Holder to create a KB-JWT in future presentations using the private key associated with the included public key, demonstrating proof of possession.</t>
</section>

<section anchor="verification"><name>Verification</name>
<t>At a high level verification works as follows:</t>

<ul spacing="compact">
<li>The Verifier receives a dSD-JWT or dSD-JWT+KB from the Delegated Holder.</li>
<li>The Verifier splits the dSD-JWT into a chain with an SD-JWT, one or more KB-SD-JWT and (in the case of a dSD-JWT+KB) a final KB-JWT.</li>
<li>The Verifier verifies the first SD-JWT+KB using the issuer key, using the second KB-SD-JWT as the KB-JWT.</li>
<li>For each KB-SD-JWT, the Verifier verifies it as an SD-JWT+KB, treating the Delegate Payload as the JWT payload. The key from the <tt>cnf</tt> claim of the previous SD-JWT is used.</li>
<li>If required by policy, the final KB-SD-JWT MUST also be validated as an SD-JWT+KB, along with the transaction binding data included there.</li>
</ul>
</section>
</section>

<section anchor="formats"><name>Formats</name>

<section anchor="dsd-jwt-and-dsd-jwt-kb-data-formats"><name>dSD-JWT and dSD-JWT+KB Data Formats</name>
<t>A dSD-JWT with a single delegation is composed of:</t>

<ul spacing="compact">
<li><t>A SD-JWT</t>

<ul spacing="compact">
<li>i.e. An issuer-signed JWT</li>
<li>zero or more disclosures</li>
</ul></li>
<li><t>A KB-SD-JWT</t>

<ul spacing="compact">
<li>Serves as the KB-JWT for the proceeding SD-JWT</li>
<li>This is also the SD-JWT containing the Delegated Payload.</li>
</ul></li>
</ul>
<t>A dSD-JWT+KB with a single delegation is composed of:</t>

<ul spacing="compact">
<li>A dSD-JWT</li>
<li>A KB-SD-JWT</li>
<li>A KB-JWT</li>
</ul>
<t>A dSD-JWT or dSD-JWT+KB with multiple delegations is composed of:</t>

<ul spacing="compact">
<li>A SD-JWT</li>
<li>Two or more KB-SD-JWTs</li>
<li>When the format is dDS-JWT-KB, a KB-JWT.</li>
</ul>

<section anchor="compact-serialization"><name>Compact Serialization</name>
<t>The dSD-JWT format extends the existing SD-JWT+KB format as follows:</t>

<sourcecode type="example"><![CDATA[<SD-JWT>~~<KB-JWT>~<Delegated Disclosure 1>~...~<Delegated Disclosure M>~
]]></sourcecode>
<t>The &lt;KB-JWT&gt; along with its disclosures is called a KB-SD-JWT.</t>
<t>The dSD-JWT+KB format further extends the dSD-JWT format by appending a delegate KB-JWT:</t>

<sourcecode type="example"><![CDATA[<SD-JWT>~~<KB-SD-JWT>~<delegate KB-JWT>
]]></sourcecode>
<t>This can be chained by replacing the KB-JWT with another KB-SD-JWT instead:</t>

<sourcecode type="example"><![CDATA[<SD-JWT>~~<KB-SD-JWT 1>~...~<KB-SD-JWT n>~<delegate KB-JWT>
]]></sourcecode>
<t>To process a dSD-JWT or a dSD-JWT+KB, the string is split on ~ as usual. The resulting array of components MUST have an empty component between the last disclosure of each SD-JWT before the following KB-SD-JWT. The following KB-SD-JWT is then used as the KB-JWT for the proceeding SD-JWT.</t>
<t>dSD-JWT+KB and dSD-JWT formats are differentiated by a trailing ~ for dSD-JWT.</t>
</section>

<section anchor="json-serialization"><name>JSON Serialization</name>
<t>For both the General and Flattened JSON Serialization, the dSD-JWT or dSD-JWT+KB is represented as a JSON object. The only change in encoding is to the format of the kb-jwt in the unprotected header, which now MUST conform to the general or flattened JSON serialization of an sd-jwt.</t>
</section>

<section anchor="delegate-payload-disclosure"><name>Delegate Payload Disclosure</name>
<t>The delegate payload disclosure is an Array disclosure, which is the base64urlencoding of <tt>[salt, JSON Object Payload]</tt>.</t>
<t>The Disclosure Payload MUST follow all rules for the payload of the Issuer-signed JWT specified in <xref target="RFC9901"/> Section 4.1.</t>
<t>The Delegate Disclosures are created as per <xref target="RFC9901"/> Section 4.2.</t>
<t>The Delegate KB-JWT is a KB-JWT as per <xref target="RFC9901"/> Section 4.3 except that <tt>sd_hash</tt>, when present, is calculated over the proceeding SD-JWT or KB-SD-JWT and its associated disclosures.</t>
</section>

<section anchor="kb-sd-jwt"><name>KB-SD-JWT and KB-SD-JWT+KB</name>
<t>This specifies two new extensions to the KB-JWT. The following additional parameter is include:</t>

<ul spacing="compact">
<li><t>“<em>delegate_payload</em>”: An array of JSON Objects. If it contains more than one element then they MUST all be replaced with disclosures. During the presentation of a dSD-JWT from a Delegate Holder to a Verifier exactly one of these MUST be disclosed.</t>

<ul spacing="compact">
<li>When presenting from a Holder to a new Delegate Holder, multiple values being present allows for multiple dSD-JWTs to be delegated with a single signature which may be convenient when using a signing key that requires a user action per signing event.</li>
</ul></li>
</ul>
<t>KB-SD-JWTs MUST conform to all the requirements of a KB-JWT and an SD-JWT except as listed below:</t>
<t>KB-JWT changes:</t>

<ul spacing="compact">
<li><t>The <tt>typ</tt> parameter value MUST be replaced with "kb+sd-jwt" for a KB-SD-JWT, and "kb+sd-jwt+kb" for a KB-SD-JWT+KB.</t>

<ul spacing="compact">
<li>If the <tt>typ</tt> is KB-SD-JWT+KB then the Delegate Payload MUST include a <tt>cnf</tt> claim.</li>
</ul></li>
<li>The <tt>sd_hash</tt> parameter is OPTIONAL. If it is not present it MUST instead include a <tt>issuer_jwt_hash</tt> parameter that hashes over only the proceeding Issuer-signed jwt or KB-SD-JWT+KB and not any disclosures.</li>
</ul>
<t>When calculating the <tt>sd_hash</tt> it is calculated from the proceeding Issuer JWT or KB-SD-JWT+KB.</t>
<t>SD-JWT changes:</t>

<ul spacing="compact">
<li>All claims that are expected to be found in the issuer-signed JWT Payload except the <tt>_sd_hash</tt> payload MUST instead be claims in the Delegate Payload.</li>
</ul>
</section>
</section>
</section>

<section anchor="verification-1"><name>Verification</name>
<t>To perform verification of an dSD-JWT or dSD-JWT+KB the following steps must be followed.</t>

<ol spacing="compact">
<li><t>Split the dSD-JWT into its component SD-JWTs</t>

<ol spacing="compact">
<li><t>For a dSD-JWT this will be:</t>

<ul spacing="compact">
<li>A SD-JWT</li>
<li>zero or more KB-SD-JWTs with <tt>typ</tt> "kb-sd-jwt+kb"</li>
<li>one KB-SD-JWT with <tt>typ</tt> “kb-sd-jwt”</li>
</ul></li>
<li><t>For a dSD-JWT+KB this will be:</t>

<ul spacing="compact">
<li>A SD-JWT</li>
<li>One or  more KB-SD-JWTs with <tt>typ</tt> kb-sd-jwt+kb”</li>
<li>One KB-JWT</li>
</ul></li>
</ol></li>
<li>Validate and process the initial SD-JWT according to <xref target="RFC9901"/> Section 7.1.</li>
<li><t>For each KB-SD-JWT except the final one:</t>

<ol spacing="compact">
<li><t>Validate and process it according to <xref target="RFC9901"/> Section 7.1</t>

<ul spacing="compact">
<li>The <tt>cnf</tt> claim of the proceeding component is used as the Issuer public key.</li>
<li>Treat the Delegate Payload as the JWT Payload for finding all claims other than the <tt>_sd_alg</tt> claim.</li>
</ul></li>
<li>Verify that there is exactly one disclosed element in the <tt>delegate_payload</tt> array.</li>
<li>If the <tt>sd_hash</tt> claim is present, calculate the digest over the proceeding SD-JWT or KB-SD-JWT and it's disclosures, as described in <xref target="RFC9901"/> Section 9.10.
d. Otherwise, verify that the <tt>issuer_jwt_hash</tt> is present and matches the base64url encoded digest of the proceeding Issuer signed JWT or KB-SD-JWT+KB.
e. Verify the <tt>typ</tt> in the JWT Payload is “kb-sd-jwt+kb”</li>
</ol></li>
<li><t>For the final KB-SD-JWT:</t>

<ol spacing="compact">
<li>Validate and process it according to 3.1 - 3.3</li>
<li>If the credential is a dSD-JWT then the type MUST be “kb-sd-jwt” otherwise it MUST be “kb-sd-jwt+kb”</li>
</ol></li>
<li><t>If the credential is a dSD-JWT+KB and Key Binding is required</t>

<ol spacing="compact">
<li>Follow section 7.3 step 5 to to verify the KB-JWT, using the final KB-SD-JWT to retrieve the Delegate Holder public key.</li>
<li>If the <tt>sd_hash</tt> claim is present, calculate the digest over the proceeding SD-JWT or KB-SD-JWT+KB and it's disclosures as described in <xref target="RFC9901"/> Section 9.10.</li>
</ol></li>
</ol>
<t>If any of the steps fail then the presentation is invalid and processing MUST be aborted. Otherwise the list of processed SD-JWT and Delegate Payloads MAY be passed to the application to be used for their intended purpose.</t>
</section>

<section anchor="delegation-using-presentation"><name>Delegation using Presentation</name>
<t>Presentation mechanisms that allow specfication of additional transaction data within the KB-JWT can be used to perform delegation. Below is a description of how this can be done using the OpenID4VP presentation protocol.</t>

<section anchor="dsd-jwt-delegation-using-openid4vp"><name>dSD-JWT Delegation using OpenID4VP</name>
<t>OpenId4VP <xref target="OIDF.OID4VP"/> specifies <tt>transaction_data</tt> within the request, which is included within the KB-JWT. To delegate an dSD-JWT or dSD-JWT+KB the <tt>transaction_type</tt> <tt>delegate</tt> MAY be used. The following additional parameters are included in the <tt>transaction_data</tt> object:</t>

<ul spacing="compact">
<li>“format”: REQUIRED string containing either <tt>dSD-JWT</tt> or <tt>dSD-JWT+KB</tt></li>
<li>“delegate_payload_disclosure”: REQUIRED String containing the Array Disclosure of the delegate payload.</li>
<li>“delegate_disclosures”: OPTIONAL Array of Strings containing the delegate_payload_disclosure</li>
</ul>
<t>The delegate payload MUST NOT contain any disclosures not provided in <tt>delegate_disclosures</tt>. The KB-JWT includes the digest of the <tt>delegate_payload</tt> in the <tt>delegate_payload</tt> claim of the KB-JWT. <tt>_sd_hash</tt> may use any hash algorithm specified for hashing the <tt>transaction_data</tt>. The Wallet MAY include additional decoy digests.</t>
<t>Multiple <tt>delegate</tt> <tt>transaction_data</tt> MAY be included in the same request. In that case, each MUST have their digest included in the <tt>delegate_payload</tt>.</t>
</section>
</section>

<section anchor="security-considerations"><name>Security Considerations</name>
<t>Security Considersations as described in <xref target="RFC9901"/> also apply to delegate SD-JWTs. When the Holder is performing a delegation, they are acting as an Issuer of an SD-JWT and so all security considerations of an issuer apply to them.</t>

<section anchor="mandatory-verification-of-delegate-sd-jwt-chain"><name>Mandatory verification of delegate SD-JWT Chain</name>
<t>It is critical that the Verifier verifies each KB-SD-JWT in the chain and ensures that it is bound to the proceeding Issuer JWT or KB-SD-JWT with the <tt>sd_hash</tt> or <tt>issuer_jwt_hash</tt>. Without verifying the binding in both directions a malicious Delegate Holder may mis-match parts of the chain if the Holder <tt>cnf</tt> is reused.</t>
</section>

<section anchor="delegation-policy"><name>Delegation Policy</name>
<t>An Issuer or Holder that wishes to limit delegation MAY include such constraints as visible claims in the Issuer signed JWT or KB-SD-JWT+KB.</t>
</section>

<section anchor="delegate-sd-jwt-revocation"><name>Delegate SD-JWT Revocation</name>
<t>While traditional mechanisms of credential revocation can be used with delegate SD-JWTs, they present a practical challenge as, unlike a traditional Issuer, an individual Holder can not easily distribute revocation information to Verifiers.</t>
<t>Having a short <tt>exp</tt> and using claims to constraining the usage of the delegated SD-JWT limits this problem, as does cases where the Holder and the Delegate Holder are managed by the same entity.</t>
</section>
</section>

<section anchor="privacy-considerations"><name>Privacy Considerations</name>
<t>The privacy considerations in <xref target="RFC9901"/> Section 10 also apply to Delegate SD-JWTs.</t>
</section>

</middle>

<back>
<references><name>References</name>
<references><name>Normative References</name>
<reference anchor="OIDF.OID4VP" target="https://openid.net/specs/openid-4-verifiable-presentations-1_0.html">
  <front>
    <title>OpenID for Verifiable Presentations 1.0</title>
    <author fullname="Oliver Terbu" initials="O." surname="Terbu">
      <organization>Mattr</organization>
    </author>
    <author fullname="Torsten Lodderstedt" initials="T." surname="Lodderstedt">
      <organization>SPRIND</organization>
    </author>
    <author fullname="Kristina Yasuda" initials="K." surname="Yasuda">
      <organization>SPRIND</organization>
    </author>
    <author fullname="Daniel Fett" initials="D." surname="Fett">
      <organization>Authlete</organization>
    </author>
    <author fullname="Joseph Heenan" initials="J." surname="Heenan">
      <organization>Authlete</organization>
    </author>
    <date year="2025" month="July" day="9"/>
  </front>
</reference>
<xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.2119.xml"/>
<xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.6838.xml"/>
<xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.7519.xml"/>
<xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.9901.xml"/>
</references>
<references><name>Informative References</name>
<reference anchor="IANA.JWT" target="https://www.iana.org/assignments/jwt">
  <front>
    <title>JSON Web Token Claims</title>
    <author>
      <organization>IANA</organization>
    </author>
  </front>
</reference>
<reference anchor="IANA.MediaTypes" target="https://www.iana.org/assignments/media-types/media-types.xhtml">
  <front>
    <title>Media Types</title>
    <author fullname="IANA"/>
  </front>
</reference>
<xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.2046.xml"/>
</references>
</references>

<section anchor="iana-considerations"><name>IANA Considerations</name>

<section anchor="json-web-token-claims-registration"><name>JSON Web Token Claims Registration</name>
<t>This specification requests registration of the following Claims in the
IANA "JSON Web Token Claims" registry <xref target="IANA.JWT"/> established by <xref target="RFC7519"/>.</t>

<ul spacing="compact">
<li>Claim Name: <tt>issuer_jwt_hash</tt></li>
<li>Claim Description: Digest of the Issuer-JWT to which the KB-SD-JWT is tied</li>
<li>Change Controller: IETF</li>
<li>Specification Document(s):  [[ <xref target="kb-sd-jwt"/> of this specification ]]</li>
</ul>
</section>

<section anchor="media-type-registration"><name>Media Type Registration</name>
<t>This section requests registration of the following media types <xref target="RFC2046"/> in
the "Media Types" registry <xref target="IANA.MediaTypes"/> in the manner described
in <xref target="RFC6838"/>.</t>
<t>To indicate that the content is a Key Binding SD-JWT:</t>

<ul spacing="compact">
<li>Type name: application</li>
<li>Subtype name: kb+sd-jwt</li>
<li>Required parameters: n/a</li>
<li>Optional parameters: n/a</li>
<li>Encoding considerations: binary; A Key Binding SD-JWT is a SD-JWT; SD-JWT values are a series of base64url-encoded values (some of which may be the empty string) separated by period ('.') and tilde ('~') characters.</li>
<li>Security considerations: See the Security Considerations section of [[ this specification ]] and <xref target="RFC9901"/>.</li>
<li>Interoperability considerations: n/a</li>
<li>Published specification: [[ this specification ]]</li>
<li>Applications that use this media type: Applications utilizing a JWT based proof of possession mechanism with futher selective disclosure.</li>
<li>Fragment identifier considerations: n/a</li>
<li><t>Additional information:</t>

<ul spacing="compact">
<li>Magic number(s): n/a</li>
<li>File extension(s): n/a</li>
<li>Macintosh file type code(s): n/a</li>
</ul></li>
<li>Person &amp; email address to contact for further information: Gareth Oliver, gco@google.com</li>
<li>Intended usage: COMMON</li>
<li>Restrictions on usage: none</li>
<li>Author: Gareth Oliver, gco@google.com</li>
<li>Change Controller: IETF</li>
<li>Provisional registration?  No</li>
</ul>
<t>To indicate that the content is a Key Binding SD-JWT+KB:</t>

<ul spacing="compact">
<li>Type name: application</li>
<li>Subtype name: kb+sd-jwt+kb</li>
<li>Required parameters: n/a</li>
<li>Optional parameters: n/a</li>
<li>Encoding considerations: binary; A Key Binding SD-JWT+KB is a SD-JWT+KB; SD-JWT values are a series of base64url-encoded values (some of which may be the empty string) separated by period ('.') and tilde ('~') characters.</li>
<li>Security considerations: See the Security Considerations section of [[ this specification ]] and <xref target="RFC9901"/>.</li>
<li>Interoperability considerations: n/a</li>
<li>Published specification: [[ this specification ]]</li>
<li>Applications that use this media type: Applications utilizing a JWT based proof of possession mechanism with futher selective disclosure.</li>
<li>Fragment identifier considerations: n/a</li>
<li><t>Additional information:</t>

<ul spacing="compact">
<li>Magic number(s): n/a</li>
<li>File extension(s): n/a</li>
<li>Macintosh file type code(s): n/a</li>
</ul></li>
<li>Person &amp; email address to contact for further information: Gareth Oliver, gco@google.com</li>
<li>Intended usage: COMMON</li>
<li>Restrictions on usage: none</li>
<li>Author: Gareth Oliver, gco@google.com</li>
<li>Change Controller: IETF</li>
<li>Provisional registration?  No</li>
</ul>
</section>
</section>

<section anchor="acknowledgments"><name>Acknowledgments</name>
</section>

</back>

</rfc>
