<?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>Supply Chain | FirewallSync</title><link>https://firewallsync.com/tags/supply-chain/</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>Thu, 19 Nov 2026 04:25:00 +0000</lastBuildDate><atom:link href="https://firewallsync.com/tags/supply-chain/index.xml" rel="self" type="application/rss+xml"/><item><title>Microsoft agent-framework PyPI Compromise: What We Know</title><link>https://firewallsync.com/posts/microsoft-agent-framework-pypi-compromise-1-26-1-1-26-2-what-we-know/</link><guid>https://firewallsync.com/posts/microsoft-agent-framework-pypi-compromise-1-26-1-1-26-2-what-we-know/</guid><pubDate>Thu, 19 Nov 2026 04:25:00 +0000</pubDate><dc:creator>John Marshall</dc:creator><category>AI Security</category><description>Two malicious releases of Microsoft's agent-framework Python package, 1.26.1 and 1.26.2, were on PyPI for under an hour on November 17, 2026. Both installed a .pth file that ran a credential stealer on every Python start. What is confirmed, what is not, and how to check your environments.</description><enclosure url="https://firewallsync.com/posts/microsoft-agent-framework-pypi-compromise-1-26-1-1-26-2-what-we-know/cover_hu7113213060184927081.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/microsoft-agent-framework-pypi-compromise-1-26-1-1-26-2-what-we-know/cover_hu7113213060184927081.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/microsoft-agent-framework-pypi-compromise-1-26-1-1-26-2-what-we-know/cover_hu7113213060184927081.jpg" alt="A heap of brown cardboard boxes and open cartons stacked against wooden shelving in a dim storeroom" width="1200" height="630"></p><p><strong>What happened:</strong> On November 17, 2026, two releases of <code>agent-framework</code>, the Python package for Microsoft Agent Framework, were published to PyPI with a credential stealer inside. Versions 1.26.1 and 1.26.2 were available for under an hour, according to <a href="https://www.wiz.io/blog/malicious-version-of-microsofts-agent-framework-published-to-pypi">Wiz</a>. Both installed a <code>.pth</code> file that ran the stealer whenever Python started in that environment, and it collected cloud, CI and registry credentials. <a href="https://www.securityweek.com/microsoft-agent-framework-releases-poisoned-with-credential-stealer/">SecurityWeek</a> reports that an Agent Framework maintainer confirmed on GitHub that the releases were removed and that an investigation is underway.</p>
<p>The package is not niche: SecurityWeek puts it at about 190,000 downloads a month. Any environment that resolved <code>agent-framework</code> without a pin in that window, on a developer laptop, a CI runner or a container build, may have installed one of the bad versions.</p>
<h2 id="timeline-utc">Timeline (UTC)</h2>
<table>
  <thead>
      <tr>
          <th>Time</th>
          <th>Event</th>
          <th>Source</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>Nov 12, 18:25</td>
          <td>Legitimate 1.26.0 published</td>
          <td>Wiz; PyPI upload time 18:24:57 to 18:25:37</td>
      </tr>
      <tr>
          <td>Nov 17, 20:35:20</td>
          <td>Malicious 1.26.1 published</td>
          <td>Chainguard (Wiz: 20:35)</td>
      </tr>
      <tr>
          <td>Nov 17, 21:08:39</td>
          <td>Malicious 1.26.2 published, after PyPI had quarantined 1.26.1</td>
          <td>Chainguard (Wiz: about 21:08)</td>
      </tr>
      <tr>
          <td>Nov 17, about 21:30</td>
          <td>Both versions no longer available on PyPI</td>
          <td>Wiz</td>
      </tr>
      <tr>
          <td>Nov 19, about 05:00</td>
          <td>PyPI&rsquo;s JSON API lists 1.26.0 as the latest version; 1.26.1 and 1.26.2 are absent</td>
          <td>Our check of <code>pypi.org/pypi/agent-framework/json</code></td>
      </tr>
  </tbody>
</table>
<p><a href="https://www.chainguard.dev/unchained/microsoft-agent-framework-compromised-on-pypi-november-2026">Chainguard</a> says its Chainguard Libraries mirror blocked 1.26.1 48 seconds after publication and 1.26.2 42 seconds after.</p>
<h2 id="confirmed-vs-not-confirmed">Confirmed vs not confirmed</h2>
<table>
  <thead>
      <tr>
          <th>Claim</th>
          <th>Status</th>
          <th>Who says so</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>1.26.1 and 1.26.2 were malicious and removed from PyPI</td>
          <td>Confirmed</td>
          <td>Wiz, Chainguard, SecurityWeek; PyPI no longer lists them</td>
      </tr>
      <tr>
          <td>1.26.0 is the latest clean release</td>
          <td>Stated by Wiz and SecurityWeek</td>
          <td>Chainguard (writing earlier) did not name a safe version and advised suspicion of any release on Nov 17 or 18</td>
      </tr>
      <tr>
          <td>Microsoft is investigating</td>
          <td>Reported</td>
          <td>SecurityWeek, citing a maintainer&rsquo;s GitHub post; we found no Microsoft blog or advisory</td>
      </tr>
      <tr>
          <td>How publishing access was obtained</td>
          <td><strong>Not confirmed</strong></td>
          <td>Wiz: the attacker &ldquo;appears to have compromised a client certificate and private key&rdquo; for Microsoft&rsquo;s ESRP signing and publishing service. SecurityWeek: &ldquo;The method used to publish the malicious packages remains unknown.&rdquo;</td>
      </tr>
      <tr>
          <td>A PyPI account created on the day of the attack was involved</td>
          <td><strong>Not confirmed</strong></td>
          <td>SafeDep, as reported by SecurityWeek, found a new maintainer account with publishing rights; its role in the uploads is unconfirmed</td>
      </tr>
      <tr>
          <td>Victim data was stolen</td>
          <td>Partly reported</td>
          <td>Wiz says the webhook.site endpoint was on a free tier that caps at 50 requests, and it identified three unique successful exfiltrations among them</td>
      </tr>
      <tr>
          <td>Who is behind it</td>
          <td><strong>Not confirmed</strong></td>
          <td>No attribution published</td>
      </tr>
  </tbody>
</table>
<p>Wiz also mentions an earlier, separate compromise of a Microsoft package (durabletask) and says the two incidents have not been linked.</p>
<h2 id="how-the-stealer-ran">How the stealer ran</h2>
<p>Both wheels added a <code>.pth</code> file to <code>site-packages</code>: <code>agent_framework_meta.pth</code> in 1.26.1 and <code>af_runtime_diag.pth</code> in 1.26.2. Python&rsquo;s <a href="https://docs.python.org/3/library/site.html"><code>site</code> module documentation</a> explains why that is enough: in a <code>.pth</code> file, &ldquo;lines starting with <code>import</code> (followed by space or tab) are executed with <code>exec()</code>.&rdquo; The <code>site</code> module processes these files at every interpreter start, so the payload ran on any <code>python</code> invocation in that environment, including test runs, linters and unrelated scripts. Python 3.15 deprecates <code>import</code> lines in <code>.pth</code> files, but they still execute during the deprecation period.</p>
<p>Per Wiz&rsquo;s analysis:</p>
<ul>
<li><strong>1.26.1</strong> loaded <code>agent_framework_meta</code>, which called <code>_telemetry._start()</code>. It detached into a separate session or daemon thread and set <code>_AF_TEL=1</code> so it would not run twice.</li>
<li><strong>1.26.2</strong> loaded a new <code>af_runtime_diag.py</code> and restored the package&rsquo;s <code>__init__.py</code> to the clean 1.26.0 version. Hunting only for 1.26.1&rsquo;s file names misses it.</li>
</ul>
<p>What it collected, as described by Wiz and Chainguard:</p>
<ul>
<li>Environment variables whose names contain words such as TOKEN, SECRET, KEY, AZURE, AWS, GITHUB and NPM, plus secrets read from other processes&rsquo; <code>/proc/&lt;pid&gt;/environ</code>.</li>
<li>Credential files including Azure CLI configuration, <code>.npmrc</code>, <code>pip.conf</code>, <code>.netrc</code>, <code>.git-credentials</code>, Docker <code>config.json</code> and Hugging Face tokens.</li>
<li>Azure DevOps OIDC tokens and Azure managed-identity tokens. Wiz counts 12 Azure resources; Chainguard says nine resource types.</li>
<li>In 1.26.2, GitHub Actions OIDC tokens for <code>api://AzureADTokenExchange</code> and <code>https://management.azure.com/</code>.</li>
</ul>
<p>The data went out in one HTTPS POST to a webhook.site URL. Wiz notes that stolen Azure tokens may stay valid for up to 24 hours.</p>
<h2 id="indicators-of-compromise">Indicators of compromise</h2>
<p>From Wiz&rsquo;s write-up:</p>
<table>
  <thead>
      <tr>
          <th>Type</th>
          <th>Value</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>Files</td>
          <td><code>agent_framework_meta.pth</code>, <code>agent_framework_meta/_telemetry.py</code>, <code>af_runtime_diag.pth</code>, <code>af_runtime_diag.py</code></td>
      </tr>
      <tr>
          <td>Environment</td>
          <td><code>_AF_TEL=1</code></td>
      </tr>
      <tr>
          <td>Network</td>
          <td><code>webhook[.]site/d381fd80-ec62-42ad-8f5c-d1b15103c9bb</code>; User-Agents <code>af-runtime-diagnostics/1</code> (1.26.1) and <code>runtime-diagnostics/1</code> (1.26.2)</td>
      </tr>
      <tr>
          <td>1.26.1 wheel SHA-256</td>
          <td><code>d27fa34414e6201d5e03e559ef634f020057554d7b3f4898dd5d7cd3e989e110</code></td>
      </tr>
      <tr>
          <td>1.26.2 wheel SHA-256</td>
          <td><code>3d20a8bc91351a9a16b6db243b848ceca0206b7a8623b02d2af553a9c9f7e0a9</code></td>
      </tr>
      <tr>
          <td><code>af_runtime_diag.pth</code> SHA-256</td>
          <td><code>325e7e9f0ec94e41ad1a1b7a3f18a6b8b5bffece2e2b97b8d3369eb967452f93</code></td>
      </tr>
      <tr>
          <td><code>af_runtime_diag.py</code> SHA-256</td>
          <td><code>54d885b7d7161c9ed96489c66364c4bfbf635929166843bba10d97d46b5a2e1f</code></td>
      </tr>
  </tbody>
</table>
<p>Chainguard advises blocking the full webhook.site path rather than the whole domain if your teams use webhook.site for legitimate testing.</p>
<h2 id="what-to-check-in-your-environment">What to check in your environment</h2>
<p><strong>1. Find installs without starting Python.</strong> Running <code>pip</code> or any Python tool in an affected environment starts the interpreter and can run the payload. Search the filesystem with shell tools instead. These commands use GNU <code>find</code> and <code>grep</code>; we tested them against a mock directory tree containing the IOC file names, not against the real malware.</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-bash" data-lang="bash"><span style="display:flex;"><span><span style="color:#75715e"># Files the two malicious wheels drop (search every filesystem you care about)</span>
</span></span><span style="display:flex;"><span>find / -xdev <span style="color:#ae81ff">\(</span> -name <span style="color:#e6db74">&#39;agent_framework_meta.pth&#39;</span> -o -name <span style="color:#e6db74">&#39;af_runtime_diag.pth&#39;</span> <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span><span style="color:#ae81ff"></span>  -o -name <span style="color:#e6db74">&#39;af_runtime_diag.py&#39;</span> -o -type d -name <span style="color:#e6db74">&#39;agent_framework_meta&#39;</span> <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span><span style="color:#ae81ff"></span>  -o -type d -name <span style="color:#e6db74">&#39;agent_framework-1.26.[12].dist-info&#39;</span> <span style="color:#ae81ff">\)</span> -print 2&gt;/dev/null
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e"># Pins and lockfile entries for the bad versions in a source tree</span>
</span></span><span style="display:flex;"><span>grep -rnE <span style="color:#e6db74">&#39;agent[-_]framework[ =&lt;&gt;~!&#34;]*1\.26\.[12]\b&#39;</span> <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span><span style="color:#ae81ff"></span>  --include<span style="color:#f92672">=</span><span style="color:#e6db74">&#39;*.txt&#39;</span> --include<span style="color:#f92672">=</span><span style="color:#e6db74">&#39;*.lock&#39;</span> --include<span style="color:#f92672">=</span><span style="color:#e6db74">&#39;*.toml&#39;</span> --include<span style="color:#f92672">=</span><span style="color:#e6db74">&#39;*.cfg&#39;</span> .
</span></span><span style="display:flex;"><span>grep -rn -A1 <span style="color:#e6db74">&#39;name = &#34;agent-framework&#34;&#39;</span> --include<span style="color:#f92672">=</span><span style="color:#e6db74">&#39;*.lock&#39;</span> . | grep -E <span style="color:#e6db74">&#39;version = &#34;1\.26\.[12]&#34;&#39;</span>
</span></span></code></pre></div><p>Also check places a filesystem search will not cover: CI job logs from November 17-18 (look for <code>agent-framework-1.26.1</code> or <code>1.26.2</code> in resolver output), container image layers built in that window, and internal package mirrors that may have cached the wheels.</p>
<p><strong>2. Check egress.</strong> Search proxy and DNS logs for the webhook.site path above. Wiz reads an HTTP 200 as data accepted and 410 or 429 as rejected, but treat any attempt as a reason to rotate.</p>
<p><strong>3. Clean, then rotate.</strong> Remove the <code>.pth</code> and module files, then rebuild the environment from a pinned, known-good set (<code>agent-framework==1.26.0</code>). Rotate everything the environment could read: Azure CLI sessions, Azure DevOps PATs and service connections, npm, PyPI, NuGet, Docker and Hugging Face tokens, git credentials and cloud keys. Our guide to <a href="/posts/how-to-detect-and-rotate-leaked-api-keys-before-attackers-use-them/">detecting and rotating leaked API keys</a> covers the order of operations.</p>
<p><strong>4. Review federated identities.</strong> For GitHub Actions workflows that installed 1.26.2 with <code>id-token: write</code>, Wiz says to treat the OIDC tokens as exposed and review the Azure federated credentials that trust those workflows. Check Azure sign-in and activity logs for managed identities reachable from affected hosts.</p>
<h2 id="what-engineers-can-take-from-it">What engineers can take from it</h2>
<ul>
<li><strong>Pin and hash-lock dependencies</strong> in CI and image builds (<code>pip install --require-hashes</code>, or a lockfile with hashes). A floating <code>agent-framework</code> requirement pulled whatever was newest during the window.</li>
<li><strong>A delay on brand-new versions helps.</strong> Both releases were gone within about an hour. A mirror or resolver rule that waits before accepting fresh uploads would have skipped them. Chainguard&rsquo;s 42 to 48 second blocks show what a curated mirror can do.</li>
<li><strong>Keep OIDC scopes narrow.</strong> Grant <code>id-token: write</code> only to jobs that deploy, and bind cloud federated credentials to specific repositories, branches or environments. Our overview of <a href="/posts/software-supply-chain-attacks-where-modern-build-pipelines-break/">where build pipelines break</a> covers the wider pattern.</li>
<li><strong>Trusted publishers are not proof of safety.</strong> If Wiz&rsquo;s reading of the ESRP credentials is right, the releases came through Microsoft&rsquo;s own publishing path. Provenance tells you where a package was built; it does not tell you the build was intended. See <a href="/posts/slsa-build-levels-and-provenance-attestations-what-they-prove-and-what-they-dont/">what SLSA provenance does and does not prove</a>.</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>Affected versions, timeline, ESRP credential reading, payload behaviour, IOCs, three exfiltrations</td>
          <td><a href="https://www.wiz.io/blog/malicious-version-of-microsofts-agent-framework-published-to-pypi">Wiz</a></td>
          <td>Qualified (researcher analysis)</td>
      </tr>
      <tr>
          <td>Second-level timeline, .pth mechanism, &ldquo;remove the payload before starting Python again&rdquo;</td>
          <td><a href="https://www.chainguard.dev/unchained/microsoft-agent-framework-compromised-on-pypi-november-2026">Chainguard</a></td>
          <td>Qualified (researcher analysis)</td>
      </tr>
      <tr>
          <td>Maintainer confirmation, ~190,000 monthly downloads, publishing method unknown, SafeDep account finding</td>
          <td><a href="https://www.securityweek.com/microsoft-agent-framework-releases-poisoned-with-credential-stealer/">SecurityWeek</a></td>
          <td>Qualified (press report)</td>
      </tr>
      <tr>
          <td>1.26.0 is the latest listed release; 1.26.1 and 1.26.2 absent</td>
          <td>PyPI JSON API for agent-framework, checked Nov 19, 2026</td>
          <td>Verified</td>
      </tr>
      <tr>
          <td><code>.pth</code> import lines are executed at startup</td>
          <td><a href="https://docs.python.org/3/library/site.html">Python <code>site</code> documentation</a></td>
          <td>Verified (verbatim)</td>
      </tr>
  </tbody>
</table>
]]></content:encoded></item><item><title>Maersk Cyberattack: Data Stolen From Acquired Legacy System</title><link>https://firewallsync.com/posts/maersk-cyberattack-legacy-system-data-theft-what-we-know/</link><guid>https://firewallsync.com/posts/maersk-cyberattack-legacy-system-data-theft-what-we-know/</guid><pubDate>Thu, 12 Nov 2026 04:45:00 +0000</pubDate><dc:creator>John Marshall</dc:creator><category>Security Operations</category><description>Maersk says attackers accessed and extracted data from a local legacy system inherited through an acquisition, that operations are unaffected and that its findings so far suggest no sensitive data was disclosed. A group calling itself WhiteArmor claims far more.</description><enclosure url="https://firewallsync.com/posts/maersk-cyberattack-legacy-system-data-theft-what-we-know/cover_hu2082571544012895419.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/maersk-cyberattack-legacy-system-data-theft-what-we-know/cover_hu2082571544012895419.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/maersk-cyberattack-legacy-system-data-theft-what-we-know/cover_hu2082571544012895419.jpg" alt="Interior of a large warehouse: tall walls of grey storage bins on the left, orange racking stacked with cardboard boxes on the right and pallets in the aisle between" width="1200" height="630"></p><p>Maersk, the Danish shipping and logistics group, said on Wednesday, November 11, 2026 that it is investigating an IT security incident involving unauthorized access to, and data extraction from, one of its local legacy systems. The company says the system came from a previous acquisition, the incident is isolated to it, and its &ldquo;findings so far strongly suggest no sensitive data has been disclosed.&rdquo; It does not expect any effect on operations.</p>
<p>A group calling itself WhiteArmor claims much more, including plaintext driver passwords and a $5 million ransom demand. Maersk has not confirmed those claims. Below is what each side has said, and what engineering teams can check in their own estates.</p>
<h2 id="what-maersk-has-said">What Maersk has said</h2>
<p>Maersk&rsquo;s statement was reported by <a href="https://1027wbow.com/2026/11/11/shipping-firm-maersk-investigates-it-security-incident/">Reuters</a> and <a href="https://www.theregister.com/security/2026/11/11/shipping-giant-maersk-probes-it-security-incident-data-theft/5309096">The Register</a>, which says it was published on Maersk&rsquo;s news page. We could not retrieve the notice itself; the quotes below are as those outlets reported them. According to the statement:</p>
<ul>
<li>The incident involves unauthorized access and data extraction from one local legacy system, described as a system &ldquo;from a previous acquisition.&rdquo;</li>
<li>Maersk started an investigation and secured the affected system.</li>
<li>&ldquo;Our findings so far strongly suggest no sensitive data has been disclosed.&rdquo;</li>
<li>The incident &ldquo;is isolated to a local system,&rdquo; with no indication of impact on other Maersk systems or on customer and partner systems connected through integrations such as APIs and EDI.</li>
<li>Maersk does not expect operations to be affected; customers can keep booking and managing shipments as usual.</li>
<li>It asks people to treat unexpected communications claiming to relate to the incident with caution and to verify them through their usual Maersk contact.</li>
</ul>
<p>Maersk has not said when the intrusion happened, how it was detected, how the attackers got in, which system was affected or what data was taken.</p>
<h2 id="confirmed-vs-claimed">Confirmed vs claimed</h2>
<table>
  <thead>
      <tr>
          <th>Item</th>
          <th>Status</th>
          <th>Source</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>Unauthorized access and data extraction from one local legacy system</td>
          <td>Confirmed by Maersk</td>
          <td>Reuters, The Register</td>
      </tr>
      <tr>
          <td>System came from a previous acquisition</td>
          <td>Confirmed by Maersk</td>
          <td>The Register</td>
      </tr>
      <tr>
          <td>No indication of impact on other Maersk, customer or partner systems</td>
          <td>Maersk&rsquo;s statement</td>
          <td>Reuters, The Register</td>
      </tr>
      <tr>
          <td>No expected effect on operations</td>
          <td>Maersk&rsquo;s statement</td>
          <td>Reuters, The Register</td>
      </tr>
      <tr>
          <td>&ldquo;No sensitive data has been disclosed&rdquo;</td>
          <td>Maersk&rsquo;s preliminary finding (&ldquo;so far&rdquo;)</td>
          <td>The Register</td>
      </tr>
      <tr>
          <td>Affected system is the LF Logistics platform</td>
          <td><strong>Not confirmed</strong>; Maersk has not named the system</td>
          <td>Security Affairs, Cybernews</td>
      </tr>
      <tr>
          <td>About 100 GB stolen, incl. driver records and plaintext passwords</td>
          <td><strong>Claimed by WhiteArmor</strong></td>
          <td>Security Affairs</td>
      </tr>
      <tr>
          <td>$5 million ransom in bitcoin, 30-day deadline</td>
          <td><strong>Claimed by WhiteArmor</strong></td>
          <td>Security Affairs</td>
      </tr>
      <tr>
          <td>WhiteArmor is responsible</td>
          <td><strong>Not confirmed</strong> by Maersk</td>
          <td>Security Affairs, Cybernews</td>
      </tr>
  </tbody>
