]> Siemens AG

Otto-Hahn-Ring 6 Munich 81739 Germany steffen.fries@siemens.com https://www.siemens.com/

Siemens AG

Otto-Hahn-Ring 6 Munich 81739 Germany thomas-werner@siemens.com https://www.siemens.com/

Cisco Systems

Richtistrasse 7 Wallisellen CH-8304 Switzerland +41 44 878 9200 lear@cisco.com

Sandelman Software Works

mcr+ietf@sandelman.ca http://www.sandelman.ca/

Operations and Management ANIMA WG This document defines enhancements to Bootstrapping a Remote Secure Key Infrastructure (BRSKI, RFC8995) to enable bootstrapping in domains featuring no or only limited connectivity between a pledge and the domain registrar. It specifically changes the interaction model from a pledge-initiated mode, as used in BRSKI, to a pledge-responding mode, where the pledge is in server role. For this, BRSKI with Pledge in Responder Mode (BRSKI-PRM) introduces a new component, the Registrar-Agent, which facilitates the communication between pledge and registrar during the bootstrapping phase. To establish the trust relation between pledge and registrar, BRSKI-PRM relies on object security rather than transport security. The approach defined here is agnostic to the enrollment protocol that connects the domain registrar to the domain CA. Status information for this document may be found at . Source for this draft and an issue tracker can be found at .

Introduction BRSKI as defined in specifies a solution for secure zero-touch (automated) bootstrapping of devices (pledges) in a customer domain, which may be associated to a specific installation location. This includes the discovery of the BRSKI registrar in the customer domain and the exchange of security information necessary to establish trust between a pledge and the domain. Security information about the customer domain, specifically the customer domain certificate, are exchanged and authenticated utilizing voucher-request and voucher-response artifacts as defined in . Vouchers are signed objects from the Manufacturer Authorized Signing Authority (MASA). The MASA issues the voucher and provides it via the domain registrar to the pledge. specifies the format of the voucher artifacts including the voucher-request. For the certificate enrollment of devices, BRSKI relies on EST to request and distribute customer domain specific device certificates. EST in turn relies for the authentication and authorization of the certification request on the credentials used by the underlying TLS between the EST client and the EST server. BRSKI addresses scenarios in which the pledge initiates the bootstrapping acting as client (referred to as initiator mode by this document). BRSKI with Pledge in Responder Mode (BRSKI-PRM) defined in this document allows the pledge to act as server, so that it can be triggered externally and at a specific time to generate bootstrapping requests in the customer domain. For this approach, this document: introduces the Registrar-Agent as new component to facilitate the communication between the pledge and the domain registrar. The Registrar-Agent may be implemented as an integrated functionality of a commissioning tool or be co-located with the domain registrar itself. BRSKI-PRM supports the identification of the Registrar-Agent that was performing the bootstrapping allowing for accountability of the pledges installation, when the Registrar-Agent is a component used by an installer and not co-located with the domain registrar. specifies the interaction (data exchange and data objects) between a pledge acting as server, the Registrar-Agent acting as client, and the domain registrar. enables the usage of arbitrary transports between the pledge and the domain registrar via the Registrar-Agent; security is addressed at the application layer, and both IP-based and non-IP connectivity can be used between pledge and Registrar-Agent. allows the application of Registrar-Agent credentials to establish TLS connections to the domain registrar; these are different from the IDevID of the pledge. The term endpoint used in the context of this document is equivalent to resource in HTTP and CoAP ; it is not used to describe a device. Endpoints are accessible via Well-Known URIs . For the interaction with the domain registrar, the Registrar-Agent will use existing BRSKI endpoints as well as additional endpoints defined in this document. To utilize the EST server endpoints on the domain registrar, the Registrar-Agent will act as client toward the registrar. The Registrar-Agent also acts as a client when communicating with a pledge that is in responder mode. Here, TLS with server-side, certificate-based authentication is only optionally supported. If TLS is optionally used between the Registrar-Agent and the pledge, the Registrar-Agent needs to identify the pledge based on its product-serial-number rather than the hostname, as the latter is not set in an IDevID certificate. BRSKI-PRM is designed to rely on object security to support also for alternative transports for which TLS may not be available, e.g., Bluetooth or NFC. This is achieved through an additional signature wrapping of the exchanged data objects involving the Registrar-Agent for transport. To utilize EST for enrollment, the domain registrar performs pre-processing of the wrapping signature before actually using EST as defined in . There may be pledges that can support both modes, initiator and responder mode. In these cases BRSKI-PRM can be combined with BRSKI as defined in or BRSKI-AE to allow for more bootstrapping flexibility.

Terminology The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 when, and only when, they appear in all capitals, as shown here. This document relies on the terminology defined in . The following terms are defined in addition:

authenticated self-contained object:

Describes an object, which is cryptographically bound to the end entity (EE) certificate. The binding is assumed to be provided through a digital signature of the actual object using the corresponding private key of the certificate.

CA:

Certification Authority, issues certificates.

Commissioning tool:

Tool to interact with devices to provide configuration data.

CSR:

Certificate Signing Request.

EE:

End entity, as defined in . Typically a device or service that owns a public-private key pair for which it manages a public key certificate.

EE certificate:

Either IDevID certificate or LDevID certificate of the EE.

endpoint:

Term equivalent to resource in HTTP and CoAP . Endpoints are accessible via Well-Known URIs .

mTLS:

mutual Transport Layer Security.

PER:

Pledge Enroll-Request is a signature wrapped CSR, signed by the pledge that requests enrollment to a domain.

POI:

Proof-of-Identity, as defined in .

POP:

Proof-of-Possession (of a private key), as defined in .

PVR:

Pledge Voucher-Request is a request for a voucher sent to the domain registrar. The PVR is signed by the Pledge.

RA:

Registration Authority, an optional system component to which a CA delegates certificate management functions such as authorization checks. In BRSKI-PRM this is a functionality of the domain registrar, as in BRSKI .

RER:

Registrar Enroll-Request is the CSR of a PER sent to the CA by the domain registrar (in its role as PKI RA).

RVR:

Registrar Voucher-Request is a request for a voucher signed by the domain registrar to the MASA. It may contain the PVR received from the pledge.

This document uses the following encoding notations in the given JWS-signed artifact examples:

BASE64URL(OCTETS):

Denotes the base64url encoding of OCTETS, per .

UTF8(STRING):

Denotes the octets of the UTF-8 representation of STRING, per .

This document includes many examples that would contain many long sequences of base64-encoded objects with no content directly comprehensible to a human reader. In order to keep those examples short, they use the token "base64encodedvalue==" as a placeholder for base64 data. The full base64 data is included in the appendices of this document.

Scope of Solution

Supported Environments and Use Case Examples BRSKI-PRM is applicable to scenarios where pledges may have no direct connection to the domain registrar, may have no continuous connection, or require coordination of the pledge requests to be provided to a domain registrar. This can be motivated by pledges deployed in environments not yet connected to the operational customer domain network, e.g., at a building construction site, or environments intentionally disconnected from the Internet, e.g., critical industrial facilities. Another example is the assembly of electrical cabinets, which are prepared in advance before the installation at a customer domain.

Building Automation In building automation a typical use case exists where a detached building or the basement is equipped with sensors, actuators, and controllers, but with only limited or no connection to the central building management system. This limited connectivity may exist during installation time or also during operation time. During the installation, for instance, a service technician collects the device-specific information from the basement network and provides them to the central building management system. This could be done using a laptop, common mobile device, or dedicated commissioning tool to transport the information. The service technician may successively collect device-specific information in different parts of the building before connecting to the domain registrar for bulk bootstrapping. A domain registrar may be part of the central building management system and already be operational in the installation network. The central building management system can then provide operational parameters for the specific devices in the basement or other detached areas. These operational parameters may comprise values and settings required in the operational phase of the sensors/actuators, among them a certificate issued by the operator to authenticate against other components and services. These operational parameters are then provided to the devices in the basement facilitated by the service technician's laptop. The Registrar-Agent, defined in this document, may be run on the technician's laptop to interact with pledges.

Infrastructure Isolation Policy This refers to any case in which the network infrastructure is normally isolated from the Internet as a matter of policy, most likely for security reasons. In such a case, limited access to a domain registrar may be allowed in carefully controlled short periods of time, for example when a batch of new devices are deployed, but prohibited at other times.

Less Operational Security in the Target-Domain The registration authority (RA) performing the authorization of a certificate request is a critical PKI component and therefore requires higher operational security than other components utilizing the issued certificates. CAs may also require higher security in the registration procedures. There may be situations in which the customer domain does not offer enough physical security to operate a RA/CA and therefore this service is transferred to a backend that offers a higher level of operational security.

Limitations The mechanism described in this document presumes the ability of the pledge and the Registrar-Agent to communicate with another. This may not be possible in constrained environments where, in particular, power must be conserved. In these situations, it is anticipated that the transceiver will be powered down most of the time. This presents a rendezvous problem: the pledge is unavailable for certain periods of time, and the Registrar-Agent is similarly presumed to be unavailable for certain periods of time. To overcome this situation, the pledges may need to be powered on, either manually or by sending a trigger signal.

Requirements Discussion and Mapping to Solution-Elements Based on the intended target environment described in , the following requirements are derived to support bootstrapping of pledges in responder mode (acting as server): To facilitate the communication between a pledge in responder mode and the registrar, additional functionality is needed either on the registrar or as a stand-alone component. This new functionality is defined as Registrar-Agent and acts as an agent of the registrar to trigger the pledge to generate requests for voucher and enrollment. These requests are then provided by the Registrar-Agent to the registrar. This requires the definition of pledge endpoints to allow interaction with the Registrar-Agent. The security of communication between the Registrar-Agent and the pledge must not rely on Transport Layer Security (TLS) to enable application of BRSKI-PRM in environments, in which the communication between the Registrar-Agent and the pledge is done over other technologies like BTLE or NFC, which may not support TLS protected communication. In addition, the pledge does not have a certificate that can easily be verified by methods. The use of authenticated self-contained objects addresses both, the TLS challenges and the technology stack challenge. By contrast, the Registrar-Agent can be authenticated by the registrar as a component, acting on behalf of the registrar. In addition the registrar must be able to verify, which Registrar-Agent was in direct contact with the pledge. It would be inaccurate for the voucher-request and voucher-response to use an assertion with value "proximity" in the voucher, as the pledge was not in direct contact with the registrar for bootstrapping. Therefore, a new Agent-Proximity Assertion value {#agt_prx} is necessary for distinguishing assertions the MASA can state. At least the following properties are required for the voucher and enrollment processing: POI: provides data-origin authentication of a data object, e.g., a voucher-request or an Enroll-Request, utilizing an existing IDevID. Certificate updates may utilize the certificate that is to be updated. POP: proves that an entity possesses and controls the private key corresponding to the public key contained in the certification request, typically by adding a signature computed using the private key to the certification request. Solution examples based on existing technology are provided with the focus on existing IETF RFCs: Voucher-Requests and Vouchers as used in already provide both, POP and POI, through a digital signature to protect the integrity of the voucher, while the corresponding signing certificate contains the identity of the signer. Enroll-Requests are data structures containing the information from a requester for a CA to create a certificate. The certification request format in BRSKI is PKCS#10 . In PKCS#10, the structure is signed to ensure integrity protection and POP of the private key of the requester that corresponds to the contained public key. In the application examples, this POP alone is not sufficient. A POI is also required for the certification request and therefore the certification request needs to be additionally bound to the existing credential of the pledge (IDevID). This binding supports the authorization decision for the certification request and may be provided directly with the certification request. While BRSKI uses the binding to TLS, BRSKI-PRM aims at an additional signature of the PKCS#10 using existing credentials on the pledge (IDevID). This allows the process to be independent of the selected transport.

Architecture

Overview For BRSKI with Pledge in Responder Mode (BRSKI-PRM), the base system architecture defined in BRSKI is enhanced to facilitate new use cases in which the pledge acts as server. The responder mode allows delegated bootstrapping using a Registrar-Agent instead of a direct connection between the pledge and the domain registrar. Necessary enhancements to support authenticated self-contained objects for certificate enrollment are kept at a minimum to enable reuse of already defined architecture elements and interactions. The format of the bootstrapping objects produced or consumed by the pledge is usually based on JSON Web Signature (JWS) and further specified in to address the requirements stated in above. In constrained environments, it may be based on COSE . An abstract overview of the BRSKI-PRM protocol can be found on slide 8 of . To support mutual trust establishment between the domain registrar and pledges not directly connected to the customer domain, this document specifies the exchange of authenticated self-contained objects with the help of a Registrar-Agent. This leads to extensions of the logical components in the BRSKI architecture as shown in . Note that the Join Proxy is not shown in the figure. In certain situations the Join Proxy may still be present and could be used by the Registrar-Agent to connect to the Registrar. For example, a Registrar-Agent application on a smartphone often can connect to local Wi-Fi without giving up their cellular network connection , but only can make link-local connections. The Registrar-Agent interacts with the pledge to transfer the required data objects for bootstrapping, which are then also exchanged between the Registrar-Agent and the domain registrar. The addition of the Registrar-Agent influences the sequences of the data exchange between the pledge and the domain registrar described in . To enable reuse of BRSKI defined functionality as much as possible, BRSKI-PRM: uses existing endpoints where the required functionality is provided. enhances existing endpoints with new supported media types, e.g., for JWS voucher. defines new endpoints where additional functionality is required, e.g., for wrapped certification request, CA certificates, or new status information.

| |<------>| (PKI RA) | . | | . | EE cert | | | . | | . +------------+ +-----+-----+ . | IDevID | . | . | | . +------------------+-----+ . +--------+ . | Key Infrastructure | . . | (e.g., PKI CA) | . . +------------------------+ . ......................................... Customer Domain ]]>

