<?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>Sigstore | FirewallSync</title><link>https://firewallsync.com/tags/sigstore/</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, 12 Nov 2026 04:40:00 +0000</lastBuildDate><atom:link href="https://firewallsync.com/tags/sigstore/index.xml" rel="self" type="application/rss+xml"/><item><title>vexctl: Create, Add, Merge and Attest OpenVEX Documents</title><link>https://firewallsync.com/posts/vexctl-create-add-merge-attest-openvex-documents/</link><guid>https://firewallsync.com/posts/vexctl-create-add-merge-attest-openvex-documents/</guid><pubDate>Thu, 12 Nov 2026 04:40:00 +0000</pubDate><dc:creator>Craig Leslie</dc:creator><category>AppSec &amp; APIs</category><description>A source-checked guide to vexctl v0.4.4: the create, add, merge and attest commands, the validation rules they enforce, why merge keeps every statement instead of resolving them, and the defaults that quietly produce weak VEX documents.</description><enclosure url="https://firewallsync.com/posts/vexctl-create-add-merge-attest-openvex-documents/cover_hu12264946083305802858.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/vexctl-create-add-merge-attest-openvex-documents/cover_hu12264946083305802858.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/vexctl-create-add-merge-attest-openvex-documents/cover_hu12264946083305802858.jpg" alt="Tall stacks of paper documents and green and brown file folders with yellow-edged pages on an office desk under ceiling lights" width="1200" height="630"></p><p><code>vexctl</code> is the OpenVEX project&rsquo;s own tool for writing VEX (Vulnerability Exploitability eXchange) documents: <code>create</code> starts a document, <code>add</code> appends a statement and bumps the version, <code>merge</code> combines documents into one timeline, and <code>attest</code> wraps a document in an in-toto attestation you can sign and attach to an image. The commands are short. The defaults behind them are where weak VEX comes from: an anonymous author, a placeholder action statement, and a merge that resolves nothing.</p>
<p>This guide reads the <a href="https://github.com/openvex/vexctl/tree/v0.4.4">vexctl v0.4.4 source</a> (the newest tag on November 12, 2026, committed June 16, 2026) and the <a href="https://github.com/openvex/go-vex/tree/v0.2.8">go-vex v0.2.8</a> library it builds on. It fills the gap left by our <a href="/posts/trivy-vex-oci-openvex-attestations-cosign-attest/">Trivy <code>--vex oci</code> guide</a>: Trivy consumes VEX but does not write it. If you need the basics of what a statement asserts, start with <a href="/posts/vex-explained-what-a-not-affected-statement-means-and-how-to-read-one/">what a not_affected statement means</a>.</p>
<h2 id="install-and-version-check">Install and version check</h2>
<p>The <a href="https://github.com/openvex/vexctl/blob/v0.4.4/README.md">README</a> gives two install routes:</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>go install github.com/openvex/vexctl@latest   <span style="color:#75715e"># or pin: @v0.4.4</span>
</span></span><span style="display:flex;"><span>brew install vexctl
</span></span></code></pre></div><p>v0.4.4&rsquo;s <code>go.mod</code> requires Go 1.26.4, <code>github.com/openvex/go-vex v0.2.8</code> and <code>github.com/sigstore/cosign/v2 v2.6.3</code>. Pin the version in CI: the behaviour below is read from that tag, and a few help texts in it are out of step with the code (covered under merge).</p>
<h2 id="vexctl-create-one-statement-new-document">vexctl create: one statement, new document</h2>
<p><code>create</code> takes positional arguments or flags (<code>create [flags] [product_id [vuln_id [status]]]</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-bash" data-lang="bash"><span style="display:flex;"><span>vexctl create <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span><span style="color:#ae81ff"></span>  --author<span style="color:#f92672">=</span><span style="color:#e6db74">&#34;Example Corp PSIRT &lt;psirt@example.com&gt;&#34;</span> <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span><span style="color:#ae81ff"></span>  --product<span style="color:#f92672">=</span><span style="color:#e6db74">&#34;pkg:oci/api-gateway@sha256:&lt;digest&gt;?repository_url=registry.example.com/team&#34;</span> <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span><span style="color:#ae81ff"></span>  --vuln<span style="color:#f92672">=</span><span style="color:#e6db74">&#34;CVE-2026-12345&#34;</span> <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span><span style="color:#ae81ff"></span>  --status<span style="color:#f92672">=</span><span style="color:#e6db74">&#34;not_affected&#34;</span> <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span><span style="color:#ae81ff"></span>  --justification<span style="color:#f92672">=</span><span style="color:#e6db74">&#34;vulnerable_code_not_in_execute_path&#34;</span> <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span><span style="color:#ae81ff"></span>  --impact-statement<span style="color:#f92672">=</span><span style="color:#e6db74">&#34;The parser that contains the flaw is never loaded by this image.&#34;</span> <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span><span style="color:#ae81ff"></span>  --file<span style="color:#f92672">=</span>api-gateway.vex.json
</span></span></code></pre></div><p><em>Illustrative: the command and flag names are taken from the v0.4.4 source; we did not run the binary for this article.</em></p>
<p>The flags that shape the statement, from <code>internal/cmd/options.go</code>:</p>
<table>
  <thead>
      <tr>
          <th>Flag</th>
          <th>Short</th>
          <th>Default</th>
          <th>Notes</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>--product</code></td>
          <td><code>-p</code></td>
          <td>none</td>
          <td>Repeatable. At least one is required. A purl or other IRI.</td>
      </tr>
      <tr>
          <td><code>--vuln</code></td>
          <td><code>-v</code></td>
          <td>none</td>
          <td>Required.</td>
      </tr>
      <tr>
          <td><code>--status</code></td>
          <td><code>-s</code></td>
          <td>none</td>
          <td><code>not_affected</code>, <code>affected</code>, <code>fixed</code> or <code>under_investigation</code>.</td>
      </tr>
      <tr>
          <td><code>--justification</code></td>
          <td><code>-j</code></td>
          <td>none</td>
          <td>Only allowed with <code>not_affected</code>. <code>vexctl list</code> prints the valid labels.</td>
      </tr>
      <tr>
          <td><code>--impact-statement</code></td>
          <td></td>
          <td>none</td>
          <td>Only allowed with <code>not_affected</code>.</td>
      </tr>
      <tr>
          <td><code>--action-statement</code></td>
          <td><code>-a</code></td>
          <td><code>No action statement provided</code></td>
          <td>Only kept when status is <code>affected</code>.</td>
      </tr>
      <tr>
          <td><code>--status-note</code></td>
          <td></td>
          <td>none</td>
          <td>How the status was determined.</td>
      </tr>
      <tr>
          <td><code>--aliases</code></td>
          <td></td>
          <td>none</td>
          <td>Other IDs (GHSA, GO-&hellip;). Duplicates, or an alias equal to <code>--vuln</code>, are rejected.</td>
      </tr>
      <tr>
          <td><code>--subcomponents</code></td>
          <td></td>
          <td>none</td>
          <td>Rejected when more than one <code>--product</code> is given.</td>
      </tr>
      <tr>
          <td><code>--author</code></td>
          <td></td>
          <td><code>Unknown Author</code></td>
          <td>Document author.</td>
      </tr>
      <tr>
          <td><code>--author-role</code></td>
          <td></td>
          <td>empty</td>
          <td>Optional.</td>
      </tr>
      <tr>
          <td><code>--id</code></td>
          <td></td>
          <td>generated</td>
          <td>Generated from the document&rsquo;s canonical hash when omitted.</td>
      </tr>
      <tr>
          <td><code>--file</code></td>
          <td></td>
          <td>stdout</td>
          <td>Output path.</td>
      </tr>
  </tbody>
</table>
<p>Two validation layers apply. vexctl&rsquo;s own checks (above) run first; then go-vex&rsquo;s statement validator enforces the <a href="https://github.com/openvex/spec/blob/main/OPENVEX-SPEC.md">OpenVEX spec</a> rules: a <code>not_affected</code> statement needs a <code>justification</code> or an <code>impact_statement</code>, and an <code>affected</code> statement needs an <code>action_statement</code>. The spec words them as MUSTs: &ldquo;For statements conveying a <code>not_affected</code> status, a VEX statement MUST include either a status justification or an impact_statement&rdquo;, and &ldquo;For a statement with &lsquo;affected&rsquo; status, a VEX statement MUST include a statement that SHOULD describe actions to remediate or mitigate the vulnerability.&rdquo;</p>
<h3 id="two-defaults-to-override-every-time">Two defaults to override every time</h3>
<p><strong>The author.</strong> go-vex sets <code>DefaultAuthor = &quot;Unknown Author&quot;</code>, and vexctl&rsquo;s validator only rejects a <em>blank</em> author, so the placeholder passes. The spec says <code>author</code> &ldquo;MUST be an individual or organization&rdquo;. A consumer that weighs VEX by issuer cannot trust an anonymous statement, so pass <code>--author</code> on <code>create</code>, <code>add</code> and <code>merge</code>.</p>
<p><strong>The action statement.</strong> The <code>-a</code> flag defaults to <code>No action statement provided</code>. For an <code>affected</code> statement that default fills the required field, so the validator is satisfied and the document carries no remediation advice. Write the real action (upgrade target, configuration change, compensating control) every time.</p>
<h3 id="reproducible-timestamps">Reproducible timestamps</h3>
<p><code>create</code> and <code>add</code> honour <code>SOURCE_DATE_EPOCH</code>; the help text says it may be &ldquo;formatted in UNIX time or RFC3339&rdquo;. Set it in release pipelines so a rebuilt document gets the same timestamp and, with the default ID, the same <code>@id</code>. go-vex serializes statement timestamps in UTC.</p>
<h2 id="vexctl-add-append-and-bump-the-version">vexctl add: append and bump the version</h2>
<p>The spec says a document&rsquo;s <code>version</code> &ldquo;must be incremented when any content within the VEX document changes&rdquo;. <code>add</code> does that for you:</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>vexctl add --in-place api-gateway.vex.json <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span><span style="color:#ae81ff"></span>  <span style="color:#e6db74">&#34;pkg:oci/api-gateway@sha256:&lt;digest&gt;?repository_url=registry.example.com/team&#34;</span> <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span><span style="color:#ae81ff"></span>  CVE-2026-23456 under_investigation
</span></span></code></pre></div><p><em>Illustrative.</em> Per <code>internal/cmd/add.go</code>, <code>add</code>:</p>
<ul>
<li>reads the document from the first positional argument or <code>-d/--document</code>, and writes to stdout unless you pass <code>-i/--in-place</code> or <code>--file</code>;</li>
<li>copies the document&rsquo;s <code>last_updated</code> (or <code>timestamp</code>) into any statement that has no timestamp of its own, so those statements keep their inherited date once the document changes;</li>
<li>refuses the new statement if any existing statement&rsquo;s <code>timestamp</code> or <code>last_updated</code> is later than the new time (&ldquo;date cannot be older than other statements&rdquo;);</li>
<li>appends the statement, sets the document&rsquo;s <code>last_updated</code> and increments <code>version</code>.</li>
</ul>
<p>The time check matters with <code>SOURCE_DATE_EPOCH</code>: an epoch older than the newest statement makes <code>add</code> fail rather than write an out-of-order history.</p>
<h2 id="vexctl-merge-a-timeline-not-a-verdict">vexctl merge: a timeline, not a verdict</h2>
<p><code>merge</code> exists for the case the README describes, &ldquo;when more than one stakeholder is issuing VEX metadata about a piece of software&rdquo;:</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>vexctl merge --author<span style="color:#f92672">=</span><span style="color:#e6db74">&#34;Example Corp PSIRT&#34;</span> <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span><span style="color:#ae81ff"></span>  --product<span style="color:#f92672">=</span><span style="color:#e6db74">&#34;pkg:apk/wolfi/bash@1.0.0&#34;</span> <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span><span style="color:#ae81ff"></span>  examples/openvex/document1.vex.json examples/openvex/document2.vex.json &gt; merged.vex.json
</span></span></code></pre></div><p>What it does, from <code>Merge()</code> in <code>pkg/ctl/implementation.go</code>:</p>
<ol>
<li><strong>Filters, optionally.</strong> With <code>--product</code> and/or <code>--vuln</code>, only matching statements are kept. Product matching is go-vex&rsquo;s, which compares purls rather than plain strings.</li>
<li><strong>Fills timestamps.</strong> A statement without a timestamp takes its source document&rsquo;s timestamp. If both are missing, merge fails: &ldquo;unable to cascade timestamp from doc to timeless statement&rdquo;.</li>
<li><strong>Keeps everything.</strong> Every matching statement is copied. There is no deduplication and no conflict resolution.</li>
<li><strong>Sorts.</strong> Statements are sorted by vulnerability name (string order), then by timestamp, oldest first.</li>
<li><strong>Names the result deterministically.</strong> Without <code>--id</code>, the new <code>@id</code> is <code>merged-vex-</code> plus the SHA-256 of the input documents&rsquo; <code>@id</code> values, sorted and joined with <code>:</code>. A document with no <code>@id</code> contributes <code>VEX-DOC-&lt;position&gt;</code>.</li>
<li><strong>Starts a fresh document.</strong> Version 1, a new timestamp, and <code>Unknown Author</code> unless you pass <code>--author</code>.</li>
</ol>
<p>Who wins? Not merge. go-vex&rsquo;s <code>EffectiveStatement()</code> returns the <em>last</em> matching statement after the same sort, so the newest statement for a product and vulnerability is the current status. That is how the README explains a merged history of <code>under_investigation</code> followed by <code>fixed</code>: tools &ldquo;replay&rdquo; the statements in order.</p>
<p>We ported steps 1 to 5 to Python (product matching simplified to exact strings) and ran the port on the two example documents in the vexctl repository:</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>$ python3 -I merge_port.py document2.vex.json document1.vex.json
</span></span><span style="display:flex;"><span>merged-vex-6b33f63783819578804350ba1cde277ddd8f90aa2bbcb706d19a61d211a8443f
</span></span><span style="display:flex;"><span>2023-12-05T05:04:34.77929922Z CVE-1234-5678 under_investigation
</span></span><span style="display:flex;"><span>2023-12-05T05:06:38.099731287Z CVE-1234-5678 fixed
</span></span><span style="display:flex;"><span>effective: fixed
</span></span></code></pre></div><p>Passing the files in the other order produced the same <code>@id</code>, because the IDs are sorted before hashing. That is a property of the port matching the source; treat it as a reading aid, not a test of the vexctl binary.</p>
<h3 id="merge-pitfalls">Merge pitfalls</h3>
<ul>
<li><strong>Clock skew decides conflicts.</strong> Two issuers stating different statuses for the same product rely on their timestamps alone. A supplier&rsquo;s <code>not_affected</code> with a later clock beats your own <code>affected</code>. Merge per issuer, or review conflicts before publishing.</li>
<li><strong>Output is stdout only.</strong> <code>merge</code> registers no <code>--file</code> flag in v0.4.4; redirect the output.</li>
<li><strong>The flag is <code>--vuln</code>.</strong> The command&rsquo;s own help example shows <code>--vulnerability=CVE-2022-3294</code>, but the flag registered in v0.4.4 is <code>--vuln</code> (constant <code>vulnLongFlag = &quot;vuln&quot;</code>). Use <code>--vuln</code>.</li>
<li><strong>Merged documents grow.</strong> History is kept, so a long-lived merged file accumulates every status change. That is by design; prune by publishing a new document rather than editing statements in place.</li>
</ul>
<h2 id="vexctl-attest-wrap-sign-attach">vexctl attest: wrap, sign, attach</h2>
<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>vexctl attest api-gateway.vex.json                      <span style="color:#75715e"># unsigned in-toto statement to stdout</span>
</span></span><span style="display:flex;"><span>vexctl attest --sign api-gateway.vex.json               <span style="color:#75715e"># sign with the sigstore flow</span>
</span></span><span style="display:flex;"><span>vexctl attest --attach api-gateway.vex.json             <span style="color:#75715e"># sign and attach to each image subject</span>
</span></span><span style="display:flex;"><span>vexctl attest --attach api-gateway.vex.json registry.example.com/team/api-gateway@sha256:&lt;digest&gt;
</span></span></code></pre></div><p><em>Illustrative.</em> From <code>internal/cmd/attest.go</code> and <code>pkg/ctl/ctl.go</code>:</p>
<ul>
<li>The predicate is the OpenVEX document; go-vex sets the predicate type to <code>https://openvex.dev/ns/v0.2.0</code>.</li>
<li>Without positional image arguments, subjects come from the document&rsquo;s products. <code>pkg:oci</code> purls become image references (the help text&rsquo;s example: <code>pkg:oci/kube-apiserver?repository_url=registry.k8s.io&amp;tag=v1.26.0</code> becomes <code>registry.k8s.io/kube-apiserver:v1.26.0</code>), and references without a digest &ldquo;will trigger a network lookup to read the image digest from the registry&rdquo;.</li>
<li>Products that are neither oci purls nor image references are kept only if they carry <code>sha256</code> or <code>sha512</code> hashes. Otherwise they are skipped with a warning, or rejected with an error if you named them explicitly.</li>
<li><code>--attach</code> (<code>-a</code>) &ldquo;always implies &ndash;sign as sigstore does not support attaching unsigned attestations&rdquo;. <code>--refs</code> (<code>-r</code>) names the images to attach to when automatic attachment fails.</li>
</ul>
<p>If your scanner reads the attestation from the registry, check the predicate type it accepts. Our <a href="/posts/trivy-vex-oci-openvex-attestations-cosign-attest/">Trivy <code>--vex oci</code> guide</a> covers how Trivy matches OpenVEX predicate types and why you should verify the signature yourself before trusting what it finds.</p>
<h2 id="where-vexctl-fits-in-a-patch-decision-flow">Where vexctl fits in a patch-decision flow</h2>
<p>VEX is the last filter before a finding becomes work: a <code>not_affected</code> statement with a sound justification closes a scanner finding that KEV, EPSS or CVSS would otherwise push up the queue. Our <a href="/posts/vulnerability-prioritization-workflow-cve-record-to-patch-ticket/">vulnerability prioritization workflow</a> shows where that step sits between the CVE record and the ticket. Product IDs are where most VEX fails in practice, so check the matching rules in our <a href="/posts/openvex-products-subcomponents-purl-matching-trivy/">OpenVEX products and subcomponents guide</a> before you publish, and see the <a href="/posts/cyclonedx-vex-analysis-state-justification-openvex-csaf-mapping/">CycloneDX VEX mapping</a> if your consumers expect CycloneDX.</p>
<p>Two more commands exist and are out of scope here: <code>vexctl filter</code> applies VEX to SARIF results (the README says &ldquo;We support results files in SARIF for now&rdquo;), and <code>vexctl generate</code> builds documents from &ldquo;golden&rdquo; template files (default directory <code>.openvex/templates</code>).</p>
<h2 id="limits-of-this-article">Limits of this article</h2>
<ul>
<li>We read the v0.4.4 source and README; we did not run the vexctl binary. Commands are marked illustrative. The merge output comes from a Python port of the merge and sort logic, not from vexctl.</li>
<li>Behaviour may change after v0.4.4. Re-check flags with <code>vexctl &lt;command&gt; --help</code> against the version you install.</li>
<li>vexctl writes OpenVEX only. CSAF and CycloneDX VEX producers follow their own formats.</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>v0.4.4 is the newest tag; dependency versions</td>
          <td><a href="https://github.com/openvex/vexctl/blob/v0.4.4/go.mod">vexctl v0.4.4 go.mod</a>, git tags</td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Flags, defaults and validation rules</td>
          <td><a href="https://github.com/openvex/vexctl/blob/v0.4.4/internal/cmd/options.go">internal/cmd/options.go</a>, <a href="https://github.com/openvex/go-vex/blob/v0.2.8/pkg/vex/vex.go">go-vex vex.go</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>add version bump and time checks</td>
          <td><a href="https://github.com/openvex/vexctl/blob/v0.4.4/internal/cmd/add.go">internal/cmd/add.go</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Merge filters, keeps, sorts and hashes IDs</td>
          <td><a href="https://github.com/openvex/vexctl/blob/v0.4.4/pkg/ctl/implementation.go">pkg/ctl/implementation.go</a>, <a href="https://github.com/openvex/go-vex/blob/v0.2.8/pkg/vex/statement.go">go-vex statement.go</a></td>
          <td>Verified (source); example run via Python port</td>
      </tr>
      <tr>
          <td>Latest statement is the effective one</td>
          <td><a href="https://github.com/openvex/go-vex/blob/v0.2.8/pkg/vex/vex.go">go-vex vex.go EffectiveStatement</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Attest predicate type and subject rules</td>
          <td><a href="https://github.com/openvex/vexctl/blob/v0.4.4/internal/cmd/attest.go">internal/cmd/attest.go</a>, <a href="https://github.com/openvex/vexctl/blob/v0.4.4/pkg/ctl/ctl.go">pkg/ctl/ctl.go</a>, <a href="https://github.com/openvex/go-vex/tree/v0.2.8/pkg/attestation">go-vex attestation</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Spec MUSTs for author, version, justification, action statement</td>
          <td><a href="https://github.com/openvex/spec/blob/main/OPENVEX-SPEC.md">OpenVEX specification</a></td>
          <td>Verified</td>
      </tr>
  </tbody>
</table>
]]></content:encoded></item><item><title>Trivy --vex oci: OpenVEX Attestations on OCI Images</title><link>https://firewallsync.com/posts/trivy-vex-oci-openvex-attestations-cosign-attest/</link><guid>https://firewallsync.com/posts/trivy-vex-oci-openvex-attestations-cosign-attest/</guid><pubDate>Wed, 11 Nov 2026 04:55:00 +0000</pubDate><dc:creator>John Marshall</dc:creator><category>Cloud Security</category><description>How Trivy's --vex oci finds an OpenVEX document attached to a container image: the three registry layouts it reads, the in-toto.io/predicate-type annotation, why it takes the first match, and the warning that matters most: Trivy does not verify the attestation's signature. Includes a verify-then-scan pattern with cosign verify-attestation.</description><enclosure url="https://firewallsync.com/posts/trivy-vex-oci-openvex-attestations-cosign-attest/cover_hu770723731423121864.jpg" type="image/jpeg" length="0"/><media:content url="https://firewallsync.com/posts/trivy-vex-oci-openvex-attestations-cosign-attest/cover_hu770723731423121864.jpg" medium="image" type="image/jpeg" width="1200" height="630"/><content:encoded><![CDATA[<p><img src="https://firewallsync.com/posts/trivy-vex-oci-openvex-attestations-cosign-attest/cover_hu770723731423121864.jpg" alt="Aerial view of a container terminal: rows of red, blue, orange and white shipping containers stacked between numbered lanes, with yellow gantry cranes on the right" width="1200" height="630"></p><p>A VEX (Vulnerability Exploitability eXchange) document is only useful if the scanner finds it. Trivy can pick one up from the registry: attach an OpenVEX document to an image with <code>cosign attest --type openvex</code>, scan with <code>trivy image --vex oci</code>, and findings you have declared <code>not_affected</code> drop out of the report.</p>
<p>The part that matters for anyone using this to gate a release: <strong>Trivy does not verify the attestation&rsquo;s signature.</strong> Its <a href="https://github.com/aquasecurity/trivy/blob/v0.76.2/docs/guide/supply-chain/vex/oci.md">documentation</a> says so in a warning box: &ldquo;Anyone able to push to the image&rsquo;s repository can attach a VEX attestation that suppresses findings, so use <code>--vex oci</code> only with registries you trust.&rdquo;</p>
<p>This article covers how discovery works in Trivy v0.76.2 (the current release on November 11, 2026), what cosign v3.1.4 writes, and a verify-then-scan pattern that closes the signature gap. It follows our <a href="/posts/openvex-products-subcomponents-purl-matching-trivy/">OpenVEX products and subcomponents guide</a>, which explains how Trivy matches statements to packages and explicitly left <code>--vex oci</code> out of scope.</p>
<h2 id="the-three-commands">The three commands</h2>
<p>From Trivy&rsquo;s VEX attestation page, the end-to-end flow is:</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"># 1. Write an OpenVEX document (by hand or with a tool such as vexctl)</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e"># 2. Attach it to the image as a signed in-toto attestation</span>
</span></span><span style="display:flex;"><span>cosign attest --predicate oci.openvex.json --type openvex &lt;IMAGE&gt;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e"># 3. Scan, letting Trivy discover the attestation</span>
</span></span><span style="display:flex;"><span>trivy image --vex oci &lt;IMAGE&gt;
</span></span><span style="display:flex;"><span>trivy image --vex oci --show-suppressed &lt;IMAGE&gt;   <span style="color:#75715e"># list what VEX filtered</span>
</span></span></code></pre></div><p>Trivy&rsquo;s page marks the feature <strong>EXPERIMENTAL</strong>: &ldquo;This feature might change without preserving backwards compatibility.&rdquo; It also notes the <code>cosign attest</code> command &ldquo;attaches the attestation only to the specified image tag. If needed, repeat the process for other tags and digests,&rdquo; and that the image you scan &ldquo;must be the same as the one to which you attached the VEX attestation.&rdquo;</p>
<h2 id="writing-the-openvex-document-for-an-image">Writing the OpenVEX document for an image</h2>
<p>The statement&rsquo;s product is the image itself, written as an <code>oci</code> package URL (purl). The <a href="https://github.com/package-url/purl-spec/blob/main/types/oci-definition.json">purl <code>oci</code> type definition</a> says the name is &ldquo;the last fragment of the repository name&rdquo;, the namespace is prohibited, and the version &ldquo;is the sha256:hex_encoded_lowercase_digest of the artifact&rdquo;. The registry location goes in the <code>repository_url</code> qualifier.</p>
<p>Trivy&rsquo;s documentation gives two forms:</p>
<table>
  <thead>
      <tr>
          <th>Product <code>@id</code></th>
          <th>Applies to</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>pkg:oci/trivy?repository_url=ghcr.io/aquasecurity/trivy</code></td>
          <td>All tags of that repository</td>
      </tr>
      <tr>
          <td><code>pkg:oci/trivy@sha256:5bd5…d159?repository_url=ghcr.io/aquasecurity/trivy</code></td>
          <td>One digest only</td>
      </tr>
      <tr>
          <td><code>…&amp;tag=0.50.0</code></td>
          <td><strong>Not supported</strong> in the product ID &ldquo;at the moment&rdquo;</td>
      </tr>
  </tbody>
