Internet-Draft CADI November 2026
Liu & Fu Expires 22 May 2027 [Page]
Workgroup:
Network Working Group
Internet-Draft:
draft-liu-cadi-03
Published:
Intended Status:
Standards Track
Expires:
Authors:
C. P. Liu
Huawei
Y. Fu
Huawei

Cryptographic Asset Discovery and Inventory

Abstract

This document compiles existing Cryptographic Asset Discovery and Inventory (CADI) methods and analyzes potential gaps. It also defines a YANG data model that augments the base network inventory model with the cryptographic assets of each network element. The data model is aligned with the Cryptography Bill of Materials (CBOM) defined in CycloneDX.

Status of This Memo

This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.

Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.

Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."

This Internet-Draft will expire on 22 May 2027.

▲

Table of Contents

1. Introduction

Cryptographic Asset Discovery and Inventory (CADI) refers to a set of tools and guidelines that assist in identifying, collecting, normalizing, correlating, and continuously maintaining all cryptography-related assets, including configurations, dependencies, and usage contexts within a given organization, system, or product scope. It requires both technical tools and management approaches.

Many Post-Quantum transition roadmaps have highlighted the importance of identifying legacy cryptographic assets inside of an organization as a crucial preparatory part. For example:

Although the exact PQ-migration roadmap in each different nations varies, the fact that cryptographic asset discovery and inventory is a key prerequisite for Chief Information Security Officers to asses a migration budget and draft a migration plan does not change.

This document analyzes existing CADI methods and potential gaps. It also defines a YANG data model that extends the network inventory with cryptographic assets.

2. Conventions and 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 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.

The following terms are defined in [RFC7950] and are not redefined here: augment, data model, and data node. The terms "network element" and "component" are used as defined in [I-D.ietf-ivy-network-inventory-yang]. The meanings of the symbols in the YANG tree diagrams are defined in [RFC8340].

This document also uses the following terms:

3. Problem Statement and Challenges

Apart from the milestones and requirements discussed above, there are also a few challenges to identify cryptographic assets:

As a result, the ideal CADI tool should meet the following requirements:

The requirements for automation, architectural agnosticism, and network management integration suggest a protocol-driven approach, potentially placing this within the scope of the IETF. However, this remains open for discussion.

4. Discovery and Identification

There are many ways of doing discovering and identification. We catagorize them into two: active identification and passive identification.

4.1. Active Identification

4.1.1. Cryptographic Bill of Materials (CBOM) and Auxiliary Methods

CBOM-based identification is to empower cryptographic asset owners or vendors to explicitly declare cryptographic usage within their products, components, or services. Usually CBOM declaration is achieved through static code scanning and/or CI/CD integration, so we keep them in the same section.

Scanning Methods:

  • Static Code Scanning:

    • SCA (Software Composition Analysis): Scan manifest files (like package.json, requirements.txt, or pom.xml) from the codebase to create CBOMS, usually for analyzing third-party libraries dependency.

    • SAST (Static Application Security Testing): Builds a Abstract Syntax Tree (AST) with parsed syntax and data flow of the target source code. It then uses AST to track call chain to end crypto library, track variables (data flow) from source to destination, do reference matching, etc.

      • SCA and SAST is used by IBM CBOMKit-Hyperion.

  • Binary / Image Scanning:

    • Scan for algorithmic constants, signatures; Extract from OS trust stores and runtime configurations... The process details are omitted in this document due to complexity.

      • Binary / Image Scanning is used by IBM CBOMKit-Theia and CycloneDX Cdxgen.

Tools and Modelling:

  • IBM CBOMkit, Static code level scanning (Hyperion) and Artifact level scanning (Theia) [IBMCBOM]: uses implements and uses relationship to create dependency diagram.

    • implements: Describes the list of protocols or algorithms this module implements.

    • uses: Describes what modules are used by this service.

    • For example, Application Nginx uses Library libssl.so that uses Protocol TLS v1.3/v1.2 that uses libcrypto.so that implements Algorithm MD5, SHA256, AES-128-GCM.

  • CycloneDX Cdxgen, Artifact level scanning [CDXGEN]: uses dependsOn and provides relationship to create dependency diagram.

    • dependsOn: Describes other modules or services this module depends on.

    • provides: Describes all capabilities this module provides.

    • For example, Application Nginx dependsOn Library libssl.so , which provides TLS 1.2.

After scanning, the result will be recorded as a CBOM object.

CBOM data specification: A standardized cryptographic asset object includes cryptographic algorithms, digital certificates, protocols, private keys, public keys, cryptographic keys, ciphertext information, digital signatures, digests (the output values of hash functions), initialization vectors (input parameters for encryption algorithms), seeds, salts, shared secrets, authentication tags, passwords, credentials, and tokens. CycloneDX 1.7 [CycloneDX] groups them into four asset types: algorithm, certificate, protocol, and related cryptographic material. Figure 1 shows an example.