shows the relations between the following main components: Pledge: Is expected to respond with the necessary data objects for bootstrapping to the Registrar-Agent. The protocol used between the pledge and the Registrar-Agent is assumed to be HTTP in the context of this document. Any other protocols (including HTTPS) can be used as long as they support the exchange of the necessary data objects. This includes CoAP or protocol to be used over Bluetooth or NFC connections A pledge acting as a server during bootstrapping leads to the following differences compared to BRSKI: The pledge is discovered by the Registrar-Agent as defined in {#discovery_uc2_ppa}. The pledge offers additional endpoints as defined in , so that the Registrar-Agent can request data required for bootstrapping the pledge. The pledge includes additional data in the PVR, which is provided by the Registrar-Agent in the voucher-request trigger as defined in . This allows the registrar to identify, with which Registrar-Agent the pledge was in contact. The order of exchanges in the BRSKI-PRM call flow is different from those in BRSKI , as the PVR and PER are collected simultaneously and provided to the registrar. This enables bulk bootstrapping of several devices. The data objects utilized for the data exchange between the pledge and the registrar are self-contained authenticated objects (signature-wrapped objects). Registrar-Agent: Provides a store and forward communication path to exchange data objects between the pledge and the domain registrar. The Registrar-Agent acts as a broker in situations in which the domain registrar is not directly reachable by the pledge. This may be due to a different technology stack or due to missing connectivity. The Registrar-Agent triggers one or more pledges to create bootstrapping artifacts such as the voucher-request and the Enroll-Request. It can then perform a (bulk) bootstrapping based on the collected data. The Registrar-Agent is expected to possess information about the domain registrar: the registrar EE certificate, LDevID(CA) certificate, and IP address, either by configuration or by using the discovery mechanism defined in . There is no trust assumption between the pledge and the Registrar-Agent as only authenticated self-contained objects are used, which are transported via the Registrar-Agent and provided either by the pledge or the domain registrar. The trust assumption between the Registrar-Agent and the domain registrar may be based on an LDevID, which is provided by the PKI responsible for the customer domain. The Registrar-Agent may be realized as stand-alone component supporting nomadic activities of a service technician moving between different installation sites. Alternatively, the Registrar-Agent may also be realized as co-located functionality for a registrar, to support pledges in responder mode. Join Proxy (not shown): Has the same functionality as described in if needed. Note that a Registrar-Agent may use a join proxy to facilitate the TLS connection to the registrar in the same way that a BRSKI pledge would use a join proxy. This is useful in cases where the Registrar-Agent does not have full IP connectivity via the domain network or cases where it has no other means to locate the registrar on the network. Domain Registrar: In general fulfills the same functionality regarding the bootstrapping of the pledge in a customer domain by facilitating the communication of the pledge with the MASA service and the domain key infrastructure (PKI). In contrast to , a BRSKI-PRM domain registrar does not interact with a pledge directly, but through the Registrar-Agent. Vendor Services: Encompass MASA and Ownership Tracker and are used as defined in . A MASA is able to support enrollment via Registrar-Agent without changes unless it checks the vouchers proximity indication, in which case it would need to be enhanced to support BRSKI-PRM to also accept the Agent-Proximity Assertion {#agt_prx}.

Nomadic Connectivity In one example instance of the PRM architecture as shown in , there is no connectivity between the location in which the pledge is installed and the location of the domain registrar. This is often the case in the aforementioned building automation use case ().

: Agent : . | . +--------+ L2 or L3 :-.-.-.-.-.-.-: . | . connectivity ^ . | ..........................!............. | Pledge Installation ! | Location ! Nomadic | ! connectivity | ! | ...........!...................|......... . v v . . .-.-.-.-.-.-.-. +-----------+ . . : Registrar- : | Domain | . . : Agent :<----->| Registrar | . . :-.-.-.-.-.-.-: +-----+-----+ . . | . . +------------------+-----+ . . | Key Infrastructure | . . | (e.g., PKI CA) | . . +------------------------+ . ......................................... Customer Domain ]]>

PRM enables support of this case through nomadic connectivity of the Registrar-Agent. To perform enrollment in this setup, multiple round trips of the Registrar-Agent between the pledge installation location and the domain registrar are required. Connectivity to domain registrar: preparation tasks for pledge bootstrapping not part of the BRSKI-PRM protocol definition, like retrieval of list of pledges to enroll. Connectivity to pledge installation location: retrieve information about available pledges (IDevID), collect request objects (i.e., Pledge Voucher-Requests and Pledge Enroll-Requests using the BRSKI-PRM approach described in and . Connectivity to domain registrar, submit collected request information of pledges, retrieve response objects (i.e., Voucher and Enroll-Response) using the BRSKI-PRM approach described in and . Connectivity to pledge installation location, provide retrieved objects to the pledges to enroll pledges and collect status using the BRSKI-PRM approach described in , , and . Connectivity to domain registrar, submit Voucher Status and Enrollment Status using the BRSKI-PRM approach described in and . Variations of this setup include cases where the Registrar-Agent uses for example WiFi to connect to the pledge installation network, and mobile network connectivity to connect to the domain registrar. Both connections may also be possible in a single location at the same time, based on installation building conditions.

Co-located Registrar-Agent and Domain Registrar Compared to BRSKI, pledges supporting BRSKI-PRM can be completely passive and only need to react when being requested to react by a Registrar-Agent. In , pledges instead need to continuously request enrollment from a domain registrar, which may result in undesirable communications pattern and possible overload of a domain registrar.

|. Agent . Registrar | . +--------+ L2 or L3 |.............. | . connectivity +-------------------+-----+ . . | . . +------------------+-----+ . . | Key Infrastructure | . . +------------------------+ . ......................................... Customer Domain ]]>

The benefits of BRSKI-PRM can be achieved even without the operational complexity of standalone Registrar-Agents by integrating the necessary functionality of the Registrar-Agent as a module into the domain registrar as shown in so that it can support the BRSKI-PRM communications to the pledge.

Agent-Proximity Assertion "Agent-proximity" is a statement in the PVR and in the voucher, that the registrar certificate was provided via the Registrar-Agent as defined in and not directly to the pledge. Agent-proximity is therefore a different assertion than "proximity", which is defined in . Agent-proximity is defined as additional assertion type in . This assertion can be verified by the registrar and also by the MASA during the voucher-request processing. In BRSKI, the pledge verifies POP of the registrar via the TLS handshake and pins that public key as the "proximity-registrar-cert" into the voucher request. This allows the MASA to verify the proximity of the pledge and registrar, facilitating a decision to assign the pledge to that domain owner. In BRSKI, the TLS connection is considered provisional until the pledge receives the voucher. In contrast, in BRSKI-PRM, the pledge has no direct connection to the registrar and MUST accept the registrar certificate provisionally until it receives the voucher as described in . In a similar fashion, the pledge MUST accept the Registrar-Agent EE certificate provisionally. See also on "provisional state". For agent-proximity, the EE certificate of the Registrar-Agent MUST be an LDevID certificate signed by the domain owner. Akin to the proximity assertion in the BRSKI case, the agent-proximity provides pledge proximity evidence to the MASA. But additionally, agent-proximity allows the domain registrar to be sure that the PVR collected by the Registrar-Agent was in fact collected by the Registrar-Agent, to which the registrar is connected to. The provisioning of the Registrar-Agent LDevID certificate is out of scope for this document, but may be done in advance using a separate BRSKI run or by other means like configuration. It is recommended to use short lived Registrar-Agent LDevIDs in the range of days or weeks as outlined in .

System Components

Domain Registrar In BRSKI-PRM, the domain registrar provides the endpoints already specified in (derived from EST ) where suitable. In addition, it MUST provide the endpoints defined in within the BRSKI-defined "/.well-known/brski/" URI path. These endpoints accommodate for the signature-wrapped objects used by BRSKI-PRM for the Pledge Enroll-Request (PER) and the provisioning of CA certificates. Endpoint Operation Exchange and Artifacts requestenroll Supply PER to Registrar wrappedcacerts Request CA Certificates According to , the domain registrar performs the pledge authorization for bootstrapping within his domain based on the Pledge Voucher-Request. This behavior is retained in BRSKI-PRM. The domain registrar MUST possess and trust the IDevID (root or issuing) CA certificate of the pledge vendor/manufacturer. Further, the domain registrar MUST have its own EE credentials.

Domain Registrar with Combined Functionality A registrar with combined BRSKI and BRSKI-PRM functionality MAY detect if the bootstrapping is performed by the pledge directly (BRSKI case) or by a Registrar-Agent (BRSKI-PRM case) based on the utilized credential for client authentication during the TLS session establishment and switch switch the operational mode from BRSKI to BRSKI-PRM. This may be supported by a specific naming in the SAN (subject alternative name) component of the EE certificate of the Registrar-Agent. Alternatively, this may be supported by using an LDevID certificate signed by the domain owner for the client authentication of the Registrar-Agent. Using an LDevID certificate also allows the registrar to verify that a Registrar-Agent is authorized to perform the bootstrapping of a pledge. See also agent-proximity assertion in . Using an LDevID certificate for TLS client authentication of the Registrar-Agent is a deviation from , in which the IDevID credential of the pledge is used to perform TLS client authentication.

Registrar-Agent The Registrar-Agent is a new component in BRSKI-PRM that provides a secure message passing service between pledges in responder mode and the domain registrar. It requires the EE certificate of the domain registrar for TLS server authentication when establishing a TLS session with the domain registrar and to provide the registrar EE certificate to the pledge for creating the Pledge Voucher-Request (PVR). The Registrar-Agent uses its own EE certificate for TLS client authentication when establishing a TLS session with the domain registrar and for signing agent-signed data. This EE certificate MUST include a SubjectKeyIdentifier (SKID), which is used as reference in the context of an agent-signed-data object as defined in . Note that this is an additional requirement for issuing the certificate, as only requires the SKID to be included for intermediate CA certificates. has a similar requirement. In BRSKI-PRM, the SKID is used in favor of providing the complete EE certificate of the Registrar-Agent to accommodate also constrained environments and reduce bandwidth needed for communication with the pledge. In addition, it follows the recommendation from BRSKI to use SKID in favor of a certificate fingerprint to avoid additional computations. In addition to the EE certificates, the Registrar-Agent is provided with the product serial number(s) of the pledge(s) to be bootstrapped. This is necessary to allow the discovery of pledge(s) by the Registrar-Agent using DNS-SD with mDNS (see ). The list may be provided by prior administrative means or the Registrar-Agent may get the information via an interaction with the pledge. For instance, describes scanning of a QR code, where the product serial number would be initialized from the 12N B005 Product Serial Number. In summary, the following information MUST be available at the Registrar-Agent before interaction with a pledge: Domain registrar EE certificate: certificate of the domain registrar to be provided to the pledge. Registrar-Agent EE certificate and corresponding private key: own operational key pair to sign agent-signed-data. Serial number(s): product serial number(s) of pledge(s) to be bootstrapped for discovery. Further, the Registrar-Agent SHOULD have synchronized time. Finally, the Registrar-Agent MAY possess the IDevID (root or issuing) CA certificate of the pledge vendor/manufacturer to validate the IDevID certificate on returned PVR or in case of TLS usage for pledge communication. The distribution of IDevID CA certificates to the Registrar-Agent is out of scope of this document and may be done by a manual configuration.

Discovery of the Registrar As a Registrar-Agent acts as representative of the domain registrar towards the pledge or may even be collocated with the domain registrar, a separate discovery of the registrar is likely not needed as Registrar-Agent and registrar are domain components and have a trust relation. Moreover, other communication (not part of this document) between the Registrar-Agent and the registrar is assumed, e.g., to exchange information about product-serial-number(s) of pledges to be discovered as outlined in . Moreover, as the standard discovery described in and the does not support of registrars with an enhanced feature set (like the support of BRSKI-PRM), this standard discovery is not applicable. As a more general solution, the BRSKI discovery mechanism can be extended to provide upfront information on the capabilities of registrars, such as the mode of operation (pledge-responder-mode or registrar-responder-mode). Defining discovery extensions is out of scope of this document. This may be provided in .

Discovery of the Pledge The discovery of the pledge by Registrar-Agent in the context of this document describes the minimum discovery approach to be supported. A more general discovery mechanism, also supporting GRASP besides DNS-SD with mDNS may be provided in . Discovery in BRSKI-PRM uses DNS-based Service Discovery over Multicast DNS to discover the pledge. Note that Section 9 provides support for conflict resolution in situations when an DNS-SD with mDNS responder receives a mDNS response with inconsistent data. Note that does not support conflict resolution of mDNS, which may be a limitation for its application. The pledge constructs a local host name based on device local information (product-serial-number), which results in "product-serial-number._brski-pledge._tcp.local". The product-serial-number composition is manufacturer dependent and may contain information regarding the manufacturer, the product type, and further information specific to the product instance. To allow distinction of pledges, the product-serial-number therefore needs to be sufficiently unique. In the absence of a more general discovery as defined in the Registrar-Agent MUST use "<product-serial-number>._brski-pledge._tcp.local", to discover a specific pledge, e.g., when connected to a local network. "_brski-pledge._tcp.local" to get a list of pledges to be bootstrapped. A manufacturer may allow the pledge to react on DNS-SD with mDNS discovery without his product-serial-number contained. This allows a commissioning tool to discover pledges to be bootstrapped in the domain. The manufacturer support this functionality as outlined in . Establishing network connectivity of the pledge is out of scope of this document but necessary to apply DNS-SD with mDNS. For Ethernet it is provided by simply connecting the network cable. For WiFi networks, connectivity can be provided by using a pre-agreed SSID for bootstrapping, e.g., as proposed in . The same approach can be used by 6LoWPAN/mesh using a pre-agreed PAN ID. How to gain network connectivity is out of scope of this document.

Pledge in Responder Mode The pledge is triggered by the Registrar-Agent to create the PVR and PER. It is also triggered for processing of the responses and the generation of status information once the Registrar-Agent has received the responses from the registrar later in the process. To enable interaction as responder with the Registrar-Agent, pledges in responder mode MUST act as servers and MUST provide the endpoints defined in within the BRSKI-defined "/.well-known/brski/" URI path. The endpoints are defined with short names to also accommodate for resource-constrained devices. Endpoint Operation Exchange and Artifacts tpvr Trigger Pledge Voucher-Request tper Trigger Pledge Enroll-Request svr Supply Voucher to Pledge scac Supply CA Certificates to Pledge ser Supply Enroll-Response to Pledge qps Query Pledge Status makes the Host header field mandatory, so it will always be present. The pledge MUST respond to all queries regardless of the Host header field provided by the client. For instance, when the Registrar-Agent reaches out to the "tpvr" endpoint on a pledge in responder mode with the full URI "http://pledge.example.com/.well-known/brski/tpvr", it sets the Host header field to "pledge.example.com" and the absolute path "/.well-known/brski/tpbr". In practice, however, the pledge often is only known by its IP address as returned by a discovery protocol, which will be included in the Host header field. As BRSKI-PRM uses authenticated self-contained data objects between the pledge and the domain registrar, the binding of the pledge identity to the requests is provided by the data object signature employing the IDevID of the pledge. Hence, pledges MUST have an Initial Device Identifier (IDevID) installed in them at the factory.

Pledge with Combined Functionality Pledges MAY support both initiator and responder mode. A pledge in initiator mode should listen for announcement messages as described in . Upon discovery of a potential registrar, it initiates the bootstrapping to that registrar. At the same time (so as to avoid the Slowloris-attack described in ), it SHOULD also respond to the triggers for responder mode described in this document. Once a pledge with combined functionality has been bootstrapped, it MAY act as client for enrollment of further certificates needed, e.g., using the enrollment protocol of choice. If it still acts as server, the defined BRSKI-PRM endpoints to trigger a Pledge Enroll-Request (PER) or to provide an Enroll-Response can be used for further certificates.

