<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:media="http://search.yahoo.com/mrss/"><channel><title>Parsing | FirewallSync</title><link>https://firewallsync.com/tags/parsing/</link><description>Practical cybersecurity writing for engineering teams that ship fast.</description><language>en-us</language><image><url>https://firewallsync.com/icon-512.png</url><title>FirewallSync</title><link>https://firewallsync.com/</link></image><lastBuildDate>Sun, 15 Nov 2026 04:50:00 +0000</lastBuildDate><atom:link href="https://firewallsync.com/tags/parsing/index.xml" rel="self" type="application/rss+xml"/><item><title>CVE problemTypes and cweId: Getting CWE From CVE JSON</title><link>https://firewallsync.com/posts/cve-problemtypes-cweid-cwe-from-cve-json/</link><guid>https://firewallsync.com/posts/cve-problemtypes-cweid-cwe-from-cve-json/</guid><pubDate>Sun, 15 Nov 2026 04:50:00 +0000</pubDate><dc:creator>Craig Leslie</dc:creator><category>AppSec &amp; APIs</category><description>The CWE for a CVE lives in problemTypes[].descriptions[].cweId, but a count across the November 15, 2026 cvelistV5 snapshot shows 24% of 2026 CVE records have no CNA cweId. Where the gaps come from, what CISA-ADP fills in (often CWE-284), and a parser that handles all four cases.</description><enclosure url="https://firewallsync.com/posts/cve-problemtypes-cweid-cwe-from-cve-json/cover_hu11811165115856360047.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/cve-problemtypes-cweid-cwe-from-cve-json/cover_hu11811165115856360047.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/cve-problemtypes-cweid-cwe-from-cve-json/cover_hu11811165115856360047.jpg" alt="Rows of wooden library card catalogue drawers with metal label holders, receding into soft focus" width="1200" height="630"></p><p><strong>Short answer:</strong> the CWE for a CVE is in <code>containers.cna.problemTypes[].descriptions[].cweId</code>. That field is optional, and a lot of records do not have it. Of the 97,709 CVE records published in 2026 in the cvelistV5 snapshot of November 15, 2026, <strong>24.1% have no CNA <code>cweId</code></strong>: 13,044 carry only text and 10,476 have no <code>problemTypes</code> at all. CISA-ADP fills 15,650 of those gaps, most often with CWE-284, a mapping CWE itself discourages. If you build CWE metrics from CVE JSON, read three places in a fixed order and keep track of which one answered.</p>
<p>This is a field-level guide for engineers building weakness dashboards, SAST/CVE correlation or CWE Top 25-style reports from raw CVE data. Where it fits in the larger triage flow is covered in the <a href="/posts/vulnerability-prioritization-workflow-cve-record-to-patch-ticket/">vulnerability prioritization workflow</a>. How ADP containers work in general is in <a href="/posts/cve-adp-containers-cisa-adp-cve-program-supplier-sadp/">CVE ADP containers: CISA-ADP, CVE Program and supplier ADPs</a>.</p>
<h2 id="the-problemtypes-structure">The problemTypes structure</h2>
<p>The <a href="https://github.com/CVEProject/cve-schema/blob/main/schema/CVE_Record_Format.json">CVE Record Format schema</a> (v5.2.0 in the repository) defines <code>problemTypes</code> as an array with at least one item. Each item has a required <code>descriptions</code> array, and each description object looks like this:</p>
<table>
  <thead>
      <tr>
          <th>Property</th>
          <th>Required</th>
          <th>Schema constraint</th>
          <th>What it holds</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>lang</code></td>
          <td>yes</td>
          <td>language tag</td>
          <td><code>en</code>, <code>en-US</code></td>
      </tr>
      <tr>
          <td><code>description</code></td>
          <td>yes</td>
          <td>string, 1-4096 chars</td>
          <td>&ldquo;Text description of problemType, or title from CWE or OWASP.&rdquo;</td>
      </tr>
      <tr>
          <td><code>cweId</code></td>
          <td>no</td>
          <td><code>^CWE-[1-9][0-9]*$</code>, 5-9 chars</td>
          <td>&ldquo;CWE ID of the CWE that best describes this problemType entry.&rdquo;</td>
      </tr>
      <tr>
          <td><code>type</code></td>
          <td>no</td>
          <td>free string, 1-128 chars</td>
          <td>&ldquo;Problemtype source, text, OWASP, CWE, etc.,&rdquo;</td>
      </tr>
      <tr>
          <td><code>references</code></td>
          <td>no</td>
          <td>references array</td>
          <td>supporting links</td>
      </tr>
  </tbody>