"components": [
 {
  "name": "google.com",
  "type": "cryptographic-asset",
  "bom-ref": "crypto/certificate/google.com@sha256:1e15e0fbd3ce9...",
  "cryptoProperties": {
    "assetType": "certificate",
    "certificateProperties": {
      "subjectName": "CN = www.google.com",
      "issuerName": "CN = GTS CA 1C3, O = Google Trust Services",
      "notValidBefore": "2016-11-21T08:00:00Z",
      "notValidAfter": "2017-11-22T07:59:59Z",
      "certificateFormat": "X.509",
      "certificateFileExtension": "crt",
      "relatedCryptographicAssets": [
        { "type": "algorithm", "ref": "crypto/algorithm/sha512-rsa" },
        { "type": "publicKey", "ref": "crypto/key/rsa-2048" }
      ]
    }
  }
 }
]
Figure 1: Example CBOM (CycloneDX 1.7)

Gaps: Obviously, this does not help with identifying the mass legacy devices, components or services.

4.2. Passive Identification

4.2.1. Simulated Handshakes

Simulated handshake is a network-probing technique where a discovery tool acts as a client and intentionally initiates cryptographic protocol negotiations (e.g., TLS, SSH, IPsec) with enterprise network endpoints without completing the full data session. During the negotiation process, the discovery tool determines the specific cryptographic protocol versions, negotiation mechanisms, and ciphersuites supported by the endpoint. This is also known as Active Probing.

Steps of simulated handshake include:

  1. Port Scan: The tool scans for typical ports for specific secure communication protocols (443 for HTTPS, 22 for SSH, etc)

  2. Probing: The tool generates a RFC-compliant connection initialization packet, including all currently standardized ciphersuites, and examine the response.

  3. Response Extraction: The target object respond with supported ciphersuites, following its own internal priority rules.

  4. Parsing: The tool intercepts this raw response and decodes it as cryptographic assets.

This works for most secure protocols that includes negotiation:

Pros and Cons/Gaps:

  • Strengths:

    • This kind of method does not require complex engineering refactoring. Since it is agnostic to the design of the target, it works best for the case where the manager operates vast heterogeneous devices from different vendors, versions and locations, hence telecommunications case.

    • This probing is one-time, thus it will not create unhandleable amount of probing packets.

  • The limitation of this method is that

    • Some masking mechanism will stop the probing (firewalls, load balancers, port-concealing protocols like Single Packet Authorization that enforce a default drop for unexpected packets), leaving a hidden security posture inside of the system.

    • Network management cannot know local application components that rests internally in the device and are not exposed over a socket.

Tools:

  • Cisco Mercury project [MERCURY] provides an open source packet capture and analysis tool. It can read network packets, identify metadata of interest, and write out the metadata (including cryptographic-related) in JSON format.

4.2.2. Traffic Pattern Analysis

Unlike simulated handshakes that actively query an endpoint, Traffic Pattern Analysis listens passively to live network traffic at strategic aggregation points. It infers cryptographic asset usage from protocol metadata, statistical characteristics, and behaviors without decrypting the underlying data payload.

Methods of Traffic Pattern Analysis includes:

  • Listen to unencrypted negotiations like clientHello/serverHello, Server Name Indication (SNI), response of an unencrypted server digital certificate request, etc.

  • Listen to handshake fingerprints and compare them to existing patterns, as protocol implementations and behaviors are often rigid.

  • Listen to packet length and arrival time, do statistical pattern recognition.

Pros and Cons/Gaps:

  • Strengths:

    • Similar to Simulated Handshakes, this kind of method is not intrusive and is agnostic to the design of the target.

  • The limitation of this method is that

    • Negotiation information like clientHello [RFC9849] and SNI are tending to be encrypted.

    • Protocols tend to have constant size packets [RFC9347].

    • Alternative routing: network requests/responses could exit through a different routing path.

4.2.3. Process Identification

Process Identification requires Endpoint Detection and Response (EDR) installed to have cryptographic visibility inside of a system.

Methods of Process Identification includes:

  • Kernel-Level System Call Auditing by deploying eBPF programs into the kernel space. These filters can capture kernel events to determine exactly which process (down to PID) have initiated an encrypted network communication.

  • Shared Library and Binary Hooking, by monitoring process load table to see if cryptographic dynamic libraries are loaded into the memory space.

  • Live Memory Scanning, by periodically scanning volatile memory for indication of creation of keys or signatures (as high-entropy memory segments), and then compare them with known patterns.

Pros and Cons/Gaps:

  • Strengths:

    • Have deeper visibility for cryptographic assets within devices.

  • The limitation of this method is that

    • Requires loading new software (at least EDR/RDR) to legacy devices.

    • Potential blind spots due to lower pattern coverage.

4.2.4. Configuration Extraction

