| RFC 9393 | CoSWID | June 2023 |
| Birkholz, et al. | Standards Track | [Page] |
ISO/IEC 19770-2:2015 Software Identification (SWID) tags provide an extensible XML-based structure to identify and describe individual software components, patches, and installation bundles. SWID tag representations can be too large for devices with network and storage constraints. This document defines a concise representation of SWID tags: Concise SWID (CoSWID) tags. CoSWID supports a set of semantics and features that are similar to those for SWID tags, as well as new semantics that allow CoSWIDs to describe additional types of information, all in a more memory-efficient format.¶
This is an Internet Standards Track document.¶
This document is a product of the Internet Engineering Task Force (IETF). It represents the consensus of the IETF community. It has received public review and has been approved for publication by the Internet Engineering Steering Group (IESG). Further information on Internet Standards is available in Section 2 of RFC 7841.¶
Information about the current status of this document, any errata, and how to provide feedback on it may be obtained athttps://www.rfc-editor.org/info/rfc9393.¶
Copyright (c) 2023 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.¶
SWID tags, as defined in ISO-19770-2:2015[SWID], provide a standardizedXML-based record format that identifies and describes a specific release ofsoftware, a patch, or an installation bundle, which are referred to as software components in this document. Different software components, and even different releases of aparticular software component, each have a different SWID tag record associatedwith them. SWID tags are meant to be flexible and able to express a broad set of metadataabout a software component.¶
SWID tags are used to support a number of processes, including but not limited to:¶
While there are very few required fields in SWID tags, there are many optionalfields that support different uses. ASWID tag consisting of only required fields might be a few hundred bytes insize; however, a tag containing many of the optional fields can be many orders ofmagnitude larger. Thus, real-world instances of SWID tags can be fairly large, and the communication ofSWID tags in usage scenarios, such as those described earlier, can cause a largeamount of data to be transported. This can be larger than acceptable forconstrained devices and networks. Concise SWID (CoSWID) tags significantly reduce the amount ofdata transported as compared to a typical SWID tagthrough the use of the ConciseBinary Object Representation (CBOR)[RFC8949].¶
Size comparisons between XML SWID and CoSWID mainly depend on domain-specific applications and the complexity of attributes used in instances.While the values stored in CoSWID are often unchanged and therefore not reduced in size compared to an XML SWID, the scaffolding that the CoSWID encoding represents is significantly smaller by taking up 10 percent or less in size.This effect is visible in representation sizes, which in early experiments benefited from a 50 percent to 85 percent reduction in generic usage scenarios.Additional size reduction is enabled with respect to the memory footprint of XML parsing/validation.¶
In a CoSWID, the human-readable labels of SWID data items are replaced withmore concise integer labels (indices). This approach allows SWID and CoSWID to share a common implicit information model, with CoSWID providing an alternate data model[RFC3444]. While SWID and CoSWID are intended to share the same implicit information model, this specification does not define this information model or a mapping between the two data formats. While an attempt to align SWID and CoSWID tags has been made here, future revisions of ISO/IEC 19770-2:2015 or this specification might cause this implicit information model to diverge, since these specifications are maintained by different standards groups.¶
The use of CBOR to express SWID information in CoSWID tags allows both CoSWID and SWID tags to be part of anenterprise security solution for a wider range of endpoints and environments.¶
In addition to defining the format of a SWID tag record, ISO/IEC 19770-2:2015defines requirements concerning the SWID tag lifecycle. Specifically, when asoftware component is installed on an endpoint, that software component's SWID tag is alsoinstalled. Likewise, when the software component is uninstalled or replaced, the SWID tagis deleted or replaced, as appropriate. As a result, ISO/IEC 19770-2:2015 describesa system wherein there is a correspondence between the set of installed softwarecomponents on an endpoint and the presence of the corresponding SWID tagsfor these components on that endpoint. CoSWIDs share the same lifecycle requirementsas a SWID tag.¶
The SWID specification and supporting guidance provided in NIST Internal Report (NISTIR) 8060 ("Guidelines for the Creation of Interoperable SoftwareIdentification (SWID) Tags")[SWID-GUIDANCE] define four types of SWID tags: primary, patch, corpus, and supplemental. The following text is paraphrased from these sources.¶
The type of a tag is determined by specific data elements, which are discussed inSection 3.Section 3 also provides normative language for CoSWID semantics that implement this lifecycle. The following information helps to explain how these semantics apply to the use of a CoSWID tag.¶
Corpus, primary, and patch tags have similar functions in that they describe the existence and/or presence of different types of software components (e.g., software installers, software installations, software patches) and, potentially, different states of these software components. Supplemental tags have the same structure as other tags but are used to provide information not contained in the referenced corpus, primary, and patch tags. All four tag types come into play at various points in the software lifecycle and support software management processes that depend on the ability to accurately determine where each software component is in its lifecycle.¶
+------------+ v |Software Software Software Software SoftwareDeployment -> Installation -> Patching -> Upgrading -> RemovalCorpus Primary Primary xPrimary xPrimarySupplemental Supplemental Supplemental xSupplemental xSupplemental Patch xPatch Primary Supplemental
Figure 1 illustrates the steps in the software lifecycle and the relationships among those lifecycle events supported by the four types of SWID and CoSWID tags. A detailed description of the four tag types is provided inSection 2.3. The figure identifies the types of tags that are used in each lifecycle event.¶
There are many ways in which software tags might be managed for the host the software is installed on. For example, software tags could be made available on the host or to an external software manager when storage is limited on the host.¶
In these cases, the host or external software manager is responsible for management of the tags, including deployment and removal of the tags as indicated by the above lifecycle. Tags are deployed, and previously deployed tags are typically removed (indicated by an "x" prefix) at each lifecycle stage as follows:¶
Corpus tags are not actually deployed on the target system but are intended to support deployment procedures and their dependencies at install time, such as to verify the installation media.¶
As a software component is upgraded to a new version, new primary and supplemental tags replace existing tags, enabling timely and accurate tracking of updates to software inventory. While not illustrated in the figure, a corpus tag can also provide information about the upgrade installer and dependencies that need to be installed before the upgrade.¶
Note: In the context of software tagging, software patching and updating differ in an important way. When installing a patch, a set of file modifications are made to pre-installed software; these modifications do not alter the version number or the descriptive metadata of an installed software component. An update can also make a set of file modifications; in that case, the version number or the descriptive metadata of an installed software component is changed.¶
As illustrated in the figure, supplemental tags can be associated with any corpus, primary, or patch tag to provide additional metadata about an installer, installed software, or installed patch, respectively.¶
Understanding the use of CoSWIDs in the software lifecycle provides a basis for understanding the information provided in a CoSWID and the associated semantics of this information. Each different SWID and CoSWID tag type provides different sets ofinformation. For example, a "corpus tag" is used todescribe a software component's installation image on an installation medium, while a"patch tag" is meant to describe a patch that modifies some other software component.¶
This document defines the CoSWID tag format, which is based on CBOR. CBOR-based CoSWID tags offer a more concise representation of SWID information as compared to the XML-based SWID tag representation in ISO-19770-2:2015. The structure of a CoSWID is described via the ConciseData Definition Language (CDDL)[RFC8610]. The resulting CoSWID datadefinition is aligned with the information able to be expressed with the XML Schema definition of ISO-19770-2:2015[SWID]. This alignment allows both SWID and CoSWID tags to represent a common set of software component information and allows CoSWID tags to support the same uses as a SWID tag.¶
The vocabulary (i.e., the CDDL names of the types and members used inthe CoSWID CDDL specification) is mapped to more concise labels represented assmall integer values (indices). The names used in the CDDL specification and the mapping tothe CBOR representation using integer indices are based on the vocabulary of theXML attribute and element names defined in ISO/IEC 19770-2:2015.¶
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.¶
The following describes the general rules and processes for encoding data using CDDL representation. Prior familiarity with CBOR and CDDL concepts will be helpful in understanding this CoSWID specification.¶
This section describes the conventions by which a CoSWID is represented in the CDDL structure. The CamelCase notation[CamelCase] used in the XML Schema definition is changed to a hyphen-separatednotation[KebabCase] (e.g., "ResourceCollection" is named "resource-collection") in the CoSWID CDDL specification.This deviation from the original notation used in the XML representation reduces ambiguity when referencingcertain attributes in corresponding textual descriptions. An attribute referred to by its name in CamelCasenotation explicitly relates to XML SWID tags; an attribute referred to by its name inKebabCase notation explicitly relates to CBOR CoSWID tags. This approach simplifies thecomposition of further work that will reference both XML SWID and CBOR CoSWID documents.¶
In most cases, mapping attribute names between SWID and CoSWID can be done automatically by converting between CamelCase and KebabCase attribute names. However, some CoSWID CDDL attribute names show greater variation relative to their corresponding SWID XML Schema attributes. This is done when the change improves clarity in the CoSWID specification. For example, the "name" and "version" SWID fields correspond to the "software-name" and "software-version" CoSWID fields, respectively. As such, it is not always possible to mechanically translate between corresponding attribute names in the two formats. In such cases, a manual mapping will need to be used. XPath expressions[W3C.REC-xpath20-20101214] need to use SWID names; seeSection 5.2.¶
The 57 human-readable text labels of the CDDL-based CoSWID vocabulary are mapped to integer indices via a block of rules at the bottom of the definition. This allows a more concise integer-based form to be stored or transported, as compared to the less efficient text-based form of the original vocabulary.¶
Through the use of CDDL-based integer labels, CoSWID allows for future expansion in subsequent revisions of this specification and through extensions (seeSection 2.2). New constructs can be associated with a new integer index. A deprecated construct can be replaced by a new construct with a new integer index. An implementation can use these integer indices to identify the construct to parse. The "CoSWID Items" registry, defined inSection 6.1, is used to ensure that new constructs are assigned a unique index value. This approach avoids the need to have an explicit CoSWID version.¶
In a number of places, the value encoding admits both integer values and text strings.The integer values are defined in a registry specific to the kind of value; the text values are not intended for interchange and are exclusively meant for private use as defined inSection 6.2.2. EncodersSHOULD NOT use string values based on the names registered in the registry, as these values are less concise than their index value equivalent; a decoderMUST, however, be prepared to accept text strings that are not specified in this document (and ignore the construct if a string is unknown).In the rest of this document, we call this an "integer label with text escape".¶
The root of the CDDL specification provided by this document is therulecoswid (as defined inSection 8):¶
start = coswid¶
In CBOR, an array is encoded using bytes that identify the array, and the array's length or stop point (see[RFC8949]). To make items that support one or more values, the following CDDL notation is used.¶
_name_ = (_label_ => _data_ / [ 2* _data_ ])¶
The CDDL rule above allows either a single data item or an array of two or more data values to be provided. When a singleton data value is provided, the CBOR markers for the array, array length, and stop point are not needed, saving bytes. When two or more data values are provided, these values are encoded as an array. This modeling pattern is used frequently in the CoSWID CDDL specification to allow for more efficient encoding of singleton values.¶
Usage of this construct can be simplified using¶
one-or-more<T> = T / [ 2* T ]¶
simplifying the above example to¶
_name_ = (_label_ => one-or-more<_data_>)¶
The following subsections describe the different parts of the CoSWID model.¶
The CDDL "text" type is represented in CBOR as a major type 3, which represents a string of Unicode characters that are encoded as UTF-8[RFC3629] (seeSection 3.1 of [RFC8949]).Thus, both SWID and CoSWID use UTF-8 for the encoding of characters in text strings.¶
To ensure that UTF-8 character strings are able to be encoded/decoded and exchanged interoperably, text strings in CoSWIDMUST be encoded in a way that is consistent with the Net-Unicode definition provided in[RFC5198].¶
All names registered with IANA according to the requirements inSection 6.2 alsoMUST be valid according to the XML Schema NMTOKEN data type (see[W3C.REC-xmlschema-2-20041028], Section 3.3.4) to ensure compatibility with the SWID specification where these names are used.¶
The CoSWID specification contains two features that are not included in the SWID specification on which it is based. These features are:¶
The following CDDL sockets (extension points) are defined in this document; they allow the addition of new information structures to their respective CDDL groups.¶
| Map Name | CDDL Socket | Defined in |
|---|---|---|
| concise-swid-tag | $$coswid-extension | Section 2.3 |
| entity-entry | $$entity-extension | Section 2.6 |
| link-entry | $$link-extension | Section 2.7 |
| software-meta-entry | $$software-meta-extension | Section 2.8 |
| resource-collection | $$resource-collection-extension | Section 2.9.2 |
| file-entry | $$file-extension | Section 2.9.2 |
| directory-entry | $$directory-extension | Section 2.9.2 |
| process-entry | $$process-extension | Section 2.9.2 |
| resource-entry | $$resource-extension | Section 2.9.2 |
| payload-entry | $$payload-extension | Section 2.9.3 |
| evidence-entry | $$evidence-extension | Section 2.9.4 |
The "CoSWID Items" registry, defined inSection 6.1, provides a registration mechanism allowing new items, and their associated index values, to be added to the CoSWID model through the use of the CDDL sockets described in the table above. This registration mechanism provides for well-known index values for data items in CoSWID extensions, allowing these index values to be recognized by implementations supporting a given extension.¶
The following additional CDDL sockets are defined in this document to allow for adding new values to corresponding type choices (i.e., to represent enumerations) via custom CDDL specifications.¶
| Enumeration Name | CDDL Socket | Defined in |
|---|---|---|
| version-scheme | $version-scheme | Section 4.1 |
| role | $role | Section 4.2 |
| ownership | $ownership | Section 4.3 |
| rel | $rel | Section 4.4 |
| use | $use | Section 4.5 |
A number of IANA registries for CoSWID values are also defined inSection 6.2; these registries allow new values to be registered with IANA for the enumerations above. This registration mechanism supports the definition of new well-known index values and names for new enumeration values used by CoSWID, which can also be used by other software tagging specifications. This registration mechanism allows new standardized enumerated values to be shared between multiple tagging specifications (and associated implementations) over time.¶
The CDDL specification for the root concise-swid-tag map is as follows. This rule and its constraintsMUST be followed when creating or validating a CoSWID tag:¶
concise-swid-tag = { tag-id => text / bstr .size 16, tag-version => integer, ? corpus => bool, ? patch => bool, ? supplemental => bool, software-name => text, ? software-version => text, ? version-scheme => $version-scheme, ? media => text, ? software-meta => one-or-more<software-meta-entry>, entity => one-or-more<entity-entry>, ? link => one-or-more<link-entry>, ? payload-or-evidence, * $$coswid-extension, global-attributes,}payload-or-evidence //= ( payload => payload-entry )payload-or-evidence //= ( evidence => evidence-entry )tag-id = 0software-name = 1entity = 2evidence = 3link = 4software-meta = 5payload = 6corpus = 8patch = 9media = 10supplemental = 11tag-version = 12software-version = 13version-scheme = 14$version-scheme /= multipartnumeric$version-scheme /= multipartnumeric-suffix$version-scheme /= alphanumeric$version-scheme /= decimal$version-scheme /= semver$version-scheme /= int / textmultipartnumeric = 1multipartnumeric-suffix = 2alphanumeric = 3decimal = 4semver = 16384¶The following list describes each member of the concise-swid-tag root map.¶
The following co-constraints apply to the information provided in the concise-swid-tag group.¶
The global-attributes group provides a list of items, including an optionallanguage definition to support the processing of text-string values, and anunbounded set of any-attribute items allowing for additional items to beprovided as a general point of extension in the model.¶
The CDDL for the global-attributes group follows:¶
global-attributes = ( ? lang => text, * any-attribute,)any-attribute = ( label => one-or-more<text> / one-or-more<int>)label = text / int¶
The following list describes each child item of this group.¶
The CDDL for the entity-entry map follows:¶
entity-entry = { entity-name => text, ? reg-id => any-uri, role => one-or-more<$role>, ? thumbprint => hash-entry, * $$entity-extension, global-attributes,}entity-name = 31reg-id = 32role = 33thumbprint = 34$role /= tag-creator$role /= software-creator$role /= aggregator$role /= distributor$role /= licensor$role /= maintainer$role /= int / texttag-creator=1software-creator=2aggregator=3distributor=4licensor=5maintainer=6¶The following list describes each child item of this group.¶
An integer or textual value (integer label with text escape; seeSection 2) representing the relationship(s) between the entity and this tag or the referenced software component. If an integer value is used, itMUST be an index value in the range -256 to 255. Integer values in the range -256 to -1 are reserved for testing and use in closed environments (seeSection 6.2.2). Integer values in the range 0 to 255 correspond to registered entries in the IANA "Software ID Entity Role Values" registry (seeSection 6.2.5).¶
The following additional requirements exist for the use of the role item:¶
The CDDL for the link-entry map follows:¶
link-entry = { ? artifact => text, href => any-uri, ? media => text, ? ownership => $ownership, rel => $rel, ? media-type => text, ? use => $use, * $$link-extension, global-attributes,}media = 10artifact = 37href = 38ownership = 39rel = 40media-type = 41use = 42$ownership /= shared$ownership /= private$ownership /= abandon$ownership /= int / textabandon=1private=2shared=3$rel /= ancestor$rel /= component$rel /= feature$rel /= installationmedia$rel /= packageinstaller$rel /= parent$rel /= patches$rel /= requires$rel /= see-also$rel /= supersedes$rel /= supplemental$rel /= -256..65536 / textancestor=1component=2feature=3installationmedia=4packageinstaller=5parent=6patches=7requires=8see-also=9supersedes=10supplemental=11$use /= optional$use /= required$use /= recommended$use /= int / textoptional=1required=2recommended=3¶The following list describes each member of this map.¶
A URI-reference[RFC3986] for the referenced resource. The href item's value can be, but is not limited to, the following (which is a slightly modified excerpt from[SWID]):¶
The CDDL for the software-meta-entry map follows:¶
software-meta-entry = { ? activation-status => text, ? channel-type => text, ? colloquial-version => text, ? description => text, ? edition => text, ? entitlement-data-required => bool, ? entitlement-key => text, ? generator => text / bstr .size 16, ? persistent-id => text, ? product => text, ? product-family => text, ? revision => text, ? summary => text, ? unspsc-code => text, ? unspsc-version => text, * $$software-meta-extension, global-attributes,}activation-status = 43channel-type = 44colloquial-version = 45description = 46edition = 47entitlement-data-required = 48entitlement-key = 49generator = 50persistent-id = 51product = 52product-family = 53revision = 54summary = 55unspsc-code = 56unspsc-version = 57¶The following list describes each child item of this group.¶
CoSWID adds explicit support for the representation of hash entries using algorithms that areregistered in the IANA "Named Information Hash Algorithm Registry"[IANA.named-information]. This array is used by both the hash (index 7) and thumbprint (index 34) values. This is the equivalent of the namespace qualified "hash" attribute in[SWID].¶
hash-entry = [ hash-alg-id: int, hash-value: bytes,]¶
The number used as a value for hash-alg-id is an integer-based hash algorithm identifier whose valueMUST refer to an ID in the IANA "Named Information Hash Algorithm Registry"[IANA.named-information] with a Status of "current" (at the time the generator software was built or later); other hash algorithmsMUST NOT be used. If the hash-alg-id is not known, then the integer value "0"MUST be used. This allows for conversion from ISO SWID tags[SWID], which do not allow an algorithm to be identified for this field.¶
The hash-valueMUST represent the raw hash value as a byte string (as opposed to, for example, base64 encoded) generated from the representation of the resource using the hash algorithm indicated by hash-alg-id.¶
The resource-collection group provides a list of items used in both evidence (created by a software discovery process) andpayload (installed in an endpoint) content of a CoSWID tag document tostructure and differentiate the content of specific CoSWID tag types. Potentialcontent includes directories, files, processes, or resources.¶
The CDDL for the resource-collection group follows:¶
path-elements-group = ( ? directory => one-or-more<directory-entry>, ? file => one-or-more<file-entry>, )resource-collection = ( path-elements-group, ? process => one-or-more<process-entry>, ? resource => one-or-more<resource-entry>, * $$resource-collection-extension,)filesystem-item = ( ? key => bool, ? location => text, fs-name => text, ? root => text,)file-entry = { filesystem-item, ? size => uint, ? file-version => text, ? hash => hash-entry, * $$file-extension, global-attributes,}directory-entry = { filesystem-item, ? path-elements => { path-elements-group }, * $$directory-extension, global-attributes,}process-entry = { process-name => text, ? pid => integer, * $$process-extension, global-attributes,}resource-entry = { type => text, * $$resource-extension, global-attributes,}hash = 7directory = 16file = 17process = 18resource = 19size = 20file-version = 21key = 22location = 23fs-name = 24root = 25path-elements = 26process-name = 27pid = 28type = 29¶The following list describes each member of the groups and maps illustrated above.¶
The CDDL for the payload-entry map follows:¶
payload-entry = { resource-collection, * $$payload-extension, global-attributes,}¶The following list describes each child item of this group.¶
The CDDL for the evidence-entry map follows:¶
evidence-entry = { resource-collection, ? date => integer-time, ? device-id => text, ? location => text, * $$evidence-extension, global-attributes,}date = 35device-id = 36¶The following list describes each child item of this group.¶
In order to create a valid CoSWID document, the structure of the corresponding CBOR messageMUSTadhere to the following CDDL specification.¶
<CODE BEGINS> file "concise-swid-tag.cddl"concise-swid-tag = { tag-id => text / bstr .size 16, tag-version => integer, ? corpus => bool, ? patch => bool, ? supplemental => bool, software-name => text, ? software-version => text, ? version-scheme => $version-scheme, ? media => text, ? software-meta => one-or-more<software-meta-entry>, entity => one-or-more<entity-entry>, ? link => one-or-more<link-entry>, ? payload-or-evidence, * $$coswid-extension, global-attributes,}payload-or-evidence //= ( payload => payload-entry )payload-or-evidence //= ( evidence => evidence-entry )any-uri = urilabel = text / int$version-scheme /= multipartnumeric$version-scheme /= multipartnumeric-suffix$version-scheme /= alphanumeric$version-scheme /= decimal$version-scheme /= semver$version-scheme /= int / textany-attribute = ( label => one-or-more<text> / one-or-more<int>)one-or-more<T> = T / [ 2* T ]global-attributes = ( ? lang => text, * any-attribute,)hash-entry = [ hash-alg-id: int, hash-value: bytes,]entity-entry = { entity-name => text, ? reg-id => any-uri, role => one-or-more<$role>, ? thumbprint => hash-entry, * $$entity-extension, global-attributes,}$role /= tag-creator$role /= software-creator$role /= aggregator$role /= distributor$role /= licensor$role /= maintainer$role /= int / textlink-entry = { ? artifact => text, href => any-uri, ? media => text, ? ownership => $ownership, rel => $rel, ? media-type => text, ? use => $use, * $$link-extension, global-attributes,}$ownership /= shared$ownership /= private$ownership /= abandon$ownership /= int / text$rel /= ancestor$rel /= component$rel /= feature$rel /= installationmedia$rel /= packageinstaller$rel /= parent$rel /= patches$rel /= requires$rel /= see-also$rel /= supersedes$rel /= supplemental$rel /= -256..65536 / text$use /= optional$use /= required$use /= recommended$use /= int / textsoftware-meta-entry = { ? activation-status => text, ? channel-type => text, ? colloquial-version => text, ? description => text, ? edition => text, ? entitlement-data-required => bool, ? entitlement-key => text, ? generator => text / bstr .size 16, ? persistent-id => text, ? product => text, ? product-family => text, ? revision => text, ? summary => text, ? unspsc-code => text, ? unspsc-version => text, * $$software-meta-extension, global-attributes,}path-elements-group = ( ? directory => one-or-more<directory-entry>, ? file => one-or-more<file-entry>, )resource-collection = ( path-elements-group, ? process => one-or-more<process-entry>, ? resource => one-or-more<resource-entry>, * $$resource-collection-extension,)file-entry = { filesystem-item, ? size => uint, ? file-version => text, ? hash => hash-entry, * $$file-extension, global-attributes,}directory-entry = { filesystem-item, ? path-elements => { path-elements-group }, * $$directory-extension, global-attributes,}process-entry = { process-name => text, ? pid => integer, * $$process-extension, global-attributes,}resource-entry = { type => text, * $$resource-extension, global-attributes,}filesystem-item = ( ? key => bool, ? location => text, fs-name => text, ? root => text,)payload-entry = { resource-collection, * $$payload-extension, global-attributes,}evidence-entry = { resource-collection, ? date => integer-time, ? device-id => text, ? location => text, * $$evidence-extension, global-attributes,}integer-time = #6.1(int); "global map member" integer indicestag-id = 0software-name = 1entity = 2evidence = 3link = 4software-meta = 5payload = 6hash = 7corpus = 8patch = 9media = 10supplemental = 11tag-version = 12software-version = 13version-scheme = 14lang = 15directory = 16file = 17process = 18resource = 19size = 20file-version = 21key = 22location = 23fs-name = 24root = 25path-elements = 26process-name = 27pid = 28type = 29entity-name = 31reg-id = 32role = 33thumbprint = 34date = 35device-id = 36artifact = 37href = 38ownership = 39rel = 40media-type = 41use = 42activation-status = 43channel-type = 44colloquial-version = 45description = 46edition = 47entitlement-data-required = 48entitlement-key = 49generator = 50persistent-id = 51product = 52product-family = 53revision = 54summary = 55unspsc-code = 56unspsc-version = 57; "version-scheme" integer indicesmultipartnumeric = 1multipartnumeric-suffix = 2alphanumeric = 3decimal = 4semver = 16384; "role" integer indicestag-creator=1software-creator=2aggregator=3distributor=4licensor=5maintainer=6; "ownership" integer indicesabandon=1private=2shared=3; "rel" integer indicesancestor=1component=2feature=3installationmedia=4packageinstaller=5parent=6patches=7requires=8see-also=9supersedes=10; supplemental=11 ; already defined; "use" integer indicesoptional=1required=2recommended=3<CODE ENDS>¶The operational model for SWID and CoSWID tags was introduced inSection 1.1, which described four different CoSWID tag types. The following additional rules apply to the use of CoSWID tags to ensure that created tags properly identify the tag type.¶
The first matching ruleMUST determine the type of the CoSWID tag.¶
Note: It is possible for some or all of the corpus, patch, and supplemental items to simultaneously have values set as "true". The rules above provide a means to determine the tag's type in such a case. For example, a SWID or CoSWID tag for a patch installer might have both corpus and patch items set to "true". In such a case, the tag is a "corpus tag". The tag installed by this installer would have only the patch item set to "true", making the installed tag type a "patch tag".¶
This section defines multiple kinds of indexed label values that are maintained in several IANA registries. SeeSection 6 for details.These values are represented as positive integers. In each registry, the value 0 is marked as Reserved.¶
The following table contains a set of values for use in the concise-swid-tag group's version-scheme item. The "Index" value indicates the value to use as the version-scheme item's value. Strings in the "Version Scheme Name" column provide human-readable text for the value and match the version schemes defined in the ISO/IEC 19770-2:2015 specification[SWID]. The "Definition" column describes the syntax of allowed values for each entry.¶
| Index | Version Scheme Name | Definition |
|---|---|---|
| 1 | multipartnumeric | Numbers separated by dots, where the numbers are interpreted as decimal integers (e.g., 1.2.3, 1.2.3.4.5.6.7, 1.4.5, 1.21) |
| 2 | multipartnumeric+suffix | Numbers separated by dots, where the numbers are interpreted as decimal integers with an additional textual suffix (e.g., 1.2.3a) |
| 3 | alphanumeric | Strictly a string, no interpretation as number |
| 4 | decimal | A single decimal floating-point number |
| 16384 | semver | A semantic version as defined by[SWID]. Also see the[SEMVER] specification for more information |
"multipartnumeric" and the numbers part of "multipartnumeric+suffix" are interpreted as a sequence of numbers and are sorted in lexicographical order by these numbers (i.e., not by the digits in the numbers) and then the textual suffix (for "multipartnumeric+suffix"). "alphanumeric" strings are sorted lexicographically as character strings. "decimal" version numbers are interpreted as single floating-point numbers (e.g., 1.25 is less than 1.3).¶
The values above are registered in the IANA "Software ID Version Scheme Values" registry, defined inSection 6.2.4. Additional entries will likely be registered over time in this registry.¶
A CoSWID producer that is aware of the version scheme that has been used to select the version valueSHOULD include the optional version-scheme item to avoid semantic ambiguity.If the CoSWID producer does not have this information, itSHOULD omit the version-scheme item.The following heuristics can be used by a CoSWID consumer, based on the version schemes' partially overlapping value spaces:¶
Note that these heuristics are imperfect and can guess wrong, which is the reason the version-scheme itemSHOULD be included by the producer.¶
The following table indicates the index value to use for the entity-entry group's role item (seeSection 2.6). These values match the entity roles defined in the ISO/IEC 19770-2:2015 specification[SWID]. The "Index" value indicates the value to use as the role item's value. Items in the "Role Name" column provide human-readable text for the value. The "Definition" column describes the semantic meaning of each entry.¶
| Index | Role Name | Definition |
|---|---|---|
| 1 | tagCreator | The person or organization that created the containing SWID or CoSWID tag. |
| 2 | softwareCreator | The person or organization entity that created the software component. |
| 3 | aggregator | From[SWID], "An organization or system that encapsulates software from their own and/or other organizations into a different distribution process (as in the case of virtualization), or as a completed system to accomplish a specific task (as in the case of a value added reseller)." |
| 4 | distributor | From[SWID], "An entity that furthers the marketing, selling and/or distribution of software from the original place of manufacture to the ultimate user without modifying the software, its packaging or its labelling." |
| 5 | licensor | From[SAM], as a "software licensor", a "person or organization who owns or holds the rights to issue a software license for a specific software [component]." |
| 6 | maintainer | The person or organization that is responsible for coordinating and making updates to the source code for the software component. ThisSHOULD be used when the "maintainer" is a different person or organization than the original "softwareCreator". |
The values above are registered in the IANA "Software ID Entity Role Values" registry, defined inSection 6.2.5. Additional values will likely be registered over time.¶
The following table indicates the index value to use for the link-entry group's ownership item (seeSection 2.7). These values match the link ownership values defined in the ISO/IEC 19770-2:2015 specification[SWID]. The "Index" value indicates the value to use as the link-entry group ownership item's value. Items in the "Ownership Type" column provide human-readable text for the value. The "Definition" column describes the semantic meaning of each entry.¶
| Index | Ownership Type | Definition |
|---|---|---|
| 1 | abandon | If the software component referenced by the CoSWID tag is uninstalled, then the referenced softwareSHOULD NOT be uninstalled. |
| 2 | private | If the software component referenced by the CoSWID tag is uninstalled, then the referenced softwareSHOULD be uninstalled as well. |
| 3 | shared | If the software component referenced by the CoSWID tag is uninstalled, then the referenced softwareSHOULD be uninstalled if no other components are sharing the software. |
The values above are registered in the IANA "Software ID Link Ownership Values" registry, defined inSection 6.2.6. Additional values will likely be registered over time.¶
The following table indicates the index value to use for the link-entry group's rel item (seeSection 2.7). These values match the link rel values defined in the ISO/IEC 19770-2:2015 specification[SWID]. The "Index" value indicates the value to use as the link-entry group ownership item's value. Items in the "Relationship Type" column provide human-readable text for the value. The "Definition" column describes the semantic meaning of each entry.¶
| Index | Relationship Type | Definition |
|---|---|---|
| 1 | ancestor | The link references a software tag for a previous release of this software. This can be useful to define an upgrade path. |
| 2 | component | The link references a software tag for a separate component of this software. |
| 3 | feature | The link references a configurable feature of this software that can be enabled or disabled without changing the installed files. |
| 4 | installationmedia | The link references the installation package that can be used to install this software. |
| 5 | packageinstaller | The link references the installation software needed to install this software. |
| 6 | parent | The link references a software tag that is the parent of the referencing tag. This relationship can be used when multiple software components are part of a software bundle, where the "parent" is the software tag for the bundle and each child is a "component". In such a case, each child component can provide a "parent" link relationship to the bundle's software tag, and the bundle can provide a "component" link relationship to each child software component. |
| 7 | patches | The link references a software tag that the referencing software patches. Typically only used for patch tags (seeSection 1.1). |
| 8 | requires | The link references a prerequisite for installing this software. A patch tag (seeSection 1.1) can use this to represent base software or another patch that needs to be installed first. |
| 9 | see-also | The link references other software that may be of interest that relates to this software. |
| 10 | supersedes | The link references other software (e.g., an older software version) that this software replaces. A patch tag (seeSection 1.1) can use this to represent another patch that this patch incorporates or replaces. |
| 11 | supplemental | The link references a software tag that the referencing tag supplements. Used on supplemental tags (seeSection 1.1). |
The values above are registered in the IANA "Software ID Link Relationship Values" registry, defined inSection 6.2.7. Additional values will likely be registered over time.¶
The following table indicates the index value to use for the link-entry group's use item (seeSection 2.7). These values match the link use values defined in the ISO/IEC 19770-2:2015 specification[SWID]. The "Index" value indicates the value to use as the link-entry group use item's value. Items in the "Use Type" column provide human-readable text for the value. The "Definition" column describes the semantic meaning of each entry.¶
| Index | Use Type | Definition |
|---|---|---|
| 1 | optional | From[SWID], "Not absolutely required; the [Link]'d software is installed only when specified." |
| 2 | required | From[SWID], "The [Link]'d software is absolutely required for an operation software installation." |
| 3 | recommended | From[SWID], "Not absolutely required; the [Link]'d software is installed unless specified otherwise." |
The values above are registered in the IANA "Software ID Link Use Values" registry, defined inSection 6.2.8. Additional values will likely be registered over time.¶
This specification defines the following scheme names for use in CoSWID and to provide interoperability with scheme names used in[SWID].Because both the "swid" and "swidpath" scheme names are to be interpreted within a local (rather than a global) context, neither of these are technically URI scheme names as defined in[RFC3986].For this reason, the "swid" and "swidpath" scheme names are registered with IANA as provisional, rather than permanent, scheme names.However, registering these scheme names as provisional ensures that the scheme names are reserved and that they are properly defined going forward.¶
The swid and swidpath expressions conform to all rules for URI syntax.All uses of these expressions encountered within a CoSWID are to be interpreted as described in this section.¶
Expressions specifying the "swid" scheme are used to reference a software tag by its tag-id. A tag-id referenced in this way can be used to identify the tag resource in the context of where it is referenced from. For example, when a tag is installed on a given device, that tag can reference related tags on the same device using expressions with this scheme.¶
For expressions that use the "swid" scheme, the scheme-specific partMUST consist of a referenced software tag's tag-id. This tag-idMUST be URI encoded according toSection 2.1 of [RFC3986].¶
The following expression is a valid example:¶
swid:2df9de35-0aff-4a86-ace6-f7dddd1ade4c¶
Expressions specifying the "swidpath" scheme are used to filter tags out of a base collection, so that matching tags are included in the identified tag collection.The XPath expression[W3C.REC-xpath20-20101214] references the data that must be found in a given software tag out of the base collection for that tag to be considered a matching tag.Tags to be evaluated (the base collection) include all tags in the context of where the "swidpath" expression is referenced from.For example, when a tag is installed on a given device, that tag can reference related tags on the same device using an expression with this scheme.¶
For URIs that use the "swidpath" scheme, the following requirements apply:¶
This document has a number of IANA considerations, as described inthe following subsections. In summary, six new registries are established by this document, with initial entries provided for each registry. New values for five other registries are also defined.¶
This document defines a new registry titled"CoSWID Items". This registry uses integer values as index values in CBOR maps. Future registrations for this registry are to be made based on[BCP26] as follows:¶
| Range | Registration Procedures |
|---|---|
| 0-32767 | Standards Action with Expert Review |
| 32768-4294967295 | Specification Required |
All negative values are reserved for private use.¶
Initial registrations for the "CoSWID Items" registryare provided below. Assignments consist of an integer index value, the item name, and a reference to the defining specification.¶
| Index | Item Name | Reference |
|---|---|---|
| 0 | tag-id | RFC 9393 |
| 1 | software-name | RFC 9393 |
| 2 | entity | RFC 9393 |
| 3 | evidence | RFC 9393 |
| 4 | link | RFC 9393 |
| 5 | software-meta | RFC 9393 |
| 6 | payload | RFC 9393 |
| 7 | hash | RFC 9393 |
| 8 | corpus | RFC 9393 |
| 9 | patch | RFC 9393 |
| 10 | media | RFC 9393 |
| 11 | supplemental | RFC 9393 |
| 12 | tag-version | RFC 9393 |
| 13 | software-version | RFC 9393 |
| 14 | version-scheme | RFC 9393 |
| 15 | lang | RFC 9393 |
| 16 | directory | RFC 9393 |
| 17 | file | RFC 9393 |
| 18 | process | RFC 9393 |
| 19 | resource | RFC 9393 |
| 20 | size | RFC 9393 |
| 21 | file-version | RFC 9393 |
| 22 | key | RFC 9393 |
| 23 | location | RFC 9393 |
| 24 | fs-name | RFC 9393 |
| 25 | root | RFC 9393 |
| 26 | path-elements | RFC 9393 |
| 27 | process-name | RFC 9393 |
| 28 | pid | RFC 9393 |
| 29 | type | RFC 9393 |
| 30 | Unassigned | |
| 31 | entity-name | RFC 9393 |
| 32 | reg-id | RFC 9393 |
| 33 | role | RFC 9393 |
| 34 | thumbprint | RFC 9393 |
| 35 | date | RFC 9393 |
| 36 | device-id | RFC 9393 |
| 37 | artifact | RFC 9393 |
| 38 | href | RFC 9393 |
| 39 | ownership | RFC 9393 |
| 40 | rel | RFC 9393 |
| 41 | media-type | RFC 9393 |
| 42 | use | RFC 9393 |
| 43 | activation-status | RFC 9393 |
| 44 | channel-type | RFC 9393 |
| 45 | colloquial-version | RFC 9393 |
| 46 | description | RFC 9393 |
| 47 | edition | RFC 9393 |
| 48 | entitlement-data-required | RFC 9393 |
| 49 | entitlement-key | RFC 9393 |
| 50 | generator | RFC 9393 |
| 51 | persistent-id | RFC 9393 |
| 52 | product | RFC 9393 |
| 53 | product-family | RFC 9393 |
| 54 | revision | RFC 9393 |
| 55 | summary | RFC 9393 |
| 56 | unspsc-code | RFC 9393 |
| 57 | unspsc-version | RFC 9393 |
| 58-4294967295 | Unassigned |
The following IANA registries provide a mechanism for new values to be added over time to common enumerations used by SWID and CoSWID. While neither the CoSWID specification nor the SWID specification is subordinate to the other and will evolve as their respective standards group chooses, there is value in supporting alignment between the two standards. Shared use of common code points, as spelled out in these registries, will facilitate this alignment -- hence the intent for shared use of these registries and the decision to use "swidsoftware-id" (rather than "swid" or "coswid") in registry names.¶
The following registries allow for the registration of index values and names. New registrations will be permitted through either a Standards Action with Expert Review policy or a Specification Required policy[BCP26].¶
The following registries also reserve the integer-based index values in the range of -1 to -256 for private use as defined bySection 4.1 of [BCP26]. This allows values -1 to -24 to be expressed as a single uint8_t in CBOR and values -25 to -256 to be expressed using an additional uint8_t in CBOR.¶
The integer-based index values in the private use range (-1 to -256) are intended for testing purposes and closed environments; values in other rangesSHOULD NOT be assigned for testing.¶
For names that correspond to private use index values, an Internationalized Domain Name prefixMUST be used to prevent name conflicts using the form¶
domainprefix/name¶
where both "domainprefix" and "name"MUST each be either a Non-Reserved LDH (NR-LDH) label or a U-label as defined by[RFC5890], and "name" alsoMUST be a unique name within the namespace defined by the "domainprefix". ("LDH" is an abbreviation for "letters, digits, hyphen".) Using a prefix in this way allows for a name to be used in the private use range. This is consistent with the guidance in[BCP178].¶
Designated expertsMUST ensure that new registration requests meet the following additional criteria:¶
This document establishes a new registry titled"Software ID Version Scheme Values". This registry provides index values for use as version-scheme item values in this document and Version Scheme Names for use in[SWID].¶
This registry uses the registration procedures defined inSection 6.2.1, with the following associated ranges:¶
| Range | Registration Procedures |
|---|---|
| 0-16383 | Standards Action with Expert Review |
| 16384-65535 | Specification Required |
AssignmentsMUST consist of an integer index value, the Version Scheme Name, and a reference to the defining specification.¶
Initial registrations for the "Software ID Version Scheme Values" registryare provided below and are derived from the textual Version Scheme Namesdefined in[SWID].¶
| Index | Version Scheme Name | Reference |
|---|---|---|
| 0 | Reserved | |
| 1 | multipartnumeric | RFC 9393,Section 4.1 |
| 2 | multipartnumeric+suffix | RFC 9393,Section 4.1 |
| 3 | alphanumeric | RFC 9393,Section 4.1 |
| 4 | decimal | RFC 9393,Section 4.1 |
| 5-16383 | Unassigned | |
| 16384 | semver | RFC 9393,Section 4.1 |
| 16385-65535 | Unassigned |
RegistrationsMUST conform to the expert review criteria defined inSection 6.2.3.¶
Designated expertsMUST also ensure that newly requested entries define a value space for the corresponding software-version item that is unique from other previously registered entries.¶
Note: The initial registrations violate this requirement but are included for backwards compatibility with[SWID]. See alsoSection 4.1.¶
This document establishes a new registry titled"Software ID Entity Role Values". This registry provides index values for use as entity-entry role item values in this document and entity role names for use in[SWID].¶
This registry uses the registration procedures defined inSection 6.2.1, with the following associated ranges:¶
| Range | Registration Procedures |
|---|---|
| 0-127 | Standards Action with Expert Review |
| 128-255 | Specification Required |
Assignments consist of an integer index value, a role name, and a reference to the defining specification.¶
Initial registrations for the "Software ID Entity Role Values" registryare provided below and are derived from the textual entity role namesdefined in[SWID].¶
| Index | Role Name | Reference |
|---|---|---|
| 0 | Reserved | |
| 1 | tagCreator | RFC 9393,Section 4.2 |
| 2 | softwareCreator | RFC 9393,Section 4.2 |
| 3 | aggregator | RFC 9393,Section 4.2 |
| 4 | distributor | RFC 9393,Section 4.2 |
| 5 | licensor | RFC 9393,Section 4.2 |
| 6 | maintainer | RFC 9393,Section 4.2 |
| 7-255 | Unassigned |
RegistrationsMUST conform to the expert review criteria defined inSection 6.2.3.¶
This document establishes a new registry titled"Software ID Link Ownership Values". This registry provides index values for use as link-entry ownership item values in this document and link ownership names for use in[SWID].¶
This registry uses the registration procedures defined inSection 6.2.1, with the following associated ranges:¶
| Range | Registration Procedures |
|---|---|
| 0-127 | Standards Action with Expert Review |
| 128-255 | Specification Required |
Assignments consist of an integer index value, an ownership type name, and a reference to the defining specification.¶
Initial registrations for the "Software ID Link Ownership Values" registryare provided below and are derived from the textual entity role namesdefined in[SWID].¶
| Index | Ownership Type Name | Reference |
|---|---|---|
| 0 | Reserved | |
| 1 | abandon | RFC 9393,Section 4.3 |
| 2 | private | RFC 9393,Section 4.3 |
| 3 | shared | RFC 9393,Section 4.3 |
| 4-255 | Unassigned |
RegistrationsMUST conform to the expert review criteria defined inSection 6.2.3.¶
This document establishes a new registry titled"Software ID Link Relationship Values". This registry provides index values for use as link-entry rel item values in this document and link ownership names for use in[SWID].¶
This registry uses the registration procedures defined inSection 6.2.1, with the following associated ranges:¶
| Range | Registration Procedures |
|---|---|
| 0-32767 | Standards Action with Expert Review |
| 32768-65535 | Specification Required |
Assignments consist of an integer index value, the relationship type name, and a reference to the defining specification.¶
Initial registrations for the "Software ID Link Relationship Values" registry are provided below and are derived from the link relationship valuesdefined in[SWID].¶
| Index | Relationship Type Name | Reference |
|---|---|---|
| 0 | Reserved | |
| 1 | ancestor | RFC 9393,Section 4.4 |
| 2 | component | RFC 9393,Section 4.4 |
| 3 | feature | RFC 9393,Section 4.4 |
| 4 | installationmedia | RFC 9393,Section 4.4 |
| 5 | packageinstaller | RFC 9393,Section 4.4 |
| 6 | parent | RFC 9393,Section 4.4 |
| 7 | patches | RFC 9393,Section 4.4 |
| 8 | requires | RFC 9393,Section 4.4 |
| 9 | see-also | RFC 9393,Section 4.4 |
| 10 | supersedes | RFC 9393,Section 4.4 |
| 11 | supplemental | RFC 9393,Section 4.4 |
| 12-65535 | Unassigned |
RegistrationsMUST conform to the expert review criteria defined inSection 6.2.3.¶
Designated expertsMUST also ensure that a newly requested entry documents the URI schemes allowed to be used in an href associated with the link relationship and the expected resolution behavior of these URI schemes. This will help to ensure that applications processing software tags are able to interoperate when resolving resources referenced by a link of a given type.¶
This document establishes a new registry titled"Software ID Link Use Values". This registry provides index values for use as link-entry use item values in this document and link use names for use in[SWID].¶
This registry uses the registration procedures defined inSection 6.2.1, with the following associated ranges:¶
| Range | Registration Procedures |
|---|---|
| 0-127 | Standards Action with Expert Review |
| 128-255 | Specification Required |
Assignments consist of an integer index value, the link use type name, and a reference to the defining specification.¶
Initial registrations for the "Software ID Link Use Values" registryare provided below and are derived from the link relationship valuesdefined in[SWID].¶
| Index | Link Use Type Name | Reference |
|---|---|---|
| 0 | Reserved | |
| 1 | optional | RFC 9393,Section 4.5 |
| 2 | required | RFC 9393,Section 4.5 |
| 3 | recommended | RFC 9393,Section 4.5 |
| 4-255 | Unassigned |
RegistrationsMUST conform to the expert review criteria defined inSection 6.2.3.¶
IANA has added the following to the "Media Types" registry[IANA.media-types].¶
IANA has assigned a CoAP Content-Format ID for the CoSWIDmedia type in the "CoAP Content-Formats" subregistry, from the "IETFReview or IESG Approval" space (256..999), within the "CoREParameters" registry[RFC7252][IANA.core-parameters]:¶
| Content Type | Content Coding | ID | Reference |
|---|---|---|---|
| application/swid+cbor | - | 258 | RFC 9393 |
IANA has allocated a tag in the "CBOR Tags" registry[IANA.cbor-tags]:¶
| Tag | Data Item | Semantics | Reference |
|---|---|---|---|
| 1398229316 | map | Concise Software Identifier (CoSWID) | RFC 9393 |
The ISO 19770-2:2015 SWID specification[SWID] describes the use of the "swid" and "swidpath" URI schemes, which are currently in use in implementations. This document continues this use for CoSWID. The following subsections provide registrations for these schemes to ensure that a registration for these schemes exists that is suitable for use in the SWID and CoSWID specifications.¶
URI schemes are registered within the "Uniform Resource Identifier (URI)Schemes" registry maintained at[IANA.uri-schemes].¶
IANA has registered the URI scheme "swid".This registration complies with[RFC7595].¶
Note: This scheme has been documented by an IETF working group and is mentioned in an IETF Standard specification. However, as it describes a locally scoped, limited-purpose form of identification, it does not fully meet the requirements for permanent registration.¶
As long as this specification (or any successors that describe this scheme) is a current IETF specification, this scheme should be considered to be "in use" and not considered for removal from the registry.¶
IANA has registered the URI scheme "swidpath". This registrationcomplies with[RFC7595].¶
Note: This scheme has been documented by an IETF working group and is mentioned in an IETF Standard specification. However, as it describes a locally scoped, limited-purpose form of identification, it does not fully meet the requirements for permanent registration.¶
As long as this specification (or any successors that describe this scheme) is a current IETF specification, this scheme should be considered to be "in use" and not considered for removal from the registry.¶
"Software Inventory Message and Attributes (SWIMA) for PA-TNC"[RFC8412] defines a standardized method for collecting an endpoint device's software inventory. A CoSWID can provide evidence of software installation that can then be used and exchanged with SWIMA. This registration adds a new entry to the IANA "Software Data Model Types" registry defined by[RFC8412] and[IANA.pa-tnc-parameters] to support CoSWID use in SWIMA as follows:¶
A Software Identifier generated from a CoSWID tag is expressed as a concatenation of the form used in[RFC5234] as follows --¶
TAG_CREATOR_REGID "_" "_" UNIQUE_ID¶
where TAG_CREATOR_REGID is the reg-id item value of the tag's entity item having the role value of 1 (corresponding to "tag-creator"), and the UNIQUE_ID is the same tag's tag-id item. If the tag-id item's value is expressed as a 16-byte binary string, the UNIQUE_IDMUST be represented using the UUID string representation defined in[RFC4122], including the "urn:uuid:" prefix.¶
The TAG_CREATOR_REGID and the UNIQUE_ID are connected with a double underscore (_), without any other connecting character or whitespace.¶
SWID tags, as defined in the ISO-19770-2:2015 XML Schema, can include cryptographic signatures to protect the integrity of the SWID tag.In general, tags are signed by the tag creator (typically, although not exclusively, the vendor of the software component that the SWID tag identifies).Cryptographic signatures can make any modification of the tag detectable, which is especially important if the integrity of the tag is important, such as when the tag is providing RIMs for files.The ISO-19770-2:2015 XML Schema uses XML Digital Signatures (XMLDSIG) to support cryptographic signatures.¶
Signing CoSWID tags follows the procedures defined in CBOR Object Signing and Encryption (COSE)[RFC9052]. A CoSWID tagMUST be wrapped in a COSE Signature structure, either COSE_Sign1 or COSE_Sign.In the first case, a Single Signer Data Object (COSE_Sign1) contains a single signature andMUST be signed by the tag creator. The following CDDL specification defines a restrictive subset of COSE header parameters thatMUST be used in the protected header in this case.¶
<CODE BEGINS> file "sign1.cddl"COSE_Sign1-coswid<payload> = [ protected: bstr .cbor protected-signed-coswid-header, unprotected: unprotected-signed-coswid-header, payload: bstr .cbor payload, signature: bstr,]cose-label = int / tstrcose-values = anyprotected-signed-coswid-header = { 1 => int, ; algorithm identifier 3 => "application/swid+cbor", * cose-label => cose-values,}unprotected-signed-coswid-header = { * cose-label => cose-values,}<CODE ENDS>¶The COSE_Sign structure allows for more than one signature, one of whichMUST be issued by the tag creator, to be applied to a CoSWID tag andMAY be used. The corresponding usage scenarios are domain specific and require well-specified application guidance.¶
<CODE BEGINS> file "sign.cddl"COSE_Sign-coswid<payload> = [ protected: bstr .cbor protected-signed-coswid-header1, unprotected: unprotected-signed-coswid-header, payload: bstr .cbor payload, signature: [ * COSE_Signature ],]protected-signed-coswid-header1 = { 3 => "application/swid+cbor", * cose-label => cose-values,}protected-signature-coswid-header = { 1 => int, ; algorithm identifier * cose-label => cose-values,}unprotected-signed-coswid-header = { * cose-label => cose-values,}COSE_Signature = [ protected: bstr .cbor protected-signature-coswid-header, unprotected: unprotected-signed-coswid-header, signature: bstr]<CODE ENDS>¶Additionally, the COSE header countersignatureMAY be used as an attribute in the unprotected header map of the COSE envelope of a CoSWID[RFC9338].The application of countersigning enables second parties to provide a signature on a signature allowing for proof that a signature existed at a given time (i.e., a timestamp).¶
A CoSWIDMUST be signed, using the above mechanism, to protect the integrity of the CoSWID tag. SeeSection 9 ("Security Considerations") for more information on why a signed CoSWID is valuable in most cases.¶
This specification allows for tagged and untagged CBOR data items that are CoSWID tags.Consequently, the CBOR tag defined by this document (Table 21) for CoSWID tagsSHOULD be used in conjunction with CBOR data items that are CoSWID tags.Other CBOR tagsMUST NOT be used with a CBOR data item that is a CoSWID tag.If tagged, both signed and unsigned CoSWID tagsMUST use the CoSWID CBOR tag.If a signed CoSWID is tagged, a CoSWID CBOR tagMUST be appended before the COSE envelope, whether it is a COSE_Untagged_Message or a COSE_Tagged_Message.If an unsigned CoSWID is tagged, a CoSWID CBOR tagMUST be appended before the CBOR data item that is the CoSWID tag.¶
<CODE BEGINS> file "tags.cddl"coswid = unsigned-coswid / signed-coswidunsigned-coswid = concise-swid-tag / tagged-coswid<concise-swid-tag>signed-coswid1 = signed-coswid-for<unsigned-coswid>signed-coswid = signed-coswid1 / tagged-coswid<signed-coswid1>tagged-coswid<T> = #6.1398229316(T)signed-coswid-for<payload> = #6.18(COSE_Sign1-coswid<payload>) / #6.98(COSE_Sign-coswid<payload>)<CODE ENDS>¶
This specification allows for a CBOR-tagged CoSWID tag to reside in a COSE envelope that is also tagged with a CoSWID CBOR tag. In cases where a tag creator is not a signer (e.g., hand-offs between entities in a trusted portion of a supply chain), retaining CBOR tags attached to unsigned CoSWID tags can be of great use. Nevertheless, redundant use of tagsSHOULD be avoided when possible.¶
The following security considerations for the use of CoSWID tags focus on:¶
A tag is considered "authoritative" if the CoSWID tag was created by thesoftware provider. An authoritative CoSWID tag contains information about a software component provided by the supplier of the software component, who is expected to be an expert in their own software. Thus, authoritative CoSWID tags can represent authoritative information about the software component. The degree to which this information can be trusted depends on the tag's chain of custody and the ability to verify a signature provided by the supplier if present in the CoSWID tag. The provisioning and validation of CoSWID tags are handled by local policy and are outside the scope of this document.¶
A signed CoSWID tag (seeSection 7) whose signature has been validated can be relied upon to be unchanged since the time at which it was signed. By contrast, the data contained in unsigned tags can be altered by any user or process with write access to the tag. To support signature validation, there is a need to associate the right key with the software provider or party originating the signature in a secure way. This operation is application specific and needs to be addressed by the application or a user of the application; a specific approach for this topic is out of scope for this document.¶
When an authoritative tag is signed, the originator of the signature can be verified. A trustworthy association between the signature and the originator of the signature can be established via trust anchors. A certification path between a trust anchor and a certificate, including a public key enabling the validation of a tag signature, can realize the assessment of trustworthiness of an authoritative tag. Verifying that the software provider is the signer is a different matter. This requires verifying that the party that signed the tag is the same party given in the software-creator role of the tag's entity item. No mechanism is defined in this document to make this association; therefore, this association will need to be handled by local policy.As always, the validity of a signature does not imply the veracity of thesigned statements: anyone can sign assertions such that the softwareis from a specific software-creator or that a specific persistent-idapplies; policy needs to be applied to evaluate these statements and to determine their suitability for a specific use.¶
Loss of control of signing credentials used to sign CoSWID tags would cast doubt on the authenticity and integrity of any CoSWID tags signed using the compromised keys. In such cases, the legitimate tag signer (namely, the software provider for an authoritative CoSWID tag) can employ uncompromised signing credentials to create a new signature on the original tag. The tag's version number would not be incremented, since the tag itself was not modified. Consumers of CoSWID tags would need to validate the tag using the new credentials and would also need to make use of revocation information available for the compromised credentials to avoid validating tags signed with them. The process for doing this is beyond the scope of this specification.¶
The CoSWID format allows the use of hash values without anaccompanying hash algorithm identifier.This exposes the tags to some risk of cross-algorithm attacks.We believe that this can become a practical problem only if someimplementations allow the use of insecure hash algorithms.Since it may not become known immediately when an algorithm becomesinsecure, this leads to a strong recommendation to only includesupport for hash algorithms that are generally considered secure, andnot just marginally so.¶
CoSWID tags are intended to contain public information about software components and, assuch, the contents of a CoSWID tag (as opposed to the set of tags that apply to the endpoint; see below) do not need to be protected against unintended disclosure on an endpoint.Conversely, generators of CoSWID tags need to ensure that only publicinformation is disclosed.The entitlement-key item is an example of information for which particular careis required; tag authors are advised not to record unprotected,private software license keys in this field.¶
CoSWID tags are intended to be easily discoverable byauthorized applications and users on an endpoint in order to make it easy to determine the tagged software load. Access to the collection of an endpoint's CoSWID tags needs to be limited to authorized applications and users using an appropriate access control mechanism.¶
Since the tag-id of a CoSWID tag can be used as a global index value, failure to ensure the tag-id's uniqueness can cause collisions or ambiguity in CoSWID tags that are retrieved or processed using this identifier. CoSWID is designed to not require a registry of identifiers. As a result, CoSWID requires the tag creator to employ a method of generating a unique tag identifier. Specific methods of generating a unique identifier are beyond the scope of this specification. A collision in tag-ids may result in false positives/negatives in software integrity checks or misidentification of installed software, undermining CoSWID use cases such as vulnerability identification, software inventory, etc. If such a collision is detected, then the tag consumer may want to contact the maintainer of the CoSWID to have them issue a correction addressing the collision; however, this also discloses to the maintainer that the consumer has the other tag with the given tag-id in their database.More generally speaking, a tag consumer needs to be robust against such collisions lest the collision become a viable attack vector.¶
CoSWID tags are designed to be easily added and removed from anendpoint along with the installation or removal of software components.On endpoints where the addition or removal of software components istightly controlled, the addition or removal of CoSWID tags can besimilarly controlled. On more open systems, where many users canmanage the software inventory, CoSWID tags can be easier to add orremove. On such systems, it can be possible to add or remove CoSWIDtags in a way that does not reflect the actual presence or absence ofcorresponding software components. Similarly, not all softwareproducts automatically install CoSWID tags, so products can be presenton an endpoint without providing a corresponding CoSWID tag. As such,any collection of CoSWID tags cannot automatically be assumed torepresent either a complete or fully accurate representation of thesoftware inventory of the endpoint. However, especially on endpoint devicesthat more strictly control the ability to add or remove applications,CoSWID tags are an easy way to provide a preliminary understanding ofthat endpoint's software inventory.¶
As CoSWID tags do not expire, inhibiting new CoSWID tags from reaching an intended consumer would render that consumer stuck with outdated information, potentially leaving associated vulnerabilities or weaknesses unmitigated. Therefore, a CoSWID tag consumer should actively check for updated tag-versions via more than one means.¶
This specification makes use of relative paths (e.g., filesystempaths) in several places.A signed CoSWID tag cannot make use of these to derive informationthat is considered to be covered under the signature.Typically, relative filesystem paths will be used to identifytargets for an installation, not sources of tag information.¶
Any report of an endpoint's CoSWID tag collection providesinformation about the software inventory of that endpoint. If such areport is exposed to an attacker, this can tell them which softwareproducts and versions thereof are present on the endpoint. Byexamining this list, the attacker might learn of the presence ofapplications that are vulnerable to certain types of attacks. Asnoted earlier, CoSWID tags are designed to be easily discoverable by authorized applications and users on anendpoint, but this does not present a significant risk, since anattacker would already need to have access to the endpoint to viewthat information. However, when the endpoint transmits its softwareinventory to another party or that inventory is stored on a serverfor later analysis, this can potentially expose this information toattackers who do not yet have access to the endpoint. For this reason, it isimportant to protect the confidentiality of CoSWID tag information thathas been collected from an endpoint in transit and at rest, not because those tagsindividually contain sensitive information but because thecollection of CoSWID tags and their association with an endpointreveals information about that endpoint's attack surface.¶
Finally, both the ISO-19770-2:2015 XML Schema SWID definition and theCoSWID CDDL specification allow for the construction of "infinite"tags with link item loops or tags that contain malicious content with the intentof creating non-deterministic states during validation or processing of those tags. While softwareproviders are unlikely to do this, CoSWID tags can be created by any party and the CoSWID tagscollected from an endpoint could contain a mixture of tags created by vendors and tags not created by vendors. For thisreason, a CoSWID tag might contain potentially maliciouscontent. Input sanitization, loop detection, and signatureverification are ways that implementations can address this concern.¶
More generally speaking, the Security Considerations sections of[RFC8949],[RFC9052], and[RFC9338] apply.¶
As noted inSection 9, collected information about an endpoint's software load, such as what might be represented by an endpoint's CoSWID tag collection, could be used by attackers to identify vulnerable software. Collections of endpoint software information also can have privacy implications for users. The set of applications a user installs can provide clues regarding personal matters such as political affiliation, banking and investments, gender, sexual orientation, medical concerns, etc. While the collection of CoSWID tags on an endpoint wouldn't increase privacy risks (since a party able to view those tags could also view the applications themselves), if those CoSWID tags are gathered and stored in a repository somewhere, visibility into the repository now also provides visibility into a user's application collection. For this reason, not only do repositories of collected CoSWID tags need to be protected against collection by malicious parties but even authorized parties will need to be vetted and made aware of privacy responsibilities associated with having access to this information. Likewise, users should be made aware that their software inventories are being collected from endpoints. Furthermore, when collected and stored by authorized parties or systems, the inventory data needs to be protected as both security and privacy-sensitive information.¶
This document draws heavily on the concepts defined in the ISO/IEC 19770-2:2015 specification. The authors of this document are grateful for the prior work of the 19770-2 contributors.¶
We are also grateful for the careful reviews provided by the IESGreviewers. Special thanks go toBenjamin Kaduk.¶
Carsten Bormann contributed to the CDDL specifications and the IANA considerations.¶