</table>
<h2 id="what-is-not-confirmed">What is not confirmed</h2>
<p>The claims come from the group&rsquo;s leak-site listing as described by <a href="https://securityaffairs.com/202869/data-breach/whitearmor-demands-5-million-from-maersk-claims-theft-of-100gb-of-data.html">Security Affairs</a> and <a href="https://cybernews.com/security/maersk-confirms-cyberattack-ransomware/">Cybernews</a>. We have not viewed the leak site and do not link to it.</p>
<ul>
<li><strong>Data volume and types.</strong> Security Affairs reports that the group claims about 100 GB from the &ldquo;OCF/LF Logistics platform&rdquo;, including &ldquo;nearly 30,000 driver records, plaintext passwords, 33 super admin accounts&rdquo;, signed delivery receipts, inventory records, purchase orders, advance shipping notices and 27,842 mobile device logs. Cybernews reports a claim of more than 16,000 plaintext driver passwords. The two reports give different figures, and neither is verified.</li>
<li><strong>The LF Logistics link.</strong> Both outlets note that Maersk bought LF Logistics in 2022 and that this could fit the &ldquo;previous acquisition&rdquo; wording. Security Affairs states that &ldquo;the company has not confirmed this connection.&rdquo;</li>
<li><strong>The ransom.</strong> Security Affairs reports a $5 million demand in bitcoin with 30 days to pay. This is the group&rsquo;s claim.</li>
<li><strong>The name.</strong> Security Affairs spells the group &ldquo;WhiteArmor&rdquo;; Cybernews uses &ldquo;WhiteArmour&rdquo;.</li>
</ul>
<p>If Maersk&rsquo;s investigation changes any of this, we will add a dated update at the top of this article.</p>
<h2 id="why-the-legacy-system-from-an-acquisition-detail-matters">Why the &ldquo;legacy system from an acquisition&rdquo; detail matters</h2>
<p>Maersk&rsquo;s own description is the useful part for engineers. Acquired platforms tend to arrive with their own identity store, admin accounts, password storage, logging and partner integrations, and they keep running until a migration finishes. Maersk says the affected system was isolated and that it sees no impact on systems connected through APIs and EDI; the open question for any company in the same position is whether that isolation was designed or simply the result of the system never being fully integrated.</p>
<p>For context: Maersk is no stranger to large incidents. In 2017 the NotPetya wiper took down its IT; The Register recalls that Maersk said at the time it expected a bill of around $300 million. Nothing reported links the two events, and the 2026 incident, as Maersk describes it, is far narrower.</p>
<h2 id="what-to-check-in-your-own-environment">What to check in your own environment</h2>
<p>These follow from the confirmed facts (an acquired legacy system, data extraction, partner integrations, phishing risk) and are not a reconstruction of the Maersk attack, whose method has not been disclosed.</p>
<ol>
<li><strong>Inventory acquired systems as their own estate.</strong> List every platform that came with an acquisition, who owns it today, whether it has its own internet exposure, and its retirement date. Systems without a named owner rarely get patched.</li>
<li><strong>Check how they store passwords.</strong> If an inherited application stores driver, supplier or customer passwords reversibly or in plaintext, that is the first thing to fix. Our <a href="/posts/password-hashing-argon2id-vs-bcrypt-vs-scrypt-which-to-use-and-with-what-parameters/">Argon2id vs bcrypt vs scrypt guide</a> covers what to migrate to and how to rehash on next login.</li>
<li><strong>Review super-admin accounts.</strong> Count administrative accounts on inherited platforms, remove unused ones and put the rest behind your central identity provider with MFA.</li>
<li><strong>Map and scope the integrations.</strong> For each API and EDI connection between the legacy system and the rest of the business, record the credentials it uses, what they can reach and when they were last rotated. Rotate them after any suspected compromise, even if the vendor says there is no indication of impact.</li>
<li><strong>Prepare for follow-on phishing.</strong> Maersk&rsquo;s warning about unexpected communications applies to anyone whose contact details may be in stolen logistics data. Our <a href="/posts/vetting-third-party-saas-tools-before-they-touch-your-data/">third-party SaaS vetting guide</a> covers questions to ask suppliers about how they hold your data.</li>
</ol>
<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>Maersk statement: unauthorized access and data extraction, local legacy system, no expected operational impact</td>
          <td><a href="https://1027wbow.com/2026/11/11/shipping-firm-maersk-investigates-it-security-incident/">Reuters via 102.7 WBOW</a></td>
          <td>Verified (two outlets)</td>
      </tr>
      <tr>
          <td>Statement quotes; system &ldquo;from a previous acquisition&rdquo;; API/EDI wording; phishing caution; NotPetya $300M context</td>
          <td><a href="https://www.theregister.com/security/2026/11/11/shipping-giant-maersk-probes-it-security-incident-data-theft/5309096">The Register</a></td>
          <td>Verified (Maersk notice not retrieved directly)</td>
      </tr>
      <tr>
          <td>WhiteArmor claims: ~100 GB, data types, $5M, 30 days; Maersk has not confirmed LF Logistics link</td>
          <td><a href="https://securityaffairs.com/202869/data-breach/whitearmor-demands-5-million-from-maersk-claims-theft-of-100gb-of-data.html">Security Affairs</a></td>
          <td>Qualified (claims, unverified)</td>
      </tr>
      <tr>
          <td>Claim of 16,000+ plaintext driver passwords; LF Logistics acquired 2022</td>
          <td><a href="https://cybernews.com/security/maersk-confirms-cyberattack-ransomware/">Cybernews</a></td>
          <td>Qualified (claims, unverified)</td>
      </tr>
  </tbody>
</table>
]]></content:encoded></item><item><title>OpenVEX Products and Subcomponents: purl Matching Rules</title><link>https://firewallsync.com/posts/openvex-products-subcomponents-purl-matching-trivy/</link><guid>https://firewallsync.com/posts/openvex-products-subcomponents-purl-matching-trivy/</guid><pubDate>Fri, 06 Nov 2026 04:40:00 +0000</pubDate><dc:creator>Craig Leslie</dc:creator><category>AppSec &amp; APIs</category><description>An OpenVEX statement suppresses a finding only when its products, subcomponents and purls line up with what the scanner found. Here is how the go-vex library behind Trivy v0.76.2 matches them: versionless purls, qualifier subsets, subcomponent scoping, timestamp inheritance and which status wins, with a schema-valid example document and a tested Python port of the rules.</description><enclosure url="https://firewallsync.com/posts/openvex-products-subcomponents-purl-matching-trivy/cover_hu10637076205791324779.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/openvex-products-subcomponents-purl-matching-trivy/cover_hu10637076205791324779.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/openvex-products-subcomponents-purl-matching-trivy/cover_hu10637076205791324779.jpg" alt="Three weathered wooden crates side by side on a white counter in front of a white brick wall" width="1200" height="630"></p><p>An OpenVEX statement only changes a scanner&rsquo;s output if its <strong>product</strong>, its <strong>subcomponents</strong> and the <strong>purls</strong> inside them match what the scanner found. In the go-vex library that Trivy v0.76.2 uses, the rules are short: the VEX purl is a pattern (no version means every version, and every qualifier it lists must be present), subcomponents narrow a statement to specific packages, and among matching statements the one with the newest timestamp wins. Most &ldquo;VEX didn&rsquo;t work&rdquo; tickets come down to one of those three.</p>
<p>This article is about the identifiers and the matching. For what the statuses and justifications mean, see <a href="/posts/vex-explained-what-a-not-affected-statement-means-and-how-to-read-one/">VEX explained</a>. For converting CycloneDX VEX to OpenVEX, see the <a href="/posts/cyclonedx-vex-analysis-state-justification-openvex-csaf-mapping/">CycloneDX VEX mapping</a>. For CSAF&rsquo;s product tree, see <a href="/posts/csaf-vex-product-tree-product-status-purl-sbom-matching/">CSAF VEX product_tree</a>.</p>
<h2 id="products-and-subcomponents-in-the-spec">Products and subcomponents in the spec</h2>
<p>The <a href="https://github.com/openvex/spec/blob/main/OPENVEX-SPEC.md">OpenVEX specification v0.2.0</a> defines a product as &ldquo;a logical unit representing a piece of software&rdquo;, broad enough that &ldquo;anything that can be described in a Software Bill of Materials (SBOM) can be thought of as a product.&rdquo; A subcomponent is &ldquo;any components possibly included in the product where the vulnerability originates.&rdquo; The spec adds that subcomponents &ldquo;SHOULD also list software identifiers and they SHOULD also be listed in the product SBOM.&rdquo;</p>
<p>Products and subcomponents share one structure, which the spec calls <code>Component</code>:</p>
<table>
  <thead>
      <tr>
          <th>Field</th>
          <th>Required</th>
          <th>What it holds</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>@id</code></td>
          <td>No</td>
          <td>An IRI for the component. A purl is a valid IRI, so <code>@id</code> can be a purl.</td>
      </tr>
      <tr>
          <td><code>identifiers</code></td>
          <td>No</td>
          <td>A map of identifier type to value. The spec lists <code>purl</code>, <code>cpe22</code> and <code>cpe23</code>, and recommends purls.</td>
      </tr>
      <tr>
          <td><code>hashes</code></td>
          <td>No</td>
          <td>A map of hash algorithm to digest, using IANA hash names.</td>
      </tr>
      <tr>
          <td><code>subcomponents</code></td>
          <td>No (products only)</td>
          <td>A list of components the statement is scoped to.</td>
      </tr>
  </tbody>
</table>
<p>All three identifying fields are optional, but the spec says a valid statement &ldquo;MUST identify a product.&rdquo; It also says the product should list &ldquo;as many software identifiers as possible to help VEX processors when matching the product.&rdquo;</p>
<p><code>products</code> itself is optional in a statement because it can be inherited from an encapsulating document, such as the subject of an in-toto attestation. Timestamps can be inherited too. The spec&rsquo;s inheritance rules are: a statement timestamp overrides the document timestamp, which overrides the encapsulating document&rsquo;s; a product ID in a statement overrides product data in the encapsulating document.</p>
<h2 id="how-go-vex-matches-a-statement">How go-vex matches a statement</h2>
<p>Trivy loads OpenVEX documents with <a href="https://github.com/openvex/go-vex">openvex/go-vex</a>, pinned to v0.2.9 in Trivy v0.76.2&rsquo;s <code>go.mod</code>. Its matching code is small enough to read in full. For a finding (CVE, product, optional subcomponent), a statement matches when all of these hold:</p>
<ol>
<li><strong>Vulnerability.</strong> The CVE ID equals the statement&rsquo;s <code>vulnerability.name</code>, its <code>@id</code>, or one of its <code>aliases</code>.</li>
<li><strong>Product.</strong> One entry in <code>products</code> matches the product identifier. A component matches if its <code>@id</code> equals the identifier exactly, or its <code>@id</code> is a purl that matches by the purl rules below, or any value in <code>identifiers</code> equals it (with purl matching for the <code>purl</code> key), or any value in <code>hashes</code> equals it.</li>
<li><strong>Subcomponent.</strong> If that product entry has no <code>subcomponents</code>, or the caller passed no subcomponent, the product match is enough. Otherwise one listed subcomponent must match the subcomponent identifier by the same component rules.</li>
</ol>
<h3 id="the-purl-rules">The purl rules</h3>
<p>go-vex&rsquo;s <code>PurlMatches(purl1, purl2)</code> treats the VEX purl as the general one and the scanned purl as the specific one:</p>
<table>
  <thead>
      <tr>
          <th>VEX purl</th>
          <th>Scanned purl</th>
          <th>Match?</th>
          <th>Rule</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>pkg:apk/alpine/git</code></td>
          <td><code>pkg:apk/alpine/git@2.43.0-r0?arch=x86_64</code></td>
          <td>Yes</td>
          <td>No version in the VEX purl matches any version</td>
      </tr>
      <tr>
          <td><code>pkg:apk/alpine/git@2.43.0-r0</code></td>
          <td><code>pkg:apk/alpine/git@2.43.0-r1</code></td>
          <td>No</td>
          <td>Versions must be equal when both are set</td>
      </tr>
      <tr>
          <td><code>pkg:apk/alpine/git@2.43.0-r0</code></td>
          <td><code>pkg:apk/alpine/git</code></td>
          <td>No</td>
          <td>A versioned VEX purl never matches a versionless scan result</td>
      </tr>
      <tr>
          <td><code>pkg:oci/app?repository_url=ghcr.io%2Facme%2Fapp</code></td>
          <td><code>pkg:oci/app?repository_url=ghcr.io%2Facme%2Fapp&amp;tag=v2</code></td>
          <td>Yes</td>
          <td>Extra qualifiers on the scanned side are ignored</td>
      </tr>
      <tr>
          <td><code>pkg:oci/app?repository_url=ghcr.io%2Facme%2Fapp</code></td>
          <td><code>pkg:oci/app</code></td>
          <td>No</td>
          <td>Every VEX qualifier must be present with the same value</td>
      </tr>
      <tr>
          <td><code>pkg:apk/alpine/git</code></td>
          <td><code>pkg:apk/alpine/git-daemon@2.43.0-r0</code></td>
          <td>No</td>
          <td>Type, namespace and name must be equal</td>
      </tr>
  </tbody>
