]> CBOR Common Deterministic Encoding (CDE) Universität Bremen TZI
Postfach 330440 Bremen D-28359 Germany +49-421-218-63921 cabo@tzi.org
Applications and Real-Time CBOR CBOR (STD 94, RFC 8949) defines "Deterministically Encoded CBOR" in its Section 4.2, providing some flexibility for application specific decisions. To facilitate Deterministic Encoding to be offered as a selectable feature of generic encoders, the present document defines a CBOR Common Deterministic Encoding (CDE) Profile that can be shared by a large set of applications with potentially diverging detailed requirements. It also defines "Basic Serialization", which stops short of the potentially more onerous requirements that make CDE fully deterministic, while employing most of its reductions of the variability needing to be handled by decoders. About This Document Status information for this document may be found at . Discussion of this document takes place on the Concise Binary Object Representation Maintenance and Extensions (CBOR) Working Group mailing list (), which is archived at . Subscribe at . Source for this draft and an issue tracker can be found at .
Introduction CBOR (STD 94, RFC 8949) defines "Deterministically Encoded CBOR" in its Section 4.2, providing some flexibility for application specific decisions. To facilitate Deterministic Encoding to be offered as a selectable feature of generic encoders, the present document defines a CBOR Common Deterministic Encoding (CDE) Profile that can be shared by a large set of applications with potentially diverging detailed requirements. It also defines "Basic Serialization", which stops short of the potentially more onerous requirements that make CDE fully deterministic, while employing most of its reductions of the variability needing to be handled by decoders.
Structure of This Document After introductory material (this introduction and ), defines the CBOR Common Deterministic Encoding Profile (CDE). defines Concise Data Definition Language (CDDL) support for indicating the use of CDE. This is followed by the conventional sections for (), (), and (). The informative provides brief checklists that implementers can use to check their CDE implementations. provides a checklist for implementing Preferred Serialization. introduces "Basic Serialization", a slightly more restricted form of Preferred Serialization that may be used by encoders to hit a sweet spot for maximizing interoperability with partial (e.g., constrained) CBOR decoder implementations. further restricts Basic Serialization to arrive at CDE. Instead of giving rise to the definition of application-specific, non-interoperable variants of CDE, this document identifies Application-level Deterministic Representation (ALDR) rules as a concept that is separate from CDE itself () and therefore out of scope for this document. ALDR rules are situated at the application-level, i.e., on top of the CDE, and address requirements on deterministic representation of application data that are specific to an application or a set of applications. ALDR rules are often provided as part of a specification for a CBOR-based protocol, or, if needed, can be provided by referencing a shared "ALDR ruleset" that is defined in a separate document.
Conventions and Definitions The conventions and definitions of apply.
  • The term "CBOR Application" ("application" for short) is not explicitly defined in ; this document uses it in the same sense as it is used there, specifically for applications that use CBOR as an interchange format and use (often generic) CBOR encoders/decoders to serialize/ingest the CBOR form of their application data to be exchanged.
  • Similarly, "CBOR Protocol" is used as in for the protocol that governs the interchange of data in CBOR format for a specific application or set of applications.
  • "Representation" stands for the process, and its result, of building the representation format out of (information-model level) application data.
  • "Serialization" is used for the subset of this process, and its result, that represents ("serializes") data in CBOR generic data model form into encoded data items. "Encoding" is often used as a synonym when the focus is on that.
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 () () when, and only when, they appear in all capitals, as shown here.
Encoding Choices in CBOR In many cases, CBOR provides more than one way to encode a data item, i.e., to serialize it into a sequence of bytes. This flexibility can provide convenience for the generator of the encoded data item, but handling the resulting variation can also put an onus on the decoder. In general, there is no single perfect encoding choice that is optimal for all applications. Choosing the right constraints on these encoding choices is one element of application protocol design. Having predefined sets of such choices is a useful way to reduce variation between applications, enabling generic implementations. Section of RFC 8949 provides a recommendation for a Preferred Serialization. This recommendation is useful for most CBOR applications, and it is a good choice for most applications. Its main constraint is to choose the shortest head (Section of RFC 8949 ) that preserves the value of a data item. Preferred Serialization allows indefinite length encoding (Section of RFC 8949 ), which does not express the length of a string, an array, or a map in its head. Supporting both definite length and indefinite length encoding is an additional onus on the decoder; many applications therefore choose not to use indefinite length encoding at all. We call Preferred Serialization with this additional constraint Basic Serialization. Basic Serialization is a common choice for applications that need to further reduce the variability that needs to be handled by decoders, potentially maximizing interoperability with partial (e.g., constrained) CBOR decoder implementations. These constraints still allow some variation. In particular, there is more than one serialization for data items that contain maps: The order of serialization of map entries is ignored in CBOR (as it is in JSON), so maps with more than one entry have all permutations of these entries as valid Basic Serializations. Deterministic Serialization builds on Basic Serialization by defining a common (namely, lexicographic) order for the entries in a map. For many applications, ensuring this common order is an additional onus on the generator that is not actually needed, so they do not choose Deterministic Serialization. However, if the objective is minimal effort for the consuming application, deterministic map ordering can be useful even outside the main use cases for Deterministic Serialization that are further discussed in . summarizes the increasingly restrictive sets of encoding choices that have been given names in this section. Constraints on the Serialization of CBOR
Set of Encoding Choices Most Important Constraint Applications
preferred shortest "head" variant most
basic + definite lengths only many
deterministic ("CDE") + common map order specific
Note that the objective to have a deterministic serialization for a specific application data item can only be fulfilled if the application itself does not generate multiple different CBOR data items that represent that same (equivalent) application data item. We speak of the need for Application-level Deterministic Representation (ALDR), and we may want to aid achieving this by the application defining rules for ALDR (see also ). Where Deterministic Representation is not actually needed, application-level representation rules of course can still be useful to amplify the benefits of Preferred or Basic Serialization.
CBOR Common Deterministic Encoding Profile (CDE) This specification defines the CBOR Common Deterministic Encoding Profile (CDE) based on the Core Deterministic Encoding Requirements defined for CBOR in Section of RFC 8949 . Note that this specific set of requirements is elective — in principle, other variants of deterministic encoding can be defined (and have been, now being phased out slowly, as detailed in Section of RFC 8949 ). In many applications of CBOR today, deterministic encoding is not used at all, as its restriction of choices can create some additional performance cost and code complexity. 's core requirements are designed to provide well-understood and easy-to-implement rules while maximizing coverage, i.e., the subset of CBOR data items that are fully specified by these rules, and also placing minimal burden on implementations. Section of RFC 8949 picks up on the interaction of extensibility (CBOR tags) and deterministic encoding. CBOR itself uses some tags to increase the range of its basic generic data types, e.g., tags 2/3 extend the range of basic major types 0/1 in a seamless way. Section of RFC 8949 recommends handling this transition the same way as with the transition between different integer representation lengths in the basic generic data model, i.e., by mandating the preferred serialization for all integers (Section of RFC 8949 ).
  1. CDE turns this recommendation into a mandate: Integers that can be represented by basic major type 0 and 1 are encoded using the deterministic encoding defined for them, and integers outside this range are encoded using the preferred serialization (Section of RFC 8949 ) of tag 2 and 3 (i.e., no leading zero bytes).