Exchanges and Artifacts The interaction of the pledge with the Registrar-Agent may be accomplished using different transports (i.e., protocols and/or network technologies). This specification utilizes HTTP as default transport. Other specifications may define alternative transports such as CoAP, Bluetooth Low Energy (BLE), or Near Field Communication (NFC). These transports may differ from and are independent of the ones used between the Registrar-Agent and the registrar. Transport independence is realized through data objects that are not bound to specific transport security and stay the same along the communication path from the pledge via the Registrar-Agent to the registrar. Therefore, authenticated self-contained artifacts (e.g., JWS-signed JSON structures or COSE-signed CBOR structures) are used for the data exchanges between the pledge and the registrar via the Registrar-Agent. provides an overview of the exchanges detailed in the following subsections.

| | | | | | | | | ~ ~ ~ ~ ~ (1) Trigger Pledge Voucher-Request ~ ~ ~ ~ ~ | | | | | |<----opt. TLS---->| | | | |<------tPVR-------| | | | |--------PVR------>| | | | | | | | | ~ ~ ~ ~ ~ (2) Trigger Pledge Enroll-Request ~ ~ ~ ~ ~ | | | | | |<----opt. TLS---->| | | | |<------tPER-------| | | | |--------PER------>| | | | | | | | | ~ ~ ~ ~ ~ (3) Supply PVR to Registrar (including backend interaction) ~ ~ ~ ~ ~ | | | | | | |<-----mTLS------>| | | | | [Registrar-Agent | | | | authenticated&authorized?] | | | |-------PVR------>| | | | | [accept device?] | | | | [contact vendor] | | | | | | | | | |<------------mTLS------------>| | | |--------------RVR------------>| | | | [extract DomainID] | | | [update audit log] | | |<-----------Voucher-----------| | |<----Voucher-----| | | | | | | | ~ ~ ~ ~ ~ (4) Supply PER to Registrar (including backend interaction) ~ ~ ~ ~ ~ | | | | | | |<----(mTLS)----->| | | | |-------PER------>| | | | | |<-----mTLS------>| | | | |-------RER------>| | | | |<--Enroll-Resp---| | | |<--Enroll-Resp---| | | | | | | | ~ ~ ~ ~ ~ (5) Request CA Certificates ~ ~ ~ ~ ~ | | | | | | |<----(mTLS)----->| | | | |---cACert-Req--->| | | | |<--cACert-Resp---| | | | | | | | ~ ~ ~ ~ ~ (6) Supply Voucher to Pledge ~ ~ ~ ~ ~ | | | | | |<----opt. TLS---->| | | | |<-----Voucher-----| | | | |------vStatus---->| | | | | | | | | ~ ~ ~ ~ ~ (7) Supply CA Certificates to Pledge ~ ~ ~ ~ ~ | | | | | |<----opt. TLS---->| | | | |<-----cACerts-----| | | | | | | | | ~ ~ ~ ~ ~ (8) Supply Enroll-Response to Pledge ~ ~ ~ ~ ~ | | | | | |<----opt. TLS---->| | | | |<---Enroll-Resp---| | | | |-----eStatus----->| | | | | | | | | ~ ~ ~ ~ ~ (9) Voucher Status Telemetry (including backend interaction) ~ ~ ~ ~ ~ | | | | | | |<----(mTLS)----->| | | | |-----vStatus---->| | | | | |<-----------(mTLS)----------->| | | |-----req device audit log---->| | | |<------device audit log-------| | | [verify audit log] | | | | | | | ~ ~ ~ ~ ~ (10) Enroll Status Telemetry ~ ~ ~ ~ ~ | | | | | | |<----(mTLS)----->| | | | |-----eStatus---->| | | | | | | | ~ ~ ~ ~ ~ (11) Query Pledge Status ~ ~ ~ ~ ~ | | | | | |<----opt. TLS---->| | | | |<-----tStatus-----| | | | |------pStatus---->| | | | | | | | | ~ ~ ~ ~ ~ ]]>

The following sub sections split the interactions shown in between the different components into: describes the acquisition exchange for the Pledge Voucher-Request initiated by the Registrar-Agent to the pledge. describes the acquisition exchange for the Pledge Enroll-Request initiated by the Registrar-Agent to the pledge. describes the issuing exchange for the Voucher initiated by the Registrar-Agent to the registrar, including the interaction of the registrar with the MASA using the RVR , as well as the artifact processing by these entities. describes the enroll exchange initiated by the Registrar-Agent to the registrar including the interaction of the registrar with the CA using the PER as well as the artifact processing by these entities. describes the retrival exchange for the optional CA certificate provisioning to the pledge initiated by the Registrar-Agent to the CA. describes the Voucher exchange initiated by the Registrar-Agent to the pledge and the returned status information. describes the certificate provisioning exchange initiated by the Registrar-Agent to the pledge. describes the Enroll-Response exchange (containing the LDevID (Pledge) certificate) initiated by the Registrar-Agent to the pledge and the returned status information. describes the Voucher status telemetry exchange initiated by the Registrar-Agent to the registrar, including the interaction of the registrar with the MASA. describes the Enroll Status telemetry exchange initiated by the Registrar-Agent to the registrar. describes the Pledge Status exchange about the general bootstrapping state initiated by the Registrar-Agent to the pledge.

Trigger Pledge Voucher-Request This exchange assumes that the Registrar-Agent has already discovered the pledge. This may be done as described in and based on DNS-SD or similar. Optionally, TLS MAY be used to provide privacy for this exchange between the Registrar-Agent and the pledge, see . shows the acquisition of the Pledge Voucher-Request (PVR) and the following subsections describe the corresponding artifacts.

| | | | |<------tPVR-------| | | | |--------PVR------>| | | | | | | | | ~ ~ ~ ~ ~ ]]>

The Registrar-Agent triggers the pledge to create the PVR via HTTP POST on the well-known pledge endpoint /.well-known/brski/tpvr. The request body MUST contain the JSON-based Pledge Voucher-Request Trigger (tPVR) artifact. The request header MUST set the Content-Type field to application/json. Upon receiving a valid tPVR, the pledge MUST reply with the PVR artifact in the body of a 200 OK response. The Content-Type field header of the response MUST be set to application/voucher-jws+json as defined in . If the pledge is unable to create the PVR, it SHOULD respond with an HTTP error code. The following client error responses MAY be used: 400 Bad Request: if the pledge detected an error in the format of the request, e.g. missing field, wrong data types, etc. or if the request is not valid JSON even though the PVR media type was set to application/json. 406 Not Acceptable: if the Accept request header field indicates a type that is unknown or unsupported, e.g., a type other than application/jose+json. 415 Unsupported Media Type: if the Content-Type request header field indicates a type that is unknown or unsupported, e.g., a type other than application/json.

Request Artifact: Pledge Voucher-Request Trigger (tPVR) The Pledge Voucher-Request Trigger (tPVR) artifact is an unsigned JSON structure providing the trigger parameters. The following CDDL explains the Pledge Voucher-Request Trigger structure.

pledgevoucherrequesttrigger = { "agent-provided-proximity-registrar-cert": bytes, "agent-signed-data": bytes } ]]>

The fields contained in the pledgevoucherrequesttrigger are: agent-provided-proximity-registrar-cert: X.509 v3 certificate structure of the domain registrar EE certificate (base64-encoded value); may be configured at the Registrar-Agent or may be fetched by the Registrar-Agent based on a prior TLS connection with this domain registrar agent-signed-data: base64-encoded JWS structure containing the SubjectKeyIdentifier of the EE (RegAgt) certificate and signing Data including the creation date and serial number of the pledge. Note that defines an opaque binary element for agent-signed data, for which the structure is defined in BRSKI-PRM.

The BRSKI-PRM Agent Signed Data structure MUST be encoded in JSON as defined in following the CDDL definition . The JWS Payload is further base64url-encoded to become the string value of the payload member as described in . The following CDDL explains the BRSKI-PRM Agent Signed Data structure.

prmasd = { "created": tdate, "serial-number": text } ]]>

The fields contained in the prmasd are: created-on: creation date and time as standard date/time string as defined in serial-number: product-serial-number in the X520SerialNumber field of the IDevID certificate of the pledge as string as defined in below shows an example for unsigned BRSKI-PRM Agent Signed Data in JSON syntax.

The JWS Protected Header of the agent-signed-data JWS structure MUST contain the following parameters (see for an example): alg: algorithm type used to create the signature, e.g., ES256 as defined in kid: base64-encoded bytes of the SubjectKeyIdentifier (the "KeyIdentifier" OCTET STRING value) of the EE (RegAgt) certificate.

Note that at the time of receiving the PVR trigger, the pledge cannot verify the registrar LDevID certificate and has no proof-of-possession of the corresponding private key for the certificate. Hence, the tPVR is an unsigned artifact and the pledge only accepts the registrar LDevID certificate provisionally until it receives the voucher as described in . The pledge will also be unable to verify the agent-signed-data itself as it does not possess the EE (RegAgt) certificate and the domain trust has not been established at this point of the communication. Verification SHOULD be done, after the voucher has been received. The trigger for the pledge to create a PVR is depicted in the following figure:

Response Artifact: Pledge Voucher-Request (PVR) The Pledge Voucher-Request (PVR) artifact is a JWS Voucher Request as defined in . Its unsigned data SHALL be constructed similar to the Voucher-Request artifact defined in . It will contain additional data provided by the Registrar-Agent as specified in the following. The payload of the PVR MUST contain the following parameters as part of the ietf-voucher-request:voucher as defined in and thus makes optional leaves in the YANG definition mandatory: created-on: SHALL contain the current date and time in yang:date-and-time format. If the pledge does not have synchronized time, it SHALL use the created-on time from the agent-signed-data, received in the trigger to create a PVR. nonce: SHALL contain a cryptographically strong pseudo-random number. serial-number: SHALL contain the pledge product-serial-number as X520SerialNumber. assertion: SHALL contain the requested voucher assertion "agent-proximity" (different value as in RFC 8995).. The ietf-voucher-request:voucher data is extended with two additional parameters that MUST be included: agent-provided-proximity-registrar-cert: base64-encoded registrar EE certificate (provided in tPVR by the Registrar-Agent); enables the registrar to verify that it is the desired registrar for handling the PVR agent-signed-data: base64-encoded agent-signed-data (provided in tPVR by the Registrar-Agent); enables the registrar to verify and log, which Registrar-Agent was in contact with the pledge, when verifying the PVR The enhancements of the YANG module for the ietf-voucher-request with these new leaves are defined in . The PVR is signed using the pledge's IDevID credential contained as x5c parameter of the JOSE header.

Trigger Pledge Enroll-Request Once the Registrar-Agent has received the PVR it can trigger the pledge to generate a Pledge Enroll-Request (PER). Optionally, TLS MAY be used to provide privacy for this exchange between the Registrar-Agent and the pledge, see . shows the the acquisition of the PER and the following subsections describe the corresponding artifacts.

| | | | |<------tPER-------| | | | |--------PER------>| | | | | | | | | ~ ~ ~ ~ ~ ]]>

The Registrar-Agent triggers the pledge to create the PER via HTTP POST on the well-known pledge endpoint /.well-known/brski/tper. As the initial enrollment aims to request a generic certificate, no certificate attributes are provided to the pledge. To avoid an empty request body an artifact is provided containing the description of the requested operation. Upon receiving a valid tPER, the pledge MUST reply with the PER artifact in the body of a 200 OK response. The response header MUST have the Content-Type field set to application/jose+json. If the pledge is unable to create the PER, it SHOULD respond with an HTTP error code. The following 4xx client error codes MAY be used: 400 Bad Request: if the pledge detected an error in the format of the request. 406 Not Acceptable: if the Accept request header field indicates a type that is unknown or unsupported. For example, a type other than application/jose+json. 415 Unsupported Media Type: if the Content-Type request header field indicates a type that is unknown or unsupported, e.g., a type other than application/json.

Request Artifact: Pledge Enroll-Request Trigger (tPER) This document specifies the trigger for a generic certificate with no CSR attributes provided to the pledge. If specific attributes in the certificate are required, they have to be inserted by the issuing RA/CA. The Pledge Enroll-Request Trigger (tPVR) artifact is an unsigned JSON structure providing the trigger parameters (tPER-data). The following CDDL explains the Pledge Enroll-Request Trigger structure.

pledgeenrollrequesttrigger = { "enroll-type": "enroll-generic-cert" } ]]>

The enroll-type field is an enum, identifying what is being enrolled. Currently only "enroll-generic-cert" for the LDevID certificate is defined. below shows an example for unsigned Pledge Enroll-Request Trigger in JSON syntax.

The Pledge Enroll-Request Trigger (tPER) artifact MUST be encoded in JSON as defined in following the CDDL definition . The Pledge Enroll-Request Trigger (tPER) artifact MAY be used to provide additional data, like CSR attributes. How to provide and use such additional data is out of scope for this specification.

Response Artifact: Pledge Enroll-Request (PER) The Pledge Enroll-Request (PER) artifact is a JWS-signed PKCS#10 Certificate Signing Request (CSR) utilizing the csr-grouping of the ietf-ztp-types YANG module as defined in . The CSR already assures POP of the private key corresponding to the contained public key. In addition, based on the PER signature using the IDevID, POI is provided. The pledge constructs the Pledge Enroll-Request (PER) artifact as a JWS structure containing the PKCS#10 request wrapped in ietf-ztp-types YANG structrue as JWS payload. Note, also allows for inclusion of certification requests in different formats used by CMP or CMC. The pledge MUST construct the PER as PKCS#10 and MUST sign it additionally with its IDevID credentials to provide proof-of-identity bound to the PKCS#10 as described below. A successful enrollment will result in a generic LDevID certificate for the pledge in the new domain. This generic LDevID certificate can be used to request further (application specific) LDevID certificates if necessary for operation. The Registrar-Agent SHALL use the enrollment endpoint requestenroll specified in this document to provide the Pledge Enroll-Request artifact to the Registrar. The JWS Protected Header of the PER MUST contain the following parameters as defined in : alg: algorithm type used to create the signature, e.g., ES256 as defined in x5c: base64-encoded pledge IDevID certificate; it MAY optionally contain the certificate chain for this certificate; if the certificate chain is not included, it MUST be available at the registrar for verification of the IDevID certificate The body of the Pledge Enroll-Request SHOULD contain a P10 parameter (for PKCS#10) as defined for ietf-ztp-types:p10-csr in : p10-csr: base64-encoded PKCS#10 of the pledge. The JOSE object is signed using the pledge's IDevID credential, which corresponds to the certificate signaled in the JOSE header. While BRSKI-PRM targets the initial enrollment, re-enrollment SHOULD be supported as described in a similar way as for enrollment in this document, if no other re-enrollment mechanism is supported. Note that in this case the current LDevID credential is used instead of the IDevID credential to create the signature of the PKCS#10 request.