The Configuration Extraction is a bit similar to the source code scanning. This section focuses more on the runtime configurations. In different use cases, the configuration extraction methods differs significantly. This section is to be extended.

Methods of Configuration Extraction includes:

  • In network device management, NETCONF and YANG provide a standardized, model-driven management interface that enables programmable configuration and state validation. The network managing platform can define a YANG model and extract configurations from a device.

  • In cloud-native development, general .yaml configuration files, .env environment variables files, Kubernetes secret manifest, etc, can be extracted by administrative scripts or through management interfaces (e.g., AWS CloudControl, Kubernetes API).

5. Inventory

5.1. Overview

The discovery methods in Section 4 produce information about cryptographic assets in different forms, e.g., CBOMs delivered by vendors or handshake results collected by scanners. To support migration planning, this information needs to be correlated with the network elements and components on which the assets are deployed, and exposed through a standard management interface.

This section defines the "ietf-network-inventory-crypto" YANG module. It augments the base network inventory model [I-D.ietf-ivy-network-inventory-yang] with a read-only cryptographic inventory of each network element. Like the base model, it is a network model: a network controller uses it to report the cryptographic assets of all network elements under its control, e.g., to an Operations Support System (OSS) or to a higher-level controller, via NETCONF [RFC6241] or RESTCONF [RFC8040].

The module complements CycloneDX CBOM [CycloneDX] rather than replacing it, as summarized in the table below. Asset types, properties, and relationships are aligned with CycloneDX 1.7, so that a vendor CBOM can be imported into a controller and controller data can be exported as a CBOM. This enables network-wide post-quantum cryptography (PQC) readiness assessment.

Table 1: CBOM Documents and the Inventory Data Model
  CycloneDX CBOM This Module
Form Document (JSON, XML) Interface (NETCONF, RESTCONF)
Scope One product or software version All network elements managed by a controller
Producer Vendor or scanning tool Network controller
Typical use Supply chain, audit Operations, PQC readiness assessment
Linked to Software components Network elements

5.2. Model Structure

The module adds a "crypto-inventory" container to each network element, alongside the "components" list of the base model. All data nodes of the container are read-only, as the augmented "network-inventory" container is "config false". It contains two lists:

"cbom-ref":

References to CBOMs that describe the network element or one of its components. Each entry contains the serial number and version of the CBOM, retrieval URIs, and a hash of the CBOM for integrity verification.

"crypto-object":

A structured list of the cryptographic assets of the network element, referred to as cryptographic objects in this module. An object can refer to the components that implement it, e.g., a Hardware Security Module (HSM) or a cryptographic library (Section 5.2.3). This list is optional and is reported only if the server supports the "crypto-objects" feature. Otherwise, clients obtain the details from the CBOMs listed in "cbom-ref".

5.2.1. Cryptographic Objects

Each cryptographic object is identified by an "id" that is unique within the network element. The common attributes are:

  • "uuid", "name", "alias", and "description": reused from the base model.

  • "usage": the purposes for which the object is used, i.e., management plane, control plane, or data plane. CycloneDX has no equivalent; this network-specific context is needed to prioritize migration.

  • "provided-by" and "depends-on": the relationships described in Section 5.2.3.

  • "last-discovered": the time at which the object was last observed.

In CycloneDX, each cryptographic asset has exactly one of four asset types. The type is therefore modeled as a YANG choice: the container that is present indicates the type and contains the type-specific properties:

  • "algorithm": primitive (e.g., signature or kem), family, parameter set, elliptic curve, and quantum security level, where the value 0 indicates a quantum-vulnerable algorithm.

  • "certificate": subject, issuer, and validity period.

  • "related-material": material type (e.g., private key), size, expiration time, and protection mechanism.

  • "protocol": protocol type, version, and cipher suites.

Only the CycloneDX properties needed for inventory and PQC readiness assessment are modeled. Further details remain available in the CBOMs referenced by "cbom-ref". Additional properties and types can be added by augmentation.

5.2.2. Naming

CycloneDX 1.7 introduces the Cryptography Registry [CDX-REGISTRY]. It defines algorithm families together with naming patterns, and elliptic curves in namespaces of the defining organizations. The Registry evolves independently of the CycloneDX specification. This module uses it as follows:

  • "family" SHOULD contain a family name from the Registry, e.g., "AES", "ML-KEM", or "SM4".

  • The "name" of an algorithm SHOULD follow the naming pattern of its family, e.g., "AES-128-GCM" or "ML-KEM-768".

  • "curve" SHOULD contain a Registry curve name in the form "<namespace>/<curve>", e.g., "nist/P-256". A curve can have aliases in other namespaces, e.g., "secg/secp256r1" and "x962/prime256v1" for "nist/P-256"; consumers need to treat aliases as the same curve.

  • A hybrid scheme is reported as an algorithm whose "primitive" is "combiner" and whose "name" is the registered name of the hybrid, e.g., the TLS group name "X25519MLKEM768" [IANA-TLS]. No "family" is reported for it; it depends on its component algorithms (Section 5.2.3).