Most tags capture more specific application semantics and therefore may be harder to define a deterministic encoding for. While the deterministic encoding of their tag internals is often covered by the Core Deterministic Encoding Requirements, the mapping of diverging platform application data types onto the tag contents may require additional attention to perform it in a deterministic way; see for more explanation as well as examples. As the CDE would continually need to address additional issues raised by the registration of new tags, this specification recommends that new tag registrations address deterministic encoding in the context of CDE. A particularly difficult field to obtain deterministic encoding for is floating point numbers, partially because they themselves are often obtained from processes that are not entirely deterministic between platforms. See for more details. Section of RFC 8949 presents a number of choices; these need to be made to obtain the CBOR Common Deterministic Encoding Profile (CDE). Specifically, CDE specifies (in the order of the bullet list at the end of Section of RFC 8949 ):
  1. Besides the mandated use of preferred serialization, there is no further specific action for the two different zero values, e.g., an encoder that is asked by an application to represent a negative floating point zero will generate 0xf98000.
  2. There is no attempt to mix integers and floating point numbers, i.e., all floating point values are encoded as the preferred floating-point representation that accurately represents the value, independent of whether the floating point value is, mathematically, an integral value (choice 2 of the second bullet).
  3. Apart from finite and infinite numbers, floating point values include NaN (not a number) values . In CDE, there is no special handling of NaN values, except that the preferred serialization rules also apply to NaNs (with zero or non-zero payloads), using the canonical encoding of NaNs as defined in Section 6.2.1 of . Specifically, this means that shorter forms of encodings for a NaN are used when that can be achieved by only removing trailing zeros in the NaN payload (example serializations are available in ). Further clarifying a "should"-level statement in Section 6.2.1 of , the CBOR encoding always uses a leading bit of 1 in the significand to encode a quiet NaN; the use of signaling NaNs by application protocols is NOT RECOMMENDED but when presented by an application these are encoded by using a leading bit of 0. Typically, most applications that employ NaNs in their storage and communication interfaces will only use a single NaN value, quiet NaN with payload 0, which therefore deterministically encodes as 0xf97e00.
  4. There is no special handling of subnormal values.
  5. CDE does not presume equivalence of basic floating point values with floating point values using other representations (e.g., tag 4/5). Such equivalences and related deterministic representation rules can be added at the ALDR level if desired, e.g., by stipulating additional equivalences and deterministically choosing exactly one representation for each such equivalence, and by restricting in general the set of data item values actually used by an application.