With the collected PVR and PER, the Registrar-Agent starts the interaction with the domain registrar. The new protected header field "created-on" is introduced to reflect freshness of the PER. The field is marked critical "crit" to ensure that it must be understood and validated by the receiver (here the domain registrar) according to . It allows the registrar to verify the timely correlation between the PER and previously exchanged messages, i.e., created-on of PER >= created-on of PVR >= created-on of PVR trigger. The registrar MAY consider to ignore any but the newest PER from the same pledge in the case the registrar has at any point in time more than one pending PER from the pledge. As the Registrar-Agent is intended to facilitate communication between the pledge and the domain registrar, a collection of requests from more than one pledge is possible. This allows bulk bootstrapping of several pledges using the same connection between the Registrar-Agent and the domain registrar.

Supply PVR to Registrar (including backend interaction) Similar to BRSKI "requestvoucher" endpoint in . The Registrar-Agent has acquired one or more PVR and PER object pairs The Registrar-Agent establishes a TLS connection to the registrar. As already stated in , the use of TLS 1.3 (or newer) is encouraged. TLS 1.2 or newer is REQUIRED on the Registrar-Agent side. TLS 1.3 (or newer) SHOULD be available on the registrar, but TLS 1.2 MAY be used. TLS 1.3 (or newer) SHOULD be available on the MASA, but TLS 1.2 MAY be used. In contrast to BRSKI TLS client authentication to the registrar is achieved by using Registrar-Agent EE credentials instead of pledge IDevID credentials. Consequently BRSKI (pledge-initiator-mode) is distinguishable from BRSKI-PRM (pledge-responder-mode) by the registrar. The registrar SHOULD verify that the Registrar-Agent is authorized to establish a connection to the registrar based on the TLS client authentication. If the connection from Registrar-Agent to registrar is established, the authorization SHOULD be verified again based on agent-signed-data contained in the PVR. This ensures that the pledge has been triggered by an authorized Registrar-Agent. With BRSKI-PRM, the pledge generates PVR and PER as JSON-in-JWS objects and the Registrar-Agent forwards them to the registrar. In , the pledge generates PVR as CMS-signed JSON and PER as PKCS#10 or PKCS#7 according to and inherited by . shows the exchanges for the Voucher Request processing and the following subsections describe the corresponding artifacts.

| | | | | [Registrar-Agent | | | | authenticated&authorized?] | | | |-------PVR------>| | | | | [accept device?] | | | | [contact vendor] | | | | | | | | | |<------------mTLS------------>| | | |--------------RVR------------>| | | | [extract DomainID] | | | [update audit log] | | |<-----------Voucher-----------| | |<----Voucher-----| | | | | | | | ~ ~ ~ ~ ~ ]]>

The HTTP request Content-Type header field for JSON-in-JWS PVR is: application/voucher-jws+json (see for the content definition), as defined in . The Registrar-Agent sets the Accept field in the request-header indicating the acceptable Content-Type for the Voucher. The HTTP response Content-Type header field is set to application/voucher-jws+json as defined in if no content negotiation is used.

Request Artifact: Pledge Voucher-Request (PVR) For BRSKI-PRM, the Registrar-Agent sends the PVR by HTTP POST to the same registrar endpoint as introduced by BRSKI: "/.well- known/brski/requestvoucher", but with a Content-Type header field for JSON-in-JWS"

Supply RVR to MASA (backend interaction) The registrar needs to convert the PVR to an RVR and supply it to the MASA. If the MASA address/URI is learned from the IDevID MASA URI extension (), then the MASA on that URI MUST support the procedures defined in this document if the PVR used JSON-JWS encoding. If the MASA is only configured on the registrar, then a registrar supporting BRKSI-PRM and other voucher encoding formats (such as those in ) SHOULD support per-message-format MASA address/URI configuration for the same IDevID trust anchor." The registrar SHALL construct the payload of the RVR as defined in , Section 5.5. The RVR encoding SHALL be JSON-in-JWS as defined in . The header of the RVR SHALL contain the following parameter as defined for JWS : alg: algorithm used to create the object signature x5c: base64-encoded registrar LDevID certificate(s) (It optionally contains the certificate chain for this certificate) The payload of the RVR MUST contain the following parameter as part of the voucher-request as defined in : created-on: current date and time in yang:date-and-time format of RVR creation nonce: copied from the PVR serial-number: product-serial-number of pledge. The registrar MUST verify that the IDevID certificate subject serialNumber of the pledge (X520SerialNumber) matches the serial-number value in the PVR. In addition, it MUST be equal to the serial-number value contained in the agent-signed data of PVR. assertion: voucher assertion requested by the pledge (agent-proximity). The registrar provides this information to assure successful verification of Registrar-Agent proximity based on the agent-signed-data. prior-signed-voucher-request: PVR as received from Registrar-Agent, see The RVR MUST be extended with the following parameter, when the assertion "agent-proximity" is requested, as defined in : agent-sign-cert: EE (RegAgt) certificate or the EE (RegAgt) certificate including certificate chain. In the context of this document it is a JSON array of base64encoded certificate information and handled in the same way as x5c header objects. If only a single object is contained in the x5c it MUST be the base64-encoded EE (RegAgt) certificate. If multiple certificates are included in the x5c, the first MUST be the base64-encoded EE (RegAgt) certificate. The MASA uses this information for verification that the Registrar-Agent is in proximity to the registrar to state the corresponding assertion "agent-proximity". The object is signed using the registrar LDevID credentials, which corresponds to the certificate referenced in the JOSE header.

The registrar SHALL send the RVR to the MASA endpoint by HTTP POST: "/.well-known/brski/requestvoucher" The RVR Content-Type header field is defined in as: application/voucher-jws+json The registrar SHOULD set the Accept header of the RVR indicating the desired media type for the voucher-response. The media type is application/voucher-jws+json as defined in . This document uses the JSON-in-JWS format throughout the definition of exchanges and in the examples. Nevertheless, alternative encodings of the voucher as used in BRSKI with JSON-in-CMS or CBOR-in-COSE_Sign for constraint environments are possible as well. The assumption is that a pledge typically supports a single encoding variant and creates the PVR in the supported format. To ensure that the pledge is able to process the voucher, the registrar MUST use the media type for Accept header in the RVR based on the media type used for the PVR. Once the MASA receives the RVR it SHALL perform the verification as described in . In addition, the following processing SHALL be performed for PVR contained in RVR "prior-signed-voucher-request" field: agent-provided-proximity-registrar-cert: The MASA MAY verify that this field contains the registrar LDevID certificate. If so, it MUST correspond to the registrar LDevID credentials used to sign the RVR. Note: Correspond here relates to the case that a single registrar LDevID certificate is used or that different registrar LDevID certificates are used, which are issued by the same CA. agent-signed-data: The MASA MAY verify this data to issue "agent-proximity" assertion. If so, the agent-signed-data MUST contain the pledge product-serial-number, contained in the "serial-number" field of the PVR (from "prior-signed-voucher-request" field) and also in "serial-number" field of the RVR. The EE (RegAgt) certificate to be used for signature verification is identified by the "kid" parameter of the JOSE header. If the assertion "agent-proximity" is requested, the RVR MUST contain the corresponding EE (RegAgt) certificate data in the "agent-sign-cert" field of the RVR. It MUST be verified by the MASA to the same domain CA as the registrar LDevID certificate. If the "agent-sign-cert" field is not set, the MASA MAY state a lower level assertion value, e.g.: "logged" or "verified". Note: Sub-CA certificate(s) MUST also be carried by "agent-sign-cert", in case the EE (RegAgt) certificate is issued by a sub-CA and not the domain CA known to the MASA. As the "agent-sign-cert" field is defined as array (x5c), it can handle multiple certificates. If validation fails, the MASA SHOULD respond with an HTTP 4xx client error status code to the registrar. The HTTP error status codes are kept the same as defined in and comprise the codes: 403, 404, 406, and 415. The registrar provides the EE certificate of the Registrar-Agent identified by the SubjectKeyIdentifier (SKID) in the header of the "agent-signed-data" from the PVR in its RVR (see also ). The MASA in turn verifies the registrar LDevID certificate is included in the PVR (contained in the "prior-signed-voucher-request" field of RVR) in the "agent-provided-proximity-registrar-cert" leaf and may assert the PVR as "verified" or "logged". In addition, the MASA may issue the assertion "agent-proximity" as follows: The MASA verifies the signature of the "agent-signed-data" contained in the "prior-signed-voucher-request", based on the provided EE certificate of the Registrar-Agent in the "agent-sign-cert" leaf of the RVR. If both can be verified successfully, the MASA can assert "agent-proximity" in the voucher. The assertion of "agent-proximity" is similar to the proximity assertion by the MASA when using BRSKI. Note that the different assertions do not provide a metric of strength as the security properties are not comparable. Depending on the MASA verification policy, it may also respond with a suitable 4xx or 5xx response status codes as described in . When successful, the Voucher will then be supplied via the registrar to the Registrar-Agent.

Issue Voucher by MASA (backend interaction) The MASA creates a voucher with Media-Type of application/voucher-jws+json as defined in . If the MASA detects that the Accept header of the PVR does not match application/voucher-jws+json it SHOULD respond with the HTTP status code "406 Not Acceptable" as the pledge will not be able to parse the response. The voucher is according to but uses the new assertion value specified . shows an example of the contents of a voucher.

The pinned-domain certificate to be put into the voucher is determined by the MASA as described in . The MASA returns the voucher-response (voucher) to the registrar.

Supply Voucher to Registrar (backend interaction) After receiving the voucher the registrar SHOULD evaluate it for transparency and logging purposes as outlined in . The registrar MUST add an additional signature to the MASA provided voucher using its registrar EE credentials. The signature is created by signing the original "JWS Payload" produced by MASA and the registrar added "JWS Protected Header" using the registrar EE credentials (see , Section 5.2 point 8. The x5c component of the "JWS Protected Header" MUST contain the registrar EE certificate as well as potential subordinate CA certificates up to (but not including) the pinned domain certificate. The pinned domain certificate is already contained in the voucher payload ("pinned-domain-cert"). (For many installations, with a single registrar credential, the registrar credential is what is pinned) In , the Registrar proved possession of the it's credential when the TLS session was setup. While the pledge could not, at the time, validate the certificate truly belonged the registrar, it did validate that the certificate it was provided was able to authenticate the TLS connection. In the BRSKI-PRM mode, with the Registrar-Agent mediating all communication, the Pledge has not as yet been able to witness that the intended Registrar really does possess the relevant private key. This second signature provides for the same level of assurance to the pledge, and that it matches the public key that the pledge received in the trigger for the PVR (see ). The registrar MUST use the same registrar EE credentials used for authentication in the TLS handshake to authenticate towards the Registrar-Agent. This has some operational implications when the registrar may be part of a scalable framework as described in . The second signature MUST either be done with the private key associated with the registrar EE certificate provided to the Registrar-Agent, or the use of a certificate chain is necessary. This ensures that the same registrar EE certificate can be used to verify the signature as transmitted in the voucher-request as also transferred in the PVR in the "agent-provided-proximity-registrar-cert". below provides an example of the voucher with two signatures.

Depending on the security policy of the operator, this signature can also be interpreted by the pledge as explicit authorization of the registrar to install the contained trust anchor. The registrar sends the voucher to the Registrar-Agent.

Response Artifact: Voucher After receiving the PVR from Registrar-Agent, the registrar SHALL perform the verification as defined in . In addition, the registrar SHALL verify the following parameters from the PVR: agent-provided-proximity-registrar-cert: MUST contain registrar's own registrar LDevID certificate to ensure the registrar in proximity of the Registrar-Agent is the desired registrar for this PVR. agent-signed-data: The registrar MUST verify that the Registrar-Agent provided data has been signed with the private key corresponding to the EE (RegAgt) certificate indicated in the "kid" JOSE header parameter. The registrar MUST verify that the LDevID(ReAgt) certificate, corresponding to the signature, is still valid. If the certificate is already expired, the registrar SHALL reject the request. Validity of used signing certificates at the time of signing the agent-signed-data is necessary to avoid that a rogue Registrar-Agent generates agent-signed-data objects to onboard arbitrary pledges at a later point in time, see also . The registrar MUST fetch the EE (RegAgt) certificate, based on the provided SubjectKeyIdentifier (SKID) contained in the "kid" header parameter of the agent-signed-data, and perform this verification. This requires, that the registrar has access to the EE (RegAgt) certificate data (including intermediate CA certificates if existent) based on the SKID. Note, the registrar may have stored the EE (RegAgt) certificate if used during TLS establishment between Registrar-Agent and registrar or it may be provided via a repository. If the registrar is unable to validate the PVR, it SHOULD respond with a HTTP 4xx/5xx error code to the Registrar-Agent. The following 4xx client error codes SHOULD be used: 403 Forbidden: if the registrar detected that one or more security related parameters are not valid or if the pledge-provided information could not be used with automated allowance. 406 Not Acceptable: if the Content-Type indicated by the Accept header is unknown or unsupported. If the validation succeeds, the registrar performs pledge authorization according to followed by obtaining a voucher from the pledge's MASA according to with the modifications described below in .

Supply PER to Registrar (including backend interaction) After receiving the voucher, the Registrar-Agent sends the PER to the registrar in the same HTTP-over-TLS connection. Which is similar to the PER processing described in . In case the PER cannot be send in the same HTTP-over-TLS connection the Registrar-Agent may send the PER in a new HTTP-over-TLS connection. The registrar is able to correlate the PVR and the PER based on the signatures and the contained product-serial-number information. Note, this also addresses situations in which a nonceless voucher is used and may be pre-provisioned to the pledge. depicts exchanges for the PER request handling and the following subsections describe the corresponding artifacts.

| | | | |-------PER------>| | | | | |<-----mTLS------>| | | | |-------RER------>| | | | |<--Enroll-Resp---| | | |<--Enroll-Resp---| | | | | | | | ~ ~ ~ ~ ~ ]]>

In case the TLS connection to the registrar is already closed, the Registrar-Agent opens a new TLS connection with the registrar as stated in .

Request Artifact: Pledge Enroll-Request (PER) As specified in deviating from BRSKI the PER is not a raw PKCS#10. As the Registrar-Agent is involved in the exchange, the PKCS#10 is wrapped in a JWS object by the pledge and signed with pledge's IDevID to ensure proof-of-identity as outlined in . EST standard endpoints (/simpleenroll, /simplereenroll, /serverkeygen, /cacerts) on the registrar cannot be used for BRSKI-PRM. This is caused by the utilization of signature wrapped-objects in BRSKI-PRM. As EST requires to sent a raw PKCS#10 request to e.g., "/.well-known/est/simpleenroll" endpoint, this document makes an enhancement by utilizing EST but with the exception to transport a signature wrapped PKCS#10 request. Therefore a new endpoint for BRSKI-PRM on the registrar is defined as "/.well-known/brski/requestenroll" The Registrar-Agent SHALL send the PER to the registrar by HTTP POST to the endpoint: "/.well-known/brski/requestenroll" The Content-Type header of PER is: application/jose+json. This is a deviation from the Content-Type header values used in and results in additional processing at the domain registrar (as EST server). Note, the registrar is already aware that the bootstrapping is performed in a pledge-responder-mode due to the use of the EE (RegAgt) certificate for TLS and the provided PVR as JSON-in-JWS object. If the registrar receives a PER with Content-Type header: application/jose+json, it MUST verify the wrapping signature using the certificate indicated in the JOSE header. The registrar verifies that the pledge's certificate (here IDevID), carried in "x5c" header field, is accepted to join the domain after successful validation of the PVR.

