A CBOR Tag for Unprotected CWT Claims Sets Fraunhofer SIT
Rheinstrasse 75 Darmstadt 64295 Germany henk.birkholz@sit.fraunhofer.de
Qualcomm Technologies Inc.
279 Farnborough Road Farnborough GU14 7LS United Kingdom jodonogh@qti.qualcomm.com
Cisco Systems
3550 Cisco Way San Jose CA 95134 USA ncamwing@cisco.com
Universität Bremen TZI
Postfach 330440 Bremen D-28359 Germany +49-421-218-63921 cabo@tzi.org
Security RATS Working Group Internet-Draft CBOR Web Token (CWT, RFC 8392) Claims Sets sometimes do not need the protection afforded by wrapping them into COSE, as is required for a true CWT. This specification defines a CBOR tag for such unprotected CWT Claims Sets (UCCS) and discusses conditions for its proper use. About This Document Status information for this document may be found at . Discussion of this document takes place on the Remote ATtestation ProcedureS (rats) Working Group mailing list (), which is archived at . Subscribe at . Source for this draft and an issue tracker can be found at .
Introduction A CBOR Web Token (CWT) as specified by is always wrapped in a CBOR Object Signing and Encryption (COSE, ) envelope. COSE provides -- amongst other things -- the end-to-end data origin authentication and integrity protection employed by RFC 8392 and optional encryption for CWTs. Under the right circumstances (), though, a signature providing proof for authenticity and integrity can be provided through the transfer protocol and thus omitted from the information in a CWT without compromising the intended goal of authenticity and integrity. In other words, if communicating parties have a pre-existing security association they can reuse it to provide authenticity and integrity for their messages, enabling the basic principle of using resources parsimoniously. Specifically, if a mutually secured channel is established between two remote peers, and if that secure channel provides the required properties (as discussed below), it is possible to omit the protection provided by COSE, creating a use case for unprotected CWT Claims Sets. Similarly, if there is one-way authentication, the party that did not authenticate may be in a position to send authentication information through this channel that allows the already authenticated party to authenticate the other party. This specification allocates a CBOR tag to mark Unprotected CWT Claims Sets (UCCS) as such and discusses conditions for its proper use in the scope of Remote Attestation Procedures (RATS) and the conveyance of Evidence from an Attester to a Verifier. This specification does not change : A true CWT does not make use of the tag allocated here; the UCCS tag is an alternative to using COSE protection and a CWT tag. Consequently, within the well-defined scope of a secured channel, it can be acceptable and economic to use the contents of a CWT without its COSE container and tag it with a UCCS CBOR tag for further processing within that scope -- or to use the contents of a UCCS CBOR tag for building a CWT to be signed by some entity that can vouch for those contents.
Terminology The term Claim is used as in . The terms Claim Key, Claim Value, and CWT Claims Set are used as in . The terms Attester, Attesting Environment and Verifier are used as in .
UCCS:
Unprotected CWT Claims Set(s); CBOR map(s) of Claims as defined by the CWT Claims Registry that are composed of pairs of Claim Keys and Claim Values.
secure channel:
A path for transferring data between two entities or components that ensures confidentiality, integrity and replay protection, as well as mutual authentication between the entities or components. The secure channel may be provided using approved cryptographic, physical or procedural methods, or a combination thereof . For the purposes of the present document, we focus on a protected communication channel used for conveyance that can ensure the same qualities associated for UCCS conveyance as CWT conveyance without any additional protection.
All terms referenced or defined in this section are capitalized in the remainder of this document. 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 when, and only when, they appear in all capitals, as shown here.
Example Use Cases Use cases involving the conveyance of Claims, in particular, Remote Attestation Procedures (RATS, see ) require a standardized data definition and encoding format that can be transferred and transported using different communication channels. As these are Claims, is a suitable format. However, the way these Claims are secured depends on the deployment, the security capabilities of the device, as well as their software stack. For example, a Claim may be securely stored and conveyed using a device's Trusted Execution Environment (TEE, see ) or especially in some resource constrained environments, the same process that provides the secure communication transport is also the delegate to compose the Claim to be conveyed. Whether it is a transfer or transport, a secure channel is presumed to be used for conveying such UCCS. The following sections further describe the RATS usage scenario and corresponding requirements for UCCS deployment.
Characteristics of a Secure Channel A secure channel for the conveyance of UCCS needs to provide the security properties that would otherwise be provided by COSE for a CWT. In this regard, UCCS is similar in security considerations to JWTs using the algorithm "none". RFC 8725 states:
[...] if a JWT is cryptographically protected end-to-end by a transport layer, such as TLS using cryptographically current algorithms, there may be no need to apply another layer of cryptographic protections to the JWT. In such cases, the use of the "none" algorithm can be perfectly acceptable.
The security considerations discussed, e.g., in Sections , , and of apply in an analogous way to the use of UCCS as elaborated on in this document. Secure channels are often set up in a handshake protocol that mutually derives a session key, where the handshake protocol establishes the (identity and thus) authenticity of one or both ends of the communication. The session key can then be used to provide confidentiality and integrity of the transfer of information inside the secure channel. A well-known example of a such a secure channel setup protocol is the TLS handshake; the TLS record protocol can then be used for secure conveyance. As UCCS were initially created for use in Remote Attestation Procedures (RATS) secure channels, the following subsection provides a discussion of their use in these channels. Where other environments are intended to be used to convey UCCS, similar considerations need to be documented before UCCS can be used.
UCCS and Remote Attestation Procedures (RATS) This section discusses use cases for UCCS in the context of RATS.
Secure Channels in RATS For the purposes of this section, the Verifier is the receiver of the UCCS and the Attester is the provider of the UCCS. Secure channels can be transient in nature. For the purposes of this specification, the mechanisms used to establish a secure channel are out of scope. As a minimum requirement in the scope of RATS Claims, the Verifier MUST authenticate the Attester as part of the establishment of the secure channel. Furthermore, the channel MUST provide integrity of the communication from the Attester to the Verifier. If confidentiality is also required, the receiving side needs to be authenticated as well; this can be achieved if the Verifier and the Attester mutually authenticate when establishing the secure channel. The extent to which a secure channel can provide assurances that UCCS originate from a trustworthy Attesting Environment depends on the characteristics of both the cryptographic mechanisms used to establish the channel and the characteristics of the Attesting Environment itself. A secure channel established or maintained using weak cryptography may not provide the assurance required by a Relying Party of the authenticity and integrity of the UCCS. Ultimately, it is up to the Verifier's policy to determine whether to accept a UCCS from the Attester and to the type of secure channel it must negotiate. While the security considerations of the cryptographic algorithms used are similar to COSE, the considerations of the secure channel should also adhere to the policy configured at each of the Attester and the Verifier. However, the policy controls and definitions are out of scope for this document. Where the security assurance required of an Attesting Environment by a Relying Party requires it, the Attesting Environment may be implemented using techniques designed to provide enhanced protection from an attacker wishing to tamper with or forge UCCS. A possible approach might be to implement the Attesting Environment in a hardened environment such as a TEE or a TPM . When UCCS emerge from the secure channel and into the Verifier, the security properties of the secure channel no longer protect the UCCS, which now are subject to the same security properties as any other unprotected data in the Verifier environment. If the Verifier subsequently forwards UCCS, they are treated as though they originated within the Verifier. As with EATs nested in other EATs (Section Nested Token of ), the secure channel does not endorse fully formed CWTs transferred through it. Effectively, the COSE envelope of a CWT shields the CWT Claims Set from the endorsement of the secure channel. (Note that EAT might add a nested UCCS Claim, and this statement does not apply to UCCS nested into UCCS, only to fully formed CWTs)
Delegated Attestation Another use case is that of a sub-Attester that has no signing keys (for example, to keep the implementation complexity to a minimum) and has a secure channel, such as a local IPC, to interact with a lead Attester (see Composite Device, ). The sub-Attester produces a UCCS with the required CWT Claims Set and sends the UCCS through the secure channel to the lead Attester. The lead Attester then computes a cryptographic hash of the UCCS and protects that hash using its signing key for Evidence, for example, using a Detached EAT Bundle ().
Privacy Preserving Channels A secure channel which preserves the privacy of the Attester may provide security properties equivalent to COSE, but only inside the life-span of the session established. In general, a Verifier cannot correlate UCCS received in different sessions from the same Attesting Environment based on the cryptographic mechanisms used when a privacy preserving secure channel is employed. In the case of a Remote Attestation, the Attester must consider whether any UCCS it returns over a privacy preserving secure channel compromises the privacy in unacceptable ways. As an example, the use of the EAT UEID Claim in UCCS over a privacy preserving secure channel allows a verifier to correlate UCCS from a single Attesting Environment across many secure channel sessions. This may be acceptable in some use-cases (e.g. if the Attesting Environment is a physical sensor in a factory) and unacceptable in others (e.g. if the Attesting Environment is a device belonging to a child).
IANA Considerations In the registry , IANA is requested to allocate the tag in from the FCFS space, with the present document as the specification reference. Values for Tags
Tag Data Item Semantics
TBD601 map Unprotected CWT Claims Set [RFCthis]
Security Considerations The security considerations of apply. The security considerations of need to be applied analogously, replacing the function of COSE with that of the secured channel. discusses security considerations for secure channels, in which UCCS might be used. This document provides the CBOR tag definition for UCCS and a discussion on security consideration for the use of UCCS in Remote Attestation Procedures (RATS). Uses of UCCS outside the scope of RATS are not covered by this document. The UCCS specification -- and the use of the UCCS CBOR tag, correspondingly -- is not intended for use in a scope where a scope-specific security consideration discussion has not been conducted, vetted and approved for that use.
General Considerations Implementations of secure channels are often separate from the application logic that has security requirements on them. Similar security considerations to those described in for obtaining the required levels of assurance include:
  • Implementations need to provide sufficient protection for private or secret key material used to establish or protect the secure channel.
  • Using a key for more than one algorithm can leak information about the key and is not recommended.
  • An algorithm used to establish or protect the secure channel may have limits on the number of times that a key can be used without leaking information about the key.
  • Evidence in a UCCS conveyed in a secure channel generally cannot be used to support trust in the credentials that were used to establish that secure channel, as this would create a circular dependency.