5.2.3. Relationships

Two relationship types are defined, matching the two dependency types of CycloneDX:

"provided-by":

From a cryptographic object to the components that implement or provide it, e.g., from a TLS implementation to a cryptographic library or a main processing unit. CycloneDX expresses this as "dependencies[].provides", in the opposite direction.

"depends-on":

From a cryptographic object to other cryptographic objects that it uses or is bound to. CycloneDX expresses this as "dependencies[].dependsOn" or "relatedCryptographicAssets". The meaning of the relationship is given by the type of the referenced object. For example, a certificate depends on an algorithm (its signature algorithm) and on a public key (its subject public key), a protocol depends on a certificate (its credential), and a combiner depends on its component algorithms.

A relationship is recorded once, at the object that uses or holds the other object; reverse relationships are not recorded. The resulting graph is expected to be acyclic.

Figure 2 shows the relationships of the example in Appendix A. Unlabeled arrows denote "depends-on", and the labeled arrow denotes "provided-by".

  +------------+  provided-by   +-------------+
  |   tls-1    +--------------->|    mpu-1    |
  | (protocol) |                | (component) |
  +--+------+--+                +-------------+
     |      |
     |      +----------------+
     v                       v
  +------------+     +----------------+
  |  dev-cert  |     | x25519mlkem768 |
  +-----+------+     +---+--------+---+
        |                |        |
        v                v        v
  +-------------+   +--------+  +------------+
  | ecdsa-p-256 |   | x25519 |  | ml-kem-768 |
  +-------------+   +--------+  +------------+
Figure 2: Example of Relationships

5.3. Tree Diagram

Figure 3 shows the tree diagram of the "ietf-network-inventory-crypto" module.

module: ietf-network-inventory-crypto

  augment /nwi:network-inventory/nwi:network-elements
            /nwi:network-element:
    +--ro crypto-inventory!
       +--ro cbom-ref* [serial-number]
       |  +--ro serial-number    cbom-serial-number
       |  +--ro version?         uint32
       |  +--ro uri*             inet:uri
       |  +--ro hash
       |  |  +--ro algorithm?   string
       |  |  +--ro value?       string
       |  +--ro component-ref?   leafref
       +--ro crypto-object* [id] {crypto-objects}?
          +--ro id                 string
          +--ro uuid?              yang:uuid
          +--ro name?              string
          +--ro alias?             string
          +--ro description?       string
          +--ro usage*             identityref
          +--ro provided-by*       leafref
          +--ro depends-on*        leafref
          +--ro last-discovered?   yang:date-and-time
          +--ro (type)
             +--:(algorithm)
             |  +--ro algorithm!
             |     +--ro primitive?                string
             |     +--ro family?                   algorithm-family
             |     +--ro parameter-set?            string
             |     +--ro curve?                    elliptic-curve
             |     +--ro quantum-security-level?   uint8
             +--:(certificate)
             |  +--ro certificate!
             |     +--ro subject?            string
             |     +--ro issuer?             string
             |     +--ro not-valid-before?   yang:date-and-time
             |     +--ro not-valid-after?    yang:date-and-time
             +--:(related-material)
             |  +--ro related-material!
             |     +--ro type?              string
             |     +--ro size?              uint32
             |     +--ro expiration-date?   yang:date-and-time
             |     +--ro secured-by?        string
             +--:(protocol)
                +--ro protocol!
                   +--ro type?           string
                   +--ro version?        string
                   +--ro cipher-suite*   string
Figure 3: Tree Diagram of ietf-network-inventory-crypto

5.4. YANG Module

This module imports types from [RFC9911] and [I-D.ietf-ivy-network-inventory-yang]. It references [CycloneDX] and [CDX-REGISTRY].

<CODE BEGINS> file "ietf-network-inventory-crypto@2026-10-30.yang"
module ietf-network-inventory-crypto {
  yang-version 1.1;
  namespace
    "urn:ietf:params:xml:ns:yang:ietf-network-inventory-crypto";
  prefix nwic;

  import ietf-yang-types {
    prefix yang;
    reference
      "RFC 9911: Common YANG Data Types";
  }
  import ietf-inet-types {
    prefix inet;
    reference
      "RFC 9911: Common YANG Data Types";
  }
  import ietf-network-inventory {
    prefix nwi;
    reference
      "RFC YYYY: A Base YANG Data Model for Network Inventory";
  }

  organization
    "IETF Network Inventory YANG (ivy) Working Group";
  contact
    "WG Web:   <https://datatracker.ietf.org/wg/ivy/>
     WG List:  <mailto:ivy@ietf.org>

     Editor:   Chunchi Peter Liu
               <mailto:liuchunchi@huawei.com>