</table>
<p>The vulnerable packages go in <code>subcomponents</code>, for example <code>pkg:apk/alpine/busybox</code>, optionally with version and qualifiers such as <code>arch</code> to narrow the statement. The matching rules (which qualifiers must match, what happens with no subcomponents) are in our <a href="/posts/openvex-products-subcomponents-purl-matching-trivy/">purl matching guide</a>.</p>
<p>A minimal document, which we validated against the <a href="https://github.com/openvex/spec/blob/main/openvex_json_schema.json">OpenVEX JSON schema</a> (Python 3.13, <code>jsonschema</code> 4.26.0):</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-11-1&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&#34;author&#34;</span>: <span style="color:#e6db74">&#34;Example Platform 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-11T05: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-2023-42363&#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/example/app&#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/busybox&#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;impact_statement&#34;</span>: <span style="color:#e6db74">&#34;The image never invokes busybox awk.&#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 repository, author and justification here are illustrative. What a <code>not_affected</code> status and its justification commit you to is covered in <a href="/posts/vex-explained-what-a-not-affected-statement-means-and-how-to-read-one/">VEX explained</a>.</p>
<h2 id="what-cosign-writes-to-the-registry">What cosign writes to the registry</h2>
<p>In the cosign v3.1.4 source, <code>--type openvex</code> maps to the predicate type <code>https://openvex.dev/ns</code> (<code>OpenVexNamespace</code> in <code>pkg/cosign/attestation</code>). Other accepted shorthands are <code>slsaprovenance</code>, <code>spdx</code>, <code>cyclonedx</code>, <code>vuln</code>, <code>link</code> and <code>custom</code>, or a full URI.</p>
<p>Where it lands depends on the cosign major version. Cosign&rsquo;s v3.0.0 changelog says v3 turns on by default &ldquo;the standardized bundle format&rdquo;, plus &ldquo;container signatures stored as an OCI Image 1.1 referring artifact&rdquo;. In v3.1.4 the <code>attest</code> flag <code>--new-bundle-format</code> defaults to <code>true</code> with the help text &ldquo;attach a Sigstore bundle using OCI referrers API&rdquo;. Cosign v2 instead stored attestations under a tag derived from the image digest.</p>
<table>
  <thead>
      <tr>
          <th>Writer</th>
          <th>Registry layout</th>
          <th>Artifact type Trivy matches</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>cosign v3 (default)</td>
          <td>OCI 1.1 referrer holding a Sigstore bundle</td>
          <td><code>application/vnd.dev.sigstore.bundle.v0.3+json</code></td>
      </tr>
      <tr>
          <td>Tools publishing a DSSE envelope as a referrer</td>
          <td>OCI 1.1 referrer</td>
          <td><code>application/vnd.dsse.envelope.v1+json</code></td>
      </tr>
      <tr>
          <td>Tools publishing a bare in-toto statement, &ldquo;such as Docker Scout&rdquo; (Trivy docs)</td>
          <td>OCI 1.1 referrer</td>
          <td><code>application/vnd.in-toto+json</code></td>
      </tr>
      <tr>
          <td>cosign v2 (default)</td>
          <td>Tag <code>sha256-&lt;hex&gt;.att</code>, one layer per <code>cosign attest</code> call</td>
          <td>n/a (legacy tag)</td>
      </tr>
  </tbody>