Enroll Pledge by Domain CA (backend interaction) If both succeed, the registrar utilizes the PKCS#10 request contained in the JWS object body as "P10" parameter of "ietf-sztp-csr:csr" for further processing of the Enroll-Request with the corresponding domain CA. It creates a Registrar Enroll-Request (RER) by utilizing the protocol expected by the domain CA. The domain registrar may either directly forward the provided PKCS#10 request to the CA or provide additional information about attributes to be included by the CA into the requested LDevID certificate. The approach of sending this information to the CA depends on the utilized certificate management protocol between the RA and the CA and is out of scope for this document.

Response Artifact: Enroll-Response (Enroll-Resp) The registrar SHOULD respond with an HTTP 200 OK in the success case or fail with HTTP 4xx/5xx status codes as defined by the HTTP standard. A successful interaction with the domain CA will result in a pledge LDevID certificate, which is then forwarded by the registrar to the Registrar-Agent using the Content-Type header: application/pkcs7-mime. Note while BRSKI-PRM targets the initial enrollment, re-enrollment may be supported in a similar way with the exception that the current LDevID certificate is used instead of the IDevID certificate to verify the wrapping signature of the PKCS#10 request (see also ).

Request CA Certificates As the pledge will verify it own certificate LDevID certificate when received, it also needs the corresponding CA certificates. This is done in EST using the "/.well-known/est/cacerts" endpoint, which provides the CA certificates over a TLS protected connection. BRSKI-PRM requires a signature wrapped CA certificate object, to avoid that the pledge can be provided with arbitrary CA certificates in an authorized way. The registrar signed CA certificate object will allow the pledge to verify the authorization to install the received CA certificate(s). As the CA certificate(s) are provided to the pledge after the voucher, the pledge has the required information (the domain certificate) to verify the wrapped CA certificate object. shows the request and provisioning of CA certificates in the infrastructure. The following subsections describe the corresponding artifacts.

| | | | |---cACert-Req--->| | | | |<--cACert-Resp---| | | | | | | | ~ ~ ~ ~ ~ ]]>

In case the TLS connection to the registrar is already closed, the Registrar-Agent opens a new TLS connection with the registrar as stated in .

Request Artifact: cACert-Request (cACert-Req) To support Registrar-Agents requesting a signature wrapped CA certificate(s) object, a new endpoint for BRSKI-PRM is defined on the registrar: "/.well-known/brski/wrappedcacerts" The Registrar-Agent SHALL requests the EST CA trust anchor database information (in form of CA certificates) by HTTP GET.

Response Artifact: cACert-Response (cACert-Resp) The Content-Type header of the response SHALL be: application/jose+json. This is a deviation from the Content-Type header values used in EST and results in additional processing at the domain registrar (as EST server). The additional processing is to sign the CA certificate(s) information using the registrar LDevID credentials. This results in a signed CA certificate(s) object (JSON-in-JWS), the CA certificates are provided as base64-encoded "x5bag" (see definition in ) in the JWS payload.

Supply Voucher to Pledge It is assumed that the Registrar-Agent already obtained the bootstrapping response objects from the domain registrar and can supply them to the pledge: voucher-response - Voucher (from MASA via Registrar) wrapped-CA-certificate(s)-response - CA certificates enrollment-response - LDevID (Pledge) certificate (from CA via registrar) To deliver these response objects, the Registrar-Agent will re-connect to the pledge. To contact the pledge, it may either discover the pledge as described in or use stored information from the first contact with the pledge. Preconditions in addition to : Registrar-Agent: obtained voucher and LDevID certificate and optionally IDevID CA certificates. The IDevID CA certificate is necessary, when the connection between the Registrar-Agent and the pledge is established using TLS to enable the Registrar-Agent to validate the pledges' IDevID certificate during the TLS handshake as described in . The Registrar-Agent MAY optionally use TLS to protect the communication as outlined in . The Registrar-Agent provides the information via distinct pledge endpoints as following. shows the provisioning of the voucher to the pledge. The following subsections describe the corresponding artifacts.

| | | | |<-----Voucher-----| | | | |------vStatus---->| | | | | | | | | ~ ~ ~ ~ ~ ]]>

Request Artifact: Voucher The Registrar-Agent SHALL send the voucher-response to the pledge by HTTP POST to the endpoint: "/.well-known/brski/svr". The Registrar-Agent voucher-response Content-Type header is application/voucher-jws+json and contains the voucher as provided by the MASA. An example is given in for a MASA signed voucher and in for the voucher with the additional signature of the registrar. A nonceless voucher may be accepted as in and may be allowed by a manufacture's pledge implementation. To perform the validation of several signatures on the voucher object, the pledge SHALL perform the signature verification in the following order: Verify MASA signature as described in , against pre-installed manufacturer trust anchor (IDevID). Install trust anchor contained in the voucher ("pinned-domain-cert") provisionally Validate the LDevID(Reg) certificate received in the agent-provided-proximity-registrar-cert in the Pledge-Voucher-Request trigger request (in the field "agent-provided-proximity-registrar-cert") Verify registrar signature of the voucher similar as described in , but take the registrar certificate instead of the MASA certificate for the verification Step3 and step 4 have been introduced in BRSKI-PRM to enable verification of LDevID(Reg) certificate and also the proof-of-possession of the corresponding private key by the registrar, which is done in BRSKI based on the established TLS channel. If all steps stated above have been performed successfully, the pledge SHALL terminate the "PROVISIONAL accept" state for the domain trust anchor and the registrar LDevID certificate. If an error occurs during the verification and validation of the voucher, this SHALL be reported in the reason field of the pledge voucher status.

Response Artifact: Voucher Status (vStatus) After voucher verification and validation the pledge MUST reply with a status telemetry message as defined in . The pledge generates the voucher-status and provides it as signed JSON-in-JWS object in response to the Registrar-Agent. The response has the Content-Type application/jose+json and is signed using the IDevID of the pledge as shown in . As the reason field is optional (see ), it MAY be omitted in case of success.

If the pledge did not did not provide voucher status telemetry information after processing the voucher, the Registrar-Agent MAY query the pledge status explicitly as described in and MAY resent the voucher depending on the Pledge status following the procedure described in .

Supply CA Certificates to Pledge shows the provisioning of the CA certificates aquired by the pledge-agent to the pledge. The following subsections describe the corresponding artifacts.

| | | | |<-----cACerts-----| | | | | | | | | ~ ~ ~ ~ ~ ]]>

Request Artifact: The Registrar-Agent SHALL provide the set of CA certificates requested from the registrar to the pledge by HTTP POST to the endpoint: "/.well-known/brski/scac". As the CA certificate provisioning is crucial from a security perspective, this provisioning SHOULD only be done, if the voucher-response has been successfully processed by pledge as reflected in the voucher status telemetry. The CA certificates message has the Content-Type application/jose+json and is signed using the credential of the registrar as shown in . The CA certificates are provided as base64-encoded "x5bag". The pledge SHALL install the received CA certificates as trust anchor after successful verification of the registrar's signature.

Response (no artifact) The verification comprises the following steps the pledge MUST perform. Maintaining the order of versification steps as indicated allows to determine, which verification has already been passed: Check content-type of the CA certificates message. If no Content-Type is contained in the HTTP header, the default Content-Type utilized in this document (JSON-in-JWS) is used. If the Content-Type of the response is in an unknown or unsupported format, the pledge SHOULD reply with a 415 Unsupported media type error code. Check the encoding of the payload. If the pledge detects errors in the encoding of the payload, it SHOULD reply with 400 Bad Request error code. Verify that the wrapped CA certificate object is signed using the registrar certificate against the pinned-domain certificate. This MAY be done by comparing the hash that is indicating the certificate used to sign the message is that of the pinned-domain certificate. If the validation against the pinned domain-certificate fails, the client SHOULD reply with a 401 Unauthorized error code. It signals that the authentication has failed and therefore the object was not accepted. Verify signature of the received wrapped CA certificate object using the domain certificate contained in the voucher. If the validation of the signature fails, the pledge SHOULD reply with a 403 Forbidden. It signals that the object could not be verified and has not been accepted. If the received CA certificates are not self-signed, i.e., an intermediate CA certificate, verify them against an already installed trust anchor, as described in section 4.1.3 of . In case of success, the pledge SHOULD reply with HTTP 200 OK without a response body.

Supply Enroll-Response to Pledge shows the supply of the Enroll-Response to the pledge. The following subsections describe the corresponding artifacts.

| | | | |<---Enroll-Resp---| | | | |-----eStatus----->| | | | | | | | | ~ ~ ~ ~ ~ ]]>

Request Artifact: Enroll-Response (Enroll-Resp) The Registrar-Agent SHALL send the Enroll-Response to the pledge by HTTP(S) POST to the endpoint: "/.well-known/brski/ser". The Content-Type header when using EST as enrollment protocol between the Registrar-Agent and the infrastructure is application/pkcs7-mime. Note: It only contains the LDevID certificate for the pledge, not the certificate chain. Upon reception, the pledge SHALL verify the received LDevID certificate. The pledge SHALL generate the enroll status and provide it in the response to the Registrar-Agent. If the verification of the LDevID certificate succeeds, the status property SHALL be set to "status": true, otherwise to "status": false

Response Artifact: Enroll Status (eStatus) After enrollment processing the pledge MUST reply with a enrollment status telemetry message as defined in . The enroll-status is also a signed object in BRSKI-PRM and results in form of JSON-in-JWS here. If the pledge verified the received LDevID certificate successfully it SHALL sign the enroll-status using its new LDevID credentials as shown in . In failure case, the pledge SHALL use its IDevID credentials. specifies the enrollment status telemetry message with two optional fields for "reason" and "reason-context". In BRSKI-PRM the optional fields are mandated to have a clear distinction between other status messages and MUST be provided therefore. This distinction is intended for better error handling on registrar side, as a status object could be send to a wrong status endpoint. The following CDDL explains enroll-status response structure. It is similar as defined in with the optional fields set to mandatory as described above.

enrollstatus-trigger = { "version": uint, "status": bool, "reason": text, "reason-context" : { $$arbitrary-map } } ]]>

The response has the Content-Type application/jose+json.

Once the Registrar-Agent has collected the information, it can connect to the registrar to provide it with the status responses.

Voucher Status Telemetry (including backend interaction) The following description requires that the Registrar-Agent has collected the status information from the pledge. It SHALL provide the status information to the registrar for further processing. Preconditions in addition to : Registrar-Agent: obtained voucher status (vStatus) and enroll status (eStatus) from pledge.

| | | | |-----vStatus---->| | | | | |<-----------(mTLS)----------->| | | |-----req device audit log---->| | | |<------device audit log-------| | | [verify audit log] | | | | | | | ~ ~ ~ ~ ~ ]]>

{: #exchangesfig_uc2_9 title="Voucher Status telemetry exchange" artwork-align="center"}~~~~ aasvg In case the TLS connection to the registrar is already closed, the Registrar-Agent opens a new TLS connection with the registrar as stated in . The Registrar-Agent MUST provide the collected pledge voucher status to the registrar. This status indicates if the pledge could process the voucher successfully or not.

Request Artifact: Voucher Status (vStatus) The Registrar-Agent sends the pledge voucher status without modification to the registrar with an HTTP-over-TLS POST using the registrar endpoint "/.well-known/brski/voucher_status". The Content-Type header is kept as application/jose+json as depicted in the example in . The registrar SHOULD log the transaction provided for a pledge via Registrar-Agent and include the identity of the Registrar-Agent in these logs. For log analysis the following may be considered: The registrar knows the interacting Registrar-Agent from the authentication of the Registrar-Agent towards the registrar using LDevID (RegAgt) and can log it accordingly. The telemetry information from the pledge can be correlated to the voucher response provided from the registrar to the Registrar-Agent and further to the pledge. The telemetry information, when provided to the registrar is provided via the Registrar-Agent and can thus be correlated. The registrar SHALL verify the signature of the pledge voucher status and validate that it belongs to an accepted device of the domain based on the contained "serial-number" in the IDevID certificate referenced in the header of the voucher status.

Response (no artifact) According to , the registrar SHOULD respond with an HTTP 200 OK without a response body in the success case or fail with HTTP 4xx/5xx status codes. The Registrar-Agent may use the response status code to signal success/failure to the service technician operating the Registrar-Agent. Within the server logs the server SHOULD capture this telemetry information. The registrar SHOULD proceed with collecting and logging status information by requesting the MASA audit-log from the MASA service as described in .

Enroll Status Telemetry The Registrar-Agent MUST provide the pledge's enroll status to the registrar. The status indicates the pledge could process the Enroll-Response (certificate) and holds the corresponding private key.

| | | | |-----eStatus---->| | | | | | | | ~ ~ ~ ~ ~ ]]>

In case the TLS connection to the registrar is already closed, the Registrar-Agent opens a new TLS connection with the registrar as stated in .

Request Artifact: Enroll Status (eStatus) The Registrar-Agent sends the pledge enroll status without modification to the registrar with an HTTP-over-TLS POST using the registrar endpoint "/.well-known/brski/enrollstatus". The Content-Type header is kept as application/jose+json as depicted in the example in . The registrar MUST verify the signature of the pledge enroll status. Also, the registrar SHALL validate that the pledge is an accepted device of the domain based on the contained product-serial-number in the LDevID certificate referenced in the header of the enroll status. The registrar SHOULD log this event. In case the pledge enroll status indicates a failure, the pledge was unable to verify the received LDevID certificate and therefore signed the enroll status with its IDevID credential. Note that the signature verification of the status information is an addition to the described handling in , and is replacing the pledges TLS client authentication by DevID credentials in .

Response (no artifact) According to , the registrar SHOULD respond with an HTTP 200 OK in the success case or fail with HTTP 4xx/5xx status codes. Based on the failure case the registrar MAY decide that for security reasons the pledge is not allowed to reside in the domain. In this case the registrar MUST revoke the certificate. An example case for the registrar revoking the issued LDevID for the pledge is when the pledge was not able to verify the received LDevID certificate and therefore did send a 406 (Not Acceptable) response. In this case the registrar may revoke the LDevID certificate as the pledge did no accepted it for installation. The Registrar-Agent may use the response to signal success / failure to the service technician operating the Registrar-Agent. Within the server log the registrar SHOULD capture this telemetry information.