The main intent here is to preserve the basic generic data model, so applications (in their ALDR rules or by referencing a separate ALDR ruleset document, see ) can make their own decisions within that data model. E.g., an application's ALDR rules can decide that it only ever allows a single NaN value that would be encoded as 0xf97e00, so a CDE implementation focusing on this application would not need to provide processing for other NaN values. Basing the definition of both CDE and ALDR rules on the generic data model of CBOR also means that there is no effect on the Concise Data Definition Language (CDDL) , except where the data description is documenting specific encoding decisions for byte strings that carry embedded CBOR.
CDDL support CDDL defines the structure of CBOR data items at the data model level; it enables being specific about the data items allowed in a particular place. It does not specify encoding, but CBOR protocols can specify the use of CDE (or simply Basic Serialization). For instance, it allows the specification of a floating point data item as "float16"; this means the application data model only foresees data that can be encoded as binary16. Note that specifying "float32" for a floating point data item enables all floating point values that can be represented as binary32; this includes values that can also be represented as binary16 and that will be so represented in Basic Serialization. defines control operators to indicate that the contents of a byte string carries a CBOR-encoded data item (.cbor) or a sequence of CBOR-encoded data items (.cborseq). CDDL specifications may want to specify that the data items should be encoded in Common CBOR Deterministic Encoding. The present specification adds two CDDL control operators that can be used for this. The control operators .cde and .cdeseq are exactly like .cbor and .cborseq except that they also require the encoded data item(s) to be encoded according to CDE. For example, a byte string of embedded CBOR that is to be encoded according to CDE can be formalized as: More importantly, if the encoded data item also needs to have a specific structure, this can be expressed by the right-hand side (instead of using the most general CDDL type any here). (Note that the .cdeseq control operator does not enable specifying different deterministic encoding requirements for the elements of the sequence. If a use case for such a feature becomes known, it could be added.) Obviously, specifications that document ALDR rules can define related control operators that also embody the processing required by those ALDR rules, and are encouraged to do so.
Security Considerations The security considerations in Section of RFC 8949 apply. The use of deterministic encoding can mitigate issues arising out of the use of non-preferred serializations specially crafted by an attacker. However, this effect only accrues if the decoder actually checks that deterministic encoding was applied correctly. More generally, additional security properties of deterministic encoding can rely on this check being performed properly.
IANA Considerations RFC Editor: please replace RFCXXXX with the RFC number of this RFC and remove this note. This document requests IANA to register the contents of into the registry "" of the registry group: New control operators to be registered
Name Reference
.cde [RFCXXXX]
.cdeseq [RFCXXXX]
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. IEEE Standard for Floating-Point Arithmetic IEEE Concise Data Definition Language (CDDL): A Notational Convention to Express Concise Binary Object Representation (CBOR) and JSON Data Structures This document proposes a notational convention to express Concise Binary Object Representation (CBOR) data structures (RFC 7049). Its main goal is to provide an easy and unambiguous way to express structures for protocol messages and data formats that use CBOR or JSON. Concise Data Definition Language (CDDL) 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 CBOR: On Deterministic Encoding and Representation Universität Bremen TZI CBOR (STD 94, RFC 8949) defines "Deterministically Encoded CBOR" in its Section 4.2. The present document provides additional information about use cases, deployment considerations, and implementation choices for Deterministic Encoding and Representation. dCBOR: A Deterministic CBOR Application Profile Blockchain Commons Blockchain Commons Universität Bremen TZI Security Theory LLC The purpose of determinism is to ensure that semantically equivalent data items are encoded into identical byte streams. CBOR (RFC 8949) defines "Deterministically Encoded CBOR" in its Section 4.2, but leaves some important choices up to the application developer. The CBOR Common Deterministic Encoding (CDE) Internet Draft builds on this by specifying a baseline for application profiles that wish to implement deterministic encoding with CBOR. The present document provides an application profile "dCBOR" that can be used to help achieve interoperable deterministic encoding based on CDE for a variety of applications wishing an even narrower and clearly defined set of choices. On Numbers in CBOR Universität Bremen TZI The Concise Binary Object Representation (CBOR), as defined in STD 94 (RFC 8949), is a data representation format whose design goals include the possibility of extremely small code size, fairly small message size, and extensibility without the need for version negotiation. Among the kinds of data that a data representation format needs to be able to carry, numbers have a prominent role, but also have inherent complexity that needs attention from protocol designers and implementers of CBOR libraries and of the applications that use them. This document gives an overview over number formats available in CBOR and some notable CBOR tags registered, and it attempts to provide information about opportunities and potential pitfalls of these number formats. // This is a rather drafty initial revision, pieced together from // various components, so it has a higher level of redundancy than // ultimately desired. Unicode Normalization Forms Unicode Standard Annex 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 for Time, Duration, and Period The Concise Binary Object Representation (CBOR, RFC 8949) 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. In CBOR, one point of extensibility is the definition of CBOR tags. RFC 8949 defines two tags for time: CBOR tag 0 (RFC 3339 time as a string) and tag 1 (POSIX time as int or float). Since then, additional requirements have become known. The present document defines a CBOR tag for time that allows a more elaborate representation of time, as well as related CBOR tags for duration and time period. This document is intended as the reference document for the IANA registration of the CBOR tags defined. CBOR Object Signing and Encryption (COSE) Key Thumbprint This specification defines a method for computing a hash value over a CBOR Object Signing and Encryption (COSE) Key. It specifies which fields within the COSE Key structure are included in the cryptographic hash computation, the process for creating a canonical representation of these fields, and how to hash the resulting byte sequence. The resulting hash value, referred to as a "thumbprint", can be used to identify or select the corresponding key. 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): Countersignatures Concise Binary Object Representation (CBOR) is a data format designed for small code size and small message size. CBOR Object Signing and Encryption (COSE) defines a set of security services for CBOR. This document defines a countersignature algorithm along with the needed header parameters and CBOR tags for COSE. This document updates RFC 9052. Modern Network Unicode Universität Bremen TZI BCP18 (RFC 2277) has been the basis for the handling of character- shaped data in IETF specifications for more than a quarter of a century now. It singles out UTF-8 (STD63, RFC 3629) as the "charset" that MUST be supported, and pulls in the Unicode standard with that. Based on this, RFC 5198 both defines common conventions for the use of Unicode in network protocols and caters for the specific requirements of the legacy protocol Telnet. In applications that do not need Telnet compatibility, some of the decisions of RFC 5198 can be cumbersome. The present specification defines "Modern Network Unicode" (MNU), which is a form of RFC 5198 Network Unicode that can be used in specifications that require the exchange of plain text over networks and where just mandating UTF-8 may not be sufficient, but there is also no desire to import all of the baggage of RFC 5198. As characters are used in different environments, MNU is defined in a one-dimensional (1D) variant that is useful for identifiers and labels, but does not use a structure of text lines. A 2D variant is defined for text that is a sequence of text lines, such as plain text documents or markdown format. Additional variances of these two base formats can be used to tailor MNU to specific areas of application.
Application-level Deterministic Representation This appendix is informative. CBOR application protocols are agreements about how to use CBOR for a specific application or set of applications. Application protocols make representation decisions in order to constrain the variety of ways in which some aspect of the information model could be represented in the CBOR data model for the application. For instance, there are several CBOR tags that can be used to represent a time stamp (such as tag 0, 1, 1001), each with some specific properties. Application protocols that need to represent a timestamp typically choose a specific tag and further constrain its use where necessary (e.g., tag 1001 was designed to cover a wide variety of applications ). Where no tag is available, the application protocol can design its own format for some application data. Even where a tag is available, the application data can choose to use its definitions without actually encoding the tag (e.g., by using its content in specific places in an "unwrapped" form). For instance, CWT defines an application data type "NumericDate" which (as an application-level rule) is formed by "unwrapping" tag 1 (see Sections and of ). CWT does stop short of using deterministic encoding. A hypothetical deterministic variant of CWT would need to make an additional ALDR rule for NumericDate, as the definition of tag 1 allows both integer and floating point numbers (Section of RFC 8949 ), which allows multiple application-level representations of integral numbers. These application rules may choose to only ever use integers, or to always use integers when the numeric value can be represented as such without loss of information, or to always use floating point numbers, or some of these for some application data and different ones for other application data. Applications that require Deterministic Representation, and that derive CBOR data items from application data without maintaining a record of which choices are to be made when representing these application data, generally make rules for these choices as part of the application protocol. In this document, we speak about these choices as Application-level Deterministic Representation Rules (ALDR rules for short). As an example, is intended to derive a (deterministic) thumbprint from a COSE key . provides the rules that are used to construct a deterministic application-level representation (ALDR rules). Only certain data from a COSE key are selected to be included in that ALDR, and, where the COSE can choose multiple representations of semantically equivalent application data, the ALDR rules choose one of them, potentially requiring a conversion ():
Note: [] supports both compressed and uncompressed point representations. For interoperability, implementations adhering to this specification MUST use the uncompressed point representation. Therefore, the y-coordinate is expressed as a bstr. If an implementation uses the compressed point representation, it MUST first convert it to the uncompressed form for the purpose of thumbprint calculation.
CDE provides for encoding commonality between different applications of CBOR once these application-level choices have been made. It can be useful for an application or a group of applications to document their choices aimed at deterministic representation of application data in a general way, constraining the set of data items handled (exclusions, e.g., no compressed point representations) and defining further mappings (reductions, e.g., conversions to uncompressed form) that help the application(s) get by with the exclusions. This can be done in the application protocol specification (as in ) or as a separate document. An early example of a separate document is the dCBOR specification . dCBOR specifies the use of CDE together with some application-level rules, i.e., an ALDR ruleset, such as a requirement for all text strings to be in Unicode Normalization Form C (NFC) — this specific requirement is an example for an exclusion of non-NFC data at the application level, and it invites implementing a reduction by routine normalization of text strings. ALDR rules (including rules specified in a ALDR ruleset document) enable simply using implementations of the common CDE; they do not "fork" CBOR in the sense of requiring distinct generic encoder/decoder implementations for each application. An implementation of specific ALDR rules combined with a CDE implementation produces well-formed, deterministically encoded CBOR according to , and existing generic CBOR decoders will therefore be able to decode it, including those that check for Deterministic Encoding ("CDE decoders", see also ). Similarly, generic CBOR encoders will be able to produce valid CBOR that can be ingested by an implementation that enforces an application's ALDR rules if the encoder was handed data model level information from an application that simply conformed to those ALDR rules. Please note that the separation between standard CBOR processing and the processing required by the ALDR rules is a conceptual one: Instead of employing generic encoders/decoders, both ALDR rule processing and standard CBOR processing can be combined into a specialized encoder/decoder specifically designed for a particular set of ALDR rules. ALDR rules are intended to be used in conjunction with an application, which typically will naturally use a subset of the CBOR generic data model, which in turn influences which subset of the ALDR rules is used by the specific application (in particular if the application simply references a more general ALDR ruleset document). As a result, ALDR rules themselves place no direct requirement on what minimum subset of CBOR is implemented. For instance, a set of ALDR rules might include rules for the processing of floating point values, but there is no requirement that implementations of that set of ALDR rules support floating point numbers (or any other kind of number, such as arbitrary precision integers or 64-bit negative integers) when they are used with applications that do not use them.
Implementers' Checklists This appendix is informative. It provides brief checklists that implementers can use to check their implementations. It uses language, specifically the keyword MUST, to highlight the specific items that implementers may want to check. It does not contain any normative mandates. This appendix is informative. Notes:
  • This is largely a restatement of parts of Section of RFC 8949 . The purpose of the restatement is to aid the work of implementers, not to redefine anything. Preferred Serialization Encoders and Decoders as well as CDE Encoders and Decoders have certain properties that are expressed using keywords in this appendix.
  • Duplicate map keys are never valid in CBOR at all (see list item "Major type 5" in Section of RFC 8949 ) no matter what sort of serialization is used. Of the various strategies listed in Section of RFC 8949 , detecting duplicates and handling them as an error instead of passing invalid data to the application is the most robust one; achieving this level of robustness is a mark of quality of implementation.
  • Preferred serialization and CDE only affect serialization. They do not place any requirements, exclusions, mappings or such on the data model level. ALDR rules such as the ALDR ruleset defined by dCBOR are different as they can affect the data model by restricting some values and ranges.
  • CBOR decoders in general (as opposed to "CDE decoders" specifically advertised as supporting CDE) are not required to check for preferred serialization or CDE and reject inputs that do not fulfill their requirements. However, in an environment that employs deterministic encoding, employing non-checking CBOR decoders negates many of its benefits. Decoder implementations that advertise "support" for preferred serialization or CDE need to check the encoding and reject input that is not encoded to the encoding specification in use. Again, ALDR rules such as those in dCBOR may pose additional requirements, such as requiring rejection of non-conforming inputs. If a generic decoder needs to be used that does not "support" CDE, a simple (but somewhat clumsy) way to check for proper CDE encoding is to re-encode the decoded data and check for bit-to-bit equality with the original input.