</table>
<p>The artifact type strings are the constants in Trivy v0.76.2 <code>pkg/oci/artifact.go</code>.</p>
<h2 id="how-trivy-discovers-the-vex-attestation">How Trivy discovers the VEX attestation</h2>
<p>We read Trivy v0.76.2&rsquo;s <code>pkg/vex/oci/oci.go</code> alongside the docs. The sequence:</p>
<ol>
<li><strong>Resolve the digest.</strong> Trivy builds an <code>oci</code> purl for the scanned image. If the purl has a version, that is the digest; otherwise it resolves the reference (tag) to a digest with a registry lookup.</li>
<li><strong>List referrers</strong> of that digest whose artifact type is one of the three in the table.</li>
<li><strong>Filter by annotation.</strong> All three artifact types are shared with SBOM and provenance attestations, so Trivy reads the optional <code>in-toto.io/predicate-type</code> annotation on each referrer descriptor. If any referrer is annotated as OpenVEX, only those are considered, &ldquo;even when none of them can be fetched or decoded&rdquo; (docs). Referrers annotated as something else are dropped without download. Unannotated referrers are downloaded and inspected only when nothing is annotated as OpenVEX.</li>
<li><strong>Take the first OpenVEX document.</strong> Trivy decodes candidates in registry order and returns the first one whose predicate is OpenVEX. A referrer it cannot download or decode is skipped with a warning.</li>
<li><strong>Fall back to the legacy tag</strong> <code>sha256-&lt;hex&gt;.att</code> if no referrer yielded a VEX document, again returning the first layer that decodes to OpenVEX.</li>
</ol>
<p>A predicate type counts as OpenVEX if it equals <code>https://openvex.dev/ns</code> or starts with <code>https://openvex.dev/ns/</code>, so both cosign&rsquo;s value and a versioned URI match.</p>
<p>Two limits are hard-coded as defences against a hostile registry: at most <strong>100</strong> attestations are processed per image (&ldquo;cosign caps the number of attestations per image at 100; mirror that&rdquo;, per the source comment), and each attestation is capped at <strong>20 MiB</strong> uncompressed. An oversized attestation fails the discovery instead of being skipped.</p>
<p>Version note: discovery from OCI 1.1 referrers was added in July 2026 (Trivy pull requests #10932 and #10986); the first release tag containing both commits is <strong>v0.73.0</strong>. Earlier Trivy releases read only the legacy <code>.att</code> tag, so they will not see attestations written by cosign v3 with default settings.</p>
<h2 id="what-this-means-in-practice">What this means in practice</h2>
<p><strong>Old VEX attestations are not merged, and the newest does not automatically win.</strong> Because step 4 returns the first match in registry order, attaching a corrected VEX document next to an older one does not guarantee Trivy uses the correction. The safest pattern is one VEX attestation per image digest, rebuilt and re-attached when statements change, or the verify-then-scan approach below where you choose the document.</p>
<p><strong>Tags drift; digests don&rsquo;t.</strong> A repository-wide product ID applies the statement to every tag, including images built after the analysis was done. Use the digest form when the justification depends on what is inside one build.</p>
<p><strong>The attestation is signed, but the scanner doesn&rsquo;t check it.</strong> Cosign signs the attestation and logs it in Rekor, but <code>--vex oci</code> reads the predicate without checking who signed it. In a registry where CI service accounts, contractors or a compromised token can push, that is a path to silently hide findings.</p>
<h2 id="verify-first-then-scan-with-a-local-file">Verify first, then scan with a local file</h2>
<p>Trivy also accepts a local VEX file (<code>--vex /path/to/vex.json</code>), and multiple <code>--vex</code> sources can be combined; the order you give them sets priority. That allows a pipeline to verify the attestation with cosign and hand Trivy only a document that passed.</p>
<p><code>cosign verify-attestation</code> takes <code>--type</code> (same shorthands as <code>attest</code>) and, for keyless signing, requires <code>--certificate-identity</code> (or <code>-regexp</code>) and <code>--certificate-oidc-issuer</code> (or <code>-regexp</code>), per the v3.1.4 command reference. Pinning those values is the same discipline as in our <a href="/posts/cosign-container-image-signing-keyless-signing-in-ci-and-why-verification-must-pin-an-identity/">cosign keyless signing guide</a>.</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>IMAGE<span style="color:#f92672">=</span>ghcr.io/example/app@sha256:...   <span style="color:#75715e"># scan and verify the same digest</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>cosign verify-attestation --type openvex <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span><span style="color:#ae81ff"></span>  --certificate-identity <span style="color:#e6db74">&#34;https://github.com/example/app/.github/workflows/release.yml@refs/heads/main&#34;</span> <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span><span style="color:#ae81ff"></span>  --certificate-oidc-issuer <span style="color:#e6db74">&#34;https://token.actions.githubusercontent.com&#34;</span> <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span><span style="color:#ae81ff"></span>  <span style="color:#e6db74">&#34;</span>$IMAGE<span style="color:#e6db74">&#34;</span> &gt; verified.jsonl
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>python3 extract_openvex.py &lt; verified.jsonl &gt; vex.json
</span></span><span style="display:flex;"><span>trivy image --vex vex.json --show-suppressed <span style="color:#e6db74">&#34;</span>$IMAGE<span style="color:#e6db74">&#34;</span>
</span></span></code></pre></div><p>The identity and issuer values are illustrative; use the workflow that actually produces your attestations. <code>extract_openvex.py</code> assumes the output format shown in the <a href="https://docs.sigstore.dev/cosign/verifying/attestation/">Sigstore attestation docs</a>, where each verified attestation is printed as JSON whose <code>payload</code> is a base64-encoded in-toto statement (<code>jq -r .payload | base64 -d</code>). Check that against the cosign version you run.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#75715e">#!/usr/bin/env python3</span>
</span></span><span style="display:flex;"><span><span style="color:#e6db74">&#34;&#34;&#34;Read `cosign verify-attestation` output on stdin (one JSON object per line,
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">each a DSSE envelope with a base64 `payload`), keep in-toto statements whose
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">predicateType is OpenVEX, and write the predicate to stdout.&#34;&#34;&#34;</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> base64<span style="color:#f92672">,</span> json<span style="color:#f92672">,</span> sys
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>OPENVEX <span style="color:#f92672">=</span> <span style="color:#e6db74">&#34;https://openvex.dev/ns&#34;</span>
</span></span><span style="display:flex;"><span>found <span style="color:#f92672">=</span> []
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">for</span> line <span style="color:#f92672">in</span> sys<span style="color:#f92672">.</span>stdin:
</span></span><span style="display:flex;"><span>    line <span style="color:#f92672">=</span> line<span style="color:#f92672">.</span>strip()
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">if</span> <span style="color:#f92672">not</span> line<span style="color:#f92672">.</span>startswith(<span style="color:#e6db74">&#34;{&#34;</span>):
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">continue</span>
</span></span><span style="display:flex;"><span>    env <span style="color:#f92672">=</span> json<span style="color:#f92672">.</span>loads(line)
</span></span><span style="display:flex;"><span>    stmt <span style="color:#f92672">=</span> json<span style="color:#f92672">.</span>loads(base64<span style="color:#f92672">.</span>b64decode(env[<span style="color:#e6db74">&#34;payload&#34;</span>]))
</span></span><span style="display:flex;"><span>    pt <span style="color:#f92672">=</span> stmt<span style="color:#f92672">.</span>get(<span style="color:#e6db74">&#34;predicateType&#34;</span>, <span style="color:#e6db74">&#34;&#34;</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">if</span> pt <span style="color:#f92672">==</span> OPENVEX <span style="color:#f92672">or</span> pt<span style="color:#f92672">.</span>startswith(OPENVEX <span style="color:#f92672">+</span> <span style="color:#e6db74">&#34;/&#34;</span>):
</span></span><span style="display:flex;"><span>        found<span style="color:#f92672">.</span>append(stmt[<span style="color:#e6db74">&#34;predicate&#34;</span>])
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">if</span> len(found) <span style="color:#f92672">!=</span> <span style="color:#ae81ff">1</span>:
</span></span><span style="display:flex;"><span>    sys<span style="color:#f92672">.</span>exit(<span style="color:#e6db74">f</span><span style="color:#e6db74">&#34;expected exactly 1 verified OpenVEX attestation, got </span><span style="color:#e6db74">{</span>len(found)<span style="color:#e6db74">}</span><span style="color:#e6db74">&#34;</span>)
</span></span><span style="display:flex;"><span>json<span style="color:#f92672">.</span>dump(found[<span style="color:#ae81ff">0</span>], sys<span style="color:#f92672">.</span>stdout, indent<span style="color:#f92672">=</span><span style="color:#ae81ff">2</span>)
</span></span></code></pre></div><p>We ran the script with Python 3.13 against a synthetic two-line input (an SBOM statement and an OpenVEX statement, built locally); it skipped the SBOM and wrote the VEX document. We did not run it against a live registry. Failing when there is not exactly one verified VEX attestation is deliberate: it surfaces the multiple-attestation ambiguity instead of guessing.</p>
<p>Where VEX fits in the wider patch decision (after KEV, EPSS and SSVC have told you what is urgent) is covered in our <a href="/posts/vulnerability-prioritization-workflow-cve-record-to-patch-ticket/">vulnerability prioritization workflow</a>.</p>
<h2 id="common-mistakes">Common mistakes</h2>
<ul>
<li><strong>Scanning a tag you didn&rsquo;t attest.</strong> The attestation is bound to a digest; a rebuilt <code>:latest</code> has a new digest and no VEX.</li>
<li><strong>Running an older Trivy against cosign v3 attestations.</strong> Before v0.73.0 Trivy did not read OCI 1.1 referrers.</li>
<li><strong>Using <code>&amp;tag=</code> in the product ID.</strong> Trivy does not support it; the statement won&rsquo;t apply.</li>
<li><strong>Treating <code>--vex oci</code> output as a signed decision.</strong> It is whatever was attached last by anyone with push rights, read in registry order.</li>
</ul>
<h2 id="limits-of-this-article">Limits of this article</h2>
<ul>
<li>Behaviour described is Trivy v0.76.2 and cosign v3.1.4, from their documentation and source. The Trivy feature is experimental and may change.</li>
<li>We did not run Trivy or cosign against a registry. The JSON document and the Python script were run locally as described; the shell commands are illustrative.</li>
<li>Registry support for the OCI 1.1 referrers API varies; check yours.</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><code>--vex oci</code> flow, three layouts, referrer precedence, annotation behaviour, tag not supported, experimental, signatures not verified</td>
          <td><a href="https://github.com/aquasecurity/trivy/blob/v0.76.2/docs/guide/supply-chain/vex/oci.md">Trivy docs: Discover VEX Attestation in OCI Registry</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>First match wins, 100-attestation and 20 MiB caps, digest resolution, OpenVEX predicate check</td>
          <td><a href="https://github.com/aquasecurity/trivy/blob/v0.76.2/pkg/vex/oci/oci.go">Trivy v0.76.2 <code>pkg/vex/oci/oci.go</code></a></td>
          <td>Verified (source reading)</td>
      </tr>
      <tr>
          <td>Artifact type strings</td>
          <td><a href="https://github.com/aquasecurity/trivy/blob/v0.76.2/pkg/oci/artifact.go">Trivy v0.76.2 <code>pkg/oci/artifact.go</code></a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Referrer discovery first released in v0.73.0</td>
          <td>Trivy git history, PRs <a href="https://github.com/aquasecurity/trivy/pull/10932">#10932</a> and <a href="https://github.com/aquasecurity/trivy/pull/10986">#10986</a></td>
          <td>Verified (git tag containment)</td>
      </tr>
      <tr>
          <td>Local file and multiple <code>--vex</code> sources, order sets priority</td>
          <td><a href="https://github.com/aquasecurity/trivy/blob/v0.76.2/docs/guide/supply-chain/vex/index.md">Trivy docs: VEX overview</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td><code>--type openvex</code> → <code>https://openvex.dev/ns</code>; <code>--new-bundle-format</code> default true</td>
          <td><a href="https://github.com/sigstore/cosign/tree/v3.1.4/cmd/cosign/cli/options">cosign v3.1.4 source</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td>Cosign v3 defaults to bundles and OCI 1.1 referrers</td>
          <td><a href="https://github.com/sigstore/cosign/blob/v3.1.4/CHANGELOG.md">cosign CHANGELOG, v3.0.0</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td><code>verify-attestation</code> flags</td>
          <td><a href="https://github.com/sigstore/cosign/blob/v3.1.4/doc/cosign_verify-attestation.md">cosign verify-attestation reference</a></td>
          <td>Verified</td>
      </tr>
      <tr>
          <td><code>verify-attestation</code> output shape</td>
          <td><a href="https://docs.sigstore.dev/cosign/verifying/attestation/">Sigstore docs: verifying attestations</a></td>
          <td>Qualified: docs example, not tested on v3.1.4</td>
      </tr>
      <tr>
          <td><code>oci</code> purl version is the digest</td>
          <td><a href="https://github.com/package-url/purl-spec/blob/main/types/oci-definition.json">purl-spec oci type definition</a></td>
          <td>Verified</td>
      </tr>
  </tbody>
</table>
]]></content:encoded></item></channel></rss>