The Verifier needs to ensure that the management of key material used establish or protect the secure channel is acceptable. This may include factors such as:
  • Ensuring that any permissions associated with key ownership are respected in the establishment of the secure channel.
  • Cryptographic algorithms are used appropriately.
  • Key material is used in accordance with any usage restrictions such as freshness or algorithm restrictions.
  • Ensuring that appropriate protections are in place to address potential traffic analysis attacks.
AES-CBC_MAC
  • A given key should only be used for messages of fixed or known length.
  • Different keys should be used for authentication and encryption operations.
  • A mechanism to ensure that IV cannot be modified is required.
contains a detailed explanation of these considerations.
AES-GCM
  • The key and nonce pair are unique for every encrypted message.
  • The maximum number of messages to be encrypted for a given key is not exceeded.
contains a detailed explanation of these considerations.
AES-CCM
  • The key and nonce pair are unique for every encrypted message.
  • The maximum number of messages to be encrypted for a given block cipher is not exceeded.
  • The number of messages both successfully and unsuccessfully decrypted is used to determine when rekeying is required.
contains a detailed explanation of these considerations.
ChaCha20 and Poly1305
  • The nonce is unique for every encrypted message.
  • The number of messages both successfully and unsuccessfully decrypted is used to determine when rekeying is required.