     Editor:   Yufan Fu
               <mailto:fuyufan2@huawei.com>";
  description
    "This module augments the base network inventory model with
     a read-only cryptographic inventory of each network element.
     The inventory consists of references to Cryptography Bills
     of Materials (CBOMs) and, optionally, a structured list of
     cryptographic objects.  Types, properties, and relationships
     are aligned with CycloneDX 1.7 (ECMA-424).

     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 (RFC 2119)
     (RFC 8174) when, and only when, they appear in all
     capitals, as shown here.

     Copyright (c) 2026 IETF Trust and the persons identified
     as authors of the code.  All rights reserved.

     Redistribution and use in source and binary forms, with or
     without modification, is permitted pursuant to, and subject
     to the license terms contained in, the Revised BSD License
     set forth in Section 4.c of the IETF Trust's Legal Provisions
     Relating to IETF Documents
     (https://trustee.ietf.org/license-info).

     This version of this YANG module is part of RFC XXXX; see
     the RFC itself for full legal notices.";

  revision 2026-10-30 {
    description
      "Initial revision.";
    reference
      "RFC XXXX: Cryptographic Asset Discovery and Inventory";
  }

  /*
   * Features
   */

  feature crypto-objects {
    description
      "Indicates that the server supports reporting a structured
       list of the cryptographic objects of each network element,
       in addition to references to CBOMs.";
  }

  /*
   * Identities
   */

  identity crypto-usage {
    description
      "Base identity for the purposes for which a cryptographic
       object is used on a network element.";
  }

  identity management-plane {
    base crypto-usage;
    description
      "Protection of management traffic, e.g., NETCONF over SSH.";
  }

  identity control-plane {
    base crypto-usage;
    description
      "Protection of control plane protocols, e.g., routing
       protocol authentication.";
  }

  identity data-plane {
    base crypto-usage;
    description
      "Protection of user traffic, e.g., IPsec or MACsec.";
  }

  identity device-identity {
    base crypto-usage;
    description
      "Identification and authentication of the device, e.g.,
       using an IDevID certificate.";
  }

  identity secure-boot {
    base crypto-usage;
    description
      "Verification of boot loaders and images during start-up.";
  }

  identity software-integrity {
    base crypto-usage;
    description
      "Verification of software images and patches.";
  }

  identity storage-protection {
    base crypto-usage;
    description
      "Protection of data at rest, e.g., configuration files or
       key stores.";
  }

  /*
   * Typedefs
   */

  typedef algorithm-family {
    type string;
    description
      "An algorithm family name registered in the CycloneDX
       Cryptography Registry, e.g., 'AES', 'ML-KEM', or 'SM4'.
       The value SHOULD match the Registry entry exactly.";
    reference
      "CycloneDX Cryptography Registry";
  }

  typedef elliptic-curve {
    type string {
      pattern '[a-z0-9]+/.+';
    }
    description
      "An elliptic curve name registered in the CycloneDX
       Cryptography Registry, in the form '<namespace>/<curve>',
       e.g., 'nist/P-256' or 'oscaa/SM2'.";
    reference
      "CycloneDX Cryptography Registry";
  }

  typedef cbom-serial-number {
    type string {
      pattern 'urn:uuid:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-'
            + '[0-9a-f]{4}-[0-9a-f]{12}';
    }
    description
      "The serial number of a CycloneDX BOM, i.e., a UUID URN.";
    reference
      "ECMA-424: CycloneDX Bill of Materials Specification,
       serialNumber";
  }

  /*
   * Augmentation
   */

  augment "/nwi:network-inventory/nwi:network-elements"
        + "/nwi:network-element" {
    description
      "Adds the cryptographic inventory to network elements.";
    container crypto-inventory {
      presence
        "Indicates that the server reports the cryptographic
         inventory of this network element.";
      description
        "The cryptographic inventory of the network element.";
      list cbom-ref {
        key "serial-number";
        description
          "References to CBOMs that describe the network element
           or one of its components.";
        leaf serial-number {
          type cbom-serial-number;
          description
            "The serial number of the CBOM.";
        }
        leaf version {
          type uint32 {
            range "1..max";
          }
          description
            "The version of the CBOM.";
        }
        leaf-list uri {
          type inet:uri;
          description
            "Locations from which the CBOM can be retrieved.";
        }
        container hash {
          description
            "The hash of the CBOM, for integrity verification.";
          leaf algorithm {
            type string;
            description
              "The hash algorithm, using the CycloneDX hash
               algorithm names, e.g., 'SHA-256' or 'SHA3-384'.";
          }
          leaf value {
            type string {
              pattern '[0-9a-fA-F]+';
            }
            description
              "The hex-encoded hash value.";
          }
        }
        leaf component-ref {
          type leafref {
            path "../../../nwi:components/nwi:component"
               + "/nwi:component-id";
          }
          description
            "The component described by the CBOM.  If not present,
             the CBOM describes the whole network element.";
        }
      }
      list crypto-object {
        if-feature "crypto-objects";
        key "id";
        description
          "The cryptographic objects of the network element.";
        leaf id {
          type string;
          description
            "An identifier of the cryptographic object, unique
             within the network element.";
        }
        uses nwi:basic-common-entity-attributes {
          refine "name" {
            description
              "The name of the cryptographic object.  The name of
               an algorithm SHOULD follow the naming pattern of its
               family in the CycloneDX Cryptography Registry, e.g.,
               'AES-128-GCM'.";
          }
        }
        leaf-list usage {
          type identityref {
            base crypto-usage;
          }
          description
            "The purposes for which the cryptographic object is
             used.";
        }
        leaf-list provided-by {
          type leafref {
            path "../../../nwi:components/nwi:component"
               + "/nwi:component-id";
          }
          description
            "The hardware or software components that implement or
             provide the cryptographic object.";
        }
        leaf-list depends-on {
          type leafref {
            path "../../crypto-object/id";
          }
          description
            "Other cryptographic objects that this object uses or is
             bound to.  The meaning of the relationship is given by
             the type of the referenced object.";
        }
        leaf last-discovered {
          type yang:date-and-time;
          description
            "The time at which the cryptographic object was last
             observed.";
        }
        choice type {
          mandatory true;
          description
            "The type of the cryptographic object.  Exactly one type
             is reported for each object.";
          reference
            "ECMA-424: CycloneDX Bill of Materials Specification,
             cryptoProperties.assetType";
          container algorithm {
            presence
              "Indicates that the object is an algorithm.";
            description
              "A cryptographic algorithm, e.g., AES-128-GCM or
               ML-KEM-768.";
            leaf primitive {
              type string;
              description
                "The cryptographic primitive, using the CycloneDX
                 values, e.g., 'block-cipher', 'ae', 'signature',
                 'key-agree', 'kem', or 'combiner'.";
            }
            leaf family {
              type algorithm-family;
              description
                "The algorithm family.  Not present for combiners.";
            }
            leaf parameter-set {
              type string;
              description
                "The parameter set, e.g., '128' for AES-128 or '768'
                 for ML-KEM-768.";
            }
            leaf curve {
              type elliptic-curve;
              description
                "The elliptic curve, if any.";
            }
            leaf quantum-security-level {
              type uint8 {
                range "0..6";
              }
              description
                "The NIST security strength category against quantum
                 attacks.  The value 0 indicates that none of the
                 categories is met, i.e., the algorithm is
                 quantum-vulnerable.";
              reference
                "ECMA-424: CycloneDX Bill of Materials Specification,
                 algorithmProperties.nistQuantumSecurityLevel";
            }
          }
          container certificate {
            presence
              "Indicates that the object is a certificate.";
            description
              "A certificate, e.g., an X.509 device certificate.";
            leaf subject {
              type string;
              description
                "The subject name.";
            }
            leaf issuer {
              type string;
              description
                "The issuer name.";
            }
            leaf not-valid-before {
              type yang:date-and-time;
              description
                "The start of the validity period.";
            }
            leaf not-valid-after {
              type yang:date-and-time;
              description
                "The end of the validity period.";
            }
          }
          container related-material {
            presence
              "Indicates that the object is related cryptographic
               material.";
            description
              "Material related to algorithms, certificates, or
               protocols, e.g., a key, a password, or a token.";
            leaf type {
              type string;
              description
                "The type of the material, using the CycloneDX
                 values, e.g., 'private-key', 'public-key',
                 'secret-key', or 'password'.";
            }
            leaf size {
              type uint32;
              units "bits";
              description
                "The size of the material.";
            }
            leaf expiration-date {
              type yang:date-and-time;
              description
                "The time at which the material expires.";
            }
            leaf secured-by {
              type string;
              description
                "The mechanism protecting the material, using the
                 CycloneDX values, e.g., 'HSM', 'TPM', 'Software',
                 or 'None'.";
            }
          }
          container protocol {
            presence
              "Indicates that the object is a protocol.";
            description
              "A cryptographic protocol, e.g., TLS, SSH, or IKEv2.";
            leaf type {
              type string;
              description
                "The protocol, using the CycloneDX values, e.g.,
                 'tls', 'ssh', 'ipsec', 'ike', 'dtls', or 'quic'.";
            }
            leaf version {
              type string;
              description
                "The protocol version, e.g., '1.3'.";
            }
            leaf-list cipher-suite {
              type string;
              description
                "The cipher suites supported by the protocol, e.g.,
                 'TLS_AES_256_GCM_SHA384'.  The algorithms of the
                 cipher suites are reported using 'depends-on'.";
            }
          }
        }
      }
    }
  }
}
<CODE ENDS>
Figure 4: ietf-network-inventory-crypto YANG Module

5.5. Operational Considerations

As with the base model, this module provides a read-only view of the cryptographic inventory known to the controller. How the controller obtains the information, e.g., by importing CBOMs or by the methods in Section 4, is outside the scope of this document.

The inventory needs to be updated when cryptographic assets change, e.g., after a software upgrade, a certificate renewal, or a configuration change. The "last-discovered" leaf allows consumers to detect stale entries.

Network-wide inventories can be large. Clients can use protocol filtering mechanisms, e.g., subtree or XPath filtering in NETCONF, to retrieve only the data they need, such as the algorithms whose "quantum-security-level" is 0.

5.6. Open Issues

This section is to be removed before publication.

The authors seek feedback from the WG on the following issues:

  • Content: whether the model includes the "crypto-object" list as an optional feature, as currently proposed, or is limited to CBOM references, leaving the content to the CBOMs.

  • Placement: whether cryptographic objects are modeled as a separate list of each network element, as currently proposed, or as a new class of components in the base model. The "parent" of a component denotes containment, whereas a cryptographic object is implemented by, used by, or bound to components.

7. Tools Compilation

Due to limited time, compiling existing CADI tools remains open and will be done in next version.

8. Security Considerations

This document has no further security considerations.

9. IANA Considerations

TBD

10. References

10.1. Normative References

[RFC7950]
Bjorklund, M., Ed., "The YANG 1.1 Data Modeling Language", RFC 7950, DOI 10.17487/RFC7950, , <https://www.rfc-editor.org/rfc/rfc7950>.
[RFC9911]
Schönwälder, J., Ed., "Common YANG Data Types", RFC 9911, DOI 10.17487/RFC9911, , <https://www.rfc-editor.org/rfc/rfc9911>.
[I-D.ietf-ivy-network-inventory-yang]
Yu, C., Belotti, S., Bouquier, J., Peruzzini, F., and P. Bedard, "A Base YANG Data Model for Network Inventory", Work in Progress, Internet-Draft, draft-ietf-ivy-network-inventory-yang-20, , <https://datatracker.ietf.org/doc/html/draft-ietf-ivy-network-inventory-yang-20>.
[CycloneDX]
Ecma International, "ECMA-424: CycloneDX Bill of Materials Specification, 2nd Edition", , <https://ecma-international.org/publications-and-standards/standards/ecma-424/>.
[CDX-REGISTRY]
OWASP CycloneDX, "CycloneDX Cryptography Registry", n.d., <https://cyclonedx.org/registry/cryptography/>.
[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, , <https://www.rfc-editor.org/rfc/rfc2119>.
[RFC8174]
Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, , <https://www.rfc-editor.org/rfc/rfc8174>.

10.2. Informative References

[RFC6241]
Enns, R., Ed., Bjorklund, M., Ed., Schoenwaelder, J., Ed., and A. Bierman, Ed., "Network Configuration Protocol (NETCONF)", RFC 6241, DOI 10.17487/RFC6241, , <https://www.rfc-editor.org/rfc/rfc6241>.
[RFC7951]
Lhotka, L., "JSON Encoding of Data Modeled with YANG", RFC 7951, DOI 10.17487/RFC7951, , <https://www.rfc-editor.org/rfc/rfc7951>.
[RFC8040]
Bierman, A., Bjorklund, M., and K. Watsen, "RESTCONF Protocol", RFC 8040, DOI 10.17487/RFC8040, , <https://www.rfc-editor.org/rfc/rfc8040>.
[RFC8340]
Bjorklund, M. and L. Berger, Ed., "YANG Tree Diagrams", BCP 215, RFC 8340, DOI 10.17487/RFC8340, , <https://www.rfc-editor.org/rfc/rfc8340>.
[RFC8792]
Watsen, K., Auerswald, E., Farrel, A., and Q. Wu, "Handling Long Lines in Content of Internet-Drafts and RFCs", RFC 8792, DOI 10.17487/RFC8792, , <https://www.rfc-editor.org/rfc/rfc8792>.
[RFC9347]
Hopps, C., "Aggregation and Fragmentation Mode for Encapsulating Security Payload (ESP) and Its Use for IP Traffic Flow Security (IP-TFS)", RFC 9347, DOI 10.17487/RFC9347, , <https://www.rfc-editor.org/rfc/rfc9347>.
[RFC9849]
Rescorla, E., Oku, K., Sullivan, N., and C. A. Wood, "TLS Encrypted Client Hello", RFC 9849, DOI 10.17487/RFC9849, , <https://www.rfc-editor.org/rfc/rfc9849>.
[IANA-TLS]
IANA, "Transport Layer Security (TLS) Parameters", n.d., <https://www.iana.org/assignments/tls-parameters>.
[G7]
"Advancing a Coordinated Roadmap for the Transition to Post-Quantum Cryptography in the Financial Sector", , <https://home.treasury.gov/system/files/136/G7-CEG-Quantum-Roadmap.pdf>.
[CISAACDI]
"Strategy for Migrating to Automated Post-Quantum Cryptography Discovery and Inventory Tools", , <https://www.cisa.gov/sites/default/files/2024-09/Strategy-for-Migrating-to-Automated-PQC-Discovery-and-Inventory-Tools.pdf>.
[NCCOEFAQ]
"Frequently Asked Questions about Post-Quantum Cryptography", , <https://pages.nist.gov/nccoe-migration-post-quantum-cryptography/FAQ/index.html>.
[OMBM2302]
"MEMORANDUM FOR THE HEADS OF EXECUTIVE DEPARTMENTS AND AGENCIES, Migrating to Post-Quantum Cryptography", , <https://www.whitehouse.gov/wp-content/uploads/2022/11/M-23-02-M-Memo-on-Migrating-to-Post-Quantum-Cryptography.pdf>.
[NIST-SP-1800-38B]
"Migration to Post-Quantum Cryptography Quantum Readiness- Cryptographic Discovery", , <https://www.nccoe.nist.gov/sites/default/files/2023-12/pqc-migration-nist-sp-1800-38b-preliminary-draft.pdf>.
[MERCURY]
"Mercury - network metadata capture and analysis.", n.d., <https://github.com/cisco/mercury/>.
[IBMCBOM]
"CBOM", n.d., <https://github.com/IBM/CBOM>.
[CDXGEN]
"CycloneDX Generator", n.d., <https://github.com/cdxgen/cdxgen>.

Appendix A. Example

Figure 5 shows an instance of the module in JSON encoding [RFC7951]. Network element "ne-1" is described by a vendor CBOM listed in "cbom-ref". It runs a TLS 1.3 implementation that is used on the management plane and provided by component "mpu-1". The TLS implementation depends on a device certificate, on the hybrid key exchange X25519MLKEM768, and on AES-256-GCM. The key exchange includes ML-KEM-768 (quantum security level 3), but the device certificate still relies on ECDSA with P-256, which is quantum-vulnerable (level 0).

=============== NOTE: '\' line wrapping per RFC 8792 ================

{
  "ietf-network-inventory:network-inventory": {
    "network-elements": {
      "network-element": [
        {
          "ne-id": "ne-1",
          "components": {
            "component": [
              {
                "component-id": "mpu-1",
                "class": "iana-hardware:module"
              }
            ]
          },
          "ietf-network-inventory-crypto:crypto-inventory": {
            "cbom-ref": [
              {
                "serial-number": "urn:uuid:3e671687-395b-41f5-a30f-\
                   a58921a69b79",
                "version": 1,
                "uri": ["https://vendor.example.com/ne-1.cdx.json"]
              }
            ],
            "crypto-object": [
              {
                "id": "tls-1",
                "name": "TLSv1.3",
                "usage": ["management-plane"],
                "provided-by": ["mpu-1"],
                "depends-on": ["dev-cert", "x25519mlkem768",
                               "aes-256-gcm"],
                "protocol": {
                  "type": "tls",
                  "version": "1.3",
                  "cipher-suite": ["TLS_AES_256_GCM_SHA384"]
                }
              },
              {
                "id": "x25519mlkem768",
                "name": "X25519MLKEM768",
                "depends-on": ["x25519", "ml-kem-768"],
                "algorithm": {
                  "primitive": "combiner"
                }
              },
              {
                "id": "x25519",
                "name": "x25519",
                "algorithm": {
                  "primitive": "key-agree",
                  "family": "ECDH",
                  "curve": "other/Curve25519",
                  "quantum-security-level": 0
                }
              },
              {
                "id": "ml-kem-768",
                "name": "ML-KEM-768",
                "algorithm": {
                  "primitive": "kem",
                  "family": "ML-KEM",
                  "parameter-set": "768",
                  "quantum-security-level": 3
                }
              },
              {
                "id": "aes-256-gcm",
                "name": "AES-256-GCM",
                "algorithm": {
                  "primitive": "ae",
                  "family": "AES",
                  "parameter-set": "256",
                  "quantum-security-level": 5
                }
              },
              {
                "id": "dev-cert",
                "name": "ne-1 device certificate",
                "usage": ["device-identity", "management-plane"],
                "depends-on": ["ecdsa-p-256"],
                "certificate": {
                  "subject": "CN=ne-1.example.com",
                  "issuer": "CN=Example CA",
                  "not-valid-after": "2028-01-01T00:00:00Z"
                }
              },
              {
                "id": "ecdsa-p-256",
                "name": "ECDSA-P-256",
                "algorithm": {
                  "primitive": "signature",
                  "family": "ECDSA",
                  "curve": "nist/P-256",
                  "quantum-security-level": 0
                }
              }
            ]
          }
        }
      ]
    }
  }
}
Figure 5: Example of Cryptographic Inventory

Authors' Addresses

Chunchi Peter Liu
Huawei
China
Yufan Fu
Huawei
China