</table>
<p>The function&rsquo;s own comment says &ldquo;Purl version ranges are not supported yet.&rdquo; A statement covering versions 1.0 to 1.4 needs either one purl per version or no version at all. Leaving the version off is the broadest possible statement, so use it only when you mean every version. Trivy&rsquo;s documentation notes that these matching rules come from a community discussion, not from the purl specification.</p>
<h3 id="which-statement-wins">Which statement wins</h3>
<p>go-vex collects every matching statement and sorts them by timestamp, using the document <code>timestamp</code> for any statement without its own. Trivy takes the last one. It removes the finding only if that statement&rsquo;s status is <code>not_affected</code> or <code>fixed</code>; <code>affected</code> and <code>under_investigation</code> leave the finding in the report.</p>
<p>This is why the spec&rsquo;s update example keeps the original document timestamp on the first statement when a second one is added. If you edit a document, bump <code>timestamp</code> and <code>version</code> at the document level, and the old statements lose their original time, the ordering of statements for the same CVE can change.</p>
<h2 id="a-tested-example">A tested example</h2>
<p>The document below has two statements for CVE-2024-32002 on a container image (the first <code>under_investigation</code> with its own timestamp, the second <code>not_affected</code> inheriting the newer document timestamp) and one statement for a Go service. It validates against the OpenVEX JSON schema (<code>openvex_json_schema.json</code> from the spec repository, checked with Python <code>jsonschema</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-json" data-lang="json"><span style="display:flex;"><span>{
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&#34;@context&#34;</span>: <span style="color:#e6db74">&#34;https://openvex.dev/ns/v0.2.0&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&#34;@id&#34;</span>: <span style="color:#e6db74">&#34;https://example.com/vex/app-2026-11-06&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&#34;author&#34;</span>: <span style="color:#e6db74">&#34;Example Security Team &lt;security@example.com&gt;&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&#34;timestamp&#34;</span>: <span style="color:#e6db74">&#34;2026-11-06T09:00:00Z&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&#34;version&#34;</span>: <span style="color:#ae81ff">2</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&#34;statements&#34;</span>: [
</span></span><span style="display:flex;"><span>    {
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">&#34;vulnerability&#34;</span>: {<span style="color:#f92672">&#34;name&#34;</span>: <span style="color:#e6db74">&#34;CVE-2024-32002&#34;</span>},
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">&#34;timestamp&#34;</span>: <span style="color:#e6db74">&#34;2026-11-01T10:00:00Z&#34;</span>,
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">&#34;products&#34;</span>: [
</span></span><span style="display:flex;"><span>        {
</span></span><span style="display:flex;"><span>          <span style="color:#f92672">&#34;@id&#34;</span>: <span style="color:#e6db74">&#34;pkg:oci/app?repository_url=ghcr.io%2Facme%2Fapp&#34;</span>,
</span></span><span style="display:flex;"><span>          <span style="color:#f92672">&#34;subcomponents&#34;</span>: [{<span style="color:#f92672">&#34;@id&#34;</span>: <span style="color:#e6db74">&#34;pkg:apk/alpine/git&#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:#f92672">&#34;status&#34;</span>: <span style="color:#e6db74">&#34;under_investigation&#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:#f92672">&#34;vulnerability&#34;</span>: {<span style="color:#f92672">&#34;name&#34;</span>: <span style="color:#e6db74">&#34;CVE-2024-32002&#34;</span>},
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">&#34;products&#34;</span>: [
</span></span><span style="display:flex;"><span>        {
</span></span><span style="display:flex;"><span>          <span style="color:#f92672">&#34;@id&#34;</span>: <span style="color:#e6db74">&#34;pkg:oci/app?repository_url=ghcr.io%2Facme%2Fapp&#34;</span>,
</span></span><span style="display:flex;"><span>          <span style="color:#f92672">&#34;subcomponents&#34;</span>: [{<span style="color:#f92672">&#34;@id&#34;</span>: <span style="color:#e6db74">&#34;pkg:apk/alpine/git&#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:#f92672">&#34;status&#34;</span>: <span style="color:#e6db74">&#34;not_affected&#34;</span>,
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">&#34;justification&#34;</span>: <span style="color:#e6db74">&#34;vulnerable_code_not_in_execute_path&#34;</span>,
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">&#34;status_notes&#34;</span>: <span style="color:#e6db74">&#34;git is installed for build-time use only; the runtime entrypoint never invokes git clone.&#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:#f92672">&#34;vulnerability&#34;</span>: {<span style="color:#f92672">&#34;name&#34;</span>: <span style="color:#e6db74">&#34;CVE-2023-0001&#34;</span>},
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">&#34;products&#34;</span>: [
</span></span><span style="display:flex;"><span>        {
</span></span><span style="display:flex;"><span>          <span style="color:#f92672">&#34;@id&#34;</span>: <span style="color:#e6db74">&#34;pkg:golang/example.com/svc@v1.4.0&#34;</span>,
</span></span><span style="display:flex;"><span>          <span style="color:#f92672">&#34;subcomponents&#34;</span>: [{<span style="color:#f92672">&#34;@id&#34;</span>: <span style="color:#e6db74">&#34;pkg:golang/golang.org/x/net@v0.17.0&#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:#f92672">&#34;status&#34;</span>: <span style="color:#e6db74">&#34;not_affected&#34;</span>,
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">&#34;justification&#34;</span>: <span style="color:#e6db74">&#34;vulnerable_code_not_present&#34;</span>
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>  ]
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>The image, service names and CVE-2023-0001 statement are illustrative. To check the matching without a registry or a real image, we wrote a Python port of go-vex v0.2.9&rsquo;s <code>PurlMatches</code>, <code>Component.Matches</code>, <code>Product.Matches</code>, <code>Statement.Matches</code> and timestamp sort, using the <code>packageurl-python</code> parser, and ran it with Python 3 against the document. It is a port, not the Go library itself, so treat it as a reading aid. Output, with long purls shortened:</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>product                                    subcomponent                          result
</span></span><span style="display:flex;"><span>pkg:oci/app?repository_url=…%2Fapp         pkg:apk/alpine/git@2.43.0-r0?arch=…   2 matches, effective=not_affected
</span></span><span style="display:flex;"><span>pkg:oci/app?repository_url=…%2Fapp         pkg:apk/alpine/git-daemon@2.43.0-r0   no match
</span></span><span style="display:flex;"><span>pkg:oci/app?repository_url=…%2Fapp         (none)                                2 matches, effective=not_affected
</span></span><span style="display:flex;"><span>pkg:oci/app                                pkg:apk/alpine/git@2.43.0-r0          no match
</span></span><span style="display:flex;"><span>pkg:oci/app?repository_url=…%2Fapp&amp;tag=v2  pkg:apk/alpine/git@2.43.0-r0          2 matches, effective=not_affected
</span></span><span style="display:flex;"><span>pkg:golang/example.com/svc@v1.4.0          pkg:golang/golang.org/x/net@v0.17.0   1 match,  effective=not_affected
</span></span><span style="display:flex;"><span>pkg:golang/example.com/svc@v1.5.0          pkg:golang/golang.org/x/net@v0.17.0   no match
</span></span><span style="display:flex;"><span>pkg:golang/example.com/svc@v1.4.0          pkg:golang/golang.org/x/net@v0.18.0   no match
</span></span></code></pre></div><p>What the rows show:</p>
<ul>
<li><strong>Row 1:</strong> the versionless <code>pkg:apk/alpine/git</code> subcomponent covers the installed <code>git@2.43.0-r0</code>. Both statements match, and the <code>not_affected</code> one wins because it inherits the later document timestamp.</li>
<li><strong>Row 2:</strong> <code>git-daemon</code> is a different package name, so the statement does not cover it, even though it ships from the same source.</li>
<li><strong>Row 3:</strong> with no subcomponent passed, the product match alone is enough. Trivy does not hit this case for an image root (see below), but other consumers of go-vex may.</li>
<li><strong>Rows 4 and 5:</strong> the <code>repository_url</code> qualifier on the VEX side must be present on the scanned side. A scan purl without it fails; one with an extra <code>tag</code> qualifier passes.</li>
<li><strong>Rows 6 to 8:</strong> pinned versions on both product and subcomponent mean a new service release (v1.5.0) or a dependency bump (x/net v0.18.0) silently drops the statement. That is often what you want, since the reachability analysis was for that build, but it means the document needs updating each release.</li>
</ul>
<h2 id="how-trivy-applies-it-to-a-dependency-tree">How Trivy applies it to a dependency tree</h2>
<p>Trivy&rsquo;s VEX guide and its <code>filterVulnerabilities</code> code show how it feeds this matcher. For each finding it first asks whether the vulnerable package itself is a not-affected product (no subcomponent). If not, it walks up the dependency graph from the vulnerable package and asks, for each parent, whether &ldquo;parent as product, vulnerable package as subcomponent&rdquo; is not affected. The finding is removed only if no path reaches the root without passing a not-affected node.</p>
<p>Two consequences:</p>
<ul>
<li><strong>A statement on an intermediate dependency can suppress a finding, but only if every path goes through it.</strong> Trivy&rsquo;s documentation gives the example of Module C reached through both B and D: a VEX statement for B does not suppress the finding, because D might still be affected.</li>
<li><strong>A statement on the image with no subcomponents suppresses the CVE in every package in that image.</strong> Trivy&rsquo;s docs call this out and recommend subcomponents for &ldquo;reducing the risk of incorrect filtering.&rdquo;</li>
</ul>
<p>Trivy needs a purl on the scanned side. Its OpenVEX matcher returns nothing when the product has no purl, so cpe-only or hash-only VEX products are not matched by Trivy even though the spec allows them. Use the purls Trivy prints in its JSON report.</p>
<h2 id="writing-statements-that-match">Writing statements that match</h2>
<p>These are our recommendations, based on the rules above:</p>
<ol>
<li><strong>Copy purls from the scanner or SBOM output.</strong> Do not type them by hand; the type, namespace and name must match exactly. Our guide to <a href="/posts/cve-packageurl-purl-cve-json-5-2-affected-sbom-matching/">CVE packageURL and SBOM purls</a> covers common purl pitfalls.</li>
<li><strong>Always add subcomponents for image-level or application-level products.</strong> A product with no subcomponents is a blanket statement.</li>
<li><strong>Add a version only when the claim depends on the build.</strong> Reachability claims (<code>vulnerable_code_not_in_execute_path</code>) usually do. &ldquo;This package never ships the vulnerable file&rdquo; claims may not.</li>
<li><strong>Be sparing with qualifiers in the VEX purl.</strong> Each one is a requirement. <code>arch</code> is useful if only one architecture is unaffected; otherwise leave it out.</li>
<li><strong>Keep timestamps on old statements when you append new ones,</strong> and bump the document <code>version</code>. Use <code>status_notes</code> to record how the status was determined. Trivy does not read it, but reviewers do.</li>
<li><strong>Track the result.</strong> Our <a href="/posts/vulnerability-prioritization-workflow-cve-record-to-patch-ticket/">prioritization workflow</a> shows where a VEX decision sits between the CVE record and the ticket.</li>
</ol>
<h2 id="limits-of-this-article">Limits of this article</h2>
<ul>
<li>Matching behaviour is from go-vex v0.2.9 and Trivy v0.76.2 source and docs. Grype, vexctl and commercial scanners have their own matchers and may differ.</li>
<li>Our test used a Python port of the go-vex rules, not the Go library or a Trivy scan. The port follows the source shown in the references; differences in purl parsing between <code>packageurl-python</code> and <code>packageurl-go</code> are possible for unusual purls.</li>
<li>We did not cover OpenVEX attestations attached to OCI images (<code>--vex oci</code>) or VEX repositories.</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>Product, subcomponent, Component fields, identifier types, inheritance and update rules</td>
          <td><a href="https://github.com/openvex/spec/blob/main/OPENVEX-SPEC.md">OpenVEX specification v0.2.0</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Example document is schema-valid</td>
          <td><a href="https://github.com/openvex/spec/blob/main/openvex_json_schema.json">openvex_json_schema.json</a>, checked with Python jsonschema</td>
          <td>Verified (tested)</td>
      </tr>
      <tr>
          <td>Trivy v0.76.2 uses go-vex v0.2.9; applies only not_affected and fixed; latest statement wins; requires a product purl</td>
          <td><a href="https://github.com/aquasecurity/trivy/blob/v0.76.2/pkg/vex/openvex.go">Trivy pkg/vex/openvex.go</a> and go.mod</td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Component, product, statement, vulnerability and purl matching rules; no version-range support; timestamp sort</td>
          <td><a href="https://github.com/openvex/go-vex/tree/v0.2.9/pkg/vex">go-vex v0.2.9 pkg/vex</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Dependency-tree traversal and the multiple-paths rule</td>
          <td><a href="https://github.com/aquasecurity/trivy/blob/v0.76.2/docs/guide/supply-chain/vex/file.md">Trivy local VEX files guide</a> and pkg/vex/vex.go</td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Match results in the example table</td>
          <td>Python port of go-vex v0.2.9 rules, run against the example document</td>
          <td>Qualified: port, not the Go library</td>
      </tr>
  </tbody>
</table>
]]></content:encoded></item><item><title>How to Secure GitHub Actions: Permissions, Secrets, and OIDC</title><link>https://firewallsync.com/posts/how-to-secure-github-actions-permissions-secrets-and-oidc/</link><guid>https://firewallsync.com/posts/how-to-secure-github-actions-permissions-secrets-and-oidc/</guid><pubDate>Sun, 01 Nov 2026 09:00:00 +0000</pubDate><dc:creator>FirewallSync Editorial</dc:creator><category>AppSec &amp; APIs</category><description>A GitHub Actions workflow often runs with more access than the task actually requires, simply because the defaults are permissive and nobody scoped them down before shipping.</description><enclosure url="https://firewallsync.com/posts/how-to-secure-github-actions-permissions-secrets-and-oidc/cover_hu14058028644612349825.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/how-to-secure-github-actions-permissions-secrets-and-oidc/cover_hu14058028644612349825.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/how-to-secure-github-actions-permissions-secrets-and-oidc/cover_hu14058028644612349825.jpg" alt="Laptop on a desk showing code" width="1200" height="630"></p><p>A GitHub Actions workflow, by default, often runs with more access than the task it performs actually requires — not because anyone deliberately over-provisioned it, but because the defaults are permissive and narrowing them down takes deliberate configuration that&rsquo;s easy to skip while getting a pipeline working.</p>
<h2 id="scope-the-github_tokens-permissions-explicitly">Scope the GITHUB_TOKEN&rsquo;s permissions explicitly</h2>
<p>Every workflow run gets an automatically generated <code>GITHUB_TOKEN</code> with permissions to the repository, and its default scope has historically been broad (write access to most repository resources) unless explicitly restricted. Setting explicit <code>permissions</code> at the workflow or job level — for example, <code>contents: read</code> for a job that only needs to check out code, without write access it doesn&rsquo;t use — limits what a compromised or misbehaving step in that workflow could actually do. Treat &ldquo;no permissions block at all&rdquo; as equivalent to &ldquo;unreviewed, possibly excessive default access,&rdquo; and set it explicitly on every workflow rather than relying on whatever the default happens to be.</p>
<h2 id="third-party-actions-run-with-your-workflows-access">Third-party actions run with your workflow&rsquo;s access</h2>
<p>An action referenced with <code>uses: someorg/some-action@v1</code> executes with the same permissions and secrets access as the rest of your workflow — it isn&rsquo;t sandboxed away from your repository&rsquo;s context. A compromised or malicious action has the same practical reach as a line of code you wrote directly into the workflow yourself. Pin third-party actions to a specific commit SHA rather than a mutable version tag; a tag can be moved to point at different code without your workflow file changing at all, while a commit SHA cannot be silently swapped underneath you.</p>
<h2 id="be-deliberate-about-pull_request-vs-pull_request_target">Be deliberate about pull_request vs pull_request_target</h2>
<p>Workflows triggered by <code>pull_request</code> from a fork do not have access to repository secrets by default — this is intentional, specifically to prevent a malicious fork PR from exfiltrating secrets through a workflow run. <code>pull_request_target</code>, by contrast, does grant secrets access and runs with the target repository&rsquo;s permissions, which is necessary for some legitimate use cases (like commenting on PRs from forks) but requires careful handling of any code checked out from the fork, since that code is now running with elevated access it wouldn&rsquo;t otherwise have. Mixing this up — using <code>pull_request_target</code> without the corresponding caution around what fork-supplied code gets executed — is a well-documented way workflows get exploited.</p>
<h2 id="oidc-removes-the-need-for-long-lived-cloud-credentials-entirely">OIDC removes the need for long-lived cloud credentials entirely</h2>
<p>Storing static cloud credentials (an AWS access key, a GCP service account key) as a GitHub secret means that credential is a standing target — if it leaks, through any of the usual channels, it remains valid until someone notices and manually rotates it. GitHub Actions supports OpenID Connect (OIDC), which lets a workflow request a short-lived token from GitHub&rsquo;s OIDC provider and exchange it for temporary cloud credentials at request time, without any static credential stored in GitHub at all. AWS, GCP, and Azure all support configuring a trust relationship that allows this exchange, scoped to specific repositories or even specific branches.</p>
<p>This is a meaningfully different security posture, not just a convenience improvement: there&rsquo;s no long-lived credential to leak, because none exists in GitHub&rsquo;s secret storage in the first place — the token issued for each workflow run is scoped to that run and expires shortly after.</p>
<h2 id="secrets-scoping-beyond-just-using-github-secrets">Secrets scoping beyond just using GitHub Secrets</h2>
<p>Even with secrets correctly stored (rather than hardcoded), using repository-level secrets for everything means every workflow in the repo has access to every secret, regardless of whether that specific workflow needs it. GitHub&rsquo;s environment-level secrets, combined with required reviewers or branch restrictions on that environment, let you scope a deployment credential so it&rsquo;s only accessible to workflow runs specifically targeting a protected environment — meaningfully narrower than blanket repository-level access.</p>
<h2 id="reusable-and-self-hosted-runner-risks">Reusable and self-hosted runner risks</h2>
<p>Self-hosted runners execute workflow code on infrastructure you control, which means a compromised workflow (through a malicious PR, a compromised dependency pulled in during the job, or a compromised action) can potentially affect that underlying infrastructure directly, not just an ephemeral GitHub-hosted VM that&rsquo;s destroyed after the run. If self-hosted runners are used for anything handling untrusted input (like workflows triggered by external contributions), the isolation and cleanup between runs needs explicit attention that GitHub-hosted runners provide automatically.</p>
<h2 id="a-practical-checklist">A practical checklist</h2>
<ul>
<li>Set explicit, minimal <code>permissions</code> on every workflow rather than relying on defaults</li>
<li>Pin third-party actions to a commit SHA, not a mutable tag</li>
<li>Understand the secrets-access difference between <code>pull_request</code> and <code>pull_request_target</code>, and handle fork-supplied code with corresponding caution in the latter</li>
<li>Adopt OIDC for cloud provider authentication instead of storing long-lived static credentials as secrets</li>
<li>Use environment-level secrets with protection rules for anything tied to deployment, rather than defaulting to repository-level scope</li>
<li>Treat self-hosted runner isolation as something requiring explicit configuration, not something GitHub-hosted runners&rsquo; automatic cleanup provides for you</li>
</ul>
<p>None of these individually make a pipeline &ldquo;secure&rdquo; — together, they reduce a CI/CD system&rsquo;s blast radius from &ldquo;one compromised link exposes everything&rdquo; to something meaningfully more contained.</p>
]]></content:encoded></item><item><title>Dependency Confusion: How Package Managers Can Become an Attack Path</title><link>https://firewallsync.com/posts/dependency-confusion-how-package-managers-can-become-an-attack-path/</link><guid>https://firewallsync.com/posts/dependency-confusion-how-package-managers-can-become-an-attack-path/</guid><pubDate>Sat, 31 Oct 2026 09:00:00 +0000</pubDate><dc:creator>FirewallSync Editorial</dc:creator><category>AppSec &amp; APIs</category><description>Dependency confusion doesn't exploit a vulnerability in any package. It exploits a resolution assumption most package managers share, and it was proven against 35+ major companies without a single CVE.</description><enclosure url="https://firewallsync.com/posts/dependency-confusion-how-package-managers-can-become-an-attack-path/cover_hu15105596631507036774.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/dependency-confusion-how-package-managers-can-become-an-attack-path/cover_hu15105596631507036774.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/dependency-confusion-how-package-managers-can-become-an-attack-path/cover_hu15105596631507036774.jpg" alt="Stack of cargo containers" width="1200" height="630"></p><p>In February 2021, security researcher Alex Birsan demonstrated a technique that compromised build systems at Apple, Microsoft, PayPal, Tesla, Uber, Yelp, and more than 30 other major companies — earning over $130,000 in bug bounties in the process. None of it involved a zero-day exploit, stolen credentials, or malware hidden inside a legitimate package. It exploited a single, widely shared assumption in how package managers resolve dependency names.</p>
<h2 id="the-assumption-being-exploited">The assumption being exploited</h2>
<p>Many organizations use internal, unscoped package names for private code — something like <code>auth-utils</code> or <code>internal-logger</code>, hosted on a private registry alongside public packages resolved from npm, PyPI, or similar. Several package managers, when configured to check both public and private registries, will resolve to whichever source has the higher version number, or will check the public registry as part of normal resolution regardless of whether a private package with the same name exists. If an attacker publishes a public package with the exact same name as your private one, at a deliberately high version number, some build configurations will pull the attacker&rsquo;s public package instead of your legitimate internal one — with no error, and no obvious signal that anything went wrong.</p>
<h2 id="how-birsan-actually-found-the-names">How Birsan actually found the names</h2>
<p>The hardest part of this attack isn&rsquo;t the publishing step — it&rsquo;s knowing what internal package names to target in the first place. Birsan&rsquo;s research found that internal package names leaked through remarkably mundane channels: <code>package.json</code> files accidentally committed to public repositories, internal package names appearing inside minified JavaScript bundled and shipped to production (since build tools sometimes embed dependency manifests into bundled output), error messages exposing internal paths, and even job postings or forum discussions mentioning internal tooling by name. None of this required any kind of breach — it was all information organizations had, in effect, published themselves without realizing what it enabled.</p>
<h2 id="why-this-isnt-caught-by-normal-vulnerability-scanning">Why this isn&rsquo;t caught by normal vulnerability scanning</h2>
<p>A dependency confusion package has no known vulnerability associated with it — it&rsquo;s often a brand-new package with no CVE, no flagged malicious signature, and nothing that would trip a traditional CVE-based scanner. The &ldquo;vulnerability&rdquo; isn&rsquo;t in any package&rsquo;s code at all; it&rsquo;s in the resolution logic deciding which package to install. This is why teams that already run vulnerability scanning in CI can still be fully exposed to this attack — the two problems are structurally different, and one doesn&rsquo;t provide any coverage for the other.</p>
<h2 id="closing-the-gap">Closing the gap</h2>
<p><strong>Scope your private packages</strong> using your registry&rsquo;s namespace/scope feature (npm&rsquo;s <code>@your-org/package-name</code> scoping, for example) rather than unscoped names — a properly scoped private package doesn&rsquo;t collide with anything in the public registry&rsquo;s global namespace, closing the ambiguity the attack depends on.</p>
<p><strong>Explicitly configure your package manager to resolve specific scopes only from your private registry</strong>, rather than allowing it to check public sources as a fallback or alongside private ones for anything internal. Most package managers support this configuration (a <code>.npmrc</code> scope-to-registry mapping, for example), and it removes the resolution ambiguity at the source rather than relying on naming conventions alone.</p>
<p><strong>Register placeholder packages for your internal names on public registries</strong>, even if they contain nothing but a notice — a defensive squatting move that closes the door on an attacker registering that name later, though this doesn&rsquo;t scale well as an organization&rsquo;s internal package count grows and shouldn&rsquo;t be relied on as the primary defense.</p>
<p><strong>Audit what your internal package names actually are, and whether any have already leaked</strong> through the same channels Birsan documented — committed manifest files, bundled minified output, error messages. This audit is worth doing once deliberately, since these leaks tend to be historical accidents rather than ongoing practices, and finding them after the fact still closes future exposure.</p>
<h2 id="why-this-attack-pattern-hasnt-gone-away">Why this attack pattern hasn&rsquo;t gone away</h2>
<p>Once Birsan&rsquo;s technique became public, hundreds of copycat packages appeared on public registries using names patterned after other companies&rsquo; likely internal package naming — some from researchers replicating the technique for further bug bounties, some with less benign intent. The underlying resolution ambiguity in package managers that don&rsquo;t enforce strict scope-based routing hasn&rsquo;t been universally fixed at the tooling level, which means the exposure Birsan demonstrated in 2021 remains present in any organization that hasn&rsquo;t specifically configured against it, regardless of how much time has passed since the original disclosure.</p>
<h2 id="a-practical-checklist">A practical checklist</h2>
<ul>
<li>Use registry scoping for all internal/private packages, never unscoped names</li>
<li>Configure your package manager to route specific scopes exclusively to your private registry</li>
<li>Audit historical leaks of internal package names in committed files, bundled output, and public discussions</li>
<li>Treat this as a distinct control from vulnerability scanning — one does not provide coverage for the other</li>
<li>Consider defensive registration of internal package names on public registries as a secondary, not primary, mitigation</li>
</ul>
]]></content:encoded></item><item><title>Software Supply Chain Attacks: Where Modern Build Pipelines Break</title><link>https://firewallsync.com/posts/software-supply-chain-attacks-where-modern-build-pipelines-break/</link><guid>https://firewallsync.com/posts/software-supply-chain-attacks-where-modern-build-pipelines-break/</guid><pubDate>Fri, 30 Oct 2026 09:00:00 +0000</pubDate><dc:creator>FirewallSync Editorial</dc:creator><category>AppSec &amp; APIs</category><description>A build pipeline trusts a long chain of things by default: the package registry, the CI runner, every plugin, every base image. Each link is a place a supply chain attack can enter without ever touching your own code.</description><enclosure url="https://firewallsync.com/posts/software-supply-chain-attacks-where-modern-build-pipelines-break/cover_hu6751882606804104270.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/software-supply-chain-attacks-where-modern-build-pipelines-break/cover_hu6751882606804104270.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/software-supply-chain-attacks-where-modern-build-pipelines-break/cover_hu6751882606804104270.jpg" alt="Rows of stacked intermodal shipping containers" width="1200" height="630"></p><p>A modern build pipeline trusts a long chain of things by default, mostly without anyone deciding to trust them explicitly: the package registry resolving your dependencies, the CI runner executing your build steps, every third-party action or plugin pulled into that process, the base image your container starts from. A supply chain attack doesn&rsquo;t need to compromise your own code at all — it just needs to compromise one link in that chain, because your pipeline will trust whatever that link delivers.</p>
<h2 id="dependency-resolution-as-an-attack-surface">Dependency resolution as an attack surface</h2>
<p>Package managers resolve dependencies by name and version, largely trusting that a package&rsquo;s identity maps to what it claims to be. This assumption is exactly what dependency confusion attacks exploit — publishing a public package under the same name as an internal one, at a higher version number, so the build system pulls the attacker&rsquo;s code instead of the legitimate internal package. This isn&rsquo;t a bug in any specific package manager; it&rsquo;s a structural consequence of how most of them are designed to resolve names across multiple registries.</p>
<p>Typosquatting works on the same trust assumption from a different angle — publishing a malicious package with a name one character off from a popular legitimate one, betting that enough developers will mistype it or copy a typo from a tutorial to make the attack worthwhile at scale.</p>
<h2 id="build-time-script-execution">Build-time script execution</h2>
<p>Most package managers support scripts that run automatically during install — npm&rsquo;s <code>postinstall</code>, for example. This means installing a dependency can execute arbitrary code on the machine running the install, before your application code ever runs, and before any application-level security control has a chance to matter. A compromised or malicious package doesn&rsquo;t need to be imported and called by your code to do damage; simply being present in <code>node_modules</code> (or the equivalent for your ecosystem) at install time can be enough.</p>
<h2 id="cicd-runners-and-third-party-actions">CI/CD runners and third-party actions</h2>
<p>CI pipelines commonly pull in third-party actions, plugins, or shared workflow steps maintained outside your organization. Each one runs with whatever permissions and secrets access your pipeline configuration grants it — meaning a compromised or malicious third-party action has the same practical reach as a compromised dependency, but often with direct access to CI secrets (cloud credentials, signing keys, deployment tokens) that application dependencies don&rsquo;t typically touch. A popular action being compromised at the source — through a maintainer account takeover, for example — propagates instantly to every pipeline that references it, especially ones pinned to a mutable tag rather than a specific commit.</p>
<h2 id="base-images-and-the-layers-you-didnt-build">Base images and the layers you didn&rsquo;t build</h2>
<p>A container build starting <code>FROM</code> a public base image inherits everything already baked into that image — and if that base image is compromised upstream, at the registry or at the maintainer level, every image built from it inherits the compromise without any change to your own Dockerfile. This is the same trust-chain problem as dependency resolution, just one layer further removed from your own code.</p>
<h2 id="why-this-class-of-attack-is-different-from-a-typical-vulnerability">Why this class of attack is different from a typical vulnerability</h2>
<p>A traditional vulnerability is a flaw in code that needs to be found and exploited. A supply chain attack often requires no vulnerability at all — it just requires the attacker to get their code accepted as a trusted input somewhere in the pipeline, at which point it executes with whatever trust and access that input normally receives. This means traditional vulnerability scanning, which looks for known-bad code patterns or known CVEs, often doesn&rsquo;t catch a well-executed supply chain attack at all, since the malicious package or action may have no publicly known vulnerability associated with it — it&rsquo;s simply doing something it wasn&rsquo;t supposed to do, using access it was never denied.</p>
<h2 id="where-this-leaves-defenses">Where this leaves defenses</h2>
<p><strong>Pin dependencies and actions to exact versions or commit hashes</strong>, not mutable tags — a tag like <code>v2</code> or <code>latest</code> can silently point to different, potentially compromised code over time, while a pinned commit hash cannot change without the reference itself being updated.</p>
<p><strong>Scope your private package names to a registry that doesn&rsquo;t allow public namespace collision</strong>, or explicitly configure your package manager to only resolve certain scopes from your private registry, closing the specific gap dependency confusion exploits.</p>
<p><strong>Restrict what CI pipeline secrets a given workflow or job actually needs</strong>, rather than granting broad access by default — a compromised third-party action in a job with narrowly scoped secrets can do meaningfully less damage than one running with access to everything.</p>
<p><strong>Generate and monitor SBOMs across your build pipeline</strong>, not just your application dependencies, so a newly disclosed compromise in a base image or build tool can be checked against your actual exposure quickly.</p>
<p>Supply chain security isn&rsquo;t a single control — it&rsquo;s an acknowledgment that your pipeline&rsquo;s trust boundary extends far beyond your own code, to every registry, runner, action, and base image it depends on, and each one needs to be treated as a real part of your attack surface rather than an assumed-safe utility.</p>
]]></content:encoded></item><item><title>Brotli CVE-2026-111497: Find and Patch Every Copy</title><link>https://firewallsync.com/posts/brotli-cve-2026-111497-find-and-patch-every-copy/</link><guid>https://firewallsync.com/posts/brotli-cve-2026-111497-find-and-patch-every-copy/</guid><pubDate>Wed, 28 Oct 2026 04:40:00 +0000</pubDate><dc:creator>John Marshall</dc:creator><category>Security Operations</category><description>CVE-2026-111497 is an out-of-bounds write in Google's Brotli decoder, now on CISA's KEV list. It ships inside Node.js, Python packages, Go modules, Envoy and more, and patched builds can still report the old Brotli version. Here is how to find every copy and check it for the fix.</description><enclosure url="https://firewallsync.com/posts/brotli-cve-2026-111497-find-and-patch-every-copy/cover_hu14059145143623990521.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/brotli-cve-2026-111497-find-and-patch-every-copy/cover_hu14059145143623990521.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/brotli-cve-2026-111497-find-and-patch-every-copy/cover_hu14059145143623990521.jpg" alt="Round straw bales stacked in tight columns, each bound with thin blue netting" width="1200" height="630"></p><p>CVE-2026-111497 is a memory-corruption bug in Google&rsquo;s Brotli decompressor. Upstream versions 1.0.3 through 1.2.0 are affected, and 1.0.10, 1.1.1 and 1.2.1 fix it. CISA added it to the <a href="https://www.cisa.gov/known-exploited-vulnerabilities-catalog">Known Exploited Vulnerabilities catalog</a> on October 27, 2026, with a federal remediation date of November 10. The hard part is not the patch. Brotli is compiled into Node.js, Python wheels, Go modules, proxies and service meshes, and several patched builds still report the old version number. Here is where it hides, what &ldquo;fixed&rdquo; looks like for each, and a tested way to check code you vendor yourself.</p>
<h2 id="are-you-affected">Are you affected?</h2>
<p>You are exposed if a vulnerable Brotli decoder processes data an attacker can supply. The <a href="https://www.cve.org/CVERecord?id=CVE-2026-111497">CVE record</a> says an attacker with &ldquo;a crafted Brotli-compressed stream&rdquo; can &ldquo;corrupt adjacent decoder state memory, disclose sensitive memory contents, cause a denial of service, or potentially execute arbitrary code&rdquo;. Google&rsquo;s CNA scored it CVSS 4.0 9.2 (Critical). The Node.js project rates its copy High.</p>
<table>
  <thead>
      <tr>
          <th>Where Brotli lives</th>
          <th>Affected</th>
          <th>Fixed in</th>
          <th>How to check</th>
          <th>Source</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>Google Brotli / libbrotli</td>
          <td>1.0.3 to 1.2.0</td>
          <td>1.0.10, 1.1.1, 1.2.1</td>
          <td>Package version, or the code check below for vendored copies</td>
          <td>CVE record, upstream CHANGELOG</td>
      </tr>
      <tr>
          <td>Node.js 22, 24, 26</td>
          <td>Earlier builds on those lines</td>
          <td>22.23.4, 24.22.1, 26.12.1</td>
          <td><code>node -v</code> (not <code>process.versions.brotli</code>)</td>
          <td>Node.js advisory</td>
      </tr>
      <tr>
          <td>End-of-life Node.js</td>
          <td>Assume affected</td>
          <td>None: upgrade</td>
          <td><code>node -v</code></td>
          <td>Node.js advisory</td>
      </tr>
      <tr>
          <td>Python <code>Brotli</code></td>
          <td>1.0.3 to 1.2.0</td>
          <td>1.2.1</td>
          <td><code>pip show Brotli</code></td>
          <td>Aikido; PyPI release date</td>
      </tr>
      <tr>
          <td>Python <code>brotlicffi</code></td>
          <td>1.2.0.x</td>
          <td>1.2.1.0</td>
          <td><code>pip show brotlicffi</code></td>
          <td>Aikido; PyPI release date</td>
      </tr>
      <tr>
          <td>Go <code>github.com/andybalholm/brotli</code></td>
          <td>Before v1.2.7</td>
          <td>v1.2.7</td>
          <td><code>go list -m github.com/andybalholm/brotli</code></td>
          <td>CVE record reference, source diff</td>
      </tr>
      <tr>
          <td>Envoy</td>
          <td>1.36.11, 1.37.7, 1.38.5, 1.39.2</td>
          <td>1.36.12, 1.37.8, 1.38.6, 1.39.3, 1.40.0</td>
          <td><code>envoy --version</code></td>
          <td>Wiz (qualified); we checked 1.39.2 against 1.39.3</td>
      </tr>
      <tr>
          <td>Istio</td>
          <td>1.29.0 to 1.29.8, 1.30.0 to 1.30.5, 1.31.0 to 1.31.1</td>
          <td>1.29.9, 1.30.6, 1.31.2</td>
          <td><code>istioctl version</code></td>
          <td>Wiz (qualified)</td>
      </tr>
      <tr>
          <td>Bun</td>
          <td>1.0.21 to 1.4.3</td>
          <td>1.4.4</td>
          <td><code>bun --version</code></td>
          <td>Wiz (qualified)</td>
      </tr>
      <tr>
          <td>Distro packages (libbrotli1, brotli)</td>
          <td>Depends on backport</td>
          <td>Distro security update</td>
          <td>Your distro&rsquo;s security tracker</td>
          <td>—</td>
      </tr>
  </tbody>