Query Pledge Status The following assumes that a Registrar-Agent may need to query the status of a pledge. This information may be useful to solve errors, when the pledge was not able to connect to the target domain during the bootstrapping. The pledge MAY provide the dedicated endpoint for the Query Pledge Status operation.

| | | | |<-----tStatus-----| | | | |------pStatus---->| | | | | | | | | ~ ~ ~ ~ ~ ]]>

The Registrar-Agent queries the Pledge Status via HTTP POST request on the well-known pledge endpoint /.well-known/brski/qps. The request body MUST contain the JWS-signed Status Trigger (tStatus) artifact. The request header MUST set the Content-Type field application/jose+json. If the pledge provides the Query Pledge Status endpoint, it MUST reply to this request with the Pledge Status (pStatus) artifact in the body of a 200 OK response. The response header MUST have the Content-Type field set to application/jose+json.

Request Artifact: Status Trigger (tStatus) The Status Query artifact is a JWS structure signing information on the requested status-type, the time and date the request is created, and the product serial-number of the pledge contacted as shown in . The following Concise Data Definition Language (CDDL) defines the structure of the unsigned Status Query data (i.e., JWS payload):

statustrigger = { "version": uint, "created-on": tdate, "serial-number": text, "status-type": text } ]]>

The version field is included to permit significant changes to the pledge status artifacts in the future. The format and semantics in this document follow the status telemetry definitions of . Hence, the version MUST be set to 1. A pledge (or Registrar-Agent) that receives a version larger than it knows about SHOULD log the contents and alert a human. The created-on field contains a standard date/time string following . The serial-number field takes the product-serial-number corresponding to the X520SerialNumber field of the IDevID certificate of the pledge. The status-type value defined for BRSKI-PRM Status Query is bootstrap. This indicates the pledge to provide current status information regarding the bootstrapping status (voucher processing and enrollment of the pledge into the new domain). As the Status Query artifact is defined generic, it may be used by other specifications to request further status information using other status types, e.g., for onboarding to get further information about enrollment of application specific LDevIDs or other parameters. This is out of scope for this specification. below shows an example for unsigned Status Query data in JSON syntax using status-type bootstrap.

The Status Query data MUST be signed by the Registrar-Agent using its private key corresponding to the EE (RegAgt) certificate. When using a JWS signature, the Status Query artifact looks as shown in and the Content-Type response header MUST be set to application/jose+json:

For details on JWS Protected Header and JWS Signature see or .

Response Artifact: Pledge Status (pStatus) When the pledge receives a Status Query with status-type bootstrap it SHALL respond with previously collected telemetry information (see and ) in a single Pledge Status artifact. The pledge-status response message is signed with IDevID or LDevID, depending on bootstrapping state of the pledge. The following CDDL defines the structure of the Pledge Status (pStatus) data:

pledgestatus = { "version": uint, "status": "factory-default" / "voucher-success" / "voucher-error" / "enroll-success" / "enroll-error" / "connect-success" / "connect-error", ?"reason" : text, ?"reason-context": { $$arbitrary-map } } ]]>

Different cases for pledge bootstrapping status may occur, which SHOULD be reflected using the status enumeration. This document specifies the status values in the context of the bootstrapping process and credential application. Other documents may enhance the above enumeration to reflect further status information. "factory-default": Pledge has not been bootstrapped. Additional information may be provided in the reason or reason-context. The pledge signs the response message using its IDevID(Pledge). "voucher-success": Pledge processed the voucher exchange successfully. Additional information may be provided in the reason or reason-context. The pledge signs the response message using its IDevID(Pledge). "voucher-error": Pledge voucher processing terminated with error. Additional information may be provided in the reason or reason-context. The pledge signs the response message using its IDevID(Pledge). "enroll-success": Pledge has processed the enrollment exchange successfully. Additional information may be provided in the reason or reason-context. The pledge signs the response message using its LDevID(Pledge). "enroll-error": Pledge enrollment-response processing terminated with error. Additional information may be provided in the reason or reason-context. The pledge signs the response message using its IDevID(Pledge). As the pledge is assumed to utilize its bootstrapped credentials (LDevID) in communication with other peers, additional status information is provided for the connectivity to other peers, which may be helpful in analyzing potential error cases. "connect-success": Pledge could successfully establish a connection to another peer. Additional information may be provided in the reason or reason-context. The pledge signs the response message using its LDevID(Pledge). "connect-error": Pledge connection establishment terminated with error. Additional information may be provided in the reason or reason-context. The pledge signs the response message using its LDevID(Pledge). The pledge-status responses are cumulative in the sense that connect-success implies enroll-success, which in turn implies voucher-success. provides an example for the bootstrapping-status information.

In case "factory-default" the pledge does not possess the domain certificate resp. the domain trust-anchor. It will not be able to verify the signature of the Registrar-Agent in the bootstrapping-status request. In cases "vouchered" and "enrolled" the pledge already possesses the domain certificate (has domain trust-anchor) and can therefore validate the signature of the Registrar-Agent. If validation of the JWS signature fails, the pledge SHOULD respond with the HTTP 403 Forbidden status code. The HTTP 406 Not Acceptable status code SHOULD be used, if the Accept header in the request indicates an unknown or unsupported format. The HTTP 415 Unsupported Media Type status code SHOULD be used, if the Content-Type of the request is an unknown or unsupported format. The HTTP 400 Bad Request status code SHOULD be used, if the Accept/Content-Type headers are correct but nevertheless the status-request cannot be correctly parsed. The pledge SHOULD by default only respond to requests from nodes it can authenticate (such as registrar agent), once the pledge is enrolled with CA certificates and a matching domain certificate.

IANA Considerations This document requires the following IANA actions.

BRSKI .well-known Registry IANA is requested to enhance the Registry entitled: "BRSKI Well-Known URIs" with the following endpoints: Path Segment Description Reference requestenroll Supply PER to registrar [THISRFC] wrappedcacerts Request wrapped CA certificates [THISRFC] tpvr Trigger Pledge Voucher-Request [THISRFC] tper Trigger Pledge Enroll-Request [THISRFC] svr Supply Voucher to pledge [THISRFC] scac Supply CA certificates to pledge [THISRFC] ser Supply Enroll-Response to pledge [THISRFC] qps Query Pledge Status [THISRFC]

DNS Service Names IANA has registered the following service names: Service Name: brski-pledge
Transport Protocol(s): tcp
Assignee: IESG iesg@ietf.org
Contact: IESG iesg@ietf.org
Description: The Bootstrapping Remote Secure Key Infrastructure Pledge
Reference: [THISRFC]

Privacy Considerations In general, the privacy considerations of apply for BRSKI-PRM also. Further privacy aspects need to be considered for: the introduction of the additional component Registrar-Agent potentially no transport layer security between Registrar-Agent and pledge describes to optional apply TLS to protect the communication between the Registrar-Agent and the pledge. The following is therefore applicable to the communication without the TLS protection. The credential used by the Registrar-Agent to sign the data for the pledge SHOULD NOT contain any personal information. Therefore, it is recommended to use an LDevID certificate associated with the commissioning device instead of an LDevID certificate associated with the service technician operating the device. This avoids revealing potentially included personal information to Registrar and MASA. The communication between the pledge and the Registrar-Agent is performed over plain HTTP. Therefore, it is subject to disclosure by a Dolev-Yao attacker (an "oppressive observer"). Depending on the requests and responses, the following information is disclosed. the Pledge product-serial-number is contained in the trigger message for the PVR and in all responses from the pledge. This information reveals the identity of the devices being bootstrapped and allows deduction of which products an operator is using in their environment. As the communication between the pledge and the Registrar-Agent may be realized over wireless link, this information could easily be eavesdropped, if the wireless network is unencrypted. Even if the wireless network is encrypted, if it uses a network-wide key, then layer-2 attacks (ARP/ND spoofing) could insert an on-path observer into the path. the Timestamp data could reveal the activation time of the device. the Status data of the device could reveal information about the current state of the device in the domain network.

Security Considerations In general, the security considerations of apply for BRSKI-PRM also. Further security aspects are considered here related to: the introduction of the additional component Registrar-Agent the reversal of the pledge communication direction (push mode, compared to BRSKI) no transport layer security between Registrar-Agent and pledge

Denial of Service (DoS) Attack on Pledge Disrupting the pledge behavior by a DoS attack may prevent the bootstrapping of the pledge to a new domain. Because in BRSKI-PRM, the pledge responds to requests from real or illicit Registrar-Agents, pledges are more subject to DoS attacks from Registrar-Agents in BRSKI-PRM than they are from illicit registrars in , where pledges do initiate the connections. A DoS attack with a faked Registrar-Agent may block the bootstrapping of the pledge due changing state on the pledge (the pledge may produce a voucher-request, and refuse to produce another one). One mitigation may be that the pledge does not limited the number of voucher-requests it creates until at least one has finished. An alternative may be that the onboarding state may expire after a certain time, if no further interaction has happened. In addition, the pledge may assume that repeated triggering for PVR are the result of a communication error with the Registrar-Agent. In that case the pledge MAY simply resent the PVR previously sent. Note that in case of resending, a contained nonce and also the contained agent-signed-data in the PVR would consequently be reused.

Misuse of acquired PVR and PER by Registrar-Agent A Registrar-Agent that uses previously requested PVR and PER for domain-A, may attempt to onboard the device into domain-B. This can be detected by the domain registrar while PVR processing. The domain registrar needs to verify that the "proximity-registrar-cert" field in the PVR matches its own registrar LDevID certificate. In addition, the domain registrar needs to verify the association of the pledge to its domain based on the product-serial-number contained in the PVR and in the IDevID certificate of the pledge. (This is just part of the supply chain integration). Moreover, the domain registrar verifies if the Registrar-Agent is authorized to interact with the pledge for voucher-requests and enroll-requests, based on the EE (RegAgt) certificate data contained in the PVR. Misbinding of a pledge by a faked domain registrar is countered as described in BRSKI security considerations .

Misuse of Registrar-Agent Credentials Concerns of misusage of a Registrar-Agent with a valid EE (RegAgt) certificate may be addressed by utilizing short-lived certificates (e.g., valid for a day) to authenticate the Registrar-Agent against the domain registrar. The EE (RegAgt) certificate may have been acquired by a prior BRSKI run for the Registrar-Agent, if an IDevID is available on Registrar-Agent. Alternatively, the EE (RegAgt) certificate may be acquired by a service technician from the domain PKI system in an authenticated way. In addition it is required that the EE (RegAgt) certificate is valid for the complete bootstrapping phase. This avoids that a Registrar-Agent could be misused to create arbitrary "agent-signed-data" objects to perform an authorized bootstrapping of a rogue pledge at a later point in time. In this misuse "agent-signed-data" could be dated after the validity time of the EE (RegAgt) certificate, due to missing trusted timestamp in the Registrar-Agents signature. To address this, the registrar SHOULD verify the certificate used to create the signature on "agent-signed-data". Furthermore the registrar also verifies the EE (RegAgt) certificate used in the TLS handshake with the Registrar-Agent. If both certificates are verified successfully, the Registrar-Agent's signature can be considered as valid.

Misuse of DNS-SD with mDNS to obtain list of pledges To discover a specific pledge a Registrar-Agent may request the service name in combination with the product-serial-number of a specific pledge. The pledge reacts on this if its product-serial-number is part of the request message. If the Registrar-Agent performs DNS-based Service Discovery without a specific product-serial-number, all pledges in the domain react if the functionality is supported. This functionality enumerates and reveals the information of devices available in the domain. The information about this is provided here as a feature to support the commissioning of devices. A manufacturer may decide to support this feature only for devices not possessing a LDevID or to not support this feature at all, to avoid an enumeration in an operative domain.

YANG Module Security Considerations The enhanced voucher-request described in is based on , but uses a different encoding based on . The security considerations as described in (Security Considerations) apply. The YANG module specified in defines the schema for data that is subsequently encapsulated by a JOSE signed-data Content-type as described in . As such, all of the YANG-modeled data is protected against modification. The use of YANG to define data structures via the "structure" statement, is relatively new and distinct from the traditional use of YANG to define an API accessed by network management protocols such as NETCONF and RESTCONF . For this reason, these guidelines do not follow the template described by (Security Considerations).

Acknowledgments We would like to thank the various reviewers, in particular Brian E. Carpenter, Charlie Kaufman (Early SECDIR review), Martin Björklund (Early YANGDOCTORS review), Marco Tiloca (Early IOTDIR review), Oskar Camenzind, Hendrik Brockhaus, and Ingo Wenda for their input and discussion on use cases and call flows. Further review input was provided by Jesser Bouzid, Dominik Tacke, and Christian Spindler. Special thanks to Esko Dijk for the in deep review and the improving proposals. Support in PoC implementations and comments resulting from the implementation was provided by Hong Rui Li and He Peng Jia.