</table>
<p>A well-formed CNA entry:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-json" data-lang="json"><span style="display:flex;"><span><span style="color:#e6db74">&#34;problemTypes&#34;</span><span style="color:#960050;background-color:#1e0010">:</span> [
</span></span><span style="display:flex;"><span>  { <span style="color:#f92672">&#34;descriptions&#34;</span>: [
</span></span><span style="display:flex;"><span>      { <span style="color:#f92672">&#34;lang&#34;</span>: <span style="color:#e6db74">&#34;en&#34;</span>, <span style="color:#f92672">&#34;type&#34;</span>: <span style="color:#e6db74">&#34;CWE&#34;</span>, <span style="color:#f92672">&#34;cweId&#34;</span>: <span style="color:#e6db74">&#34;CWE-352&#34;</span>,
</span></span><span style="display:flex;"><span>        <span style="color:#f92672">&#34;description&#34;</span>: <span style="color:#e6db74">&#34;CWE-352 Cross-Site Request Forgery (CSRF)&#34;</span> } ] }
</span></span><span style="display:flex;"><span>]
</span></span></code></pre></div><p>Two schema details cause most parser bugs:</p>
<ul>
<li><strong><code>problemTypes</code> is not required for a CNA.</strong> The <code>cnaPublishedContainer</code> required list is <code>providerMetadata</code>, <code>descriptions</code>, <code>affected</code> and <code>references</code>. The schema&rsquo;s description text says the field &ldquo;Must contain: At least one entry&rdquo;, but validation will not enforce that.</li>
<li><strong><code>type</code> is free text.</strong> In the full corpus the most common values are <code>CWE</code> (198,469 descriptions) and <code>text</code> (183,625), then a missing <code>type</code> (19,161), <code>Impact</code> (2,778) and lower-case <code>cwe</code> (1,586), plus a tail of one-off values such as &ldquo;RCE (Remote Code Execution)&rdquo;. <code>type: &quot;CWE&quot;</code> does not guarantee a <code>cweId</code> is present.</li>
</ul>
<p>The program rules match the schema&rsquo;s looseness. <a href="https://www.cve.org/Resources/Roles/Cnas/CNA_Rules_v4.1.0.pdf">CNA Operational Rules 4.1.0</a> (effective May 14, 2025), rule 5.1.7, say a CNA &ldquo;MUST identify the type of Vulnerability&rdquo; and that the record &ldquo;SHOULD use the Common Weakness Enumeration (CWE)&rdquo;. A text label satisfies the MUST.</p>
<h2 id="how-often-the-cna-supplies-a-cweid">How often the CNA supplies a cweId</h2>
<p>We streamed the <code>2026-11-15_all_CVEs_at_midnight</code> release zip from cvelistV5 and counted every record in state <code>PUBLISHED</code>, grouped by the year of <code>cveMetadata.datePublished</code>. Each record lands in exactly one CNA bucket.</p>
<table>
  <thead>
      <tr>
          <th>Publication year</th>
          <th>Published records</th>
          <th>CNA cweId</th>
          <th>CNA text only</th>
          <th>No problemTypes</th>
          <th>No cweId anywhere (CNA or CISA-ADP)</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>2024</td>
          <td>39,924</td>
          <td>25,623 (64.2%)</td>
          <td>9,054 (22.7%)</td>
          <td>5,247 (13.1%)</td>
          <td>5,366 (13.4%)</td>
      </tr>
      <tr>
          <td>2025</td>
          <td>48,150</td>
          <td>34,764 (72.2%)</td>
          <td>6,982 (14.5%)</td>
          <td>6,404 (13.3%)</td>
          <td>5,626 (11.7%)</td>
      </tr>
      <tr>
          <td>2026 (to Nov 15)</td>
          <td>97,709</td>
          <td>74,189 (75.9%)</td>
          <td>13,044 (13.3%)</td>
          <td>10,476 (10.7%)</td>
          <td>7,870 (8.1%)</td>
      </tr>
  </tbody>
</table>
<p>CNA coverage is improving year on year, but roughly one in four 2026 records still needs a fallback. Most records with a CNA <code>cweId</code> have exactly one: across all years, 157,531 of 177,478 (88.8%) list a single distinct CWE and 19,947 list two or more. Treat <code>cweId</code> as a set, not a scalar.</p>
<h2 id="where-the-gaps-come-from">Where the gaps come from</h2>
<p>The gaps are not random. They follow individual CNAs&rsquo; publishing habits, which matters because a dashboard filtered to one vendor can show zero CWE data for that vendor without anything being wrong with your parser.</p>
<table>
  <thead>
      <tr>
          <th>CNA (<code>assignerShortName</code>)</th>
          <th>2026 records</th>
          <th>Pattern</th>
          <th>Example</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>Linux</code></td>
          <td>8,262</td>
          <td>no <code>problemTypes</code> in any 2026 record</td>
          <td>CVE-2026-74687</td>
      </tr>
      <tr>
          <td><code>oracle</code></td>
          <td>4,154</td>
          <td>all text only (risk sentence such as &ldquo;Easily exploitable vulnerability allows &hellip;&rdquo;)</td>
          <td>CVE-2026-82997</td>
      </tr>
      <tr>
          <td><code>mitre</code></td>
          <td>3,773</td>
          <td>3,027 text-only, description <code>n/a</code></td>
          <td>CVE-2026-104586</td>
      </tr>
      <tr>
          <td><code>WPScan</code></td>
          <td>2,314</td>
          <td>CWE named in text with <code>type: &quot;CWE&quot;</code>, no <code>cweId</code> (2,312 records)</td>
          <td>CVE-2026-82126</td>
      </tr>
      <tr>
          <td><code>apple</code></td>
          <td>1,196</td>
          <td>all text only</td>
          <td>CVE-2026-86917</td>
      </tr>
      <tr>
          <td><code>Chrome</code></td>
          <td>3,972</td>
          <td>705 text-only (labels such as &ldquo;Inappropriate implementation&rdquo;)</td>
          <td>CVE-2026-106484</td>
      </tr>
      <tr>
          <td><code>mozilla</code></td>
          <td>968</td>
          <td>no <code>problemTypes</code> in any 2026 record</td>
          <td></td>
      </tr>
  </tbody>
</table>
<p>The WPScan pattern deserves its own handling. Its entries look like this:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-json" data-lang="json"><span style="display:flex;"><span>{ <span style="color:#f92672">&#34;description&#34;</span>: <span style="color:#e6db74">&#34;CWE-284 Improper Access Control&#34;</span>, <span style="color:#f92672">&#34;lang&#34;</span>: <span style="color:#e6db74">&#34;en&#34;</span>, <span style="color:#f92672">&#34;type&#34;</span>: <span style="color:#e6db74">&#34;CWE&#34;</span> }
</span></span></code></pre></div><p>A parser that only reads <code>cweId</code> drops these. In 2026, 3,063 records name a CWE ID only in CNA text, and 2,559 description objects have <code>type</code> <code>CWE</code> or <code>cwe</code> with no <code>cweId</code>, 2,359 of them from WPScan. CISA&rsquo;s own <a href="https://github.com/cisagov/vulnrichment">Vulnrichment README</a> uses a WPScan record, CVE-2024-3477, as its example of CISA adding a CWE; the CNA text in that record already says &ldquo;CWE-352 Cross-Site Request Forgery (CSRF)&rdquo;.</p>
<h2 id="what-cisa-adp-adds">What CISA-ADP adds</h2>
<p>The <a href="https://github.com/cisagov/vulnrichment">Vulnrichment README</a> says that once CVEs are SSVC-scored, &ldquo;some higher-risk CVEs will also receive enrichment of CWE and/or CVSS data points, where possible&rdquo;, that CISA populates the ADP container only for CVEs &ldquo;that do not already have these fields populated by the originating CNA&rdquo;, and that &ldquo;At no point will CISA overwrite the originating CNA&rsquo;s data&rdquo;. If a CNA later adds the data, &ldquo;the CISA ADP will drop its own assessments&rdquo;. When both exist, it says the CNA&rsquo;s data &ldquo;should take precedence&rdquo;.</p>
<p>In 2026 records:</p>
<ul>
<li>CISA-ADP carries a <code>cweId</code> in 16,066 records. In 15,650 of them the CNA had none.</li>
<li>In 416 records both containers carry a <code>cweId</code>; in 101 they differ. Per the README, prefer the CNA value.</li>
<li>Of the 3,063 records where the CNA named a CWE only in text, CISA-ADP has a <code>cweId</code> in 2,591, and in 2,544 it is the same ID the text already named.</li>
<li>The only other ADP supplying <code>cweId</code> across the corpus is <code>redhat-SADP</code> (1,124 records). CISA-ADP has 44,152.</li>
</ul>
<p>The most frequent CWEs CISA-ADP adds when the CNA gave none, 2026 records:</p>
<table>
  <thead>
      <tr>
          <th>CWE</th>
          <th>Records</th>
          <th>CWE mapping note</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>CWE-284 Improper Access Control</td>
          <td>3,334</td>
          <td>Pillar; usage DISCOURAGED</td>
      </tr>
      <tr>
          <td>CWE-200 Exposure of Sensitive Information</td>
          <td>975</td>
          <td></td>
      </tr>
      <tr>
          <td>CWE-79 Cross-site Scripting</td>
          <td>829</td>
          <td></td>
      </tr>
      <tr>
          <td>CWE-269 Improper Privilege Management</td>
          <td>717</td>
          <td></td>
      </tr>
      <tr>
          <td>CWE-416 Use After Free</td>
          <td>696</td>
          <td></td>
      </tr>
  </tbody>
</table>
<p>CWE-284&rsquo;s own <a href="https://cwe.mitre.org/data/definitions/284">definition page</a> (CWE 5.0) lists vulnerability mapping usage as &ldquo;DISCOURAGED&rdquo;, says the ID &ldquo;should not be used to map to real-world vulnerabilities&rdquo;, and calls it &ldquo;extremely high-level, a Pillar&rdquo; that is &ldquo;not useful for trend analysis&rdquo;. Most of those 3,334 (2,624) are Oracle records whose CNA entry is text only. CVE-2026-82997 is one, where CISA-ADP adds CWE-284 to a CNA entry that reads &ldquo;Easily exploitable vulnerability allows low privileged attacker with network access via T3, IIOP to compromise Service Delivery Platform.&rdquo; The pillar choice reflects how little the CNA text says, so treat these as &ldquo;access-control-ish, details unknown&rdquo;, not as evidence that access control is your top weakness class.</p>
<h2 id="a-parser-that-handles-all-four-cases">A parser that handles all four cases</h2>
<p>This Python 3 function (tested with Python 3.13 against the five records listed below, fetched from <code>raw.githubusercontent.com/CVEProject/cvelistV5/main/cves/...</code>) returns the CWE set and where it came from:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#f92672">import</span> json<span style="color:#f92672">,</span> re<span style="color:#f92672">,</span> sys
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>CWE_RE <span style="color:#f92672">=</span> re<span style="color:#f92672">.</span>compile(<span style="color:#e6db74">r</span><span style="color:#e6db74">&#34;\bCWE-[1-9][0-9]*\b&#34;</span>)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">def</span> <span style="color:#a6e22e">cwe_ids</span>(record):
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;&#34;&#34;Return (ids, source) for one CVE JSON 5.x record.
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">    source: &#39;cna&#39;, &#39;cna-text&#39;, &#39;cisa-adp&#39; or &#39;none&#39;.&#34;&#34;&#34;</span>
</span></span><span style="display:flex;"><span>    c <span style="color:#f92672">=</span> record[<span style="color:#e6db74">&#34;containers&#34;</span>]
</span></span><span style="display:flex;"><span>    texts, ids <span style="color:#f92672">=</span> [], set()
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> pt <span style="color:#f92672">in</span> c[<span style="color:#e6db74">&#34;cna&#34;</span>]<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;problemTypes&#34;</span>, []):
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">for</span> d <span style="color:#f92672">in</span> pt<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;descriptions&#34;</span>, []):
</span></span><span style="display:flex;"><span>            <span style="color:#66d9ef">if</span> d<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;cweId&#34;</span>):
</span></span><span style="display:flex;"><span>                ids<span style="color:#f92672">.</span>add(d[<span style="color:#e6db74">&#34;cweId&#34;</span>])
</span></span><span style="display:flex;"><span>            <span style="color:#66d9ef">else</span>:
</span></span><span style="display:flex;"><span>                texts<span style="color:#f92672">.</span>append(d<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;description&#34;</span>, <span style="color:#e6db74">&#34;&#34;</span>))
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">if</span> ids:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> sorted(ids), <span style="color:#e6db74">&#34;cna&#34;</span>
</span></span><span style="display:flex;"><span>    found <span style="color:#f92672">=</span> {m <span style="color:#66d9ef">for</span> t <span style="color:#f92672">in</span> texts <span style="color:#66d9ef">for</span> m <span style="color:#f92672">in</span> CWE_RE<span style="color:#f92672">.</span>findall(t)}
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">if</span> found:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> sorted(found), <span style="color:#e6db74">&#34;cna-text&#34;</span>      <span style="color:#75715e"># CWE named in prose only</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> adp <span style="color:#f92672">in</span> c<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;adp&#34;</span>, []):
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">if</span> adp[<span style="color:#e6db74">&#34;providerMetadata&#34;</span>]<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;shortName&#34;</span>) <span style="color:#f92672">!=</span> <span style="color:#e6db74">&#34;CISA-ADP&#34;</span>:
</span></span><span style="display:flex;"><span>            <span style="color:#66d9ef">continue</span>
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">for</span> pt <span style="color:#f92672">in</span> adp<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;problemTypes&#34;</span>, []):
</span></span><span style="display:flex;"><span>            <span style="color:#66d9ef">for</span> d <span style="color:#f92672">in</span> pt<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;descriptions&#34;</span>, []):
</span></span><span style="display:flex;"><span>                <span style="color:#66d9ef">if</span> d<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;cweId&#34;</span>):
</span></span><span style="display:flex;"><span>                    ids<span style="color:#f92672">.</span>add(d[<span style="color:#e6db74">&#34;cweId&#34;</span>])
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> (sorted(ids), <span style="color:#e6db74">&#34;cisa-adp&#34;</span>) <span style="color:#66d9ef">if</span> ids <span style="color:#66d9ef">else</span> ([], <span style="color:#e6db74">&#34;none&#34;</span>)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">if</span> __name__ <span style="color:#f92672">==</span> <span style="color:#e6db74">&#34;__main__&#34;</span>:
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> path <span style="color:#f92672">in</span> sys<span style="color:#f92672">.</span>argv[<span style="color:#ae81ff">1</span>:]:
</span></span><span style="display:flex;"><span>        r <span style="color:#f92672">=</span> json<span style="color:#f92672">.</span>load(open(path))
</span></span><span style="display:flex;"><span>        print(r[<span style="color:#e6db74">&#34;cveMetadata&#34;</span>][<span style="color:#e6db74">&#34;cveId&#34;</span>], <span style="color:#f92672">*</span>cwe_ids(r))
</span></span></code></pre></div><p>Output on the November 15, 2026 versions of those records:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>CVE-2024-2905 [&#39;CWE-732&#39;] cna
</span></span><span style="display:flex;"><span>CVE-2024-3477 [&#39;CWE-352&#39;] cna-text
</span></span><span style="display:flex;"><span>CVE-2026-74687 [] none
</span></span><span style="display:flex;"><span>CVE-2026-82126 [&#39;CWE-284&#39;] cna-text
</span></span><span style="display:flex;"><span>CVE-2026-82997 [&#39;CWE-284&#39;] cisa-adp
</span></span></code></pre></div><p>Design choices, and their limits:</p>
<ul>
<li><strong>CNA text before CISA-ADP.</strong> The CNA is the authoritative source under the README&rsquo;s precedence rule, and in 2,544 of 2,591 overlapping cases the two agree anyway. Swap the order if you only trust structured fields.</li>
<li><strong>The regex can over-match.</strong> A description such as &ldquo;similar to CWE-79&rdquo; would be captured. In the corpus the prose-only CWE strings are overwhelmingly titles in the form &ldquo;CWE-NNN Name&rdquo;, but log <code>cna-text</code> results separately.</li>
<li><strong>Keep the source column.</strong> Store <code>source</code> with each row. It lets you report &ldquo;CNA-mapped&rdquo; and &ldquo;enriched&rdquo; weaknesses separately and lets you drop discouraged pillars from trend charts without losing the records.</li>
<li><strong>Re-read on updates.</strong> CISA-ADP values can disappear when a CNA adds its own. If you sync incrementally with <a href="/posts/cvelistv5-delta-json-deltalog-incremental-cve-sync/">cvelistV5 delta.json and deltaLog.json</a>, re-run the extractor on every updated record rather than caching the first answer.</li>
</ul>
<h2 id="common-mistakes">Common mistakes</h2>
<ul>
<li><strong>Reading <code>problemTypes[0].descriptions[0].cweId</code> only.</strong> 11.2% of records with CNA CWE data list more than one distinct CWE, and some put a text entry first.</li>
<li><strong>Assuming <code>type</code> tells you what you have.</strong> Lower-case <code>cwe</code>, missing <code>type</code> and <code>Impact</code> all occur.</li>
<li><strong>Treating &ldquo;no CWE&rdquo; as &ldquo;unknown vulnerability class&rdquo; for every vendor equally.</strong> Linux kernel and Mozilla records will always be in that bucket until those CNAs change practice.</li>
<li><strong>Merging CISA-ADP CWE-284 into a Top-N chart without a label.</strong> It becomes a top-three entry by volume in 2026 for reasons unrelated to the underlying bugs.</li>
<li><strong>Mixing CWE with severity signals.</strong> CWE says what kind of bug it is, not how urgent it is. Severity and exploitation come from <a href="/posts/cve-json-cvss-metrics-cvssv4-0-cvssv3-1-basescore-trap/">CVSS in the record</a>, <a href="/posts/cisa-vulnrichment-how-to-read-ssvc-values-in-a-cve-record-and-turn-them-into-a-patch-decision/">CISA&rsquo;s SSVC values</a> and KEV.</li>
</ul>
<h2 id="how-mitres-top-25-deals-with-the-same-data">How MITRE&rsquo;s Top 25 deals with the same data</h2>
<p>The <a href="https://cwe.mitre.org/top25/archive/2025/2025_methodology.html">2025 CWE Top 25 methodology</a> used 39,080 CVE records published between June 1, 2024 and June 1, 2025, including mappings &ldquo;added by CISA Vulnrichment after publication&rdquo;. About 9,468 (24%) were flagged for re-mapping review, for example where the CWE was too abstract or commonly misused. If you build an internal ranking from raw CVE data you get the unreviewed version of that dataset, so expect pillars and class-level CWEs to rank higher than they do in the published list.</p>
<h2 id="limits-of-this-article">Limits of this article</h2>
<ul>
<li>Counts come from one snapshot (the <code>cve_2026-11-15_0000Z</code> release) and change daily as records are published, updated and enriched.</li>
<li>Years are grouped by <code>datePublished</code>, not by CVE ID year.</li>
<li>We did not validate whether each CWE is the correct mapping for its vulnerability, only where it is recorded.</li>
<li>CWE usage notes are quoted from CWE 5.0 for CWE-284 only; check the definition page of any other CWE before excluding it.</li>
</ul>
<h2 id="sources-and-verification">Sources and verification</h2>
<table>
  <thead>
      <tr>
          <th>Important claim</th>
          <th>Source</th>
          <th>Status</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>problemTypes structure, cweId pattern, CNA required fields</td>
          <td><a href="https://github.com/CVEProject/cve-schema/blob/main/schema/CVE_Record_Format.json">CVE Record Format schema</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>CNA MUST identify vulnerability type; SHOULD use CWE (rule 5.1.7)</td>
          <td><a href="https://www.cve.org/Resources/Roles/Cnas/CNA_Rules_v4.1.0.pdf">CNA Operational Rules 4.1.0</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>CNA/ADP coverage counts, CNA patterns, CISA-ADP gap-fill counts</td>
          <td>cvelistV5 release <code>cve_2026-11-15_0000Z</code>, counted with Python</td>
          <td>Verified (our count)</td>
      </tr>
      <tr>
          <td>CISA-ADP adds CWE for some CVEs, never overwrites CNA, drops on CNA update, CNA precedence</td>
          <td><a href="https://github.com/cisagov/vulnrichment">cisagov/vulnrichment README</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>CWE-284 is a Pillar with mapping usage DISCOURAGED</td>
          <td><a href="https://cwe.mitre.org/data/definitions/284">CWE-284 definition</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Top 25 2025 dataset size, window and re-mapping share</td>
          <td><a href="https://cwe.mitre.org/top25/archive/2025/2025_methodology.html">2025 CWE Top 25 methodology</a></td>
          <td>Verified</td>
      </tr>
  </tbody>
</table>
]]></content:encoded></item><item><title>CVSS v4 Supplemental Metrics in CVE Records: Who Sets Them</title><link>https://firewallsync.com/posts/cvss-v4-supplemental-metrics-in-cve-records-automatable-provider-urgency/</link><guid>https://firewallsync.com/posts/cvss-v4-supplemental-metrics-in-cve-records-automatable-provider-urgency/</guid><pubDate>Sat, 14 Nov 2026 04:40:00 +0000</pubDate><dc:creator>John Marshall</dc:creator><category>Security Operations</category><description>CVSS v4.0 Supplemental metrics (Safety, Automatable, Recovery, Value Density, Response Effort, Provider Urgency) never change the score. A count across every published CVE record shows only 3.4% of CNA v4.0 entries set any of them, which CNAs do, how the JSON fields and vector string drift apart, and how to use them without overtrusting them.</description><enclosure url="https://firewallsync.com/posts/cvss-v4-supplemental-metrics-in-cve-records-automatable-provider-urgency/cover_hu4154979156842941863.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/cvss-v4-supplemental-metrics-in-cve-records-automatable-provider-urgency/cover_hu4154979156842941863.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/cvss-v4-supplemental-metrics-in-cve-records-automatable-provider-urgency/cover_hu4154979156842941863.jpg" alt="A lit red no-entry signal with a white horizontal bar, glowing against a dark background at night" width="1200" height="630"></p><p><strong>Short answer:</strong> CVSS v4.0 added six optional <em>Supplemental</em> metrics that describe a vulnerability without changing its score. They are real fields in the CVE JSON 5 schema, but almost nobody fills them in. Across every published CVE record in the cvelistV5 snapshot of November 14, 2026, only <strong>3.4%</strong> of records with a CNA <code>cvssV4_0</code> entry set any Supplemental metric, and two vendors, Juniper and Palo Alto Networks, produce nearly a third of them (516 of 1,661 entries). If you parse them, parse both the JSON fields and the vector string, and treat them as the supplier&rsquo;s opinion at publication time.</p>
<p>This article covers the field names and values, who actually sets them, two parsing traps, and where they fit in a patch decision. For the overall flow from CVE record to ticket, see the <a href="/posts/vulnerability-prioritization-workflow-cve-record-to-patch-ticket/">vulnerability prioritization workflow</a>. For reading the rest of a v4.0 vector, see <a href="/posts/how-to-read-a-cvss-v4-0-vector-string-metric-by-metric-with-real-cve-records/">how to read a CVSS v4.0 vector string</a>.</p>
<h2 id="the-six-supplemental-metrics">The six Supplemental metrics</h2>
<p>The <a href="https://www.first.org/cvss/v4.0/specification-document">CVSS v4.0 specification</a> introduces &ldquo;a new, optional metric group called the Supplemental metric group&rdquo; and states: &ldquo;No metric will have any impact on the final calculated CVSS score (e.g. CVSS-BTE).&rdquo; The values &ldquo;convey additional extrinsic characteristics of the vulnerability itself.&rdquo;</p>
<table>
  <thead>
      <tr>
          <th>Metric</th>
          <th>Vector</th>
          <th>Allowed values</th>
          <th>CVE JSON property</th>
          <th>JSON enum</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>Safety</td>
          <td><code>S</code></td>
          <td>X, N, P</td>
          <td><code>Safety</code></td>
          <td>NEGLIGIBLE, PRESENT</td>
      </tr>
      <tr>
          <td>Automatable</td>
          <td><code>AU</code></td>
          <td>X, N, Y</td>
          <td><code>Automatable</code></td>
          <td>NO, YES</td>
      </tr>
      <tr>
          <td>Recovery</td>
          <td><code>R</code></td>
          <td>X, A, U, I</td>
          <td><code>Recovery</code></td>
          <td>AUTOMATIC, USER, IRRECOVERABLE</td>
      </tr>
      <tr>
          <td>Value Density</td>
          <td><code>V</code></td>
          <td>X, D, C</td>
          <td><code>valueDensity</code></td>
          <td>DIFFUSE, CONCENTRATED</td>
      </tr>
      <tr>
          <td>Vulnerability Response Effort</td>
          <td><code>RE</code></td>
          <td>X, L, M, H</td>
          <td><code>vulnerabilityResponseEffort</code></td>
          <td>LOW, MODERATE, HIGH</td>
      </tr>
      <tr>
          <td>Provider Urgency</td>
          <td><code>U</code></td>
          <td>X, Clear, Green, Amber, Red</td>
          <td><code>providerUrgency</code></td>
          <td>CLEAR, GREEN, AMBER, RED</td>
      </tr>
  </tbody>
</table>
<p>Every JSON enum also allows <code>NOT_DEFINED</code>, which is the schema default (<a href="https://github.com/CVEProject/cve-schema/blob/main/schema/imports/cvss/cvss-v4.0.json">cve-schema <code>cvss-v4.0.json</code></a>). In the vector, <code>X</code> means Not Defined, and the spec tells consumers to &ldquo;treat unspecified Threat, Environmental and Supplemental as Not Defined.&rdquo;</p>
<p>What each one means, in the spec&rsquo;s words:</p>
<ul>
<li><strong>Safety:</strong> whether consequences meet the IEC 61508 consequence categories. <code>P</code> (Present) versus <code>N</code> (Negligible).</li>
<li><strong>Automatable:</strong> &ldquo;Can an attacker automate exploitation events for this vulnerability across multiple targets?&rdquo; <code>Y</code> means &ldquo;Attackers can reliably automate all 4 steps of the kill chain.&rdquo;</li>
<li><strong>Recovery:</strong> whether the system recovers services automatically (<code>A</code>), needs user intervention (<code>U</code>), or is irrecoverable by the user (<code>I</code>) after an attack.</li>
<li><strong>Value Density:</strong> what one exploitation event gains the attacker. <code>D</code> (Diffuse): &ldquo;The vulnerable system has limited resources.&rdquo; <code>C</code> (Concentrated): &ldquo;The vulnerable system is rich in resources.&rdquo;</li>
<li><strong>Vulnerability Response Effort:</strong> how hard it is for the consumer to respond, from <code>L</code> (&ldquo;low/trivial&rdquo;) to <code>H</code> (&ldquo;significant and/or difficult&rdquo;).</li>
<li><strong>Provider Urgency:</strong> an optional &ldquo;pass-through&rdquo; metric for the provider&rsquo;s own assessment, from Clear (&ldquo;no urgency (Informational)&rdquo;) to Red (&ldquo;the highest urgency&rdquo;).</li>
</ul>
<p>Two schema details trip up parsers:</p>
<ol>
<li><strong>Property-name casing is inconsistent.</strong> <code>Safety</code>, <code>Automatable</code> and <code>Recovery</code> start with a capital letter; the other three are camelCase. A loop that lower-cases the first letter of every metric name will miss three of them.</li>
<li><strong>Provider Urgency uses words in the vector.</strong> The vector segment is <code>U:Amber</code>, not <code>U:A</code>, and the JSON value is <code>AMBER</code>. A regex for single-letter values silently drops it.</li>
</ol>
<h2 id="who-actually-sets-them">Who actually sets them</h2>
<p>We streamed every record in the cvelistV5 midnight release of November 14, 2026 (<code>2026-11-14_all_CVEs_at_midnight.zip.zip</code>), kept records in state <code>PUBLISHED</code>, and counted CNA <code>cvssV4_0</code> entries where either the JSON property is set to something other than <code>NOT_DEFINED</code> or the vector has a non-<code>X</code> segment. Counts below are from that run; the method is described so you can repeat it.</p>
<table>
  <thead>
      <tr>
          <th>Measure</th>
          <th>Count</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>Published records with a CNA <code>cvssV4_0</code> entry</td>
          <td>46,973 (47,055 entries)</td>
      </tr>
      <tr>
          <td>Records with at least one Supplemental metric</td>
          <td>1,609 (3.4%)</td>
      </tr>
      <tr>
          <td>CNA entries with at least one Supplemental metric</td>
          <td>1,661</td>
      </tr>
      <tr>
          <td>Entries with all six set</td>
          <td>257</td>
      </tr>
      <tr>
          <td>CNAs publishing v4.0 / of those, using Supplemental at least once</td>
          <td>326 / 149</td>
      </tr>
  </tbody>
</table>
<p>By metric, across the 1,661 entries:</p>
<table>
  <thead>
      <tr>
          <th>Metric</th>
          <th>Entries set</th>
          <th>Value split</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>Automatable</td>
          <td>1,210</td>
          <td>YES 732, NO 478</td>
      </tr>
      <tr>
          <td>Provider Urgency</td>
          <td>1,152</td>
          <td>AMBER 617, GREEN 212, RED 208, CLEAR 115</td>
      </tr>
      <tr>
          <td>Response Effort</td>
          <td>1,123</td>
          <td>MODERATE 726, LOW 330, HIGH 67</td>
      </tr>
      <tr>
          <td>Recovery</td>
          <td>1,067</td>
          <td>USER 679, AUTOMATIC 345, IRRECOVERABLE 43</td>
      </tr>
      <tr>
          <td>Value Density</td>
          <td>891</td>
          <td>DIFFUSE 448, CONCENTRATED 443</td>
      </tr>
      <tr>
          <td>Safety</td>
          <td>475</td>
          <td>NEGLIGIBLE 314, PRESENT 161</td>
      </tr>
  </tbody>
</table>
<p>Who sets them matters more than the totals:</p>
<table>
  <thead>
      <tr>
          <th>CNA</th>
          <th>CNA v4.0 entries</th>
          <th>With Supplemental</th>
          <th>Typical pattern</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>VulDB</td>
          <td>14,115</td>
          <td>0</td>
          <td>none</td>
      </tr>
      <tr>
          <td>VulnCheck</td>
          <td>11,610</td>
          <td>2</td>
          <td>none</td>
      </tr>
      <tr>
          <td>GitHub (GitHub_M)</td>
          <td>5,841</td>
          <td>31</td>
          <td>occasional</td>
      </tr>
      <tr>
          <td>icscert (CISA ICS)</td>
          <td>947</td>
          <td>0</td>
          <td>none</td>
      </tr>
      <tr>
          <td>Juniper</td>
          <td>426</td>
          <td>258</td>
          <td>AU, R, RE, often V</td>
      </tr>
      <tr>
          <td>Palo Alto Networks</td>
          <td>263</td>
          <td>258</td>
          <td>AU, R, V, RE, U</td>
      </tr>
  </tbody>
</table>
<p>Other frequent users in the snapshot include bcorg (mostly <code>U</code> only), Apache, OpenText, GovTech CSG and Google Cloud (mostly <code>U</code> only). By CVE ID year, 880 of the 1,661 entries are 2026 IDs, 456 are 2025 and 301 are 2024.</p>
<p>The practical reading: a missing <code>AU</code> or <code>U</code> is a statement about which CNA wrote the record, not about the vulnerability. The two largest producers of v4.0 scores leave every Supplemental metric undefined.</p>
<p>Only five ADP <code>cvssV4_0</code> entries exist in the snapshot (all CISA-ADP), and none set a Supplemental metric. CISA&rsquo;s exploitation and automatability signals arrive through SSVC instead; see <a href="/posts/cisa-vulnrichment-how-to-read-ssvc-values-in-a-cve-record-and-turn-them-into-a-patch-decision/">how to read SSVC values in a CVE record</a>.</p>
<h2 id="trap-the-vector-and-the-json-fields-drift-apart">Trap: the vector and the JSON fields drift apart</h2>
<p>The schema stores each Supplemental value twice: once as a segment in <code>vectorString</code> and once as its own property. In 61 CNA entries they disagree on which metrics are set. GitHub (22), NLnet Labs (14) and Vaadin (7) account for most of them. Two real shapes:</p>
<ul>
<li><code>CVE-2026-110803</code> (Vaadin): JSON sets all six properties (<code>Automatable: YES</code>, <code>providerUrgency: CLEAR</code> and so on) while the vector ends at <code>SA:N</code> with no Supplemental segments.</li>
<li><code>CVE-2026-41292</code> (NLnet Labs): the vector ends <code>E:U/U:Red</code>, but no <code>providerUrgency</code> property exists.</li>
</ul>
<p>We found no entry where both sides were set to different defined values; the drift is always one side missing. Tools that read only <code>vectorString</code> or only the JSON properties will each miss part of the data.</p>
<h2 id="a-parser-that-reads-both-and-flags-drift">A parser that reads both and flags drift</h2>
<p>This Python 3 function (run with Python 3.13 against the three records named in this article, downloaded from <code>raw.githubusercontent.com/CVEProject/cvelistV5/main/cves/...</code>) returns defined Supplemental values from a <code>cvssV4_0</code> object, preferring the vector and falling back to JSON, and reports mismatches:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#f92672">import</span> json<span style="color:#f92672">,</span> sys
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e"># vector abbreviation -&gt; (JSON property in cvss-v4.0.json, vector value -&gt; JSON enum)</span>
</span></span><span style="display:flex;"><span>SUPPLEMENTAL <span style="color:#f92672">=</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;S&#34;</span>:  (<span style="color:#e6db74">&#34;Safety&#34;</span>, {<span style="color:#e6db74">&#34;N&#34;</span>: <span style="color:#e6db74">&#34;NEGLIGIBLE&#34;</span>, <span style="color:#e6db74">&#34;P&#34;</span>: <span style="color:#e6db74">&#34;PRESENT&#34;</span>}),
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;AU&#34;</span>: (<span style="color:#e6db74">&#34;Automatable&#34;</span>, {<span style="color:#e6db74">&#34;N&#34;</span>: <span style="color:#e6db74">&#34;NO&#34;</span>, <span style="color:#e6db74">&#34;Y&#34;</span>: <span style="color:#e6db74">&#34;YES&#34;</span>}),
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;R&#34;</span>:  (<span style="color:#e6db74">&#34;Recovery&#34;</span>, {<span style="color:#e6db74">&#34;A&#34;</span>: <span style="color:#e6db74">&#34;AUTOMATIC&#34;</span>, <span style="color:#e6db74">&#34;U&#34;</span>: <span style="color:#e6db74">&#34;USER&#34;</span>, <span style="color:#e6db74">&#34;I&#34;</span>: <span style="color:#e6db74">&#34;IRRECOVERABLE&#34;</span>}),
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;V&#34;</span>:  (<span style="color:#e6db74">&#34;valueDensity&#34;</span>, {<span style="color:#e6db74">&#34;D&#34;</span>: <span style="color:#e6db74">&#34;DIFFUSE&#34;</span>, <span style="color:#e6db74">&#34;C&#34;</span>: <span style="color:#e6db74">&#34;CONCENTRATED&#34;</span>}),
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;RE&#34;</span>: (<span style="color:#e6db74">&#34;vulnerabilityResponseEffort&#34;</span>, {<span style="color:#e6db74">&#34;L&#34;</span>: <span style="color:#e6db74">&#34;LOW&#34;</span>, <span style="color:#e6db74">&#34;M&#34;</span>: <span style="color:#e6db74">&#34;MODERATE&#34;</span>, <span style="color:#e6db74">&#34;H&#34;</span>: <span style="color:#e6db74">&#34;HIGH&#34;</span>}),
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;U&#34;</span>:  (<span style="color:#e6db74">&#34;providerUrgency&#34;</span>, {<span style="color:#e6db74">&#34;Clear&#34;</span>: <span style="color:#e6db74">&#34;CLEAR&#34;</span>, <span style="color:#e6db74">&#34;Green&#34;</span>: <span style="color:#e6db74">&#34;GREEN&#34;</span>, <span style="color:#e6db74">&#34;Amber&#34;</span>: <span style="color:#e6db74">&#34;AMBER&#34;</span>, <span style="color:#e6db74">&#34;Red&#34;</span>: <span style="color:#e6db74">&#34;RED&#34;</span>}),
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">def</span> <span style="color:#a6e22e">supplemental</span>(cvss4):
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;&#34;&#34;Return {json_field: value} for defined Supplemental metrics, plus conflicts.&#34;&#34;&#34;</span>
</span></span><span style="display:flex;"><span>    segs <span style="color:#f92672">=</span> dict(p<span style="color:#f92672">.</span>split(<span style="color:#e6db74">&#34;:&#34;</span>, <span style="color:#ae81ff">1</span>) <span style="color:#66d9ef">for</span> p <span style="color:#f92672">in</span> cvss4<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;vectorString&#34;</span>, <span style="color:#e6db74">&#34;&#34;</span>)<span style="color:#f92672">.</span>split(<span style="color:#e6db74">&#34;/&#34;</span>)[<span style="color:#ae81ff">1</span>:] <span style="color:#66d9ef">if</span> <span style="color:#e6db74">&#34;:&#34;</span> <span style="color:#f92672">in</span> p)
</span></span><span style="display:flex;"><span>    out, conflicts <span style="color:#f92672">=</span> {}, []
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> abbr, (field, mapping) <span style="color:#f92672">in</span> SUPPLEMENTAL<span style="color:#f92672">.</span>items():
</span></span><span style="display:flex;"><span>        from_vec <span style="color:#f92672">=</span> mapping<span style="color:#f92672">.</span>get(segs<span style="color:#f92672">.</span>get(abbr))            <span style="color:#75715e"># None if absent or X</span>
</span></span><span style="display:flex;"><span>        from_json <span style="color:#f92672">=</span> cvss4<span style="color:#f92672">.</span>get(field)
</span></span><span style="display:flex;"><span>        from_json <span style="color:#f92672">=</span> <span style="color:#66d9ef">None</span> <span style="color:#66d9ef">if</span> from_json <span style="color:#f92672">in</span> (<span style="color:#66d9ef">None</span>, <span style="color:#e6db74">&#34;NOT_DEFINED&#34;</span>) <span style="color:#66d9ef">else</span> from_json
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">if</span> from_vec <span style="color:#f92672">!=</span> from_json:          <span style="color:#75715e"># differs, or one side missing</span>
</span></span><span style="display:flex;"><span>            conflicts<span style="color:#f92672">.</span>append((field, from_vec, from_json))
</span></span><span style="display:flex;"><span>        value <span style="color:#f92672">=</span> from_vec <span style="color:#f92672">or</span> from_json
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">if</span> value:
</span></span><span style="display:flex;"><span>            out[field] <span style="color:#f92672">=</span> value
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> out, conflicts
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">if</span> __name__ <span style="color:#f92672">==</span> <span style="color:#e6db74">&#34;__main__&#34;</span>:
</span></span><span style="display:flex;"><span>    record <span style="color:#f92672">=</span> json<span style="color:#f92672">.</span>load(open(sys<span style="color:#f92672">.</span>argv[<span style="color:#ae81ff">1</span>]))
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> m <span style="color:#f92672">in</span> record[<span style="color:#e6db74">&#34;containers&#34;</span>][<span style="color:#e6db74">&#34;cna&#34;</span>]<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;metrics&#34;</span>, []):
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">if</span> <span style="color:#e6db74">&#34;cvssV4_0&#34;</span> <span style="color:#f92672">in</span> m:
</span></span><span style="display:flex;"><span>            vals, conflicts <span style="color:#f92672">=</span> supplemental(m[<span style="color:#e6db74">&#34;cvssV4_0&#34;</span>])
</span></span><span style="display:flex;"><span>            print(record[<span style="color:#e6db74">&#34;cveMetadata&#34;</span>][<span style="color:#e6db74">&#34;cveId&#34;</span>], vals)
</span></span><span style="display:flex;"><span>            <span style="color:#66d9ef">for</span> c <span style="color:#f92672">in</span> conflicts:
</span></span><span style="display:flex;"><span>                print(<span style="color:#e6db74">&#34;  vector/JSON mismatch:&#34;</span>, c)
</span></span></code></pre></div><p>Output for <code>CVE-2024-0012</code> (two v4.0 entries, one per scenario) and <code>CVE-2026-41292</code>:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>CVE-2024-0012 {&#39;Automatable&#39;: &#39;NO&#39;, &#39;Recovery&#39;: &#39;USER&#39;, &#39;valueDensity&#39;: &#39;CONCENTRATED&#39;, &#39;vulnerabilityResponseEffort&#39;: &#39;HIGH&#39;, &#39;providerUrgency&#39;: &#39;RED&#39;}
</span></span><span style="display:flex;"><span>CVE-2024-0012 {&#39;Automatable&#39;: &#39;NO&#39;, &#39;Recovery&#39;: &#39;USER&#39;, &#39;valueDensity&#39;: &#39;CONCENTRATED&#39;, &#39;vulnerabilityResponseEffort&#39;: &#39;HIGH&#39;, &#39;providerUrgency&#39;: &#39;RED&#39;}
</span></span><span style="display:flex;"><span>CVE-2026-41292 {&#39;providerUrgency&#39;: &#39;RED&#39;}
</span></span><span style="display:flex;"><span>  vector/JSON mismatch: (&#39;providerUrgency&#39;, &#39;RED&#39;, None)
</span></span></code></pre></div><p>This is illustrative ingestion code: it reads the CNA container only and does not validate the rest of the vector. Store the CNA short name next to each value so a dashboard can show who said it.</p>
<h2 id="automatable-cvss-au-versus-ssvc-automatable">Automatable: CVSS AU versus SSVC Automatable</h2>
<p>CVSS <code>AU</code> and SSVC Automatable are close cousins. CERT/CC&rsquo;s SSVC decision point asks &ldquo;Can an attacker reliably automate creating exploitation events for this vulnerability?&rdquo; and defines yes as &ldquo;Attackers can reliably automate steps 1-4 of the kill chain&rdquo; (<a href="https://github.com/CERTCC/SSVC/blob/main/src/ssvc/decision_points/ssvc/automatable.py">CERTCC/SSVC <code>automatable.py</code></a>). The CVSS definition likewise refers to &ldquo;all 4 steps of the kill chain.&rdquo;</p>
<p>They can still disagree within a single record. In <code>CVE-2024-0012</code>, the PAN-OS management web interface authentication bypass, Palo Alto Networks&rsquo; CVSS vector says <code>AU:N</code>. The CISA-ADP SSVC entry in the same record, timestamped 2024-11-18, says <code>Exploitation: active</code>, <code>Automatable: yes</code>, <code>Technical Impact: total</code>. CISA added the CVE to KEV on 2024-11-18.</p>
<p>The record does not explain the difference, so we will not guess at it. The lesson for tooling is narrower: the CNA&rsquo;s <code>AU</code> is the CNA&rsquo;s assessment, and nothing in the schema ties it to exploitation evidence elsewhere in the record. Of the 117 KEV CVEs with a CNA v4.0 entry in this snapshot, 24 carry any Supplemental metric. KEV status comes from the <a href="/posts/cisa-kev-json-feed-what-each-field-means-and-how-to-match-it-against-a-scanner-export/">KEV catalog</a>, not from CVSS.</p>
<h2 id="how-to-use-them-in-a-patch-decision">How to use them in a patch decision</h2>
<ul>
<li><strong>Display, do not score.</strong> Show <code>AU</code>, <code>R</code>, <code>RE</code> and <code>U</code> on the ticket as supplier context. The spec is explicit that they do not change the CVSS number, so do not fold them into one.</li>
<li><strong>Prefer SSVC and KEV for exploitation-driven urgency.</strong> Where CISA-ADP has SSVC values, they reflect exploitation status; CVSS Supplemental values do not. See <a href="/posts/cvss-vs-epss-vs-kev-which-signal-should-decide-what-you-patch-first/">CVSS vs EPSS vs KEV</a> for how the signals divide the work.</li>
<li><strong>Use Response Effort for scheduling, not priority.</strong> <code>RE:H</code> (as in CVE-2024-0012) is a planning hint: the fix needs real work, so book the window early.</li>
<li><strong>Treat Safety: Present as a routing flag.</strong> 161 entries set <code>S:P</code>. If you run OT, medical or vehicle systems, route those to the owners who understand IEC 61508 consequences.</li>
<li><strong>Never require a value.</strong> A rule like &ldquo;page on <code>U:Red</code>&rdquo; fires for 208 entries in the entire CVE corpus and stays silent for every VulDB, VulnCheck and CISA ICS v4.0 score.</li>
</ul>
<h2 id="common-mistakes">Common mistakes</h2>
<ol>
<li>Reading only <code>vectorString</code> or only the JSON properties. Read both; 61 CNA entries differ.</li>
<li>Assuming camelCase for all six JSON names. Three are capitalised.</li>
<li>Parsing <code>U</code> as a single letter. Its values are <code>Clear</code>, <code>Green</code>, <code>Amber</code>, <code>Red</code>.</li>
<li>Treating an absent <code>AU</code> as &ldquo;not automatable&rdquo;. It almost always means &ldquo;not evaluated&rdquo;.</li>
<li>Adding Supplemental metrics into a custom score and labelling it CVSS. The spec says they do not affect the score; a blended number is your own model, so name it as such.</li>
</ol>
<h2 id="limits-of-this-article">Limits of this article</h2>
<p>Counts come from one cvelistV5 snapshot (midnight UTC, November 14, 2026) and cover CNA containers in published records of every CVE year; they will change as CNAs publish and update records. We did not check whether CNAs revise Supplemental values over time, and we have not assessed whether any CNA&rsquo;s values are accurate. The per-CNA table names the short names used in <code>cveMetadata.assignerShortName</code>.</p>
<h2 id="sources-and-verification">Sources and verification</h2>
<table>
  <thead>
      <tr>
          <th>Important claim</th>
          <th>Source</th>
          <th>Status</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>Six Supplemental metrics, allowed vector values, &ldquo;No metric will have any impact on the final calculated CVSS score&rdquo;</td>
          <td><a href="https://www.first.org/cvss/v4.0/specification-document">FIRST CVSS v4.0 Specification Document</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>JSON property names, enums, NOT_DEFINED default</td>
          <td><a href="https://github.com/CVEProject/cve-schema/blob/main/schema/imports/cvss/cvss-v4.0.json">cve-schema cvss-v4.0.json</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Corpus counts (3.4%, per-metric and per-CNA figures, 61 mismatches, 257 with all six)</td>
          <td><a href="https://github.com/CVEProject/cvelistV5/releases">cvelistV5 release <code>cve_2026-11-14_0000Z</code></a>, our count</td>
          <td>Verified (computed)</td>
      </tr>
      <tr>
          <td>CVE-2024-0012 AU:N, U:Red, RE:H; CISA-ADP SSVC Automatable: yes</td>
          <td><a href="https://github.com/CVEProject/cvelistV5/blob/main/cves/2024/0xxx/CVE-2024-0012.json">CVE-2024-0012 record in cvelistV5</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>CVE-2024-0012 added to KEV 2024-11-18; KEV CVE counts</td>
          <td><a href="https://github.com/cisagov/kev-data">cisagov/kev-data</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>SSVC Automatable definition</td>
          <td><a href="https://github.com/CERTCC/SSVC/blob/main/src/ssvc/decision_points/ssvc/automatable.py">CERTCC/SSVC automatable.py</a></td>
          <td>Verified</td>
      </tr>
  </tbody>
</table>
]]></content:encoded></item><item><title>CVE JSON CVSS Metrics: cvssV4_0, cvssV3_1, baseScore Trap</title><link>https://firewallsync.com/posts/cve-json-cvss-metrics-cvssv4-0-cvssv3-1-basescore-trap/</link><guid>https://firewallsync.com/posts/cve-json-cvss-metrics-cvssv4-0-cvssv3-1-basescore-trap/</guid><pubDate>Fri, 13 Nov 2026 04:30:00 +0000</pubDate><dc:creator>John Marshall</dc:creator><category>Security Operations</category><description>How the metrics array in a CVE JSON 5 record actually looks across all 96,879 CVEs published in 2026: which CVSS versions CNAs ship, when CISA-ADP fills the gap, what scenarios mean, why cvssV4_0.baseScore is sometimes a Base+Threat score, and a tested script that picks one score per record and says where it came from.</description><enclosure url="https://firewallsync.com/posts/cve-json-cvss-metrics-cvssv4-0-cvssv3-1-basescore-trap/cover_hu14428814069900906085.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/cve-json-cvss-metrics-cvssv4-0-cvssv3-1-basescore-trap/cover_hu14428814069900906085.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/cve-json-cvss-metrics-cvssv4-0-cvssv3-1-basescore-trap/cover_hu14428814069900906085.jpg" alt="Black-and-white close-up of two round pressure gauges with needles and a regulator valve on old industrial pipework" width="1200" height="630"></p><p><strong>Short answer.</strong> A CVE JSON 5 record can hold zero, one or several CVSS scores, from the CNA and from Authorized Data Publishers such as CISA-ADP, in different CVSS versions and for different scenarios. Across the 96,879 CVEs published in 2026, under a third carry a CNA CVSS v4.0 score, a fifth carry no CNA score at all, and the field called <code>baseScore</code> in a v4.0 entry sometimes holds a Base+Threat score. If your pipeline reads &ldquo;the CVSS score&rdquo; from a record, it is making several choices whether you wrote them down or not. This article shows what the field-level data looks like and gives a tested selection script.</p>
<p><strong>Scope.</strong> We read <code>CVE_Record_Format.json</code> and <code>imports/cvss/cvss-v4.0.json</code> from the CVEProject/cve-schema main branch on November 13, 2026, and streamed every record in the cvelistV5 release <code>cve_2026-11-13_0000Z</code> (<code>2026-11-13_all_CVEs_at_midnight.zip</code>). Counts cover records in state PUBLISHED with a <code>datePublished</code> in 2026. Scores were recomputed with the Red Hat <code>cvss</code> Python library v3.6 on Python 3. For how to read a v4.0 vector itself, see <a href="/posts/how-to-read-a-cvss-v4-0-vector-string-metric-by-metric-with-real-cve-records/">How to Read a CVSS v4.0 Vector String</a>; for where these scores sit in a patch decision, see the <a href="/posts/vulnerability-prioritization-workflow-cve-record-to-patch-ticket/">vulnerability prioritization workflow</a>.</p>
<h2 id="what-the-schema-says">What the schema says</h2>
<p><code>metrics</code> lives in a container: the CNA&rsquo;s (<code>containers.cna.metrics</code>) or an ADP&rsquo;s (<code>containers.adp[].metrics</code>). It is not required in the CNA published container, whose required fields are <code>providerMetadata</code>, <code>descriptions</code>, <code>affected</code> and <code>references</code>.</p>
<p>When present, <code>metrics</code> is an array (<code>minItems: 1</code>). The schema&rsquo;s description of an entry is &ldquo;impact type information (e.g. a text description, CVSSv2, CVSSv3, CVSSV4, etc.)&rdquo;, and it uses <code>anyOf</code> to require at least one of these keys:</p>
<table>
  <thead>
      <tr>
          <th>Key</th>
          <th>Content</th>
          <th>Validated against</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>cvssV4_0</code></td>
          <td>CVSS v4.0 object</td>
          <td><code>imports/cvss/cvss-v4.0.json</code> (FIRST schema)</td>
      </tr>
      <tr>
          <td><code>cvssV3_1</code></td>
          <td>CVSS v3.1 object</td>
          <td><code>imports/cvss/cvss-v3.1.json</code></td>
      </tr>
      <tr>
          <td><code>cvssV3_0</code></td>
          <td>CVSS v3.0 object</td>
          <td><code>imports/cvss/cvss-v3.0.json</code></td>
      </tr>
      <tr>
          <td><code>cvssV2_0</code></td>
          <td>CVSS v2.0 object</td>
          <td><code>imports/cvss/cvss-v2.0.json</code></td>
      </tr>
      <tr>
          <td><code>other</code></td>
          <td><code>{type, content}</code>: &ldquo;A non-standard impact description, may be prose or JSON block&rdquo;</td>
          <td>free-form</td>
      </tr>
  </tbody>
</table>
<p>Two optional siblings matter for parsing:</p>
<ul>
<li><strong><code>format</code></strong>: &ldquo;Name of the scoring format.&rdquo; In practice, 55,806 CNA entries in 2026 set it to <code>CVSS</code>, so do not use it to detect the version. Use the key name.</li>
<li><strong><code>scenarios</code></strong>: an array of <code>{lang, value}</code>. The schema says: &ldquo;If no specific scenario is given, GENERAL is used as the default and applies when no more specific metric matches.&rdquo;</li>
</ul>
<p>The v4.0 object requires <code>version</code>, <code>vectorString</code>, <code>baseScore</code> and <code>baseSeverity</code>, and allows the individual metric fields: Base, Threat (<code>exploitMaturity</code>), Environmental (<code>modified*</code> and the requirement fields) and Supplemental (<code>Safety</code>, <code>Automatable</code>, <code>Recovery</code>, <code>valueDensity</code>, <code>vulnerabilityResponseEffort</code>, <code>providerUrgency</code>). There is <strong>no</strong> <code>threatScore</code> or <code>environmentalScore</code> field. That gap causes the trap described below.</p>
<p>ADP containers use the same <code>metrics</code> structure. CISA-ADP also uses <code>other</code> for its own data: in 2026 records we counted 90,133 <code>other</code> entries of type <code>ssvc</code> and 215 of type <code>kev</code>. Those are what <a href="/posts/cisa-vulnrichment-how-to-read-ssvc-values-in-a-cve-record-and-turn-them-into-a-patch-decision/">CISA Vulnrichment&rsquo;s SSVC values</a> and the KEV date come from, so a parser that keeps only CVSS keys throws them away.</p>
<h2 id="what-2026-records-actually-contain">What 2026 records actually contain</h2>
<table>
  <thead>
      <tr>
          <th>CNA CVSS formats present (2026 published records)</th>
          <th>Records</th>
          <th>Share</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>v3.1 only</td>
          <td>45,507</td>
          <td>47.0%</td>
      </tr>
      <tr>
          <td>none</td>
          <td>20,408</td>
          <td>21.1%</td>
      </tr>
      <tr>
          <td>v3.1 + v4.0</td>
          <td>12,458</td>
          <td>12.9%</td>
      </tr>
      <tr>
          <td>v4.0 only</td>
          <td>11,296</td>
          <td>11.7%</td>
      </tr>
      <tr>
          <td>v2.0 + v3.0 + v3.1 + v4.0</td>
          <td>6,370</td>
          <td>6.6%</td>
      </tr>
      <tr>
          <td>v3.0 only</td>
          <td>612</td>
          <td>0.6%</td>
      </tr>
      <tr>
          <td>v3.0 + v4.0</td>
          <td>216</td>
          <td>0.2%</td>
      </tr>
      <tr>
          <td>v2.0 + v3.1 + v4.0</td>
          <td>12</td>
          <td>&lt;0.1%</td>
      </tr>
      <tr>
          <td><strong>Total</strong></td>
          <td><strong>96,879</strong></td>
          <td></td>
      </tr>
  </tbody>
</table>
<p>Totals across those rows: 30,352 records (31.3%) had a CNA v4.0 entry, and 64,347 (66.4%) a CNA v3.1 entry.</p>
<p>v4.0 adoption is concentrated. VulnCheck (10,176 records), VulDB (6,370) and GitHub (4,287) published 68.6% of the CNA v4.0 records. VulDB&rsquo;s 6,370 v4.0 records match the 6,370 records in the four-version row, and the VulDB record we opened (CVE-2026-82598) lists v4.0, v3.1, v3.0 and v2.0 entries side by side. A parser that takes the first entry in the array gets whichever one the CNA happened to list first.</p>
<p>Of the 20,408 records with no CNA CVSS, <strong>15,148</strong> had a CVSS v3.1 entry from CISA-ADP, and <strong>5,260</strong> had no CVSS from either the CNA or CISA-ADP. (A few of those carry a supplier ADP score or a CNA <code>other</code> rating such as &ldquo;Red Hat severity rating&rdquo;, which appeared in 1,476 CNA entries.) Only 4 CISA-ADP entries in 2026 used v4.0.</p>
<h2 id="the-basescore-trap">The baseScore trap</h2>
<p>The CVSS v4.0 specification names scores by the metric groups used: CVSS-B (Base), CVSS-BT (Base and Threat), CVSS-BE and CVSS-BTE. Our <a href="/posts/how-to-read-a-cvss-v4-0-vector-string-metric-by-metric-with-real-cve-records/">vector-string article</a> covers that nomenclature. The CVE schema, though, gives the v4.0 object only one score field, <code>baseScore</code>. When a CNA puts a Threat metric in the vector, it has to decide which number goes in that field. CNAs decide differently.</p>
<p>We took every CNA <code>cvssV4_0</code> entry from 2026 whose <code>vectorString</code> sets Exploit Maturity to something other than X, recomputed the score with and without the <code>E:</code> metric, and compared both to the stored <code>baseScore</code>:</p>
<table>
  <thead>
      <tr>
          <th>Stored <code>baseScore</code> equals&hellip;</th>
          <th>Entries</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>Base-only score (CVSS-B)</td>
          <td>5,816</td>
      </tr>
      <tr>
          <td>Base+Threat score (CVSS-BT)</td>
          <td>1,067</td>
      </tr>
      <tr>
          <td>Both equal (E metric did not change the score)</td>
          <td>68</td>
      </tr>
      <tr>
          <td>Neither</td>
          <td>3</td>
      </tr>
      <tr>
          <td><strong>Total with E set</strong></td>
          <td><strong>6,954</strong></td>
      </tr>
  </tbody>
</table>
<p>The split follows the CNA. VulDB accounts for 5,790 of the Base-only entries. GitHub (432), Palo Alto Networks (120), QNAP (106) and NETGEAR (48) lead the CVSS-BT side. Two real records show the difference:</p>
<ul>
<li><strong>CVE-2026-82598 (VulDB)</strong>: vector <code>CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:L/VA:L/SC:N/SI:N/SA:N/E:P</code>, stored <code>baseScore</code> 6.9. The full vector computes to 5.5; without <code>E:P</code>, 6.9. The stored number is CVSS-B.</li>
<li><strong>CVE-2026-41129 (GitHub, a Craft CMS SSRF)</strong>: vector <code>CVSS:4.0/AV:N/AC:L/AT:N/PR:H/UI:N/VC:H/VI:L/VA:N/SC:N/SI:N/SA:N/E:P</code>, stored <code>baseScore</code> 5.5, severity MEDIUM. Without <code>E:P</code> the score is 7.0 (HIGH). The stored number is CVSS-BT.</li>
</ul>
<p>Both are valid by the schema. But if your SLA says &ldquo;High and above within 14 days&rdquo;, the second record misses the bar because the CNA folded in Exploit Maturity, and the first meets the bar or misses it purely on base impact. If you also add an exploitation signal from <a href="/posts/cisa-kev-json-feed-what-each-field-means-and-how-to-match-it-against-a-scanner-export/">KEV</a> or <a href="/posts/epss-data-feed-columns-percentile-vs-probability-and-how-to-join-it-to-a-scanner-export/">EPSS</a>, a CVSS-BT number counts exploit evidence twice in one direction or the other. Decide which you want, recompute it from the vector, and label it.</p>
<p>Exploit Maturity values seen in CNA v4.0 entries in 2026: <code>NOT_DEFINED</code> 10,620, field absent 19,051, <code>UNREPORTED</code> 482, <code>PROOF_OF_CONCEPT</code> 210 and <code>ATTACKED</code> 41. Those counts come from the <code>exploitMaturity</code> JSON field, which not every producer fills even when the vector sets <code>E:</code>. Read the vector, not the field.</p>
<h2 id="scenarios-one-cve-several-scores">Scenarios: one CVE, several scores</h2>
<p>3,543 CNA metrics entries in 2026 named a scenario other than GENERAL. F5&rsquo;s CVE-2026-41225 is a clean example. It has three entries:</p>
<table>
  <thead>
      <tr>
          <th>Scenario</th>
          <th>Format</th>
          <th>Score</th>
          <th>Vector</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>GENERAL</td>
          <td>cvssV3_1</td>
          <td>7.2</td>
          <td><code>CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H</code></td>
      </tr>
      <tr>
          <td>GENERAL</td>
          <td>cvssV4_0</td>
          <td>8.6</td>
          <td><code>CVSS:4.0/AV:N/AC:L/AT:N/PR:H/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N</code></td>
      </tr>
      <tr>
          <td>Appliance Mode</td>
          <td>cvssV3_1</td>
          <td>9.1</td>
          <td><code>CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:C/C:H/I:H/A:H</code></td>
      </tr>
  </tbody>
</table>
<p>If you run the product in the named configuration, the scenario-specific score is the one that applies to you. A dashboard that shows the maximum overstates risk for everyone else, and one that shows the first entry may understate it for appliance-mode customers. Pick GENERAL by default, and let asset metadata select a named scenario when it matches.</p>
<h2 id="cna-and-cisa-adp-disagree-more-than-you-would-expect">CNA and CISA-ADP disagree more than you would expect</h2>
<p>CISA-ADP mostly adds CVSS where the CNA has none (see <a href="/posts/cve-adp-containers-cisa-adp-cve-program-supplier-sadp/">ADP containers</a>). In 468 records from 2026 both published a v3.1 score. In 58 of those (12.4%) the base scores differed: CISA-ADP was higher in 31 and lower in 27. Some gaps are large. In CVE-2026-41080 (libexpat hash flooding, assigned by MITRE), the CNA entry is <code>AV:L/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:L</code> (2.9) and CISA-ADP&rsquo;s is <code>AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N</code> (7.5). Those two analysts read the impact very differently. Averaging them would produce a number nobody asserted. Store both, with provider, and let your policy say which one drives the SLA.</p>
<h2 id="a-tested-script-pick-one-score-and-keep-its-provenance">A tested script: pick one score and keep its provenance</h2>
<p>This script applies a fixed order: CNA before CISA-ADP, v4.0 before v3.1 before v3.0, GENERAL (or unlabelled) scenarios before named ones. For v4.0 it recomputes CVSS-B and CVSS-BT from the vector and says which one <code>baseScore</code> holds. It needs <code>pip install cvss</code> (we used v3.6).</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#e6db74">&#34;&#34;&#34;Pick one CVSS entry per CVE JSON 5.x record, and say where it came from.
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">Order: CNA v4.0 &gt; CNA v3.1 &gt; CNA v3.0 &gt; CISA-ADP v3.1. GENERAL scenario first.
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">Requires: pip install cvss (Red Hat library, v3.6 tested).&#34;&#34;&#34;</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> json<span style="color:#f92672">,</span> sys
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> cvss <span style="color:#f92672">import</span> CVSS4
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>ORDER <span style="color:#f92672">=</span> [<span style="color:#e6db74">&#34;cvssV4_0&#34;</span>, <span style="color:#e6db74">&#34;cvssV3_1&#34;</span>, <span style="color:#e6db74">&#34;cvssV3_0&#34;</span>]
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">def</span> <span style="color:#a6e22e">is_general</span>(entry):
</span></span><span style="display:flex;"><span>    sc <span style="color:#f92672">=</span> entry<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;scenarios&#34;</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> <span style="color:#f92672">not</span> sc <span style="color:#f92672">or</span> any(s<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;value&#34;</span>, <span style="color:#e6db74">&#34;&#34;</span>)<span style="color:#f92672">.</span>upper() <span style="color:#f92672">==</span> <span style="color:#e6db74">&#34;GENERAL&#34;</span> <span style="color:#66d9ef">for</span> s <span style="color:#f92672">in</span> sc)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">def</span> <span style="color:#a6e22e">candidates</span>(record):
</span></span><span style="display:flex;"><span>    cna <span style="color:#f92672">=</span> record[<span style="color:#e6db74">&#34;containers&#34;</span>][<span style="color:#e6db74">&#34;cna&#34;</span>]<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;metrics&#34;</span>, [])
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> fmt <span style="color:#f92672">in</span> ORDER:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">for</span> e <span style="color:#f92672">in</span> sorted(cna, key<span style="color:#f92672">=</span><span style="color:#66d9ef">lambda</span> e: <span style="color:#f92672">not</span> is_general(e)):
</span></span><span style="display:flex;"><span>            <span style="color:#66d9ef">if</span> fmt <span style="color:#f92672">in</span> e:
</span></span><span style="display:flex;"><span>                <span style="color:#66d9ef">yield</span> <span style="color:#e6db74">&#34;cna&#34;</span>, fmt, e
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> adp <span style="color:#f92672">in</span> record[<span style="color:#e6db74">&#34;containers&#34;</span>]<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;adp&#34;</span>, []):
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">if</span> adp[<span style="color:#e6db74">&#34;providerMetadata&#34;</span>]<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;shortName&#34;</span>) <span style="color:#f92672">==</span> <span style="color:#e6db74">&#34;CISA-ADP&#34;</span>:
</span></span><span style="display:flex;"><span>            <span style="color:#66d9ef">for</span> e <span style="color:#f92672">in</span> adp<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;metrics&#34;</span>, []):
</span></span><span style="display:flex;"><span>                <span style="color:#66d9ef">if</span> <span style="color:#e6db74">&#34;cvssV3_1&#34;</span> <span style="color:#f92672">in</span> e:
</span></span><span style="display:flex;"><span>                    <span style="color:#66d9ef">yield</span> <span style="color:#e6db74">&#34;CISA-ADP&#34;</span>, <span style="color:#e6db74">&#34;cvssV3_1&#34;</span>, e
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">def</span> <span style="color:#a6e22e">pick</span>(record):
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> source, fmt, e <span style="color:#f92672">in</span> candidates(record):
</span></span><span style="display:flex;"><span>        m <span style="color:#f92672">=</span> e[fmt]
</span></span><span style="display:flex;"><span>        out <span style="color:#f92672">=</span> {<span style="color:#e6db74">&#34;source&#34;</span>: source, <span style="color:#e6db74">&#34;format&#34;</span>: fmt, <span style="color:#e6db74">&#34;stored&#34;</span>: m[<span style="color:#e6db74">&#34;baseScore&#34;</span>],
</span></span><span style="display:flex;"><span>               <span style="color:#e6db74">&#34;vector&#34;</span>: m[<span style="color:#e6db74">&#34;vectorString&#34;</span>],
</span></span><span style="display:flex;"><span>               <span style="color:#e6db74">&#34;scenario&#34;</span>: [s[<span style="color:#e6db74">&#34;value&#34;</span>] <span style="color:#66d9ef">for</span> s <span style="color:#f92672">in</span> e<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;scenarios&#34;</span>, [])] <span style="color:#f92672">or</span> [<span style="color:#e6db74">&#34;(none)&#34;</span>]}
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">if</span> fmt <span style="color:#f92672">==</span> <span style="color:#e6db74">&#34;cvssV4_0&#34;</span>:
</span></span><span style="display:flex;"><span>            parts <span style="color:#f92672">=</span> m[<span style="color:#e6db74">&#34;vectorString&#34;</span>]<span style="color:#f92672">.</span>split(<span style="color:#e6db74">&#34;/&#34;</span>)
</span></span><span style="display:flex;"><span>            base_only <span style="color:#f92672">=</span> <span style="color:#e6db74">&#34;/&#34;</span><span style="color:#f92672">.</span>join(p <span style="color:#66d9ef">for</span> p <span style="color:#f92672">in</span> parts <span style="color:#66d9ef">if</span> <span style="color:#f92672">not</span> p<span style="color:#f92672">.</span>startswith(<span style="color:#e6db74">&#34;E:&#34;</span>))
</span></span><span style="display:flex;"><span>            out[<span style="color:#e6db74">&#34;cvss_b&#34;</span>] <span style="color:#f92672">=</span> float(CVSS4(base_only)<span style="color:#f92672">.</span>base_score)
</span></span><span style="display:flex;"><span>            out[<span style="color:#e6db74">&#34;cvss_bt&#34;</span>] <span style="color:#f92672">=</span> float(CVSS4(m[<span style="color:#e6db74">&#34;vectorString&#34;</span>])<span style="color:#f92672">.</span>base_score)
</span></span><span style="display:flex;"><span>            out[<span style="color:#e6db74">&#34;stored_is&#34;</span>] <span style="color:#f92672">=</span> (<span style="color:#e6db74">&#34;B and BT equal&#34;</span> <span style="color:#66d9ef">if</span> out[<span style="color:#e6db74">&#34;cvss_b&#34;</span>] <span style="color:#f92672">==</span> out[<span style="color:#e6db74">&#34;cvss_bt&#34;</span>] <span style="color:#66d9ef">else</span>
</span></span><span style="display:flex;"><span>                                <span style="color:#e6db74">&#34;CVSS-B&#34;</span> <span style="color:#66d9ef">if</span> out[<span style="color:#e6db74">&#34;stored&#34;</span>] <span style="color:#f92672">==</span> out[<span style="color:#e6db74">&#34;cvss_b&#34;</span>] <span style="color:#66d9ef">else</span>
</span></span><span style="display:flex;"><span>                                <span style="color:#e6db74">&#34;CVSS-BT&#34;</span> <span style="color:#66d9ef">if</span> out[<span style="color:#e6db74">&#34;stored&#34;</span>] <span style="color:#f92672">==</span> out[<span style="color:#e6db74">&#34;cvss_bt&#34;</span>] <span style="color:#66d9ef">else</span> <span style="color:#e6db74">&#34;neither&#34;</span>)
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> out
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> {<span style="color:#e6db74">&#34;source&#34;</span>: <span style="color:#66d9ef">None</span>, <span style="color:#e6db74">&#34;note&#34;</span>: <span style="color:#e6db74">&#34;no CVSS from CNA or CISA-ADP&#34;</span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">if</span> __name__ <span style="color:#f92672">==</span> <span style="color:#e6db74">&#34;__main__&#34;</span>:
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> path <span style="color:#f92672">in</span> sys<span style="color:#f92672">.</span>argv[<span style="color:#ae81ff">1</span>:]:
</span></span><span style="display:flex;"><span>        rec <span style="color:#f92672">=</span> json<span style="color:#f92672">.</span>load(open(path))
</span></span><span style="display:flex;"><span>        print(rec[<span style="color:#e6db74">&#34;cveMetadata&#34;</span>][<span style="color:#e6db74">&#34;cveId&#34;</span>], json<span style="color:#f92672">.</span>dumps(pick(rec)))
</span></span></code></pre></div><p>We ran it on record files fetched from <code>raw.githubusercontent.com/CVEProject/cvelistV5/main/cves/2026/...</code> on November 13, 2026 (output trimmed to the key fields):</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>CVE-2026-1995   source=CISA-ADP format=cvssV3_1 stored=7.8
</span></span><span style="display:flex;"><span>CVE-2026-41080  source=cna format=cvssV3_1 stored=2.9 scenario=GENERAL
</span></span><span style="display:flex;"><span>CVE-2026-41129  source=cna format=cvssV4_0 stored=5.5 cvss_b=7.0 cvss_bt=5.5 stored_is=CVSS-BT
</span></span><span style="display:flex;"><span>CVE-2026-41225  source=cna format=cvssV4_0 stored=8.6 cvss_b=8.6 cvss_bt=8.6 stored_is=&#34;B and BT equal&#34; scenario=GENERAL
</span></span><span style="display:flex;"><span>CVE-2026-82598  source=cna format=cvssV4_0 stored=6.9 cvss_b=6.9 cvss_bt=5.5 stored_is=CVSS-B
</span></span><span style="display:flex;"><span>CVE-2026-86471  source=cna format=cvssV4_0 stored=9.3 cvss_b=9.3 cvss_bt=9.3 stored_is=&#34;B and BT equal&#34; scenario=GENERAL
</span></span></code></pre></div><p>CVE-2026-1995 (an IDrive Cloud Backup Client privilege escalation, CNA CERT/CC) has no CNA CVSS, so the CISA-ADP v3.1 score is used and labelled. CVE-2026-86471 (Apache CouchDB) sets <code>E:A</code>; Attacked is the worst-case Exploit Maturity, so Base and Base+Threat are equal.</p>
<p>This is a starting point, not a policy. You might prefer v3.1 over v4.0 while your SLAs are still written in v3.1 bands (the two versions&rsquo; scores are not comparable), keep the CISA-ADP score alongside the CNA one, or pick a named scenario from asset data.</p>
<h2 id="common-mistakes">Common mistakes</h2>
<ul>
<li><strong>Reading <code>metrics[0]</code>.</strong> The array order is the CNA&rsquo;s choice; some records list four CVSS versions.</li>
<li><strong>Detecting the version from <code>format</code>.</strong> Most entries just say <code>CVSS</code>. Use the key (<code>cvssV4_0</code>, <code>cvssV3_1</code>, &hellip;) or the <code>version</code> field.</li>
<li><strong>Treating v4.0 <code>baseScore</code> as CVSS-B.</strong> Recompute from <code>vectorString</code> if your policy cares.</li>
<li><strong>Dropping <code>other</code>.</strong> CISA-ADP&rsquo;s SSVC and KEV entries are <code>other</code>; so are vendor ratings such as Red Hat&rsquo;s.</li>
<li><strong>Overwriting CNA with ADP (or the reverse).</strong> Keep both with <code>providerMetadata.shortName</code>.</li>
<li><strong>Ignoring <code>scenarios</code>.</strong> The highest score may belong to a configuration you do not run.</li>
</ul>
<h2 id="limits-of-this-article">Limits of this article</h2>
<p>Counts are a snapshot of cvelistV5 at 00:00 UTC on November 13, 2026, restricted to records published in 2026. CNAs update records, so numbers will drift. Score recomputation used one library; where we compared stored and recomputed values, three entries matched neither, and we did not investigate them. We do not say which CNA practice is correct. The schema permits both, and the CVSS v4.0 specification&rsquo;s naming guidance applies to how scores are displayed, not to this JSON field.</p>
<h2 id="sources-and-verification">Sources and verification</h2>
<table>
  <thead>
      <tr>
          <th>Important claim</th>
          <th>Source</th>
          <th>Status</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>metrics optional in CNA container; array structure; anyOf of five keys; <code>format</code>, <code>scenarios</code> and GENERAL default; <code>other</code> = {type, content}</td>
          <td><a href="https://github.com/CVEProject/cve-schema/blob/main/schema/CVE_Record_Format.json">CVE_Record_Format.json, CVEProject/cve-schema</a> (read Nov 13, 2026)</td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>v4.0 object required fields; no Threat/Environmental score fields; Supplemental field names</td>
          <td><a href="https://github.com/CVEProject/cve-schema/blob/main/schema/imports/cvss/cvss-v4.0.json">cvss-v4.0.json import, CVEProject/cve-schema</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>CVSS-B / BT / BE / BTE nomenclature</td>
          <td><a href="https://www.first.org/cvss/v4.0/specification-document">CVSS v4.0 Specification Document, FIRST</a></td>
          <td>Verified in our Oct 17, 2026 article; not re-read today</td>
      </tr>
      <tr>
          <td>All 2026 counts (formats, CISA-ADP fill, other types, scenarios, B vs BT split, CNA vs ADP disagreement, CNA concentration)</td>
          <td>Our script over <a href="https://github.com/CVEProject/cvelistV5/releases">cvelistV5 release cve_2026-11-13_0000Z</a></td>
          <td>Qualified: our computation, snapshot date stated</td>
      </tr>
      <tr>
          <td>Example records CVE-2026-1995, -41080, -41129, -41225, -82598, -86471 (vectors, stored scores, scenarios)</td>
          <td><a href="https://github.com/CVEProject/cvelistV5/tree/main/cves/2026">cvelistV5 record files</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Recomputed CVSS-B / CVSS-BT values</td>
          <td>Red Hat <a href="https://pypi.org/project/cvss/"><code>cvss</code></a> library v3.6, run Nov 13, 2026</td>
          <td>Qualified: one implementation</td>
      </tr>
  </tbody>
</table>
]]></content:encoded></item></channel></rss>