Preferred Serialization In the following, the abbreviation "ai" will be used for the 5-bit additional information field in the first byte of an encoded CBOR data item, which follows the 3-bit field for the major type.
Preferred Serialization Encoders
  1. Shortest-form encoding of the argument MUST be used for all major types. Major type 7 is used for floating-point and simple values; floating point values have its specific rules for how the shortest form is derived for the argument. The shortest form encoding for any argument that is not a floating point value is:
    • 0 to 23 and -1 to -24 MUST be encoded in the same byte as the major type.
    • 24 to 255 and -25 to -256 MUST be encoded only with an additional byte (ai = 0x18).
    • 256 to 65535 and -257 to -65536 MUST be encoded only with an additional two bytes (ai = 0x19).
    • 65536 to 4294967295 and -65537 to -4294967296 MUST be encoded only with an additional four bytes (ai = 0x1a).
  2. If floating-point numbers are emitted, the following apply:
    • The length of the argument indicates half (binary16, ai = 0x19), single (binary32, ai = 0x1a) and double (binary64, ai = 0x1b) precision encoding. If multiple of these encodings preserve the precision of the value to be encoded, only the shortest form of these MUST be emitted. That is, encoders MUST support half-precision and single-precision floating point.
    • Infinites and NaNs, and thus NaN payloads, MUST be supported, to the extent possible on the platform. As with all floating point numbers, Infinites and NaNs MUST be encoded in the shortest of double, single or half precision that preserves the value:
      • Positive and negative infinity and zero MUST be represented in half-precision floating point.
      • For NaNs, the value to be preserved includes the sign bit, the quiet bit, and the NaN payload (whether zero or non-zero). The shortest form is obtained by removing the rightmost N bits of the payload, where N is the difference in the number of bits in the significand (mantissa representation) between the original format and the shortest format. This trimming is performed only (preserves the value only) if all the rightmost bits removed are zero. (This will always represent a double or single quiet NaN with a zero NaN payload in a half-precision quiet NaN.)
  3. If tags 2 and 3 are supported, the following apply:
    • Positive integers from 0 to 2^64 - 1 MUST be encoded as a type 0 integer.
    • Negative integers from -(2^64) to -1 MUST be encoded as a type 1 integer.
    • Leading zeros MUST NOT be present in the byte string content of tag 2 and 3.
    (This also applies to the use of tags 2 and 3 within other tags, such as 4 or 5.)