</table>
<p>The Envoy, Istio and Bun ranges come from <a href="https://www.wiz.io/blog/cve-2026-111497-brotli-rce-node-js">Wiz&rsquo;s write-up</a>, not from those projects&rsquo; advisories. We did not read those advisories directly. For Envoy we checked the source instead: <code>bazel/repository_locations.bzl</code> pins Brotli <code>1.2.0</code> at tag v1.39.2, while v1.39.3 pins a Brotli commit whose <code>decode.c</code> contains the fix.</p>
<p>Linux distributions usually backport fixes and keep the upstream version. Our Ubuntu 24.04 sandbox, for example, has <code>libbrotli1 1.1.0-2ubuntu0.1</code>. That string alone does not tell you whether the fix is in. Use your distribution&rsquo;s security tracker for the CVE.</p>
<h3 id="why-the-version-string-can-mislead-you">Why the version string can mislead you</h3>
<p>Node.js patched its bundled Brotli in place. On the fixed Node.js 22.23.4 the reported library version is still the old one:</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-console" data-lang="console"><span style="display:flex;"><span>$ node -v
</span></span><span style="display:flex;"><span>v22.23.4
</span></span><span style="display:flex;"><span>$ node -p process.versions.brotli
</span></span><span style="display:flex;"><span>1.1.0
</span></span></code></pre></div><p>We ran that in our sandbox. The source tree agrees: <code>deps/brotli/c/common/version.h</code> declares 1.1.0 at both v22.23.3 and v22.23.4, and 1.2.0 at v24.22.1 and v26.12.1, but only the fixed tags contain the patched decoder (v22.23.3 and v24.22.0 do not). A scanner that flags <code>process.versions.brotli &lt; 1.2.1</code> will raise false positives on fixed Node.js. A scanner that trusts a vendored <code>version.h</code> can miss real exposure the other way round. For Node.js, use the Node.js version. For anything else you vendor, check the code.</p>
<h2 id="what-the-bug-is">What the bug is</h2>
<p>The <a href="https://nodejs.org/en/blog/vulnerability/october-2026-security-releases">Node.js advisory</a> gives the clearest description: &ldquo;An invalid block switch was reported as a temporary need for more input instead of a permanent format error, so the streaming decoder kept appending input bytes to an eight-byte internal buffer.&rdquo;</p>
<p>The upstream diff between v1.2.0 and v1.2.1 of <code>c/dec/decode.c</code> shows exactly that. <code>DecodeBlockTypeAndLength()</code> used to return a plain boolean, so &ldquo;invalid stream&rdquo; and &ldquo;need more input&rdquo; looked the same, and the non-safe callers ignored the result altogether (<code>static void DecodeLiteralBlockSwitch(...)</code>). After the fix the function returns a <code>BrotliDecoderErrorCode</code>, emits <code>BROTLI_DECODER_ERROR_FORMAT_BLOCK_SWITCH</code> for the invalid case, and every caller checks it through a new <code>BROTLI_SAFE_WITH_STATUS</code> macro. That matches the two weaknesses in the CVE record: CWE-252 (unchecked return value) and CWE-787 (out-of-bounds write).</p>
<p>The flaw was found by Khai Tran and Sylvie Mayer of OpenAI Codex Security, who are credited in both the CVE record and the Node.js advisory.</p>
<h2 id="where-untrusted-brotli-reaches-your-code">Where untrusted Brotli reaches your code</h2>
<p>The flaw is in decompression, so look for places that decode data you did not produce:</p>
<ul>
<li><strong>Request bodies.</strong> Any endpoint or middleware that inflates <code>Content-Encoding: br</code> uploads.</li>
<li><strong>Outbound HTTP.</strong> HTTP clients decode Brotli responses for you. If an attacker controls or can redirect the URL (webhooks, link previews, feed fetchers, scrapers), they control the compressed bytes.</li>
<li><strong>Files and archives</strong> that contain Brotli streams.</li>
<li><strong>Proxies and meshes</strong> that decompress traffic to inspect or transform it.</li>
</ul>
<p>Two behaviours we checked, because they mean code that never mentions Brotli can still run it:</p>
<ul>
<li><strong>Node.js <code>fetch()</code> decodes Brotli it never asked for.</strong> On Node.js 22.23.4, <code>fetch()</code> sent <code>accept-encoding: gzip, deflate</code>. When our local test server replied with <code>content-encoding: br</code>, <code>fetch()</code> decompressed the body anyway. A hostile server can choose Brotli whatever the client advertises.</li>
<li><strong>Python&rsquo;s requests turns Brotli on when it is installed.</strong> urllib3&rsquo;s <code>util/request.py</code> appends <code>br</code> to its default <code>Accept-Encoding</code> when <code>brotlicffi</code> or <code>brotli</code> can be imported. With Brotli 1.2.1 installed, <code>requests.utils.default_headers()</code> returned <code>gzip, deflate, br</code> in our test. The decoding then runs in whichever Brotli package is installed.</li>
</ul>
<h2 id="what-to-do-now">What to do now</h2>
<ol>
<li><strong>Update the runtimes.</strong> Node.js to 22.23.4, 24.22.1 or 26.12.1 or later. Move off end-of-life Node.js lines: the advisory notes that &ldquo;End-of-Life versions are always affected when a security release occurs.&rdquo;</li>
<li><strong>Update language packages</strong> in every lockfile and image: <code>Brotli&gt;=1.2.1</code>, <code>brotlicffi&gt;=1.2.1.0</code>, <code>github.com/andybalholm/brotli v1.2.7</code>. Both Python fixes were published to PyPI on October 22, 2026.</li>
<li><strong>Update proxies and meshes</strong> (Envoy, Istio) and Bun to the fixed releases above. Confirm the ranges against each project&rsquo;s own advisory.</li>
<li><strong>Apply distro updates</strong> for <code>libbrotli</code>/<code>brotli</code>, then restart the long-running processes that loaded the old library.</li>
<li><strong>Rebuild container images.</strong> A fixed base image does not help a running container that was built from the old one.</li>
<li><strong>Hunt for vendored copies</strong> with the check below.</li>
</ol>
<p>If you cannot patch a service today, reduce what it decodes. As a stopgap, reject <code>Content-Encoding: br</code> request bodies at the edge for services that do not need them, and stop server-side fetchers from decoding responses from untrusted URLs. This is our editorial suggestion, not vendor guidance, and it does not replace the update.</p>
<h3 id="inventory-commands">Inventory commands</h3>
<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-sh" data-lang="sh"><span style="display:flex;"><span><span style="color:#75715e"># Node.js: the version that matters</span>
</span></span><span style="display:flex;"><span>node -v
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e"># Python: every environment and image</span>
</span></span><span style="display:flex;"><span>pip show Brotli brotlicffi 2&gt;/dev/null | grep -E <span style="color:#e6db74">&#39;^(Name|Version)&#39;</span>
</span></span><span style="display:flex;"><span>pipdeptree -r -p Brotli          <span style="color:#75715e"># who pulls it in</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e"># Go modules</span>
</span></span><span style="display:flex;"><span>go list -m all | grep andybalholm/brotli
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e"># Debian/Ubuntu and RHEL-family system libraries</span>
</span></span><span style="display:flex;"><span>dpkg -l <span style="color:#e6db74">&#39;libbrotli*&#39;</span> 2&gt;/dev/null | awk <span style="color:#e6db74">&#39;/^ii/{print $2, $3}&#39;</span>
</span></span><span style="display:flex;"><span>rpm -q brotli libbrotli 2&gt;/dev/null
</span></span></code></pre></div><p>The <code>pip</code>, <code>node</code> and <code>dpkg</code> lines were run in our sandbox. The <code>go</code>, <code>pipdeptree</code> and <code>rpm</code> lines are standard tool usage that we did not run here.</p>
<h3 id="checking-vendored-source-for-the-fix">Checking vendored source for the fix</h3>
<p>C and C++ projects often copy <code>c/dec/decode.c</code> into their tree, and Go programs carry <code>decode.go</code> in the module cache or a <code>vendor/</code> directory. This script looks for the patched function signature instead of trusting any version string:</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-sh" data-lang="sh"><span style="display:flex;"><span><span style="color:#75715e">#!/bin/sh
</span></span></span><span style="display:flex;"><span><span style="color:#75715e"></span><span style="color:#75715e"># brotli-fixcheck.sh DIR...: find vendored Brotli decoder sources and report</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e"># whether they carry the CVE-2026-111497 fix. Looks at the code, not the</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e"># version string, because patched Node.js still reports the old version.</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">for</span> root in <span style="color:#e6db74">&#34;</span>$@<span style="color:#e6db74">&#34;</span>; <span style="color:#66d9ef">do</span>
</span></span><span style="display:flex;"><span>  find <span style="color:#e6db74">&#34;</span>$root<span style="color:#e6db74">&#34;</span> <span style="color:#ae81ff">\(</span> -name decode.c -path <span style="color:#e6db74">&#39;*dec*&#39;</span> <span style="color:#ae81ff">\)</span> -o <span style="color:#ae81ff">\(</span> -name decode.go -path <span style="color:#e6db74">&#39;*brotli*&#39;</span> <span style="color:#ae81ff">\)</span> 2&gt;/dev/null |
</span></span><span style="display:flex;"><span>  <span style="color:#66d9ef">while</span> read -r f; <span style="color:#66d9ef">do</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">if</span> grep -q <span style="color:#e6db74">&#39;BrotliDecoderErrorCode DecodeBlockTypeAndLength&#39;</span> <span style="color:#e6db74">&#34;</span>$f<span style="color:#e6db74">&#34;</span> <span style="color:#f92672">||</span>
</span></span><span style="display:flex;"><span>       grep -q <span style="color:#e6db74">&#39;func decodeBlockTypeAndLength(.*) int {&#39;</span> <span style="color:#e6db74">&#34;</span>$f<span style="color:#e6db74">&#34;</span>; <span style="color:#66d9ef">then</span>
</span></span><span style="display:flex;"><span>      echo <span style="color:#e6db74">&#34;PATCHED    </span>$f<span style="color:#e6db74">&#34;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">elif</span> grep -q <span style="color:#e6db74">&#39;DecodeBlockTypeAndLength\|decodeBlockTypeAndLength&#39;</span> <span style="color:#e6db74">&#34;</span>$f<span style="color:#e6db74">&#34;</span>; <span style="color:#66d9ef">then</span>
</span></span><span style="display:flex;"><span>      echo <span style="color:#e6db74">&#34;VULNERABLE </span>$f<span style="color:#e6db74">&#34;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">fi</span>
</span></span><span style="display:flex;"><span>  <span style="color:#66d9ef">done</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">done</span>
</span></span></code></pre></div><p>We tested it against 12 sources pulled from GitHub: upstream Brotli v1.0.9, v1.0.10, v1.1.0, v1.1.1, v1.2.0 and v1.2.1; Node.js <code>deps/brotli</code> at v22.23.3, v22.23.4, v24.22.0 and v24.22.1; and <code>andybalholm/brotli</code> v1.2.6 and v1.2.7. It reported every fixed release as <code>PATCHED</code> and every earlier one as <code>VULNERABLE</code>. Run it over source trees, <code>vendor/</code> directories and <code>$(go env GOMODCACHE)</code>.</p>
<p>It cannot inspect compiled binaries, and a heavily modified fork may not match either pattern. Treat &ldquo;no output&rdquo; as &ldquo;no recognisable copy found&rdquo;, not as &ldquo;safe&rdquo;.</p>
<h2 id="what-to-hunt-for">What to hunt for</h2>
<p>No vendor or agency has published indicators of compromise for this CVE, and CISA&rsquo;s KEV entry does not require forensic triage (<code>forensicTriage: No</code>). Practical checks:</p>
<ul>
<li><strong>Crashes.</strong> Segfaults or aborts in Node.js, Python or proxy processes since late October, especially in services that fetch remote content or accept compressed uploads.</li>
<li><strong>Unexpected Brotli.</strong> Requests with <code>Content-Encoding: br</code> to endpoints that never receive compressed bodies. Wiz recommends reviewing WAF, application and network logs for suspicious Brotli-compressed traffic.</li>
<li><strong>Outbound fetches</strong> from services that took user-supplied URLs, close in time to a crash.</li>
</ul>
<h2 id="limits-of-this-article">Limits of this article</h2>
<p>We did not reproduce the memory corruption or test any exploit. Our checks cover version strings, source code and HTTP client behaviour in a sandbox: Node.js 22.23.4, Python with Brotli 1.2.1, Ubuntu 24.04. The Envoy, Istio and Bun ranges come from a security vendor&rsquo;s summary. The list of affected software is not complete. Wiz notes that other products that bundle or link vulnerable versions of the Brotli C decoder may also be affected.</p>
<p>For the wider process of keeping dependency updates moving, see <a href="/posts/dependency-audits-without-slowing-down-releases/">dependency audits without slowing down releases</a>. For publishing or reading &ldquo;not affected&rdquo; statements about a library like this, see <a href="/posts/vex-explained-what-a-not-affected-statement-means-and-how-to-read-one/">VEX explained</a>. Last week&rsquo;s <a href="/posts/php2shell-cve-2026-109618-cve-2026-109619-patch-and-hunt/">PHP2Shell patch-and-hunt guide</a> covers the two PHP runtime flaws CISA added to KEV the day before.</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>Affected 1.0.3–1.2.0; fixed 1.0.10, 1.1.1, 1.2.1; CVSS 4.0 9.2; CWE-252/787; credit</td>
          <td><a href="https://github.com/CVEProject/cvelistV5/blob/main/cves/2026/111xxx/CVE-2026-111497.json">CVE-2026-111497 record (cvelistV5)</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>KEV added 2026-10-27, due 2026-11-10, forensicTriage No; SSVC exploitation active</td>
          <td><a href="https://github.com/cisagov/kev-data">CISA KEV data</a>; CISA ADP in the CVE record</td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>1.2.1 released 2026-10-21 with the CVE fix; code change</td>
          <td><a href="https://github.com/google/brotli/blob/v1.2.1/CHANGELOG.md">google/brotli CHANGELOG</a>; <code>c/dec/decode.c</code> v1.2.0 vs v1.2.1</td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Node.js fixed releases, root cause, EOL statement</td>
          <td><a href="https://nodejs.org/en/blog/vulnerability/october-2026-security-releases">Node.js October 2026 security releases</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Patched Node.js reports the old Brotli version</td>
          <td><code>node -p process.versions.brotli</code> on v22.23.4; <code>deps/brotli</code> at the listed tags</td>
          <td>Verified (our test)</td>
      </tr>
      <tr>
          <td>Go fix in andybalholm/brotli v1.2.7</td>
          <td><a href="https://github.com/andybalholm/brotli/releases/tag/v1.2.7">Release v1.2.7</a>; <code>decode.go</code> v1.2.6 vs v1.2.7</td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Python Brotli 1.2.1, brotlicffi 1.2.1.0</td>
          <td><a href="https://www.aikido.dev/blog/python-packages-vulnerable-node2shell-brotli-cve-2026-111497">Aikido</a>; PyPI upload dates 2026-10-22</td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>urllib3/requests advertise <code>br</code> when Brotli is installed</td>
          <td><a href="https://github.com/urllib3/urllib3/blob/main/src/urllib3/util/request.py">urllib3 <code>util/request.py</code></a>; our test</td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Envoy, Istio, Bun ranges</td>
          <td><a href="https://www.wiz.io/blog/cve-2026-111497-brotli-rce-node-js">Wiz</a>; Envoy <code>repository_locations.bzl</code> at v1.39.2/v1.39.3</td>
          <td>Qualified</td>
      </tr>
      <tr>
          <td>Envoy and other consumers affected</td>
          <td><a href="https://www.openwall.com/lists/oss-security/2026/10/23/25">oss-security, 2026-10-23</a>, <a href="https://www.openwall.com/lists/oss-security/2026/10/24/6">2026-10-24</a></td>
          <td>Verified</td>
      </tr>
  </tbody>