As networked devices become smaller, more portable, and more ubiquitous, the ability to operate with less configured infrastructure is increasingly important. In particular, the ability to look up DNS resource record data types (including, but not limited to, host names) in the absence of a conventional managed DNS server is useful. Multicast DNS (mDNS) provides the ability to perform DNS-like operations on the local link in the absence of any conventional Unicast DNS server. In addition, Multicast DNS designates a portion of the DNS namespace to be free for local use, without the need to pay any annual fee, and without the need to set up delegations or otherwise configure a conventional DNS server to answer for those names. The primary benefits of Multicast DNS names are that (i) they require little or no administration or configuration to set them up, (ii) they work when no infrastructure is present, and (iii) they work during infrastructure failures. This document specifies how DNS resource records are named and structured to facilitate service discovery. Given a type of service that a client is looking for, and a domain in which the client is looking for that service, this mechanism allows clients to discover a list of named instances of that desired service, using standard DNS queries. This mechanism is referred to as DNS-based Service Discovery, or DNS-SD. This document profiles certificate enrollment for clients using Certificate Management over CMS (CMC) messages over a secure transport. This profile, called Enrollment over Secure Transport (EST), describes a simple, yet functional, certificate management protocol targeting Public Key Infrastructure (PKI) clients that need to acquire client certificates and associated Certification Authority (CA) certificates. It also supports client-generated public/private key pairs as well as key pairs generated by the CA. JSON Web Signature (JWS) represents content secured with digital signatures or Message Authentication Codes (MACs) using JSON-based data structures. Cryptographic algorithms and identifiers for use with this specification are described in the separate JSON Web Algorithms (JWA) specification and an IANA registry defined by that specification. Related encryption capabilities are described in the separate JSON Web Encryption (JWE) specification. This document defines a strategy to securely assign a pledge to an owner using an artifact signed, directly or indirectly, by the pledge's manufacturer. This artifact is known as a "voucher". This document defines an artifact format as a YANG-defined JSON document that has been signed using a Cryptographic Message Syntax (CMS) structure. Other YANG-derived formats are possible. The voucher artifact is normally generated by the pledge's manufacturer (i.e., the Manufacturer Authorized Signing Authority (MASA)). This document only defines the voucher artifact, leaving it to other documents to describe specialized protocols for accessing it. 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. This memo defines a path prefix for "well-known locations", "/.well-known/", in selected Uniform Resource Identifier (URI) schemes. In doing so, it obsoletes RFC 5785 and updates the URI schemes defined in RFC 7230 to reserve that space. It also updates RFC 7595 to track URI schemes that support well-known URIs in their registry. This document specifies automated bootstrapping of an Autonomic Control Plane. To do this, a Secure Key Infrastructure is bootstrapped. This is done using manufacturer-installed X.509 certificates, in combination with a manufacturer's authorizing service, both online and offline. We call this process the Bootstrapping Remote Secure Key Infrastructure (BRSKI) protocol. Bootstrapping a new device can occur when using a routable address and a cloud service, only link-local connectivity, or limited/disconnected networks. Support for deployment models with less stringent security requirements is included. Bootstrapping is complete when the cryptographic identity of the new key infrastructure is successfully deployed to the device. The established secure connection can be used to deploy a locally issued certificate to the device as well. The CBOR Object Signing and Encryption (COSE) message structure uses references to keys in general. For some algorithms, additional properties are defined that carry parameters relating to keys as needed. The COSE Key structure is used for transporting keys outside of COSE messages. This document extends the way that keys can be identified and transported by providing attributes that refer to or contain X.509 certificates. Siemens AG Sandelman Software Works [TODO: I-D.draft-ietf-anima-rfc8366bis] defines a digital artifact called voucher as a YANG-defined JSON document that is signed using a Cryptographic Message Syntax (CMS) structure. This document introduces a variant of the voucher artifact in which CMS is replaced by the JSON Object Signing and Encryption (JOSE) mechanism described in RFC7515 to support deployments in which JOSE is preferred over CMS. In addition to explaining how the format is created, the "application/voucher-jws+json" media type is registered and examples are provided. Watsen Networks Vigil Security, LLC sn3rd This draft extends the input to the "get-bootstrapping-data" RPC defined in RFC 8572 to include an optional certificate signing request (CSR), enabling a bootstrapping device to additionally obtain an identity certificate (e.g., an LDevID from IEEE 802.1AR) as part of the "onboarding information" response provided in the RPC-reply. Watsen Networks Sandelman Software Cisco Systems Futurewei Technologies Inc. Huawei This document defines a strategy to securely assign a pledge to an owner using an artifact signed, directly or indirectly, by the pledge's manufacturer. This artifact is known as a "voucher". This document defines an artifact format as a YANG-defined JSON or CBOR document that has been signed using a variety of cryptographic systems. The voucher artifact is normally generated by the pledge's manufacturer (i.e., the Manufacturer Authorized Signing Authority (MASA)). This document updates RFC8366, merging a number of extensions into the YANG. The RFC8995 voucher request is also merged into this document. 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. 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. JavaScript Object Notation (JSON) is a lightweight, text-based, language-independent data interchange format. It was derived from the ECMAScript Programming Language Standard. JSON defines a small set of formatting rules for the portable representation of structured data. This document removes inconsistencies with other specifications of JSON, repairs specification errors, and offers experience-based interoperability guidance. This document defines a date and time format for use in Internet protocols that is a profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar. This memo represents a republication of PKCS #10 v1.7 from RSA Laboratories' Public-Key Cryptography Standards (PKCS) series, and change control is retained within the PKCS process. The body of this document, except for the security considerations section, is taken directly from the PKCS #9 v2.0 or the PKCS #10 v1.7 document. This memo provides information for the Internet community. ISO/IEC 10646-1 defines a large character set called the Universal Character Set (UCS) which encompasses most of the world's writing systems. The originally proposed encodings of the UCS, however, were not compatible with many current applications and protocols, and this has led to the development of UTF-8, the object of this memo. UTF-8 has the characteristic of preserving the full US-ASCII range, providing compatibility with file systems, parsers and other software that rely on US-ASCII values but are transparent to other values. This memo obsoletes and replaces RFC 2279. This document defines the base syntax for CMC, a Certificate Management protocol using the Cryptographic Message Syntax (CMS). This protocol addresses two immediate needs within the Internet Public Key Infrastructure (PKI) community: 1. The need for an interface to public key certification products and services based on CMS and PKCS #10 (Public Key Cryptography Standard), and 2. The need for a PKI enrollment protocol for encryption only keys due to algorithm or hardware design. CMC also requires the use of the transport document and the requirements usage document along with this document for a full definition. [STANDARDS-TRACK] Many application technologies enable secure communication between two entities by means of Transport Layer Security (TLS) with Internet Public Key Infrastructure using X.509 (PKIX) certificates. This document specifies procedures for representing and verifying the identity of application services in such interactions. This document obsoletes RFC 6125. The Network Configuration Protocol (NETCONF) defined in this document provides mechanisms to install, manipulate, and delete the configuration of network devices. It uses an Extensible Markup Language (XML)-based data encoding for the configuration data as well as the protocol messages. The NETCONF protocol operations are realized as remote procedure calls (RPCs). This document obsoletes RFC 4741. [STANDARDS-TRACK] The Constrained Application Protocol (CoAP) is a specialized web transfer protocol for use with constrained nodes and constrained (e.g., low-power, lossy) networks. The nodes often have 8-bit microcontrollers with small amounts of ROM and RAM, while constrained networks such as IPv6 over Low-Power Wireless Personal Area Networks (6LoWPANs) often have high packet error rates and a typical throughput of 10s of kbit/s. The protocol is designed for machine- to-machine (M2M) applications such as smart energy and building automation. CoAP provides a request/response interaction model between application endpoints, supports built-in discovery of services and resources, and includes key concepts of the Web such as URIs and Internet media types. CoAP is designed to easily interface with HTTP for integration with the Web while meeting specialized requirements such as multicast support, very low overhead, and simplicity for constrained environments. This document describes an HTTP-based protocol that provides a programmatic interface for accessing data defined in YANG, using the datastore concepts defined in the Network Configuration Protocol (NETCONF). This memo provides guidelines for authors and reviewers of specifications containing YANG modules. Recommendations and procedures are defined, which are intended to increase interoperability and usability of Network Configuration Protocol (NETCONF) and RESTCONF protocol implementations that utilize YANG modules. This document obsoletes RFC 6087. This document defines two strategies for handling long lines in width-bounded text content. One strategy, called the "single backslash" strategy, is based on the historical use of a single backslash ('\') character to indicate where line-folding has occurred, with the continuation occurring with the first character that is not a space character (' ') on the next line. The second strategy, called the "double backslash" strategy, extends the first strategy by adding a second backslash character to identify where the continuation begins and is thereby able to handle cases not supported by the first strategy. Both strategies use a self-describing header enabling automated reconstitution of the original content. This document specifies the GeneRic Autonomic Signaling Protocol (GRASP), which enables autonomic nodes and Autonomic Service Agents to dynamically discover peers, to synchronize state with each other, and to negotiate parameter settings with each other. GRASP depends on an external security environment that is described elsewhere. The technical objectives and parameters for specific application scenarios are to be described in separate documents. Appendices briefly discuss requirements for the protocol and existing protocols with comparable features. 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. The Hypertext Transfer Protocol (HTTP) is a stateless application-level protocol for distributed, collaborative, hypertext information systems. This document describes the overall architecture of HTTP, establishes common terminology, and defines aspects of the protocol that are shared by all versions. In this definition are core protocol elements, extensibility mechanisms, and the "http" and "https" Uniform Resource Identifier (URI) schemes. This document updates RFC 3864 and obsoletes RFCs 2818, 7231, 7232, 7233, 7235, 7538, 7615, 7694, and portions of 7230. This informational document details a protocol to load Manufacturer Usage Description (MUD) definitions from RFC 8520 for devices that do not have them integrated. This document is published to inform the Internet community of this mechanism to allow interoperability and to serve as a basis of other standards work if there is interest. Siemens AG Siemens AG Siemens AG This document defines an enhancement of Bootstrapping Remote Secure Key Infrastructure (BRSKI, RFC 8995). It supports alternative certificate enrollment protocols, such as CMP, that use authenticated self-contained signed objects for certification messages. This offers the following advantages. The origin of requests and responses can be authenticated independently of message transfer. This supports end-to-end authentication (proof of origin) also over multiple hops, as well as asynchronous operation of certificate enrollment. This in turn provides architectural flexibility where and when to ultimately authenticate and authorize certification requests while retaining full-strength integrity and authenticity of certification requests. FreeRADIUS Sandelman Software Works This document describes a method by which an unconfigured device can use EAP to join a network on which further device onboarding, network attestation or other remediation can be done. While RFC 5216 supports EAP-TLS without a client certificate, that document defines no method by which unauthenticated EAP-TLS can be used. This draft addresses that issue. First, by defining the @eap.arpa domain, and second by showing how it can be used to provide quarantined network access for onboarding unauthenticated devices. Futurewei USA Siemens AG IoTconsultancy.nl This document specifies how BRSKI entities, such as registrars, proxies, pledges or others that are acting as responders, can be discovered and selected by BRSKI entities acting as initiators. Institute of Electrical and Electronics Engineers This document aims at simple, interoperable, and automated PKI management operations covering typical use cases of industrial and Internet of Things (IoT) scenarios. This is achieved by profiling the Certificate Management Protocol (CMP), the related Certificate Request Message Format (CRMF), and transfer based on HTTP or Constrained Application Protocol (CoAP) in a succinct but sufficiently detailed and self-contained way. To make secure certificate management for simple scenarios and constrained devices as lightweight as possible, only the most crucial types of operations and options are specified as mandatory. More specialized or complex use cases are supported with optional features. Sandelman Software Works Huawei Technologies This document describes a number of operational modes that a BRSKI Registration Authority (Registrar) may take on. Each mode is defined, and then each mode is given a relevance within an over applicability of what kind of organization the Registrar is deployed into. This document does not change any protocol mechanisms. This document includes operational advice about avoiding unwanted consequences. This document describes the use of the Bidirectional Forwarding Detection (BFD) protocol in point-to-point Virtual eXtensible Local Area Network (VXLAN) tunnels used to form an overlay network. Sandelman Software Works This document provides a taxonomy of methods used by manufacturers of silicon and devices to secure private keys and public trust anchors. This deals with two related activities: how trust anchors and private keys are installed into devices during manufacturing, and how the related manufacturer held private keys are secured against disclosure. This document does not evaluate the different mechanisms, but rather just serves to name them in a consistent manner in order to aid in communication. RFCEDITOR: please remove this paragraph. This work is occurring in https://github.com/mcr/idevid-security-considerations

Examples These examples are folded according to Single Backslash rule.

Example Pledge Voucher-Request (PVR) - from Pledge to Registrar-Agent The following is an example request sent from a Pledge to the Registrar-Agent, in "General JWS JSON Serialization". The message size of this PVR is: 4649 bytes

Example Parboiled Registrar Voucher-Request (RVR) - from Registrar to MASA The term parboiled refers to food which is partially cooked. In , the term refers to a pledge-voucher-request (PVR) which has been received by the Registrar, and then has been processed by the Registrar ("cooked"), and is now being forwarded to the MASA. The following is an example registrar-voucher-request (RVR) sent from the Registrar to the MASA, in "General JWS JSON Serialization". Note that the previous PVR can be seen in the payload as "prior-signed-voucher-request". The message size of this RVR is: 13257 bytes

Example Voucher - from MASA to Pledge, via Registrar and Registrar-Agent The following is an example voucher-response from MASA to Pledge via Registrar and Registrar-Agent, in "General JWS JSON Serialization". The message size of this Voucher is: 1916 bytes

Example Voucher, MASA issued Voucher with additional Registrar signature (from MASA to Pledge, via Registrar and Registrar-Agent) The following is an example voucher-response from MASA to Pledge via Registrar and Registrar-Agent, in "General JWS JSON Serialization". The message size of this Voucher is: 3006 bytes

HTTP-over-TLS operations between Registrar-Agent and Pledge The use of HTTP-over-TLS between Registrar-Agent and pledge has been identified as an optional mechanism. Provided that the key-agreement in the underlying TLS protocol connection can be properly authenticated, the use of TLS provides privacy for the voucher and enrollment operations between the pledge and the Registrar-Agent. The authenticity of the onboarding and enrollment is not dependant upon the security of the TLS connection. The use of HTTP-over-TLS is not mandated by this document for a number of reasons: A certificate is generally required in order to do TLS. While there are other modes of authentication including PSK, various EAP methods and raw public key, they do no help as there is no previous relationship between the Registrar-Agent. The pledge can use it's IDevID certificate to authenticate itself, but DNS-ID methods do not apply as the pledge does not have a FQDN. Instead a new mechanism is required, which authenticates the X520SerialNumber DN attribute which must be present in every IDevID. If the Registrar-Agent has a preconfigured list of which product-serial-number(s), from which manufacturers it expects to see, then it can attempt to match this pledge against a list of potential devices. In many cases only the list of manufacturers is known ahead of time, so at most the Registrar-Agent can show the X520SerialNumber to the (human) operator who may then attempt to confirm that they are standing in front of a device with that product-serial-number. The use of scannable QRcodes may help automate this in some cases. The CA used to sign the IDevID will be a manufacturer private PKI as described in . The anchors for this PKI will never be part of the public WebPKI anchors which are distributed with most smartphone operating systems. A Registrar-Agent application will need to use different APIs in order to initiate an HTTPS connection without performing WebPKI verification. The application will then have to do it's own certificate chain verification against a store of manufacturer trust anchors. In the Android ecosystem this involved use of a customer TrustManager: many application developers do not create these correctly, and there is significant push to remove this option as it has repeatedly resulted in security failures. See The use of the Host: (or :authority in HTTP/2) is explained in . This header is mandatory, and so a compliant HTTPS client is going to insert it. But, the contents of this header will at best be an IP address that came from the discovery process. The pledge MUST therefore ignore the Host: header when it processes requests, and the pledge MUST NOT do any kind of name-base virtual hosting using the IP address/port combination. Note that there is no requirement for the pledge to operate it's BRSKI-PRM service on port 80 or port 443, so if there is no reason for name-based virtual hosting. Note that an Extended Key Usage (EKU) for TLS WWW Server authentication cannot be expected in the pledge's IDevID certificate. IDevID certificates are intended to be widely useable and EKU does not support that use.