contains a detailed explanation of these considerations.
References Normative References Concise Binary Object Representation (CBOR) The Concise Binary Object Representation (CBOR) is a data format whose design goals include the possibility of extremely small code size, fairly small message size, and extensibility without the need for version negotiation. These design goals make it different from earlier binary serializations such as ASN.1 and MessagePack. This document obsoletes RFC 7049, providing editorial improvements, new details, and errata fixes while keeping full compatibility with the interchange format of RFC 7049. It does not create a new version of the format. CBOR Object Signing and Encryption (COSE) Concise Binary Object Representation (CBOR) is a data format designed for small code size and small message size. There is a need for the ability to have basic security services defined for this data format. This document defines the CBOR Object Signing and Encryption (COSE) protocol. This specification describes how to create and process signatures, message authentication codes, and encryption using CBOR for serialization. This specification additionally describes how to represent cryptographic keys using CBOR. JSON Web Token (JWT) JSON Web Token (JWT) is a compact, URL-safe means of representing claims to be transferred between two parties. The claims in a JWT are encoded as a JSON object that is used as the payload of a JSON Web Signature (JWS) structure or as the plaintext of a JSON Web Encryption (JWE) structure, enabling the claims to be digitally signed or integrity protected with a Message Authentication Code (MAC) and/or encrypted. JSON Web Token Best Current Practices JSON Web Tokens, also known as JWTs, are URL-safe JSON-based security tokens that contain a set of claims that can be signed and/or encrypted. JWTs are being widely used and deployed as a simple security token format in numerous protocols and applications, both in the area of digital identity and in other application areas. This Best Current Practices document updates RFC 7519 to provide actionable guidance leading to secure implementation and deployment of JWTs. CBOR Web Token (CWT) CBOR Web Token (CWT) is a compact means of representing claims to be transferred between two parties. The claims in a CWT are encoded in the Concise Binary Object Representation (CBOR), and CBOR Object Signing and Encryption (COSE) is used for added application-layer security protection. A claim is a piece of information asserted about a subject and is represented as a name/value pair consisting of a claim name and a claim value. CWT is derived from JSON Web Token (JWT) but uses CBOR rather than JSON. Concise Binary Object Representation (CBOR) Tags IANA Key words for use in RFCs to Indicate Requirement Levels In many standards track documents several words are used to signify the requirements in the specification. These words are often capitalized. This document defines these words as they should be interpreted in IETF documents. This document specifies an Internet Best Current Practices for the Internet Community, and requests discussion and suggestions for improvements. Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words RFC 2119 specifies common key words that may be used in protocol specifications. This document aims to reduce the ambiguity by clarifying that only UPPERCASE usage of the key words have the defined special meanings. Informative References The Transport Layer Security (TLS) Protocol Version 1.3 This document specifies version 1.3 of the Transport Layer Security (TLS) protocol. TLS allows client/server applications to communicate over the Internet in a way that is designed to prevent eavesdropping, tampering, and message forgery. This document updates RFCs 5705 and 6066, and obsoletes RFCs 5077, 5246, and 6961. This document also specifies new requirements for TLS 1.2 implementations. Remote Attestation Procedures Architecture Fraunhofer SIT Microsoft Sandelman Software Works Intel Corporation Huawei Technologies In network protocol exchanges it is often useful for one end of a communication to know whether the other end is in an intended operating state. This document provides an architectural overview of the entities involved that make such tests possible through the process of generating, conveying, and evaluating evidentiary claims. An attempt is made to provide for a model that is neutral toward processor architectures, the content of claims, and protocols. Trusted Execution Environment Provisioning (TEEP) Architecture Broadcom Arm Limited Microsoft Amazon A Trusted Execution Environment (TEE) is an environment that enforces that any code within that environment cannot be tampered with, and that any data used by such code cannot be read or tampered with by any code outside that environment. This architecture document motivates the design and standardization of a protocol for managing the lifecycle of trusted applications running inside such a TEE. Trusted Platform Module Library Specification, Family "2.0", Level 00, Revision 01.59 ed., Trusted Computing Group The Entity Attestation Token (EAT) Security Theory LLC Qualcomm Technologies Inc. Qualcomm Technologies Inc. Red Hound Software, Inc. An Entity Attestation Token (EAT) provides an attested claims set that describes state and characteristics of an entity, a device like a smartphone, IoT device, network equipment or such. This claims set is used by a relying party, server or service to determine how much it wishes to trust the entity. An EAT is either a CBOR Web Token (CWT) or JSON Web Token (JWT) with attestation-oriented claims. CBOR Object Signing and Encryption (COSE): Structures and Process Concise Binary Object Representation (CBOR) is a data format designed for small code size and small message size. There is a need to be able to define basic security services for this data format. This document defines the CBOR Object Signing and Encryption (COSE) protocol. This specification describes how to create and process signatures, message authentication codes, and encryption using CBOR for serialization. This specification additionally describes how to represent cryptographic keys using CBOR. This document, along with RFC 9053, obsoletes RFC 8152. CBOR Object Signing and Encryption (COSE): Initial Algorithms Concise Binary Object Representation (CBOR) is a data format designed for small code size and small message size. There is a need to be able to define basic security services for this data format. This document defines a set of algorithms that can be used with the CBOR Object Signing and Encryption (COSE) protocol (RFC 9052). This document, along with RFC 9052, obsoletes RFC 8152. Recommendation for Random Number Generation Using Deterministic Random Bit Generators
CDDL does not define CDDL for CWT Claims Sets. This specification proposes using the definitions in for the CWT Claims Set defined in . Note that these definitions have been built such that they also can describe Claims sets by disabling feature "cbor" and enabling feature "json", but this flexibility is not the subject of the present specification.
CDDL definition for Claims-Set Claims-Set = { * $$Claims-Set-Claims * Claim-Label .feature "extended-claims-label" => any } Claim-Label = CBOR-ONLY<int> / text string-or-uri = text $$Claims-Set-Claims //= ( iss-claim-label => string-or-uri ) $$Claims-Set-Claims //= ( sub-claim-label => string-or-uri ) $$Claims-Set-Claims //= ( aud-claim-label => string-or-uri ) $$Claims-Set-Claims //= ( exp-claim-label => ~time ) $$Claims-Set-Claims //= ( nbf-claim-label => ~time ) $$Claims-Set-Claims //= ( iat-claim-label => ~time ) $$Claims-Set-Claims //= ( cti-claim-label => bytes ) iss-claim-label = JC<"iss", 1> sub-claim-label = JC<"sub", 2> aud-claim-label = JC<"aud", 3> exp-claim-label = JC<"exp", 4> nbf-claim-label = JC<"nbf", 5> iat-claim-label = JC<"iat", 6> cti-claim-label = CBOR-ONLY<7> ; jti in JWT: different name and text JSON-ONLY<J> = J .feature "json" CBOR-ONLY<C> = C .feature "cbor" JC<J,C> = JSON-ONLY<J> / CBOR-ONLY<C>
Specifications that define additional Claims should also supply additions to the $$Claims-Set-Claims socket, e.g.: ; [RFC8747] $$Claims-Set-Claims //= ( 8: CWT-cnf ) ; cnf CWT-cnf = { (1: CWT-COSE-Key) // (2: CWT-Encrypted_COSE_Key) // (3: CWT-kid) } CWT-COSE-Key = COSE_Key CWT-Encrypted_COSE_Key = COSE_Encrypt / COSE_Encrypt0 CWT-kid = bytes ; [RFC8693] $$Claims-Set-Claims //= ( 9: CWT-scope ) ; scope ; TO DO: understand what this means: ; scope The scope of an access token as defined in [RFC6749]. ; scope 9 byte string or text string [IESG] [RFC8693, Section 4.2] CWT-scope = bytes / text ; [RFC-ietf-ace-oauth-authz-45, Section 5.10] $$Claims-Set-Claims //= ( 38: CWT-ace-profile ) ; ace_profile CWT-ace-profile = $CWT-ACE-Profiles / int .feature "ace_profile-extend" ; fill in from IANA registry ; https://www.iana.org/assignments/ace/ace.xhtml#ace-profiles : $CWT-ACE-Profiles /= 1 ; coap_dtls $$Claims-Set-Claims //= ( 39: CWT-cnonce ) ; cnonce CWT-cnonce = bytes $$Claims-Set-Claims //= ( 40: CWT-exi ) ; exi CWT-exi = uint ; in seconds (5.10.3) ;;; insert CDDL from 9052-to-be to complete these CDDL definitions.
Example The example CWT Claims Set from can be turned into an UCCS by enclosing it with a tag number TBD601: ( { / iss / 1: "coap://as.example.com", / sub / 2: "erikw", / aud / 3: "coap://light.example.com", / exp / 4: 1444064944, / nbf / 5: 1443944944, / iat / 6: 1443944944, / cti / 7: h'0b71' } ) ]]>
Acknowledgements suggested some improvements to the CDDL.