</table>
]]></content:encoded></item><item><title>Verify Signed Container Images in Kubernetes with Sigstore policy-controller: Keyless Policy and Safe Rollout</title><link>https://firewallsync.com/posts/verify-signed-container-images-in-kubernetes-sigstore-policy-controller-keyless-policy-and-rollout/</link><guid>https://firewallsync.com/posts/verify-signed-container-images-in-kubernetes-sigstore-policy-controller-keyless-policy-and-rollout/</guid><pubDate>Wed, 14 Oct 2026 06:08:00 +0000</pubDate><dc:creator>FirewallSync Editorial</dc:creator><category>Cloud Security</category><description>Signing images only helps if something refuses the unsigned ones. This guide covers Sigstore's policy-controller admission webhook: opting namespaces in, writing a ClusterImagePolicy that pins a GitHub Actions workflow identity, rolling out in warn mode, and the failure-policy trade-off the Helm chart defaults create.</description><enclosure url="https://firewallsync.com/posts/verify-signed-container-images-in-kubernetes-sigstore-policy-controller-keyless-policy-and-rollout/cover_hu540727492569119796.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/verify-signed-container-images-in-kubernetes-sigstore-policy-controller-keyless-policy-and-rollout/cover_hu540727492569119796.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/verify-signed-container-images-in-kubernetes-sigstore-policy-controller-keyless-policy-and-rollout/cover_hu540727492569119796.jpg" alt="A row of gray metal fare gates with orange tops and green lights at a station entrance, with a blue sign in Chinese characters and an arrow, a wall monitor, and glass barriers to the right" width="1200" height="630"></p><p>If your CI pipeline signs container images but your cluster will pull anything, the signatures protect nothing. The enforcement step is an admission controller that checks each image before Kubernetes starts it. <strong>Sigstore policy-controller</strong> is one such controller, built to verify signatures and attestations created with cosign (Sigstore&rsquo;s signing tool). This guide explains how it decides, how to write a keyless policy pinned to a specific GitHub Actions workflow, and how to roll it out without locking yourself out of your own cluster.</p>
<p>This is a follow-up to our article on <a href="/posts/cosign-container-image-signing-keyless-signing-in-ci-and-why-verification-must-pin-an-identity/">signing images with cosign and why verification must pin an identity</a>. We read the Sigstore policy-controller documentation, its README and Helm chart files, Sigstore&rsquo;s CI quickstart, GitHub&rsquo;s OIDC documentation and Kubernetes&rsquo; admission webhook documentation on October 14, 2026. We did not install policy-controller or run any manifest below, so this is research-based explanation, not tested configuration. Placeholders in angle brackets are for you to fill in.</p>
<h2 id="the-short-answer">The short answer</h2>
<p>Install policy-controller, label the namespaces you want checked, and create a <code>ClusterImagePolicy</code> that names the image patterns to check and the identities allowed to have signed them. Start in <code>warn</code> mode, decide what happens to images that match no policy, and give the webhook more than one replica before you switch any production namespace to enforcement, because the chart&rsquo;s default failure policy rejects requests when the webhook is unreachable.</p>
<h2 id="what-an-admission-controller-does-here">What an admission controller does here</h2>
<p>A Kubernetes admission webhook is an HTTPS service the API server calls when matching requests arrive, such as creating or updating a Deployment. A validating webhook can reject the request. Policy-controller&rsquo;s overview describes it as an admission controller that enforces policy using verifiable supply-chain metadata from cosign, and says it can validate signatures and attestations on container images and apply policies written in CUE or Rego against attestations. The same page notes the component is &ldquo;still actively under development.&rdquo;</p>
<p>Two details from the documentation shape everything else:</p>
<ul>
<li><strong>It matches by digest.</strong> Image patterns are matched against image digests, and the controller resolves tags to digests so the running image matches what was admitted. A tag like <code>:1.4</code> can move; a digest cannot.</li>
<li><strong>It is opt-in per namespace.</strong> Out of the box, only namespaces labelled <code>policy.sigstore.dev/include: &quot;true&quot;</code> are validated.</li>
</ul>
<h2 id="install-and-opt-in">Install and opt in</h2>
<p>The installation page lists these steps, with Helm v3 and a cluster you can reach with <code>kubectl</code> as prerequisites:</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-bash" data-lang="bash"><span style="display:flex;"><span>helm repo add sigstore https://sigstore.github.io/helm-charts
</span></span><span style="display:flex;"><span>helm repo update
</span></span><span style="display:flex;"><span>kubectl create namespace cosign-system
</span></span><span style="display:flex;"><span>helm install policy-controller -n cosign-system sigstore/policy-controller
</span></span><span style="display:flex;"><span>kubectl get pods -n cosign-system
</span></span></code></pre></div><p>Then opt a namespace in, using the example command from the overview page:</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-bash" data-lang="bash"><span style="display:flex;"><span>kubectl label namespace &lt;my-namespace&gt; policy.sigstore.dev/include<span style="color:#f92672">=</span>true
</span></span></code></pre></div><p>The documentation does not give a minimum Kubernetes version. Pin the chart and image versions you deploy rather than relying on a floating install. When we read the chart&rsquo;s <code>Chart.yaml</code> on its main branch, it listed chart version 0.10.8 with <code>appVersion</code> 0.13.1, while the project&rsquo;s releases page listed v0.15.1 as the latest release and described v0.15.0 as upgrading cosign from v2 to v3. The release page shows dates without a year, so we do not date those releases. The practical point: check which controller version a chart install actually gives you, and read the release notes for cosign-version changes before you upgrade.</p>
<h2 id="write-a-keyless-policy-pinned-to-one-workflow">Write a keyless policy pinned to one workflow</h2>
<p>Policy-controller&rsquo;s documented structure is:</p>
<ul>
<li><code>spec.images</code>: a list of <code>glob</code> patterns for the images the policy covers. Hosts default to <code>index.docker.io</code> and single-name images to <code>library</code>.</li>
<li><code>spec.authorities</code>: ways an image can pass. An authority is a <code>key</code> (public key, secret reference or KMS URI), a <code>keyless</code> block with Fulcio details and <code>identities</code>, or <code>static</code>, which passes or fails without checking a signature.</li>
<li><code>spec.mode</code>: set to <code>warn</code> to admit non-compliant images with a warning.</li>
<li><code>spec.match</code>: optionally limits the policy to resource kinds such as <code>deployments</code> or <code>jobs</code>.</li>
</ul>
<p>For images signed by a GitHub Actions workflow with cosign keyless signing, the identity to pin has two parts. The issuer is the OIDC (OpenID Connect) token issuer, <code>https://token.actions.githubusercontent.com</code>, which GitHub&rsquo;s documentation lists. The subject is the signer identity in the certificate; Sigstore&rsquo;s CI quickstart shows it as <code>https://github.com/USERNAME/REPOSITORY_NAME/.github/workflows/WORKFLOW_NAME@refs/heads/BRANCH_NAME</code>.</p>
<p>A policy for images from your organization, accepting only the release workflow on version tags, would look like this, built from the documented 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-yaml" data-lang="yaml"><span style="display:flex;"><span><span style="color:#f92672">apiVersion</span>: <span style="color:#ae81ff">policy.sigstore.dev/v1beta1</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">kind</span>: <span style="color:#ae81ff">ClusterImagePolicy</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">metadata</span>:
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">name</span>: <span style="color:#ae81ff">require-release-workflow-signature</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">spec</span>:
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">mode</span>: <span style="color:#ae81ff">warn</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">images</span>:
</span></span><span style="display:flex;"><span>  - <span style="color:#f92672">glob</span>: <span style="color:#e6db74">&#34;ghcr.io/&lt;org&gt;/**&#34;</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">authorities</span>:
</span></span><span style="display:flex;"><span>  - <span style="color:#f92672">keyless</span>:
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">identities</span>:
</span></span><span style="display:flex;"><span>      - <span style="color:#f92672">issuer</span>: <span style="color:#ae81ff">https://token.actions.githubusercontent.com</span>
</span></span><span style="display:flex;"><span>        <span style="color:#f92672">subjectRegExp</span>: <span style="color:#ae81ff">https://github\.com/&lt;org&gt;/[^/]+/\.github/workflows/release\.yml@refs/tags/v.+</span>
</span></span></code></pre></div><p>We have not applied this manifest. Before relying on it, test it with the project&rsquo;s <code>policy-tester</code> tool, which the README describes as checking a ClusterImagePolicy against an image. We also did not confirm whether the controller anchors regular expressions to the whole string or what Fulcio URL it uses when <code>url</code> is omitted, so check both for your version.</p>
<h3 id="a-caution-about-the-documentations-own-regular-expression-example">A caution about the documentation&rsquo;s own regular-expression example</h3>
<p>The overview page&rsquo;s GitHub Actions example uses this value for <code>subjectRegExp</code>:</p>
<pre tabindex="0"><code>https://github.com/mycompany/*/.github/workflows/*@*
</code></pre><p>Read as a regular expression, <code>*</code> repeats the preceding character instead of acting as a wildcard, and an unescaped <code>.</code> matches any character. We tested that string with Python&rsquo;s <code>re</code> module (the meanings of <code>.</code> and <code>*</code> are the same in Go&rsquo;s regular-expression syntax, but we did not run policy-controller itself). It did not match <code>https://github.com/mycompany/app/.github/workflows/build.yml@refs/heads/main</code>, and it did match the odd string <code>https://github.com/mycompany/.github/workflows@</code>. The example is probably shorthand, but copying it literally would either match nothing you intended or match things you did not. Write the expression the way the policy above does: escape dots, use <code>[^/]+</code> for one path segment, and name the workflow file and ref pattern you actually trust. We verified our own expression against three strings in Python: it matched a <code>release.yml</code> tag-ref identity under <code>mycompany/app</code>, and rejected both a branch-ref identity and a look-alike owner <code>mycompanyx</code>.</p>
<h2 id="how-policies-combine-and-the-traps">How policies combine, and the traps</h2>
<p>The overview says: every matching <code>ClusterImagePolicy</code> must pass, and within one policy any passing authority is enough.</p>
<ul>
<li><strong>Adding a second authority loosens a policy.</strong> If one authority pins your release workflow and another accepts any signature from a public issuer, the second one wins. Keep authorities that mean the same trust level together and put different trust levels in different policies.</li>
<li><strong><code>static</code> authorities skip verification.</strong> <code>action: pass</code> passes images with no signature check at all. Use only deliberately.</li>
<li><strong>Overlapping globs stack.</strong> An image matching two policies must satisfy both.</li>
</ul>
<h3 id="decide-the-no-match-behavior-first">Decide the no-match behavior first</h3>
<p>Per the overview, an image that matches no policy is rejected unless the <code>config-policy-controller</code> ConfigMap in the release namespace sets <code>no-match-policy</code> to <code>warn</code>, <code>allow</code> or <code>deny</code>. With only your own registry covered by a policy, every third-party image, such as a sidecar or a base-image-derived job, in an opted-in namespace is a &ldquo;no match&rdquo;. Choose between listing those registries in policies (with their own authorities), or setting <code>no-match-policy</code> explicitly. Release v0.15.0 notes say image references are now logged when no-match-policy is <code>warn</code> or <code>deny</code>, which helps you find what you forgot.</p>
<h2 id="rolling-out-without-an-outage">Rolling out without an outage</h2>
<ol>
<li><strong>Run <code>policy-tester</code> against your real images</strong> from CI, before touching the cluster.</li>
<li><strong>Label one non-critical namespace</strong> and set <code>mode: warn</code>. Deploy normally and collect the warnings.</li>
<li><strong>Set <code>no-match-policy: warn</code></strong> for the pilot so third-party images surface as warnings, not failures.</li>
<li><strong>Fix identities you did not expect.</strong> A warning on an image you thought was signed usually means the signing workflow or ref differs from your pattern.</li>
<li><strong>Switch the policy to enforce</strong> (remove <code>mode: warn</code>, since by default an unsatisfied policy blocks admission) for that namespace only, then widen.</li>
</ol>
<h3 id="the-webhook-is-now-in-your-deployment-path">The webhook is now in your deployment path</h3>
<p>The Kubernetes documentation says <code>failurePolicy</code> controls what happens when calling the webhook fails: <code>Fail</code> means an error calling the webhook causes admission to fail and the request is rejected, <code>Ignore</code> lets the request continue; <code>Fail</code> is the default. Network errors, timeouts and bad responses are among the errors it covers. The timeout can be set between 1 and 30 seconds.</p>
<p>The policy-controller Helm chart&rsquo;s <code>values.yaml</code> on its main branch, which we read on October 14, 2026, sets <code>webhook.failurePolicy: Fail</code> and <code>webhook.replicaCount: 1</code>. We did not check which of the chart&rsquo;s webhook configurations that value feeds. Put together, and as our analysis rather than a tested result: a single webhook pod that is rescheduled, OOM-killed or unreachable could cause creates and updates in opted-in namespaces to be rejected until it returns. The opt-in label limits the blast radius to those namespaces, which is a reason to start small and to keep critical namespaces out until you have run the failure case in a test cluster: scale the webhook to zero and see what breaks. Raising the replica count is a chart value; whether you prefer fail-closed (safer against unsigned images, riskier for availability) or fail-open (the reverse) is a decision for your threat model, not a default to accept unread.</p>
<h2 id="what-this-does-not-prove">What this does not prove</h2>
<ul>
<li><strong>A signature is not a vulnerability assessment.</strong> It shows which identity produced an image, not that the image is free of flaws. See our article on <a href="/posts/container-image-scanning-what-ci-pipelines-still-miss/">what scanning still misses</a>.</li>
<li><strong>It checks requests, not running pods.</strong> We found nothing in the documentation about re-verifying workloads that are already running.</li>
<li><strong>Identity pins are only as good as your CI.</strong> If an attacker can get a malicious change into the pinned workflow on the pinned ref, the signature will be valid. Pair this with locked-down workflow permissions and provenance checks from <a href="/posts/slsa-build-levels-and-provenance-attestations-what-they-prove-and-what-they-dont/">SLSA attestations</a>.</li>
<li><strong>Documentation gaps remain.</strong> The installation page does not describe webhook failure behavior, and the overview describes the project as under active development; check the release notes of the version you run.</li>
</ul>
<h2 id="sources-and-verification">Sources and verification</h2>
<table>
  <thead>
      <tr>
          <th>Important claim</th>
          <th>Source</th>
          <th>Verification</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>policy-controller validates cosign signatures and attestations; opt-in label policy.sigstore.dev/include; every matching policy must pass and any authority within one suffices; no-match-policy values and default rejection; ClusterImagePolicy fields; warn mode; tag-to-digest resolution; &ldquo;still actively under development&rdquo;</td>
          <td><a href="https://docs.sigstore.dev/policy-controller/overview/">Sigstore: Policy Controller overview</a></td>
          <td>Verified: read October 14, 2026; project under active development</td>
      </tr>
      <tr>
          <td>Helm install commands; prerequisites; no minimum Kubernetes version stated; webhook failure behavior not described</td>
          <td><a href="https://docs.sigstore.dev/policy-controller/installation/">Sigstore: policy-controller installation</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>policy-tester tool description</td>
          <td><a href="https://github.com/sigstore/policy-controller/blob/main/README.md">policy-controller README</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>v0.15.0 upgraded cosign v2 to v3 and logs image references under warn or deny no-match-policy; v0.15.1 latest listed</td>
          <td><a href="https://github.com/sigstore/policy-controller/releases">policy-controller releases</a></td>
          <td>Qualified: page lists dates without a year; read October 14, 2026</td>
      </tr>
      <tr>
          <td>Chart main branch: chart 0.10.8, appVersion 0.13.1; webhook.failurePolicy Fail; replicaCount 1</td>
          <td><a href="https://github.com/sigstore/helm-charts/blob/main/charts/policy-controller/Chart.yaml">Chart.yaml</a> and <a href="https://github.com/sigstore/helm-charts/blob/main/charts/policy-controller/values.yaml">values.yaml</a></td>
          <td>Qualified: main branch at time of reading; which webhook the value feeds not checked</td>
      </tr>
      <tr>
          <td>failurePolicy semantics, Fail as default, timeout 1 to 30 seconds</td>
          <td><a href="https://kubernetes.io/docs/reference/access-authn-authz/extensible-admission-controllers/">Kubernetes: dynamic admission control</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>GitHub Actions OIDC issuer URL</td>
          <td><a href="https://docs.github.com/en/actions/reference/security/oidc">GitHub Docs: OIDC reference</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>GitHub workflow signer identity format and verify flags</td>
          <td><a href="https://docs.sigstore.dev/quickstart/quickstart-ci/">Sigstore: CI quickstart</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Docs example subjectRegExp does not match a typical repository path when read as a regular expression</td>
          <td>Our test in Python&rsquo;s re module</td>
          <td>Qualified: not run in policy-controller; Go regexp syntax for these characters is the same</td>
      </tr>
      <tr>
          <td>Example policy and rollout order</td>
          <td>Our analysis</td>
          <td>Qualified: untested; editorial judgment</td>
      </tr>
  </tbody>
</table>
]]></content:encoded></item><item><title>Cosign Container Image Signing: Keyless Signing in CI and Why Verification Must Pin an Identity</title><link>https://firewallsync.com/posts/cosign-container-image-signing-keyless-signing-in-ci-and-why-verification-must-pin-an-identity/</link><guid>https://firewallsync.com/posts/cosign-container-image-signing-keyless-signing-in-ci-and-why-verification-must-pin-an-identity/</guid><pubDate>Tue, 13 Oct 2026 06:06:00 +0000</pubDate><dc:creator>FirewallSync Editorial</dc:creator><category>AppSec &amp; APIs</category><description>Signing a container image with Sigstore's cosign takes one command; the security comes from what the verifier insists on. Here is how keyless signing works in a GitHub Actions job, what to pin when verifying, and what an August 2026 cosign advisory shows about trusting the verifier.</description><enclosure url="https://firewallsync.com/posts/cosign-container-image-signing-keyless-signing-in-ci-and-why-verification-must-pin-an-identity/cover_hu8055220339597418561.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/cosign-container-image-signing-keyless-signing-in-ci-and-why-verification-must-pin-an-identity/cover_hu8055220339597418561.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/cosign-container-image-signing-keyless-signing-in-ci-and-why-verification-must-pin-an-identity/cover_hu8055220339597418561.jpg" alt="Close-up of the double doors of a weathered blue shipping container, with a small padlock hanging from the latch on the right door" width="1200" height="630"></p><p>Signing a container image with <strong>cosign</strong>, the command-line client of the open-source Sigstore project, is a one-line command. Whether the signature protects anyone depends on the other end: the verifier has to say <em>who</em> must have signed the image and <em>which identity provider</em> must have vouched for them. This article walks through keyless signing in a GitHub Actions job, what to pin when verifying, and why an August 2026 advisory about cosign&rsquo;s own verification is a good reminder that the verifier is part of your trust chain.</p>
<p>We read the Sigstore documentation, the cosign command reference, the <code>sigstore/cosign-installer</code> README, GitHub&rsquo;s documentation on its OIDC tokens, the cosign release notes and the cosign security advisory on October 13, 2026. We did not run any of the commands for this article, so it is research-based explanation, not hands-on testing. Placeholders in angle brackets are for you to fill in.</p>
<h2 id="the-short-answer">The short answer</h2>
<ul>
<li><strong>Sign:</strong> <code>cosign sign &lt;image&gt;@&lt;digest&gt;</code> in your release job. In keyless mode no key pair is stored: cosign gets a short-lived certificate for the job&rsquo;s OIDC identity.</li>
<li><strong>Verify:</strong> run <code>cosign verify</code> with <code>--certificate-identity</code> and <code>--certificate-oidc-issuer</code> set to the identity and issuer you expect, in the place where images are deployed or pulled.</li>
<li><strong>Keep cosign patched</strong> on both signing and verifying machines. The advisory below shows verification code can itself have bugs.</li>
</ul>
<h2 id="what-keyless-signing-does">What keyless signing does</h2>
<p>Per the <a href="https://docs.sigstore.dev/cosign/signing/overview/">Sigstore cosign documentation</a>, keyless signing &ldquo;associates identities, rather than keys, with an artifact signature.&rdquo; Cosign uses an ephemeral key; the page notes the private key is destroyed shortly after signing. <strong>Fulcio</strong>, Sigstore&rsquo;s certificate authority, &ldquo;issues short-lived certificates binding an ephemeral key to an OpenID Connect identity.&rdquo; The signing event is logged in <strong>Rekor</strong>, a signature transparency log, &ldquo;providing an auditable record.&rdquo; Our article on <a href="/posts/slsa-build-levels-and-provenance-attestations-what-they-prove-and-what-they-dont/">SLSA build levels and provenance</a> describes the same flow in the context of attestations.</p>
<p>In an automated environment cosign can take an OIDC token directly via <code>--identity-token</code>; the documentation says the token&rsquo;s audiences claim must contain <code>sigstore</code>. In GitHub Actions, the cosign installer&rsquo;s example relies on the job&rsquo;s GitHub OIDC token instead.</p>
<h2 id="signing-in-github-actions">Signing in GitHub Actions</h2>
<p>The <a href="https://github.com/sigstore/cosign-installer"><code>sigstore/cosign-installer</code> README</a> provides an example workflow. The elements that matter for security are:</p>
<ul>
<li><strong>Permissions.</strong> The job needs <code>id-token: write</code> (annotated in the example as &ldquo;needed for signing the images with GitHub OIDC Token&rdquo;). GitHub&rsquo;s <a href="https://docs.github.com/en/actions/reference/security/oidc">OIDC documentation</a> states that without <code>id-token: write</code> the OIDC JWT ID token cannot be requested. The example also grants <code>packages: write</code> for pushing to <code>ghcr.io</code> and <code>contents: read</code>.</li>
<li><strong>Sign by digest.</strong> The example builds and pushes the image, takes the digest from the build step&rsquo;s output and signs <code>tag@digest</code> references. We read this as the reason the digest matters: a tag can later be re-pointed to a different image, while a digest identifies specific content. (The cosign signing page we read does not itself state a digest recommendation; this is our reading of the example.)</li>
<li><strong>No secret for keyless.</strong> The README&rsquo;s keyless step runs <code>cosign sign --yes ${images}</code> with no key. Its other example signs with a key held in repository secrets, which brings back the problem of protecting a long-lived key.</li>
<li><strong>Untrusted values in shell.</strong> The example passes values through environment variables rather than inline expressions, following GitHub&rsquo;s guidance on script injection.</li>
<li><strong>Pin the installer.</strong> The README says the <code>cosign-release</code> input pins a specific cosign version and that you then maintain that version yourself. Pinning also applies to the installer action: the example references <code>sigstore/cosign-installer@v4.1.0</code>; for stronger protection against a moved tag you can pin actions to a full commit SHA (our suggestion, not from the README).</li>
</ul>
<p>The signature is stored with the image in the registry. The signing documentation says signatures use the OCI 1.1 referrer specification, and <code>cosign tree &lt;image&gt;</code> shows what is attached. Your registry must support what cosign pushes; we did not test registry compatibility.</p>
<h2 id="verifying-pin-the-identity-and-the-issuer">Verifying: pin the identity and the issuer</h2>
<p>This is the step that turns a signature into a control. For keyless signatures, the <a href="https://github.com/sigstore/cosign/blob/main/doc/cosign_verify.md">cosign command reference</a> says the identity flags are mandatory:</p>
<pre tabindex="0"><code>cosign verify &lt;registry&gt;/&lt;repo&gt;@&lt;digest&gt; \
  --certificate-identity=&lt;expected signer identity&gt; \
  --certificate-oidc-issuer=https://token.actions.githubusercontent.com