History of Changes [RFC Editor: please delete] Proof of Concept Code available From IETF draft 11 -> IETF draft 12: Updated acknowledgements to reflect early reviews Addressed Shepherd review part 2 (Pull Request #132) From IETF draft 10 -> IETF draft 11: issue #79, clarified that BRSKI discovery in the context of BRSKI-PRM is not needed in . issue #103, removed step 6 in verification handling for the wrapped CA certificate provisioning as only applicable after enrollment issue #128: included notation of nomadic operation of the Registrar-Agent in , including proposed text from PR #131 issue #130, introduced DNS service discovery name for brski_pledge to enable discovery by the Registrar-Agent in removed unused reference RFC 5280 removed site terminology deleted duplicated text in clarified registrar discovery and relation to BRSKI-Discovery in clarified discovery of pledges by the Registrar-Agent in , deleted reference to GRASP as handled in BRSKI-Discovery addressed comments from SECDIR early review From IETF draft 09 -> IETF draft 10: issue #79, clarified discovery in the context of BRSKI-PRM and included information about future discovery enhancements in a separate draft in . issue #93, included information about conflict resolution in mDNS and GRASP in issue #103, included verification handling for the wrapped CA certificate provisioning in issue #106, included additional text to elaborate more the registrar status handling in and issue #116, enhanced DoS description in issue #120, included statement regarding pledge host header processing in issue #122, availability of product-serial-number information on registrar agent clarified in issue #123, Clarified usage of alternative voucher formats in issue #124, determination of pinned domain certificate done as in RFC 8995 included in issue #125, remove strength comparison of voucher assertions in and issue #130, aligned the usage of site and domain throughout the document changed naming of registrar certificate from LDevID(RegAgt) to EE (RegAgt) certificate throughout the document change x5b to x5bag according to updated JSON examples -> "signature": BASE64URL(JWS Signature) From IETF draft 08 -> IETF draft 09: issue #80, enhanced with clarification on the product-serial-number and the inclusion of GRASP issue #81, enhanced introduction with motivation for agent_signed_data issue #82, included optional TLS protection of the communication link between Registrar-Agent and pledge in the introduction , and issue #83, enhanced and with note to re-enrollment issue #87, clarified available information at the Registrar-Agent in issue #88, clarified, that the PVR in and PER in may contain the certificate chain. If not contained it MUST be available at the registrar. issue #91, clarified that a separate HTTP connection may also be used to provide the PER in resolved remaining editorial issues discovered after WGLC (responded to on the mailing list in Reply 1 and Reply 2) resulting in more consistent descriptions issue #92: kept separate endpoint for wrapped CSR on registrar issue #94: clarified terminology (possess vs. obtained) issue #95: clarified optional IDevID CA certificates on Registrar-Agent issue #96: updated exchangesfig_uc2_3 to correct to just one CA certificate provisioning issue #97: deleted format explanation in exchanges_uc2_3 as it may be misleading issue #99: motivated verification of second signature on voucher in issue #100: included negative example in issue #101: included handling if voucher telemetry information has not been received by the Registrar-Agent issue #102: relaxed requirements for CA certs provisioning in issue #105: included negative example in issue #107: included example for certificate revocation in issue #108: renamed heading to Pledge-Status Request of issue #111: included pledge-status response processing for authenticated requests in issue #112: added "Example key word in pledge-status response in issue #113: enhanced description of status reply for "factory-default" in issue #114: Consideration of optional TLS usage in Privacy Considerations issue #115: Consideration of optional TLS usage in Privacy Considerations to protect potentially privacy related information in the bootstrapping like status information, etc. issue #116: Enhanced DoS description and mitigation options in security consideration section updated references From IETF draft 07 -> IETF draft 08: resolved editorial issues discovered after WGLC (still open issues remaining) resolved first comments from the Shepherd review as discussed in PR #85 on the ANIMA github From IETF draft 06 -> IETF draft 07: WGLC resulted in a removal of the voucher enhancements completely from this document to RFC 8366bis, containing all enhancements and augmentations of the voucher, including the voucher-request as well as the tree diagrams smaller editorial corrections From IETF draft 05 -> IETF draft 06: Update of list of reviewers Issue #67, shortened the pledge endpoints to prepare for constraint deployments Included table for new endpoints on the registrar in the overview of the Registrar-Agent addressed review comments from SECDIR early review (terminology clarifications, editorial improvements) addressed review comments from IOTDIR early review (terminology clarifications, editorial improvements) From IETF draft 04 -> IETF draft 05: Restructured document to have a distinct section for the object flow and handling and shortened introduction, issue #72 Added security considerations for using mDNS without a specific product-serial-number, issue #75 Clarified pledge-status responses are cumulative, issue #73 Removed agent-sign-cert from trigger data to save bandwidth and remove complexity through options, issue #70 Changed terminology for LDevID(Reg) certificate to registrar LDevID certificate, as it does not need to be an LDevID, issue #66 Added new protected header parameter (created-on) in PER to support freshness validation, issue #63 Removed reference to CAB Forum as not needed for BRSKI-PRM specifically, issue #65 Enhanced error codes in section 5.5.1, issue #39, #64 Enhanced security considerations and privacy considerations, issue #59 Issue #50 addressed by referring to the utilized enrollment protocol Issue #47 MASA verification of LDevID(RegAgt) to the same registrar LDevID certificate domain CA Reworked terminology of "enrollment object", "certification object", "enrollment request object", etc., issue #27 Reworked all message representations to align with encoding Added explanation of MASA requiring domain CA cert in section 5.5.1 and section 5.5.2, issue #36 Defined new endpoint for pledge bootstrapping status inquiry, issue #35 in section , IANA considerations and section Included examples for several objects in section including message example sizes, issue #33 PoP for private key to registrar certificate included as mandatory, issues #32 and #49 Issue #31, clarified that combined pledge may act as client/server for further (re)enrollment Issue #42, clarified that Registrar needs to verify the status responses with and ensure that they match the audit log response from the MASA, otherwise it needs drop the pledge and revoke the certificate Issue #43, clarified that the pledge shall use the create time from the trigger message if the time has not been synchronized, yet. Several editorial changes and enhancements to increasing readability. From IETF draft 03 -> IETF draft 04: In deep Review by Esko Dijk lead to issues #22-#61, which are bein stepwise integrated Simplified YANG definition by augmenting the voucher-request from RFC 8995 instead of redefining it. Added explanation for terminology "endpoint" used in this document, issue #16 Added clarification that Registrar-Agent may collect PVR or PER or both in one run, issue #17 Added a statement that nonceless voucher may be accepted, issue #18 Simplified structure in section , issue #19 Removed join proxy in and added explanatory text, issue #20 Added description of pledge-CAcerts endpoint plus further handling of providing a wrapped CA certs response to the pledge in section ; also added new required registrar endpoint (section and IANA considerations) for the registrar to provide a wrapped CA certs response, issue #21 utilized defined abbreviations in the document consistently, issue #22 Reworked text on discovery according to issue #23 to clarify scope and handling Added several clarifications based on review comments From IETF draft 02 -> IETF draft 03: Updated examples to state "base64encodedvalue==" for x5c occurrences Include link to SVG graphic as general overview Restructuring of section 5 to flatten hierarchy Enhanced requirements and motivation in Several editorial improvements based on review comments From IETF draft 01 -> IETF draft 02: Issue #15 included additional signature on voucher from registrar in section and section The verification of multiple signatures is described in section Included representation for General JWS JSON Serialization for examples Included error responses from pledge if it is not able to create a Pledge-Voucher-Request or an enrollment request in section Removed open issue regarding handling of multiple CSRs and Enroll-Responses during the bootstrapping as the initial target it the provisioning of a generic LDevID certificate. The defined endpoint on the pledge may also be used for management of further certificates. From IETF draft 00 -> IETF draft 01: Issue #15 lead to the inclusion of an option for an additional signature of the registrar on the voucher received from the MASA before forwarding to the Registrar-Agent to support verification of POP of the registrars private key in section and exchanges_uc2_3. Based on issue #11, a new endpoint was defined for the registrar to enable delivery of the wrapped enrollment request from the pledge (in contrast to plain PKCS#10 in simple enroll). Decision on issue #8 to not provide an additional signature on the enrollment-response object by the registrar. As the Enroll-Response will only contain the generic LDevID certificate. This credential builds the base for further configuration outside the initial enrollment. Decision on issue #7 to not support multiple CSRs during the bootstrapping, as based on the generic LDevID certificate the pledge may enroll for further certificates. Closed open issue #5 regarding verification of ietf-ztp-types usage as verified via a proof-of-concept in section . Housekeeping: Removed already addressed open issues stated in the draft directly. Reworked text in from introduction to section pledge-responder-mode Fixed "serial-number" encoding in PVR/RVR Added prior-signed-voucher-request in the parameter description of the registrar-voucher-request in . Note added in if sub-CAs are used, that the corresponding information is to be provided to the MASA. Inclusion of limitation section (pledge sleeps and needs to be waked up. Pledge is awake but Registrar-Agent is not available) (Issue #10). Assertion-type aligned with voucher in RFC8366bis, deleted related open issues. (Issue #4) Included table for endpoints in for better readability. Included registrar authorization check for Registrar-Agent during TLS handshake in section . Also enhanced figure with the authorization step on TLS level. Enhanced description of registrar authorization check for Registrar-Agent based on the agent-signed-data in section . Also enhanced figure with the authorization step on Pledge-Voucher-Request level. Changed agent-signed-cert to an array to allow for providing further certificate information like the issuing CA cert for the LDevID(RegAgt) certificate in case the registrar and the Registrar-Agent have different issuing CAs in (issue #12). This also required changes in the YANG module in Addressed YANG warning (issue #1) Inclusion of examples for a trigger to create a Pledge-Voucher-Request and an Pledge Enroll-Request. From IETF draft-ietf-anima-brski-async-enroll-03 -> IETF anima-brski-prm-00: Moved UC2 related parts defining the Pledge in Responder Mode from draft-ietf-anima-brski-async-enroll-03 to this document This required changes and adaptations in several sections to remove the description and references to UC1. Addressed feedback for voucher-request enhancements from YANG doctor early review, meanwhile moved to as well as in the security considerations (formerly named ietf-async-voucher-request). Renamed ietf-async-voucher-request to IETF-voucher-request-prm to to allow better listing of voucher related extensions; aligned with constraint voucher (#20) Utilized ietf-voucher-request-async instead of ietf-voucher-request in voucher exchanges to utilize the enhanced voucher-request. Included changes from draft-ietf-netconf-sztp-csr-06 regarding the YANG definition of csr-types into the enrollment request exchange. From IETF draft 02 -> IETF draft 03: Housekeeping, deleted open issue regarding YANG voucher-request in as voucher-request was enhanced with additional leaf. Included open issues in YANG model in regarding assertion value agent-proximity and csr encapsulation using SZTP sub module). From IETF draft 01 -> IETF draft 02: Defined call flow and objects for interactions in UC2. Object format based on draft for JOSE signed voucher artifacts and aligned the remaining objects with this approach in . Terminology change: issue #2 pledge-agent -> Registrar-Agent to better underline Registrar-Agent relation. Terminology change: issue #3 PULL/PUSH -> pledge-initiator-mode and pledge-responder-mode to better address the pledge operation. Communication approach between pledge and Registrar-Agent changed by removing TLS-PSK (former section TLS establishment) and associated references to other drafts in favor of relying on higher layer exchange of signed data objects. These data objects are included also in the Pledge-Voucher-Request and lead to an extension of the YANG module for the voucher-request (issue #12). Details on trust relationship between Registrar-Agent and registrar (issue #4, #5, #9) included in . Recommendation regarding short-lived certificates for Registrar-Agent authentication towards registrar (issue #7) in the security considerations. Introduction of reference to Registrar-Agent signing certificate using SKID in Registrar-Agent signed data (issue #37). Enhanced objects in exchanges between pledge and Registrar-Agent to allow the registrar to verify agent-proximity to the pledge (issue #1) in . Details on trust relationship between Registrar-Agent and pledge (issue #5) included in . Split of use case 2 call flow into sub sections in . From IETF draft 00 -> IETF draft 01: Update of scope in to include in which the pledge acts as a server. This is one main motivation for use case 2. Rework of use case 2 in to consider the transport between the pledge and the pledge-agent. Addressed is the TLS channel establishment between the pledge-agent and the pledge as well as the endpoint definition on the pledge. First description of exchanged object types (needs more work) Clarification in discovery options for enrollment endpoints at the domain registrar based on well-known endpoints do not result in additional /.well-known URIs. Update of the illustrative example. Note that the change to /brski for the voucher related endpoints has been taken over in the BRSKI main document. Updated references. Included Thomas Werner as additional author for the document. From individual version 03 -> IETF draft 00: Inclusion of discovery options of enrollment endpoints at the domain registrar based on well-known endpoints in new section as replacement of section 5.1.3 in the individual draft. This is intended to support both use cases in the document. An illustrative example is provided. Missing details provided for the description and call flow in pledge-agent use case , e.g. to accommodate distribution of CA certificates. Updated CMP example in to use lightweight CMP instead of CMP, as the draft already provides the necessary /.well-known endpoints. Requirements discussion moved to separate section in . Shortened description of proof of identity binding and mapping to existing protocols. Removal of copied call flows for voucher exchange and registrar discovery flow from in UC1 to avoid doubling or text or inconsistencies. Reworked abstract and introduction to be more crisp regarding the targeted solution. Several structural changes in the document to have a better distinction between requirements, use case description, and solution description as separate sections. History moved to appendix. From individual version 02 -> 03: Update of terminology from self-contained to authenticated self-contained object to be consistent in the wording and to underline the protection of the object with an existing credential. Note that the naming of this object may be discussed. An alternative name may be attestation object. Simplification of the architecture approach for the initial use case having an offsite PKI. Introduction of a new use case utilizing authenticated self-contain objects to onboard a pledge using a commissioning tool containing a pledge-agent. This requires additional changes in the BRSKI call flow sequence and led to changes in the introduction, the application example,and also in the related BRSKI-PRM call flow. From individual version 01 -> 02: Update of introduction text to clearly relate to the usage of IDevID and LDevID. Update of description of architecture elements and changes to BRSKI in . Enhanced consideration of existing enrollment protocols in the context of mapping the requirements to existing solutions in . From individual version 00 -> 01: Update of examples, specifically for building automation as well as two new application use cases in . Deletion of asynchronous interaction with MASA to not complicate the use case. Note that the voucher exchange can already be handled in an asynchronous manner and is therefore not considered further. This resulted in removal of the alternative path the MASA in Figure 1 and the associated description in . Enhancement of description of architecture elements and changes to BRSKI in . Consideration of existing enrollment protocols in the context of mapping the requirements to existing solutions in . New section starting with the mapping to existing enrollment protocols by collecting boundary conditions.

Contributors IoTconsultancy.nl

esko.dijk@iotconsultancy.nl

Futurewei

tte@cs.fau.de

Siemens Schweiz AG

ietf@kovatsch.net