Preferred Serialization Decoders There are no special requirements that CBOR decoders need to meet to be a Preferred Serialization Decoder. Partial decoder implementations need to pay attention to at least the following requirements:
  1. Decoders MUST accept shortest-form encoded arguments (see Section of RFC 8949 ).
  2. If arrays or maps are supported, definite-length arrays or maps MUST be accepted.
  3. If text or byte strings are supported, definite-length text or byte strings MUST be accepted.
  4. If floating-point numbers are supported, the following apply:
    • Half-precision values MUST be accepted.
    • Double- and single-precision values SHOULD be accepted; leaving these out is only foreseen for decoders that need to work in exceptionally constrained environments.
    • If double-precision values are accepted, single-precision values MUST be accepted.
    • Infinites and NaNs, and thus NaN payloads, MUST be accepted and presented to the application (not necessarily in the platform number format, if that doesn't support those values).
  5. If big numbers (tags 2 and 3) are supported, type 0 and type 1 integers MUST be accepted where a tag 2 or 3 would be accepted. Leading zero bytes in the tag content of a tag 2 or 3 MUST be ignored.
Basic Serialization Basic Serialization further restricts Preferred Serialization by not using indefinite length encoding. A CBOR encoder can choose to employ Basic Serialization in order to reduce the variability that needs to be handled by decoders, potentially maximizing interoperability with partial (e.g., constrained) CBOR decoder implementations.
Basic Serialization Encoders The Basic Serialization Encoder requirements are identical to the Preferred Serialization Encoder requirements, with the following additions:
  1. If maps or arrays are emitted, they MUST use definite-length encoding (never indefinite-length).
  2. If text or byte strings are emitted, they MUST use definite-length encoding (never indefinite-length).
Basic Serialization Decoders The Basic Serialization Decoder requirements are identical to the Preferred Serialization Decoder requirements.
CDE
CDE Encoders
  1. CDE encoders MUST only emit CBOR fulfilling the basic serialization rules ().
  2. CDE encoders MUST sort maps by the CBOR representation of the map key. The sorting is byte-wise lexicographic order of the encoded map key data items.
  3. CDE encoders MUST generate CBOR that fulfills basic validity (Section of RFC 8949 ). Note that this includes not emitting duplicate keys in a major type 5 map as well as emitting only valid UTF-8 in major type 3 text strings. Note also that CDE does NOT include a requirement for Unicode normalization ; contains some rationale that went into not requiring routine use of Unicode normalization processes.
CDE Decoders The term "CDE Decoder" is a shorthand for a CBOR decoder that advertises supporting CDE (see the start of this appendix).
  1. CDE decoders MUST follow the rules for preferred (and thus basic) serialization decoders ().
  2. CDE decoders MUST check for ordering map keys and for basic validity of the CBOR encoding (see Section of RFC 8949 , which includes a check against duplicate map keys and invalid UTF-8). To be called a CDE decoder, it MUST NOT present to the application a decoded data item that fails one of these checks (except maybe via special diagnostic channels with no potential for confusion with a correctly CDE-decoded data item).
List of Tables
  1. Constraints on the Serialization of CBOR
  2. New control operators to be registered
Acknowledgments An earlier version of this document was based on the work of Wolf McNally and Christopher Allen as documented in , which serves as an example for an ALDR ruleset document. We would like to explicitly acknowledge that this work has contributed greatly to shaping the concept of a CBOR Common Deterministic Encoding and ALDR rules/rulesets on top of that.
Contributors Security Theory LLC
lgl@securitytheory.com
Laurence provided most of the text that became .