</code></pre><p>What each flag means, per the reference:</p>
<table>
  <thead>
      <tr>
          <th>Flag</th>
          <th>Meaning in the reference</th>
          <th>What to put there</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>--certificate-identity</code></td>
          <td>The identity expected in a valid Fulcio certificate; valid values include email addresses, DNS names, IP addresses and URIs. One of this or <code>--certificate-identity-regexp</code> must be set for keyless flows</td>
          <td>The identity of your release workflow (see below)</td>
      </tr>
      <tr>
          <td><code>--certificate-oidc-issuer</code></td>
          <td>The OIDC issuer expected in the certificate; the reference gives <code>https://token.actions.githubusercontent.com</code> as an example. One of this or <code>--certificate-oidc-issuer-regexp</code> must be set</td>
          <td>For GitHub Actions: <code>https://token.actions.githubusercontent.com</code></td>
      </tr>
  </tbody>
</table>
<p><strong>Exact vs regexp.</strong> The regexp variants accept Go regular expressions. A loose pattern (for example one that matches any repository in an organization, or any branch) widens who can satisfy your policy. Prefer exact values where you can; if you must use a pattern, anchor it. This is our recommendation.</p>
<p><strong>What identity string to expect.</strong> We did not verify, from the sources above, the exact format of the identity that appears in a certificate issued to a GitHub Actions job, so we do not state one here. GitHub&rsquo;s OIDC documentation defines claims in the <em>token</em> (for example the <code>sub</code> claim, formatted like <code>repo:ORG/REPO:ref:refs/heads/BRANCH</code> in its examples, and <code>job_workflow_ref</code> for reusable workflows), but how those claims map into the Fulcio certificate identity is not something we confirmed. A reasonable procedure (our suggestion): sign a test image from your real release workflow, inspect the certificate on that signature, record the identity and issuer you see there, and then pin those exact values.</p>
<p><strong>What a passing check tells you.</strong> That the image content matches the signed digest and that a signer with the pinned identity signed it, with the signing recorded in the transparency log. It does not tell you the image is free of vulnerabilities or malicious code, or that the workflow that signed it was itself uncompromised. For vulnerability status, see our articles on <a href="/posts/vex-explained-what-a-not-affected-statement-means-and-how-to-read-one/">VEX statements</a> and <a href="/posts/container-image-scanning-what-ci-pipelines-still-miss/">what container image scanning still misses</a>.</p>
<p>Where to run it: at the point of consumption, such as a deploy job or an admission step in your cluster, failing the deployment on mismatch. The cosign reference documents the command-line flags; we did not review Kubernetes admission tooling, so that part is outside this article.</p>
<h2 id="a-reminder-that-the-verifier-needs-patching-too">A reminder that the verifier needs patching too</h2>
<p>On August 6, 2026, the cosign project published advisory <a href="https://github.com/sigstore/cosign/security/advisories/GHSA-fx35-mq7g-6g98">GHSA-fx35-mq7g-6g98</a>, &ldquo;Verification bypass via public key in legacy bundle.&rdquo; The facts as stated in the advisory:</p>
<table>
  <thead>
      <tr>
          <th>Item</th>
          <th>Detail</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>Severity</td>
          <td>High, CVSS 7.4 (vector CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:N/I:H/A:N)</td>
      </tr>
      <tr>
          <td>CVE</td>
          <td>None assigned (&ldquo;No known CVE&rdquo;)</td>
      </tr>
      <tr>
          <td>Affected commands</td>
          <td><code>cosign verify-blob</code> and <code>cosign verify-blob-attestation</code>, when given a legacy JSON <code>--bundle</code></td>
      </tr>
      <tr>
          <td>Affected versions</td>
          <td>cosign v2.6.4 and earlier; cosign v3.1.2 and earlier</td>
      </tr>
      <tr>
          <td>Patched versions</td>
          <td>v2.6.5 and v3.1.3</td>
      </tr>
      <tr>
          <td>Mechanism</td>
          <td>If the bundle&rsquo;s <code>cert</code> field is not a valid X.509 certificate, cosign treated it as a raw public key; certificate chain and identity checks were skipped, so <code>--certificate-identity</code> and <code>--certificate-oidc-issuer</code> were ignored</td>
      </tr>
      <tr>
          <td>Not affected</td>
          <td>The protobuf bundle format and OCI image verification, per the advisory</td>
      </tr>
      <tr>
          <td>Workaround</td>
          <td>Upgrade; or migrate to the standardized protobuf bundle format (<code>--new-bundle-format</code>); <code>cosign bundle create</code> can convert existing bundles</td>
      </tr>
  </tbody>
</table>
<p><strong>What this means for container image signing.</strong> The advisory says OCI image verification is not affected, so a pipeline that only runs <code>cosign verify</code> on images in a registry is outside the described bug. It matters if you also sign and verify <strong>blobs</strong>, such as release binaries, tarballs or SBOM files, using separate bundle files. The general lesson is practical: identity pinning only helps if the verifier actually enforces it, so track cosign releases on every machine that verifies. The cosign <a href="https://github.com/sigstore/cosign/releases">releases page</a> lists v3.1.3 and v2.6.5 as the August 6, 2026 releases that carry the fix. The same page records a bundle-format change in the 2.6 line: its notes say the default for signing is now the bundle format, and that <code>--new-bundle-format=false</code> signs in the old format; verification in 3.1.x accepts both formats. Check the release notes for your version before changing flags.</p>
<h2 id="a-rollout-checklist-our-suggestion">A rollout checklist (our suggestion)</h2>
<ol>
<li>Sign only release images from a protected workflow, by digest.</li>
<li>Give the signing job only the permissions it needs: <code>id-token: write</code>, plus whatever the registry push requires.</li>
<li>Sign a test image, inspect the certificate, and record the exact identity and issuer to pin.</li>
<li>Verify wherever the image is deployed, with exact identity and issuer flags, and fail closed.</li>
<li>Pin and update cosign deliberately on signing and verifying hosts; subscribe to the project&rsquo;s security advisories.</li>
<li>If you also use blob signatures, confirm none depend on legacy JSON bundles on affected versions.</li>
<li>Remember what signing does not cover: see our <a href="/posts/sbom-minimum-elements-2026-what-cisa-and-partners-changed-from-the-2021-ntia-baseline/">SBOM minimum-elements</a> article for the inventory side.</li>
</ol>
<h2 id="limits-of-this-article">Limits of this article</h2>
<p>We did not run cosign, sign or verify anything, or test any registry. The cosign command reference we cite is the <code>main</code> branch of the project&rsquo;s repository, which may differ from the version you run; the Sigstore signing page we read did not discuss differences between cosign v2 and v3. We did not confirm the exact certificate-identity format for GitHub Actions jobs, did not review the Sigstore Public Good Instance&rsquo;s operational policies or Kubernetes admission tooling, and did not independently re-score the advisory&rsquo;s CVSS vector.</p>
<h2 id="sources-and-verification">Sources and verification</h2>
<p>Checked on October 13, 2026.</p>
<table>
  <thead>
      <tr>
          <th>Important claim</th>
          <th>Source</th>
          <th>Verification</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>Keyless signing associates identities rather than keys; ephemeral key destroyed; Fulcio issues short-lived certificates; Rekor logs signing; <code>--identity-token</code> audience must contain <code>sigstore</code></td>
          <td><a href="https://docs.sigstore.dev/cosign/signing/overview/">Sigstore, cosign signing overview</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td><code>cosign sign &lt;image&gt;</code> (keyless) and <code>--key</code> signing; signatures use the OCI 1.1 referrer specification; <code>cosign tree</code></td>
          <td><a href="https://docs.sigstore.dev/cosign/signing/signing_with_containers/">Sigstore, signing containers</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Workflow needs <code>id-token: write</code>; example signs <code>tag@digest</code> with <code>cosign sign --yes</code>; <code>cosign-release</code> pinning; installer example version v4.1.0</td>
          <td><a href="https://github.com/sigstore/cosign-installer">sigstore/cosign-installer README</a></td>
          <td>Verified: example versions may change</td>
      </tr>
      <tr>
          <td>Without <code>id-token: write</code> the OIDC token cannot be requested; GitHub issuer URL</td>
          <td><a href="https://docs.github.com/en/actions/reference/security/oidc">GitHub Docs, OIDC reference</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Keyless verification requires <code>--certificate-identity</code> or its regexp form and <code>--certificate-oidc-issuer</code> or its regexp form</td>
          <td><a href="https://github.com/sigstore/cosign/blob/main/doc/cosign_verify.md">cosign verify reference</a></td>
          <td>Qualified: <code>main</code> branch documentation</td>
      </tr>
      <tr>
          <td>Advisory GHSA-fx35-mq7g-6g98: published August 6, 2026; High, CVSS 7.4; no CVE; affected and patched versions; affected commands; OCI image verification not affected</td>
          <td><a href="https://github.com/sigstore/cosign/security/advisories/GHSA-fx35-mq7g-6g98">GitHub advisory</a></td>
          <td>Verified: score as published by the project</td>
      </tr>
      <tr>
          <td>v3.1.3 and v2.6.5 released August 6, 2026 with the fix; bundle-format default note</td>
          <td><a href="https://github.com/sigstore/cosign/releases">cosign releases</a></td>
          <td>Qualified: page shows month and day only; year inferred from asset timestamps</td>
      </tr>
      <tr>
          <td>Digest rationale, exact-vs-regexp advice, certificate-inspection procedure, rollout checklist</td>
          <td>Our analysis</td>
          <td>Qualified: editorial judgment, labelled as such</td>
      </tr>
  </tbody>
</table>
]]></content:encoded></item><item><title>VEX Explained: What a "Not Affected" Statement Means and How to Read One</title><link>https://firewallsync.com/posts/vex-explained-what-a-not-affected-statement-means-and-how-to-read-one/</link><guid>https://firewallsync.com/posts/vex-explained-what-a-not-affected-statement-means-and-how-to-read-one/</guid><pubDate>Tue, 13 Oct 2026 06:05:00 +0000</pubDate><dc:creator>FirewallSync Editorial</dc:creator><category>AppSec &amp; APIs</category><description>A VEX document is a supplier's signed-off claim about whether a specific product is affected by a specific vulnerability. Here is what the four statuses and five justifications mean in CISA's guidance, how OpenVEX and CSAF express them, and why a VEX claim is something to evaluate, not obey.</description><enclosure url="https://firewallsync.com/posts/vex-explained-what-a-not-affected-statement-means-and-how-to-read-one/cover_hu12796011277069913728.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/vex-explained-what-a-not-affected-statement-means-and-how-to-read-one/cover_hu12796011277069913728.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/vex-explained-what-a-not-affected-statement-means-and-how-to-read-one/cover_hu12796011277069913728.jpg" alt="A black magnifying glass, a black spiral notebook with a blank white card, a pencil and an eraser on a white desk" width="1200" height="630"></p><p><strong>VEX</strong>, short for Vulnerability Exploitability eXchange, is a way for a supplier (or another party) to say, in a structured document, whether a specific product is affected by a specific vulnerability. A VEX statement about a library you find in your scanner output answers the question the scanner cannot: &ldquo;this component is present, but can the flaw actually be reached?&rdquo; This article explains the vocabulary CISA defined, shows how two formats (OpenVEX and CSAF) express it, and sets out how to evaluate a &ldquo;not affected&rdquo; claim before you let it close a ticket.</p>
<p>We read CISA&rsquo;s June 2022 status-justification guidance, the OpenVEX specification, the CSAF 2.0 standard and parts of Trivy&rsquo;s documentation on October 13, 2026. We did not write or consume a VEX document in a live pipeline for this article, so it is research-based explanation, not hands-on testing.</p>
<h2 id="the-short-answer">The short answer</h2>
<ul>
<li>A VEX statement ties <strong>one product</strong> to <strong>one vulnerability</strong> and gives a <strong>status</strong>.</li>
<li>CISA&rsquo;s guidance says the status must be one of <strong>NOT AFFECTED, AFFECTED, FIXED or UNDER INVESTIGATION</strong>.</li>
<li>A NOT AFFECTED status can carry a <strong>justification</strong> from a fixed list of five, so a tool can act on it.</li>
<li>It is a claim by whoever wrote the document. CISA says the consumer &ldquo;may choose to accept it or not.&rdquo;</li>
</ul>
<h2 id="what-a-vex-document-must-contain">What a VEX document must contain</h2>
<p>CISA&rsquo;s guidance states that VEX documents must contain four things: VEX metadata, product details, vulnerability details and product status. CISA also published a separate &ldquo;Minimum Requirements for VEX&rdquo; document (the CISA page is dated April 21, 2023). We could not download that PDF (CISA&rsquo;s server returned &ldquo;Access Denied&rdquo; to our request), so we rely on the OpenVEX specification, which says it aims to meet those minimum requirements, and on the CISA status-justification guidance quoted above.</p>
<h2 id="the-four-statuses">The four statuses</h2>
<table>
  <thead>
      <tr>
          <th>Status (CISA name)</th>
          <th>Meaning</th>
          <th>OpenVEX value</th>
          <th>CSAF 2.0 field under <code>product_status</code></th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>NOT AFFECTED</td>
          <td>No remediation is required for this vulnerability in this product</td>
          <td><code>not_affected</code></td>
          <td><code>known_not_affected</code></td>
      </tr>
      <tr>
          <td>AFFECTED</td>
          <td>The product is affected; remediation or mitigation is recommended</td>
          <td><code>affected</code></td>
          <td><code>known_affected</code></td>
      </tr>
      <tr>
          <td>FIXED</td>
          <td>These product versions contain a fix</td>
          <td><code>fixed</code></td>
          <td><code>fixed</code></td>
      </tr>
      <tr>
          <td>UNDER INVESTIGATION</td>
          <td>Impact is not yet known</td>
          <td><code>under_investigation</code></td>
          <td><code>under_investigation</code></td>
      </tr>
  </tbody>
</table>
<p>Sources: <a href="https://www.cisa.gov/sites/default/files/2023-01/VEX_Status_Justification_Jun22.pdf">CISA, VEX Status Justifications (June 2022)</a>; <a href="https://github.com/openvex/spec/blob/main/OPENVEX-SPEC.md">OpenVEX specification</a>; <a href="https://docs.oasis-open.org/csaf/csaf/v2.0/os/csaf-v2.0-os.html">CSAF 2.0 standard</a>. The column pairing is our mapping of equivalent concepts; each source defines its own values. CSAF defines further categories (for example <code>first_affected</code> and <code>last_affected</code>) that have no direct CISA counterpart.</p>
<p>The OpenVEX specification uses a hypothetical timeline to show why the statuses exist. A vendor learns of a new CVE and publishes <code>under_investigation</code>; later it finds the product affected and publishes <code>affected</code> with mitigation advice; when it ships a patch it publishes <code>fixed</code>. Without that sequence, the spec notes, a scanner user &ldquo;will simply get a third party alert with no details on how the status is evolving,&rdquo; and the alert becomes a false positive once the product is patched.</p>
<h2 id="the-five-not-affected-justifications">The five &ldquo;not affected&rdquo; justifications</h2>
<p>A justification is the machine-readable reason behind a NOT AFFECTED claim. CISA lists five. The definitions below paraphrase CISA&rsquo;s June 2022 document; the examples in the last column are CISA&rsquo;s.</p>
<table>
  <thead>
      <tr>
          <th>Justification</th>
          <th>What the supplier is asserting</th>
          <th>CISA example</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>component_not_present</code></td>
          <td>The vulnerable component is not in the product</td>
          <td>A Python and Elixir product with no Java code cannot be affected by Log4j</td>
      </tr>
      <tr>
          <td><code>vulnerable_code_not_present</code></td>
          <td>The component is present, but the specific vulnerable code is not</td>
          <td>The compiler stripped the relevant function, or the vulnerable code was added in a later version than the one shipped</td>
      </tr>
      <tr>
          <td><code>vulnerable_code_not_in_execute_path</code></td>
          <td>The vulnerable code is present but can never run in this product</td>
          <td>An application that uses OpenSSL only for random-number generation is not exposed to Heartbleed, which was never called from that function</td>
      </tr>
      <tr>
          <td><code>vulnerable_code_cannot_be_controlled_by_adversary</code></td>
          <td>The code runs, but an attacker cannot influence it enough to trigger the flaw without another vulnerability</td>
          <td>A hard-coded variable denies user input to the vulnerable function</td>
      </tr>
      <tr>
          <td><code>inline_mitigations_already_exist</code></td>
          <td>Built-in protections that an attacker or user cannot bypass or disable prevent exploitation</td>
          <td>Input is sanitized further upstream within the product</td>
      </tr>
  </tbody>
</table>
<p>Two caveats from CISA&rsquo;s own text are easy to miss:</p>
<ol>
<li>For <code>vulnerable_code_not_in_execute_path</code>, CISA warns that &ldquo;a single path of execution should not be assumed since the attacker may be able to divert the path of execution.&rdquo;</li>
<li>For <code>inline_mitigations_already_exist</code>, CISA notes that mitigations are effective &ldquo;only in the scenario where the threat model of the software allows it,&rdquo; and a mitigation that works in one product may not in another. The OpenVEX specification adds that this justification &ldquo;could be difficult to prove conclusively.&rdquo;</li>
</ol>
<p>CISA also distinguishes the last two. With <code>vulnerable_code_cannot_be_controlled_by_adversary</code>, nothing the attacker does can reach the vulnerable code in a way that triggers it. With <code>inline_mitigations_already_exist</code>, the attacker can influence execution, but another control blocks the attack. Both, CISA says, &ldquo;rely on an expert analysis of the structure of the code.&rdquo;</p>
<h2 id="how-the-formats-express-it">How the formats express it</h2>
<h3 id="openvex">OpenVEX</h3>
<p>OpenVEX is a JSON format. Per its specification, a document requires <code>@context</code>, <code>@id</code>, <code>author</code>, <code>timestamp</code>, <code>version</code> and <code>statements</code>. Each statement needs a vulnerability, a status and at least one product (these can be inherited from the document in some cases, and the specification says a document with incomplete statements is not valid). For <code>not_affected</code>, the statement must include either a justification or an <code>impact_statement</code>, which is free text. The specification says free-text impact statements are &ldquo;highly discouraged for automated systems.&rdquo; For <code>affected</code>, it must include an <code>action_statement</code> describing how to remediate or mitigate.</p>
<p>A minimal not-affected statement looks like this. Everything below is an invented placeholder: the CVE number, the product identifier and the author are not real.</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></span><span style="display:flex;"><span>  <span style="color:#f92672">&#34;@context&#34;</span>: <span style="color:#e6db74">&#34;https://openvex.dev/ns/v0.2.0&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&#34;@id&#34;</span>: <span style="color:#e6db74">&#34;https://example.com/vex/2026-0001&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&#34;author&#34;</span>: <span style="color:#e6db74">&#34;Example Product Security Team&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&#34;timestamp&#34;</span>: <span style="color:#e6db74">&#34;2026-10-13T06:00:00Z&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&#34;version&#34;</span>: <span style="color:#ae81ff">1</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&#34;statements&#34;</span>: [
</span></span><span style="display:flex;"><span>    {
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">&#34;vulnerability&#34;</span>: { <span style="color:#f92672">&#34;name&#34;</span>: <span style="color:#e6db74">&#34;CVE-2026-00000&#34;</span> },
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">&#34;products&#34;</span>: [{ <span style="color:#f92672">&#34;@id&#34;</span>: <span style="color:#e6db74">&#34;pkg:oci/example-app@1.4.2&#34;</span> }],
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">&#34;status&#34;</span>: <span style="color:#e6db74">&#34;not_affected&#34;</span>,
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">&#34;justification&#34;</span>: <span style="color:#e6db74">&#34;vulnerable_code_not_in_execute_path&#34;</span>
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>  ]
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>The <code>version</code> field, the specification says, must be incremented when any content of the document changes, which is how a supplier moves from <code>under_investigation</code> to <code>fixed</code> over time.</p>
<h3 id="csaf-20">CSAF 2.0</h3>
<p>CSAF (Common Security Advisory Framework) is an OASIS Standard, approved November 18, 2022, with an errata release dated January 26, 2024 that changes only an aggregator schema. Its <strong>Profile 5: VEX</strong> requires a product tree, a list of vulnerabilities, and at least one of the <code>fixed</code>, <code>known_affected</code>, <code>known_not_affected</code> or <code>under_investigation</code> product-status lists. It also sets two content rules:</p>
<ul>
<li>For each product in <code>known_not_affected</code>, an impact statement must exist, either as a machine-readable <strong>flag</strong> or as a human-readable <code>impact</code> entry in <code>threats</code>.</li>
<li>For each product in <code>known_affected</code>, product-specific action information must be given in <code>remediations</code>; the categories <code>no_fix_planned</code> and <code>none_available</code> are permitted.</li>
</ul>
<p>CSAF&rsquo;s flag labels are the same five justification values as CISA&rsquo;s list.</p>
<h2 id="reading-a-vex-statement-critically">Reading a VEX statement critically</h2>
<p>A scanner that supports VEX can hide findings based on these documents. That is the point, and also the risk. These are our practical checks, not requirements from CISA, OpenVEX or OASIS:</p>
<ol>
<li><strong>Match the product exactly.</strong> Check that the product identifier and version in the statement are the ones you deploy, not a sibling image or a different build.</li>
<li><strong>Check who signed it.</strong> OpenVEX says the author&rsquo;s identity &ldquo;SHOULD be cryptographically associated with the signature of the VEX document.&rdquo; An unsigned file fetched from an arbitrary location is a weaker basis than a signed statement from the supplier.</li>
<li><strong>Prefer machine-readable justifications.</strong> A bare <code>not_affected</code> with free text gives your tooling, and a future auditor, little to evaluate.</li>
<li><strong>Weigh the justification type.</strong> <code>component_not_present</code> is something you can verify against your own SBOM. <code>inline_mitigations_already_exist</code> relies on the supplier&rsquo;s threat model, which is hard to check from outside.</li>
<li><strong>Treat known-exploited vulnerabilities with extra care.</strong> If a vulnerability is on CISA&rsquo;s Known Exploited Vulnerabilities list, a wrong &ldquo;not affected&rdquo; is expensive. Our article on <a href="/posts/cvss-vs-epss-vs-kev-which-signal-should-decide-what-you-patch-first/">CVSS, EPSS and KEV</a> covers how to use that signal.</li>
<li><strong>Keep the audit trail.</strong> Record which VEX document suppressed which finding, and re-evaluate when the document&rsquo;s version changes.</li>
</ol>
<p>CISA&rsquo;s guidance also notes that VEX statements cover <em>known</em> vulnerabilities and that attackers often chain flaws; new vulnerabilities may emerge that do affect a product. A &ldquo;not affected&rdquo; for one CVE says nothing about the next.</p>
<h2 id="using-vex-with-scanners">Using VEX with scanners</h2>
<p>Tool support varies. As one example, Trivy&rsquo;s documentation says VEX can be used &ldquo;to filter vulnerabilities based on their status,&rdquo; and shows the <code>--vex</code> option with four sources: a VEX repository, a local file, a VEX attestation stored in an OCI registry, or VEX files referenced in an SBOM. That page was marked &ldquo;EXPERIMENTAL&rdquo; when we read it and warned that the feature &ldquo;might change without preserving backwards compatibility.&rdquo; We did not test Trivy or any other scanner&rsquo;s VEX handling, and we did not check which formats each scanner accepts, so confirm support for your chosen format and version before relying on it.</p>
<h2 id="where-vex-fits">Where VEX fits</h2>
<ul>
<li><strong>With an SBOM:</strong> the SBOM lists components; VEX says which vulnerabilities in them matter. See our article on the <a href="/posts/sbom-minimum-elements-2026-what-cisa-and-partners-changed-from-the-2021-ntia-baseline/">2026 SBOM minimum elements</a>.</li>
<li><strong>With exploitation signals:</strong> VEX says whether a product is affected, not whether a flaw is being exploited. For that, check the <a href="/posts/cisa-kev-json-feed-what-each-field-means-and-how-to-match-it-against-a-scanner-export/">KEV feed</a> and <a href="/posts/cisa-vulnrichment-how-to-read-ssvc-values-in-a-cve-record-and-turn-them-into-a-patch-decision/">CISA&rsquo;s Vulnrichment SSVC values</a>.</li>
<li><strong>With provenance:</strong> signing and provenance tell you who built an artifact and how, not whether a given CVE affects it. See <a href="/posts/slsa-build-levels-and-provenance-attestations-what-they-prove-and-what-they-dont/">SLSA build levels and provenance attestations</a>.</li>
<li><strong>With image scanning:</strong> VEX is one way to reduce noise from scanners; see <a href="/posts/container-image-scanning-what-ci-pipelines-still-miss/">what container image scanning still misses</a>.</li>
</ul>
<h2 id="limits-of-this-article">Limits of this article</h2>
<p>We could not read CISA&rsquo;s &ldquo;Minimum Requirements for VEX&rdquo; PDF (access denied). The CISA status-justification document is from June 2022 and its own text says it is not exhaustive and that CISA may add justifications later; we did not look for later revisions. We did not review the CycloneDX VEX specification, or the details of any scanner&rsquo;s VEX support beyond the Trivy page above. The OpenVEX specification page is titled v0.2.0 but also contains an older revision-table entry using a different version number, so check the version your tools implement.</p>
<h2 id="sources-and-verification">Sources and verification</h2>
<p>Checked on October 13, 2026.</p>
<table>
  <thead>
      <tr>
          <th>Important claim</th>
          <th>Source</th>
          <th>Verification</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>VEX documents must contain metadata, product details, vulnerability details and product status; four statuses; five not-affected justifications; statements are the author&rsquo;s assertions the consumer may accept or not</td>
          <td><a href="https://www.cisa.gov/sites/default/files/2023-01/VEX_Status_Justification_Jun22.pdf">CISA, VEX Status Justifications, June 2022</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Definitions and examples for each justification; the caveats on execution path and inline mitigations</td>
          <td>Same document, sections 3.3 to 3.7</td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>CISA published &ldquo;Minimum Requirements for VEX,&rdquo; page dated April 21, 2023</td>
          <td><a href="https://www.cisa.gov/resources-tools/resources/minimum-requirements-vulnerability-exploitability-exchange-vex">CISA resource page</a></td>
          <td>Qualified: PDF itself could not be downloaded</td>
      </tr>
      <tr>
          <td>OpenVEX required fields; justification or impact statement required for <code>not_affected</code>; free text discouraged for automation; <code>action_statement</code> for <code>affected</code>; author signature recommendation; version incrementing</td>
          <td><a href="https://github.com/openvex/spec/blob/main/OPENVEX-SPEC.md">OpenVEX specification</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>OpenVEX says it aims to meet CISA&rsquo;s April 2023 minimum requirements</td>
          <td>Same specification, overview</td>
          <td>Qualified: the OpenVEX project&rsquo;s own claim</td>
      </tr>
      <tr>
          <td>CSAF 2.0 is an OASIS Standard dated November 18, 2022; errata dated January 26, 2024</td>
          <td><a href="https://docs.oasis-open.org/csaf/csaf/v2.0/csaf-v2.0.html">CSAF 2.0 errata 01</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>CSAF Profile 5 requirements; <code>product_status</code> categories; flag labels</td>
          <td><a href="https://docs.oasis-open.org/csaf/csaf/v2.0/os/csaf-v2.0-os.html">CSAF 2.0 standard</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Trivy <code>--vex</code> options; page marked experimental</td>
          <td><a href="https://trivy.dev/latest/docs/supply-chain/vex/">Trivy VEX documentation</a></td>
          <td>Qualified: read October 13, 2026; may change</td>
      </tr>
      <tr>
          <td>Status mapping table; reading checklist</td>
          <td>Our analysis</td>
          <td>Qualified: editorial judgment, labelled as such</td>
      </tr>
  </tbody>
</table>
<h2 id="correction">Correction</h2>
<p><em>October 13, 2026:</em> An earlier version of this article said OpenVEX meets CISA&rsquo;s minimum requirements for VEX. The OpenVEX specification says it <em>aims to meet</em> them. The wording has been corrected in three places.</p>
]]></content:encoded></item><item><title>SLSA Build Levels and Provenance Attestations: What They Prove and What They Don't</title><link>https://firewallsync.com/posts/slsa-build-levels-and-provenance-attestations-what-they-prove-and-what-they-dont/</link><guid>https://firewallsync.com/posts/slsa-build-levels-and-provenance-attestations-what-they-prove-and-what-they-dont/</guid><pubDate>Mon, 12 Oct 2026 06:10:00 +0000</pubDate><dc:creator>FirewallSync Editorial</dc:creator><category>AppSec &amp; APIs</category><description>SLSA Build Level 1, 2 and 3 describe how trustworthy a build's provenance is, not whether the code is safe. Here is what each level promises, how Sigstore and GitHub artifact attestations fit in, and how to verify an attestation with the GitHub CLI.</description><enclosure url="https://firewallsync.com/posts/slsa-build-levels-and-provenance-attestations-what-they-prove-and-what-they-dont/cover_hu17136422527361664766.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/slsa-build-levels-and-provenance-attestations-what-they-prove-and-what-they-dont/cover_hu17136422527361664766.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/slsa-build-levels-and-provenance-attestations-what-they-prove-and-what-they-dont/cover_hu17136422527361664766.jpg" alt="Three cream envelopes, each closed with a bronze wax seal stamped with a tree design, on a white surface" width="1200" height="630"></p><p>SLSA, pronounced &ldquo;salsa&rdquo; and short for Supply-chain Levels for Software Artifacts, is a framework for describing how much you can trust the way a software artifact was built. A SLSA <strong>Build level</strong> (L1, L2 or L3) is a statement about the build platform and the <strong>provenance</strong> it produces: a signed record of what was built, from what inputs, by which builder. It is not a statement that the software is free of bugs or backdoors. This article explains what each level means, how Sigstore signing and GitHub artifact attestations produce provenance, and what a consumer has to check for any of it to matter.</p>
<p>We read the SLSA specification pages (v1.2 and the retired v1.1), the Sigstore overview, GitHub&rsquo;s attestation documentation and the GitHub CLI manual on October 12, 2026. We did not build or sign any artifacts for this article; it is research-based explanation, not hands-on testing.</p>
<h2 id="the-short-answer">The short answer</h2>
<ul>
<li><strong>Build L1:</strong> provenance exists. It records how the package was built, but the specification says it &ldquo;can be used to prevent mistakes but is trivial to bypass or forge.&rdquo;</li>
<li><strong>Build L2:</strong> the build runs on a hosted platform that generates and signs the provenance. This addresses tampering after the build. Forging the provenance requires an explicit attack, which the specification notes may still be easy.</li>
<li><strong>Build L3:</strong> the platform is hardened so that runs cannot influence one another and the signing secret is unreachable from user-defined build steps. This addresses tampering during the build.</li>
</ul>
<p>Source: <a href="https://slsa.dev/spec/v1.2/build-track-basics">SLSA v1.2, Build track basics</a>.</p>
<h2 id="what-provenance-contains">What &ldquo;provenance&rdquo; contains</h2>
<p>Provenance is a document (in SLSA&rsquo;s case an <em>attestation</em>, a signed statement about an artifact) linking an artifact&rsquo;s cryptographic digest to a description of how it was built. The SLSA provenance format uses the predicate type <code>https://slsa.dev/provenance/v1</code>. For Build L1, the specification requires the following fields:</p>
<table>
  <thead>
      <tr>
          <th>Field</th>
          <th>What it holds</th>
          <th>Notes from the specification</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>buildDefinition.buildType</code></td>
          <td>A URI naming the build template</td>
          <td>Should resolve to a human-readable specification</td>
      </tr>
      <tr>
          <td><code>buildDefinition.externalParameters</code></td>
          <td>Inputs the user controls</td>
          <td>Must be complete at L3; consumers should reject unexpected fields</td>
      </tr>
      <tr>
          <td><code>runDetails.builder.id</code></td>
          <td>A URI identifying the trusted build platform</td>
          <td>Intended to determine the SLSA Build level the consumer assigns</td>
      </tr>
  </tbody>
</table>
<p>Optional fields include <code>resolvedDependencies</code> (for example, the exact git commit a repository reference resolved to), <code>internalParameters</code> set by the platform, and run metadata such as start and finish times. These field requirements are from the v1.1 provenance page; that page is marked retired in favour of v1.2, and the v1.2 pages we read did not mention changes to the provenance format.</p>
<h2 id="why-the-levels-differ">Why the levels differ</h2>
<p>The levels are not about better paperwork. Each answers a different attacker.</p>
<table>
  <thead>
      <tr>
          <th>Level</th>
          <th>Who produces the provenance</th>
          <th>Main threat addressed</th>
          <th>What it does not stop</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>L1</td>
          <td>Build platform, possibly unsigned and incomplete</td>
          <td>Mistakes; missing documentation</td>
          <td>Anyone who simply edits or forges the record</td>
      </tr>
      <tr>
          <td>L2</td>
          <td>Hosted build platform, which signs it</td>
          <td>Tampering after the build</td>
          <td>A build run that is itself manipulated; a tenant who can reach the signing key</td>
      </tr>
      <tr>
          <td>L3</td>
          <td>Hardened hosted platform</td>
          <td>Tampering during the build, including by other tenants or insiders</td>
          <td>Malicious or vulnerable source; compromised dependencies</td>
      </tr>
  </tbody>
</table>
<p>Level descriptions are from the SLSA <a href="https://slsa.dev/spec/v1.2/build-track-basics">v1.2 build track basics</a> and <a href="https://slsa.dev/spec/v1.2/build-requirements">build requirements</a>. The &ldquo;does not stop&rdquo; column is our reading of what each level&rsquo;s requirements leave out; the specification itself defines the levels by what they require. The L3 requirements include that it &ldquo;MUST NOT be possible for one build to persist or influence the build environment of a subsequent build,&rdquo; and that provenance be &ldquo;strongly resistant to forgery by tenants.&rdquo;</p>
<h2 id="what-changed-in-slsa-v12">What changed in SLSA v1.2</h2>
<p>SLSA v1.0 removed source-code requirements to focus on the Build track. According to the v1.2 &ldquo;What&rsquo;s new&rdquo; page, v1.2 adds a <strong>Source track</strong> that helps organizations secure their source development process, updates the threat model, and reorganizes the specification to support multiple tracks. The page gives no release date. This article covers the Build track only; we did not review the Source track requirements. The v1.1 pages are marked &ldquo;Retired&rdquo; and point to v1.2 as current.</p>
<h2 id="how-sigstore-produces-the-signature">How Sigstore produces the signature</h2>
<p>Sigstore is an open project for signing and verifying software. In its keyless flow, according to the <a href="https://docs.sigstore.dev/about/overview/">Sigstore overview</a>:</p>
<ol>
<li><strong>Cosign</strong>, the client, generates a new key pair.</li>
<li>It sends the public key and an OpenID Connect (OIDC) identity token to <strong>Fulcio</strong>, the certificate authority.</li>
<li>Fulcio checks the token and issues a short-lived certificate binding the identity to the public key. (The page does not give a lifetime.)</li>
<li>Cosign signs the artifact, then discards the private key.</li>
<li>The artifact digest, signature and certificate are recorded in <strong>Rekor</strong>, an append-only transparency log.</li>
<li>A verifier checks the signature, confirms the certificate&rsquo;s identity is the one it expects, validates the certificate against Sigstore&rsquo;s root of trust, and verifies Rekor&rsquo;s proof of inclusion.</li>
</ol>
<p>For CI signing, the identity in the certificate can describe the workflow rather than a person. The practical point: no long-lived signing key exists to steal, but the signature is only meaningful if the verifier decides <em>which identity</em> is acceptable.</p>
<h2 id="github-artifact-attestations-and-the-slsa-level">GitHub artifact attestations and the SLSA level</h2>
<p>GitHub&rsquo;s <a href="https://docs.github.com/en/actions/concepts/security/artifact-attestations">documentation</a> says artifact attestations are signed claims about where and how software was built, including links to the workflow, repository, organization, environment, commit SHA and triggering event, and that they can include an SBOM. It states:</p>
<ul>
<li>Attestations alone provide <strong>SLSA v1.0 Build Level 2</strong>. Build Level 3 requires builds to run in a <strong>reusable workflow</strong> shared across repositories, which isolates the build from the calling workflow.</li>
<li>Public repositories use the Sigstore Public Good Instance, with the bundle written to a publicly readable transparency log. Private repositories use GitHub&rsquo;s own Sigstore instance, with no transparency log, federating only with GitHub Actions.</li>
<li>Attestations are not a guarantee that an artifact is secure; you still need to define and evaluate a policy.</li>
<li>Sign released software people will run or download, not frequent test builds or individual source files.</li>
</ul>
<p>Note the version: GitHub&rsquo;s page refers to SLSA v1.0 levels. We did not check whether GitHub has published a mapping to v1.2.</p>
<h2 id="verifying-the-step-most-teams-skip">Verifying: the step most teams skip</h2>
<p>Provenance nobody checks protects nobody. The GitHub CLI&rsquo;s <a href="https://cli.github.com/manual/gh_attestation_verify"><code>gh attestation verify</code></a> takes an artifact and requires at least one of <code>--owner</code> or <code>--repo</code>; the manual says that &ldquo;the more precisely you specify the actor&rsquo;s identity, the stronger the verification guarantees.&rdquo; It checks the actor identity against the certificate and the predicate type, which defaults to <code>https://slsa.dev/provenance/v1</code>.</p>
<pre tabindex="0"><code>gh attestation verify example.bin --repo github/example
gh attestation verify example.bin --owner github --signer-repo actions/example
</code></pre><p>(Both are examples from the manual; <code>github/example</code> is a placeholder.) Useful flags documented in the manual:</p>
<ul>
<li><code>--signer-workflow</code> or <code>--signer-repo</code>: needed when a reusable workflow produced the attestation.</li>
<li><code>--deny-self-hosted-runners</code>: fails verification for attestations generated on self-hosted runners.</li>
<li><code>--bundle</code>: verify offline from stored attestations.</li>
<li><code>--format json</code>: machine-readable output. The manual warns that only <code>signature.certificate</code> and <code>verifiedTimestamps</code> are tamper-resistant, and that <code>statement.predicate</code> can be falsified if an attacker controls the workflow, so policies should not rely on it alone.</li>
</ul>
<p>That last warning is worth sitting with. If an attacker controls the build workflow, the provenance they get signed is truthful about <em>which workflow ran</em>, not about the workflow being benign. This is why pinning the expected signer workflow matters more than reading the contents.</p>
<h2 id="what-provenance-does-not-prove">What provenance does not prove</h2>
<p>These are our conclusions from the framework&rsquo;s definitions, not claims the specification makes in these words:</p>
<ul>
<li><strong>That the source is trustworthy.</strong> Provenance links an artifact to a commit; it says nothing about whether the commit is malicious. Source controls are what the Source track is for.</li>
<li><strong>That dependencies are safe.</strong> Provenance records inputs; it does not vet them. See our guides to <a href="/posts/dependency-audits-without-slowing-down-releases/">dependency audits without slowing releases</a> and to what <a href="/posts/container-image-scanning-what-ci-pipelines-still-miss/">container image scanning still misses</a>.</li>
<li><strong>That the software has no known vulnerabilities.</strong> For that you need an inventory (<a href="/posts/sbom-minimum-elements-2026-what-cisa-and-partners-changed-from-the-2021-ntia-baseline/">SBOM</a>) and prioritization (<a href="/posts/cvss-vs-epss-vs-kev-which-signal-should-decide-what-you-patch-first/">CVSS, EPSS and KEV</a>).</li>
<li><strong>That the build platform itself is uncompromised.</strong> The level is only as good as the platform&rsquo;s isolation.</li>
</ul>
<h2 id="a-practical-adoption-order-our-suggestion">A practical adoption order (our suggestion)</h2>
<ol>
<li>Produce attestations for released artifacts only, on a hosted builder (this reaches L2 on GitHub per its documentation).</li>
<li>Write down the expected identity for each artifact: repository, and signer workflow if you use a reusable workflow.</li>
<li>Verify in the place where artifacts are consumed (deployment pipeline or admission step), failing closed on mismatch.</li>
<li>Move high-value artifacts to a reusable workflow to target L3, and test that your verification command pins that workflow.</li>
<li>Treat provenance as one control alongside SBOMs, dependency review and source protections.</li>
</ol>
<h2 id="limits-of-this-article">Limits of this article</h2>
<p>We did not run signing or verification ourselves. We did not read the SLSA Source track requirements, GitHub plan requirements, the Sigstore certificate lifetime, or any mapping of GitHub&rsquo;s attestations to SLSA v1.2. The SLSA v1.1 pages we used for the provenance fields are retired.</p>
<h2 id="sources-and-verification">Sources and verification</h2>
<p>Checked on October 12, 2026.</p>
<table>
  <thead>
      <tr>
          <th>Important claim</th>
          <th>Source</th>
          <th>Verification</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>Build L0 to L3 definitions, focus and quoted phrases</td>
          <td><a href="https://slsa.dev/spec/v1.2/build-track-basics">SLSA v1.2 Build track basics</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>L3 isolation and unforgeability requirements</td>
          <td><a href="https://slsa.dev/spec/v1.2/build-requirements">SLSA v1.2 Build requirements</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>v1.2 adds a Source track, updates the threat model; no date given</td>
          <td><a href="https://slsa.dev/spec/v1.2/whats-new">SLSA v1.2 What&rsquo;s new</a></td>
          <td>Qualified: page gives no release date</td>
      </tr>
      <tr>
          <td>Provenance predicate type and L1-required fields</td>
          <td><a href="https://slsa.dev/spec/v1.1/provenance">SLSA v1.1 Provenance</a></td>
          <td>Qualified: v1.1 page, marked retired; no format change noted in v1.2 pages</td>
      </tr>
      <tr>
          <td>Sigstore keyless flow and component roles</td>
          <td><a href="https://docs.sigstore.dev/about/overview/">Sigstore overview</a></td>
          <td>Verified; certificate lifetime not stated</td>
      </tr>
      <tr>
          <td>GitHub attestations: SLSA v1.0 Build L2 alone, L3 with reusable workflows; public vs private Sigstore instances</td>
          <td><a href="https://docs.github.com/en/actions/concepts/security/artifact-attestations">GitHub Docs, artifact attestations</a></td>
          <td>Qualified: refers to SLSA v1.0</td>
      </tr>
      <tr>
          <td><code>gh attestation verify</code> options and JSON caveat</td>
          <td><a href="https://cli.github.com/manual/gh_attestation_verify">GitHub CLI manual</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>What provenance does not prove; adoption order</td>
          <td>Our analysis</td>
          <td>Qualified: editorial judgment</td>
      </tr>
  </tbody>
</table>
]]></content:encoded></item><item><title>SBOM Minimum Elements 2026: 17 Fields and What Changed</title><link>https://firewallsync.com/posts/sbom-minimum-elements-2026-what-cisa-and-partners-changed-from-the-2021-ntia-baseline/</link><guid>https://firewallsync.com/posts/sbom-minimum-elements-2026-what-cisa-and-partners-changed-from-the-2021-ntia-baseline/</guid><pubDate>Sun, 11 Oct 2026 06:05:00 +0000</pubDate><dc:creator>FirewallSync Editorial</dc:creator><category>AppSec &amp; APIs</category><description>On July 29, 2026, CISA and international partners published updated minimum elements for a software bill of materials, replacing the 2021 NTIA document. Here is what changed in the data fields and practices, what did not, and what to ask your suppliers and your tooling for.</description><enclosure url="https://firewallsync.com/posts/sbom-minimum-elements-2026-what-cisa-and-partners-changed-from-the-2021-ntia-baseline/cover_hu17806621991921323946.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/sbom-minimum-elements-2026-what-cisa-and-partners-changed-from-the-2021-ntia-baseline/cover_hu17806621991921323946.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/sbom-minimum-elements-2026-what-cisa-and-partners-changed-from-the-2021-ntia-baseline/cover_hu17806621991921323946.jpg" alt="Tall stacks of wooden crates in a warehouse, with open crates of oranges in the foreground" width="1200" height="630"></p><p>A software bill of materials (SBOM) is, in the words of the guidance itself, &ldquo;a nested inventory, a list of ingredients that make up software applications and systems.&rdquo; On <strong>July 29, 2026</strong>, the U.S. Cybersecurity and Infrastructure Security Agency (CISA), the National Security Agency (NSA), the Federal Bureau of Investigation (FBI) and agencies from other countries published the <em>2026 Minimum Elements for a Software Bill of Materials</em>. It &ldquo;updates and replaces&rdquo; the <em>Minimum Elements For a Software Bill of Materials</em> that the U.S. National Telecommunications and Information Administration (NTIA) published on <strong>July 12, 2021</strong>. If you buy, build or operate software and you ask anyone for an SBOM, this is now the reference list of what to ask for.</p>
<p>This article is research-based: we read the full 2026 document, the 2021 NTIA document, and CISA&rsquo;s announcement. We did not generate SBOMs with any tool or check how specific tools map to these fields.</p>
<h2 id="what-this-document-is-and-what-it-is-not">What this document is, and what it is not</h2>
<ul>
<li><strong>Who published it:</strong> CISA with the NSA, the FBI and, according to the document&rsquo;s header, 15 further organizations from other countries (among them Australia, Canada, France, Germany, India, Italy, Japan, the Netherlands, New Zealand, Poland, South Korea, Slovakia and the Czech Republic). Its acknowledgements note that the European Commission&rsquo;s DG CONNECT contributed, but that the document does not interpret EU law and does not bind the Commission.</li>
<li><strong>Version history:</strong> version 1.0 was the NTIA document of July 12, 2021; version 2.0 was a public-comment draft of August 22, 2025; version 2.1, dated July 29, 2026, incorporates the comments received. CISA&rsquo;s announcement says more than 90 comments were received.</li>
<li><strong>Not a mandate:</strong> the document states the minimum elements &ldquo;do not create new requirements; they refine how organizations should generate and request SBOMs,&rdquo; and its disclaimer says it is not advice for compliance, regulatory or legal purposes. Do not read it as a law. Individual contracts or regulations may point to it, but that is separate.</li>
<li><strong>Scope:</strong> it applies to SBOMs for all software, including open source, AI software and software as a service (SaaS). It says AI systems and SaaS may need additional elements, which are out of scope. For AI it points to separate G7 joint guidance published in May 2026.</li>
</ul>
<h2 id="what-changed-in-the-data-fields">What changed in the data fields</h2>
<p>The 2021 document listed seven baseline data fields: Supplier Name, Component Name, Version of the Component, Other Unique Identifiers, Dependency Relationship, Author of SBOM Data and Timestamp. The 2026 document&rsquo;s Appendix A table lists <strong>17</strong> data fields, in two groups: SBOM Metadata (about the SBOM document) and Component Data (about each component).</p>
<p>CISA&rsquo;s announcement names four new elements: Component Hash Algorithm, Component License, SBOM Tool Name and SBOM Generation Context. The document itself is more complete. Its Notable Updates section lists <strong>ten</strong> new elements: SBOM Author Signature, SBOM Data Format Name, SBOM Data Format Version, SBOM Generation Context, SBOM Tool Name, SBOM Tool Version, SBOM Version, Component Hash Value, Component Hash Algorithm and Component License. We count ten from that list; the announcement&rsquo;s four are a subset, not a conflict.</p>
<table>
  <thead>
      <tr>
          <th>2026 data field</th>
          <th>Group</th>
          <th>Status vs 2021</th>
          <th>What it is (paraphrased from the document)</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>SBOM Author</td>
          <td>Metadata</td>
          <td>Major update (was Author of SBOM Data)</td>
          <td>Entity that created the SBOM data; the operator of the tool, not the tool</td>
      </tr>
      <tr>
          <td>SBOM Author Signature</td>
          <td>Metadata</td>
          <td>New</td>
          <td>Digital signature attributable to the author, to show the data was not modified</td>
      </tr>
      <tr>
          <td>SBOM Data Format Name / Version</td>
          <td>Metadata</td>
          <td>New</td>
          <td>Which format (and format version) the SBOM uses</td>
      </tr>
      <tr>
          <td>SBOM Generation Context</td>
          <td>Metadata</td>
          <td>New</td>
          <td>Lifecycle phase when generated, such as before build, build, or after build</td>
      </tr>
      <tr>
          <td>SBOM Timestamp</td>
          <td>Metadata</td>
          <td>Minor update</td>
          <td>Date and time of the most recent update; should follow RFC 9557</td>
      </tr>
      <tr>
          <td>SBOM Tool Name / Version</td>
          <td>Metadata</td>
          <td>New</td>
          <td>The tool that generated or amended the SBOM, and its version</td>
      </tr>
      <tr>
          <td>SBOM Version</td>
          <td>Metadata</td>
          <td>New</td>
          <td>Identifies a change from a previous version of the SBOM</td>
      </tr>
      <tr>
          <td>Component Producer</td>
          <td>Component</td>
          <td>Major update (was Supplier Name)</td>
          <td>Entity that created or developed the component; one organization per component</td>
      </tr>
      <tr>
          <td>Component Name</td>
          <td>Component</td>
          <td>Minor update</td>
          <td>Name assigned by the producer; multiple entries allowed for alternate names</td>
      </tr>
      <tr>
          <td>Component Version</td>
          <td>Component</td>
          <td>Major update</td>
          <td>Producer&rsquo;s identifier for the version; mark unknown if not provided</td>
      </tr>
      <tr>
          <td>Component Identifiers</td>
          <td>Component</td>
          <td>Major update (was Other Unique Identifiers)</td>
          <td>At least one common identifier, such as CPE or Package-URL (PURL)</td>
      </tr>
      <tr>
          <td>Component Dependency Relationship</td>
          <td>Component</td>
          <td>Minor update</td>
          <td>One component is necessary for the operation of another</td>
      </tr>
      <tr>
          <td>Component Hash Value / Algorithm</td>
          <td>Component</td>
          <td>New</td>
          <td>Hash of the executable component artifact and the algorithm used</td>
      </tr>
      <tr>
          <td>Component License</td>
          <td>Component</td>
          <td>New</td>
          <td>License identifiers, such as SPDX license identifiers</td>
      </tr>
  </tbody>
</table>
<p>A few details worth knowing:</p>
<ul>
<li><strong>Why &ldquo;Supplier&rdquo; became &ldquo;Component Producer&rdquo;:</strong> the document says Supplier Name &ldquo;has proven ambiguous in practice, particularly around distributors of software,&rdquo; and that some ambiguity will remain even with the new name.</li>
<li><strong>Hashes:</strong> the Component Hash Value is computed over the executable component artifact. If the SBOM author does not have access to it, the document says to indicate the value is unknown. The algorithm should be identified using IANA Hash Function Textual Names and be approved by a relevant authority such as NIST.</li>
<li><strong>Generation context matters:</strong> the document&rsquo;s example is that an SBOM generated from source code is &ldquo;before build,&rdquo; while one produced by binary analysis tools is &ldquo;after build.&rdquo; The same software can have different component data depending on when the SBOM is generated, so this field tells a reader how much to trust the data.</li>
<li><strong>Identifiers:</strong> a field may carry multiple identifiers; if there are several, the author should include all of them.</li>
</ul>
<h2 id="what-changed-in-practices-and-processes">What changed in practices and processes</h2>
<table>
  <thead>
      <tr>
          <th>Element</th>
          <th>2026 expectation (paraphrased)</th>
          <th>Change from 2021</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>Coverage</td>
          <td>Include all components, including transitive dependencies. &ldquo;There is no minimum depth.&rdquo; Duplicate instances with different metadata are listed separately.</td>
          <td>Replaces Depth, which was defined as top-level dependencies only</td>
      </tr>
      <tr>
          <td>Explicitly Identifying Unknown Information</td>
          <td>If a field is not provided, state whether it is unknown to the author or withheld. An SBOM may be considered incomplete if essential data is withheld.</td>
          <td>Replaces Known Unknowns</td>
      </tr>
      <tr>
          <td>Frequency</td>
          <td>Each software version or update should have an associated SBOM; issue a revised one when errors or new details are found</td>
          <td>Rewritten; intent unchanged per the document</td>
      </tr>
      <tr>
          <td>Distribution and Delivery</td>
          <td>Available promptly to those who need them; access controls must not block authorized parties or trusted security tools</td>
          <td>Simplified; absorbs the removed Access Control element</td>
      </tr>
      <tr>
          <td>Accommodation of Updates to SBOM Data</td>
          <td>Accommodate corrections; correct errors promptly; errors may feed risk decisions</td>
          <td>Replaces Accommodation of Mistakes</td>
      </tr>
      <tr>
          <td>Machine-Processable Data</td>
          <td>Use widely used, open, machine-processable formats; avoid accepting new-software SBOMs in deprecated format versions</td>
          <td>Replaces Automation Support; SWID tags dropped</td>
      </tr>
  </tbody>
</table>
<p>Coverage carries the biggest practical change. The document&rsquo;s own illustration: from a vulnerability management view, the recipient of an SBOM &ldquo;should be able to conclude that a newly reported vulnerability does not affect them if the SBOM does not list the component associated with the vulnerability.&rdquo; That only works if the SBOM is comprehensive, including transitive dependencies (dependencies of your dependencies). It also allows linking to separate SBOMs for subcomponents, provided the recipient has access to all of them.</p>
<h2 id="spdx-cyclonedx-and-the-format-question">SPDX, CycloneDX and the format question</h2>
<p>The document names two data formats as widely used: SPDX (System Package Data eXchange), cited with ISO/IEC 5962:2021, and CycloneDX, cited with ECMA-424, which it dates December 2025. It does not tell you to pick one. Producers choose &ldquo;based on factors that may be specific to organizations, industries, or sectors,&rdquo; while consumers &ldquo;should accept any widely used, interoperable, and machine-processable SBOM format.&rdquo;</p>
<p>For current version numbers, the CycloneDX specification overview showed version 1.7, released October 21, 2025, when we checked. The SPDX specifications page identified SPDX Document Version 3.0 as the current version; it shows no release dates for versions. We did not verify how each tool&rsquo;s output maps onto the 17 fields. When evaluating a generator, check whether its output actually includes, for example, hash values, license identifiers and generation context, rather than assuming it does.</p>
<h2 id="what-this-means-in-practice">What this means in practice</h2>
<p>These are our suggestions based on the guidance, not requirements in it:</p>
<ol>
<li><strong>Update the SBOM request language</strong> in vendor questionnaires. Instead of &ldquo;provide an SBOM,&rdquo; ask for one that satisfies the 2026 Minimum Elements, in a named format and version, with Coverage including transitive dependencies. See our <a href="/posts/vetting-third-party-saas-tools-before-they-touch-your-data/">guide to vetting third-party SaaS tools</a> for the wider vendor review.</li>
<li><strong>Check your generation tooling</strong> for the new metadata: tool name and version, generation context, timestamp, and a signature if you share SBOMs externally.</li>
<li><strong>Generate at more than one point</strong> if you can. Because components differ by lifecycle phase, a source-based SBOM and a post-build SBOM are not interchangeable.</li>
<li><strong>Pair SBOMs with vulnerability prioritization.</strong> An SBOM tells you whether you have a component; it does not tell you whether the flaw is exploitable in your product. The guidance points to VEX and CSAF for that; see <a href="/posts/vex-explained-what-a-not-affected-statement-means-and-how-to-read-one/">how to read a VEX not-affected statement</a>. Our comparison of <a href="/posts/cvss-vs-epss-vs-kev-which-signal-should-decide-what-you-patch-first/">CVSS, EPSS and KEV</a> covers prioritization, and <a href="/posts/dependency-audits-without-slowing-down-releases/">dependency audits without slowing releases</a> and <a href="/posts/container-image-scanning-what-ci-pipelines-still-miss/">container image scanning</a> cover where the component data comes from in CI.</li>
<li><strong>Treat unknowns as data.</strong> Mark fields you cannot fill as unknown rather than omitting them, as the guidance asks, and treat &ldquo;unknown&rdquo; in a vendor SBOM as a follow-up question, not a pass.</li>
</ol>
<h2 id="limits-of-this-article">Limits of this article</h2>
<p>We did not verify the claims of third-party summaries that count the changes differently; we counted from the document. We did not check whether the U.S. federal procurement rules, the EU Cyber Resilience Act or any other regime now references the 2026 document. The document itself only notes that the EU Cyber Resilience Act (Regulation (EU) 2024/2847) requires manufacturers of products with digital elements to provide an SBOM as part of technical documentation, and states that it does not interpret EU law. Check your own contractual and regulatory obligations separately.</p>
<h2 id="sources-and-verification">Sources and verification</h2>
<p>Checked on October 11, 2026.</p>
<table>
  <thead>
      <tr>
          <th>Important claim</th>
          <th>Source</th>
          <th>Verification</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>2026 Minimum Elements published July 29, 2026; version history 1.0 (July 12, 2021), 2.0 (August 22, 2025), 2.1 (July 29, 2026); updates and replaces NTIA 2021</td>
          <td><a href="https://www.cisa.gov/sites/default/files/2026-07/2026_cisa_sbom_minimum_elements_508c.pdf">CISA, 2026 Minimum Elements for a SBOM (PDF)</a> and <a href="https://www.cisa.gov/resources-tools/resources/2026-minimum-elements-software-bill-materials-sbom">CISA resource page</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>17 data fields in Appendix A; ten elements listed as new; definitions; Access Control removed; SWID removed; Depth replaced by Coverage; unknown-information rules; no new requirements; not compliance advice</td>
          <td>Same PDF</td>
          <td>Verified: counts are our own from the document&rsquo;s tables and lists</td>
      </tr>
      <tr>
          <td>CISA announcement names four new elements and says 90+ comments were received</td>
          <td><a href="https://www.cisa.gov/news-events/news/cisa-and-partners-unveil-updated-software-bill-materials-resource-improves-transparency-security-and">CISA announcement, July 29, 2026</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>2021 baseline had seven data fields; published July 12, 2021</td>
          <td><a href="https://www.ntia.gov/files/ntia/publications/sbom_minimum_elements_report.pdf">NTIA, The Minimum Elements For a Software Bill of Materials (PDF)</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>CycloneDX 1.7 released October 21, 2025; developed with Ecma International as ECMA-424</td>
          <td><a href="https://cyclonedx.org/specification/overview/">CycloneDX specification overview</a></td>
          <td>Qualified: current as of the date we read it</td>
      </tr>
      <tr>
          <td>SPDX specifications page identifies 3.0 as the current document version and links ISO/IEC 5962:2021</td>
          <td><a href="https://spdx.dev/use/specifications/">SPDX specifications</a></td>
          <td>Qualified: page shows no release dates for versions</td>
      </tr>
      <tr>
          <td>Practical recommendations in &ldquo;What this means in practice&rdquo;</td>
          <td>Our analysis of the above</td>
          <td>Qualified: editorial judgment, not requirements of the guidance</td>
      </tr>
  </tbody>
</table>
]]></content:encoded></item><item><title>Dependency Audits Without Slowing Down Releases</title><link>https://firewallsync.com/posts/dependency-audits-without-slowing-down-releases/</link><guid>https://firewallsync.com/posts/dependency-audits-without-slowing-down-releases/</guid><pubDate>Tue, 29 Sep 2026 09:00:00 +0000</pubDate><dc:creator>FirewallSync Editorial</dc:creator><category>AppSec &amp; APIs</category><description>Most supply-chain security advice assumes you can afford to review every dependency by hand. Here's a tiered approach that scales with a normal release cadence.</description><enclosure url="https://firewallsync.com/posts/dependency-audits-without-slowing-down-releases/cover_hu13734281080967451350.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/dependency-audits-without-slowing-down-releases/cover_hu13734281080967451350.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/dependency-audits-without-slowing-down-releases/cover_hu13734281080967451350.jpg" alt="Lines of code on a dark screen" width="1200" height="630"></p><p>The standard advice on software supply chain security — review every new dependency before it merges — assumes a review capacity most teams don&rsquo;t have. Applied literally, it either gets ignored under deadline pressure or becomes a bottleneck that developers route around by vendoring code instead of adding a package. Neither outcome improves security.</p>
<h2 id="tier-dependencies-by-blast-radius-not-by-novelty">Tier dependencies by blast radius, not by novelty</h2>
<p>Not every dependency deserves the same scrutiny. A left-pad-style utility with no filesystem or network access carries a different risk profile than a package that touches auth tokens, makes outbound requests, or runs a postinstall script. Build a simple tiering rule — anything with install scripts, network access, or crypto/auth involvement gets manual review; everything else gets automated scanning only — and most of your review capacity goes where it actually matters.</p>
<h2 id="automate-the-boring-80">Automate the boring 80%</h2>
<p>Automated tooling (SCA scanners, lockfile diffing, typosquat detection) should catch known-bad packages, suspicious version jumps, and newly-added transitive dependencies without a human in the loop. Wire this into CI as a blocking check for the high-risk tier only — for everything else, let it flag and log rather than block, so it doesn&rsquo;t become the thing engineers learn to bypass.</p>
<h2 id="audit-on-update-not-just-on-add">Audit on update, not just on add</h2>
<p>Most supply-chain incidents involve a package that was fine when it was added and got compromised later — through a maintainer account takeover or a malicious version bump. A one-time review at add-time misses this entirely. Add a lightweight second check specifically for version bumps in your high-risk tier: does the diff match what the changelog claims, and did maintainership change hands recently? This catches the incident pattern that&rsquo;s actually been showing up in real breach reports, which add-time review structurally can&rsquo;t.</p>
]]></content:encoded></item></channel></rss>