<?xml version="1.0" encoding="UTF-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
    <title>bomwerk - Blog</title>
    <subtitle>SBOM and vulnerability evidence for the EU Cyber Resilience Act, taken from what your products ship, with every gap stated. Open source, runs on your own machines, no telemetry.</subtitle>
    <link rel="self" type="application/atom+xml" href="https://bomwerk.com/blog/atom.xml"/>
    <link rel="alternate" type="text/html" href="https://bomwerk.com/blog/"/>
    <generator uri="https://www.getzola.org/">Zola</generator>
    <updated>2026-11-12T00:00:00+00:00</updated>
    <id>https://bomwerk.com/blog/atom.xml</id>
    <entry xml:lang="en">
        <title>Your CI Clone Has No Submodules. Your SBOM Should Still Know Their Versions.</title>
        <published>2026-11-12T00:00:00+00:00</published>
        <updated>2026-11-12T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://bomwerk.com/blog/ci-clone-has-no-submodules/"/>
        <id>https://bomwerk.com/blog/ci-clone-has-no-submodules/</id>
        
        <content type="html" xml:base="https://bomwerk.com/blog/ci-clone-has-no-submodules/">&lt;p&gt;Say your product vendors OpenSSL, an RTOS or a vendor SDK as a git submodule. Your CI starts with &lt;code&gt;actions&#x2F;checkout&lt;&#x2F;code&gt;. By default, that action does not fetch submodules. The folder is there, and it is empty.&lt;&#x2F;p&gt;
&lt;p&gt;A scanner that looks at the files sees a folder name and nothing else. No version. A vulnerability database cannot answer a question about &quot;openssl, version unknown&quot;. (A CVE, short for Common Vulnerabilities and Exposures, is a public ID for one flaw, and each one comes with a list of affected versions.) The SBOM (Software Bill of Materials) your pipeline produces is the one you would hand to an auditor or a customer. It should not have blanks where the risky parts are.&lt;&#x2F;p&gt;
&lt;p&gt;But git does know the version. The superproject records which commit each submodule is pinned to, as a &quot;gitlink&quot; entry in &lt;code&gt;.git&#x2F;index&lt;&#x2F;code&gt;. It is the exact commit &lt;code&gt;git submodule update&lt;&#x2F;code&gt; would check out.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;what-bomwerk-does-with-it&quot;&gt;What bomwerk does with it&lt;&#x2F;h2&gt;
&lt;p&gt;&lt;code&gt;bomwerk scan&lt;&#x2F;code&gt; now reads that entry. It parses &lt;code&gt;.git&#x2F;index&lt;&#x2F;code&gt; as a file and never runs &lt;code&gt;git&lt;&#x2F;code&gt;. The submodule becomes &lt;code&gt;pkg:github&#x2F;openssl&#x2F;openssl@&amp;lt;commit&amp;gt;&lt;&#x2F;code&gt; at High confidence, the same as if you had checked it out.&lt;&#x2F;p&gt;
&lt;p&gt;We keep three golden fixtures of the same test tree, and CI compares every scan against them. This is what they say about OpenSSL:&lt;&#x2F;p&gt;
&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;Clone state&lt;&#x2F;th&gt;&lt;th&gt;openssl in the SBOM&lt;&#x2F;th&gt;&lt;th&gt;Confidence&lt;&#x2F;th&gt;&lt;th&gt;Exit code&lt;&#x2F;th&gt;&lt;&#x2F;tr&gt;&lt;&#x2F;thead&gt;&lt;tbody&gt;
&lt;tr&gt;&lt;td&gt;No usable &lt;code&gt;.git&lt;&#x2F;code&gt; (an exported tree)&lt;&#x2F;td&gt;&lt;td&gt;&lt;code&gt;pkg:github&#x2F;openssl&#x2F;openssl&lt;&#x2F;code&gt;&lt;&#x2F;td&gt;&lt;td&gt;Low&lt;&#x2F;td&gt;&lt;td&gt;1&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;Default CI clone, submodule never checked out&lt;&#x2F;td&gt;&lt;td&gt;&lt;code&gt;pkg:github&#x2F;openssl&#x2F;openssl@&amp;lt;commit&amp;gt;&lt;&#x2F;code&gt;&lt;&#x2F;td&gt;&lt;td&gt;High&lt;&#x2F;td&gt;&lt;td&gt;0&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;Submodule checked out&lt;&#x2F;td&gt;&lt;td&gt;&lt;code&gt;pkg:github&#x2F;openssl&#x2F;openssl@&amp;lt;commit&amp;gt;&lt;&#x2F;code&gt;&lt;&#x2F;td&gt;&lt;td&gt;High&lt;&#x2F;td&gt;&lt;td&gt;0&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;&#x2F;tbody&gt;&lt;&#x2F;table&gt;
&lt;p&gt;The commit in these fixtures is synthetic. The middle row is the new one. In that fixture, the number of components a vulnerability lookup can match goes from 6 to 7:&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;json&quot; class=&quot;language-json &quot;&gt;&lt;code class=&quot;language-json&quot; data-lang=&quot;json&quot;&gt;{
  &amp;quot;name&amp;quot;: &amp;quot;openssl&amp;quot;,
  &amp;quot;purl&amp;quot;: &amp;quot;pkg:github&amp;#x2F;openssl&amp;#x2F;openssl@fedcba9876543210fedcba9876543210fedcba98&amp;quot;,
  &amp;quot;version&amp;quot;: &amp;quot;fedcba9876543210fedcba9876543210fedcba98&amp;quot;,
  &amp;quot;evidence&amp;quot;: { &amp;quot;occurrences&amp;quot;: [ { &amp;quot;location&amp;quot;: &amp;quot;third_party&amp;#x2F;openssl&amp;quot; } ] }
}
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;The coverage file calls it &lt;code&gt;matched&lt;&#x2F;code&gt;, high confidence. That is an excerpt of the golden file, with the build identifiers left out.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;why-it-exits-0&quot;&gt;Why it exits 0&lt;&#x2F;h2&gt;
&lt;p&gt;A default CI clone is not a broken run. It is the normal shape of a CI run. So the note that a commit was read from the index, warning &lt;code&gt;BW-GIT-006&lt;&#x2F;code&gt;, is informational. It is still printed, written to the &lt;code&gt;--warnings&lt;&#x2F;code&gt; file and shown in the HTML report. It just never fails a build on its own. Most of our warning codes count toward exit code 1. This is the first that does not.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;safe-on-repositories-you-do-not-control&quot;&gt;Safe on repositories you do not control&lt;&#x2F;h2&gt;
&lt;p&gt;A scanner reads other people&#x27;s files, so the reader is strict:&lt;&#x2F;p&gt;
&lt;ul&gt;
&lt;li&gt;It reads index versions 2, 3 and 4, in SHA-1 and SHA-256 repositories.&lt;&#x2F;li&gt;
&lt;li&gt;It refuses a split index, a sparse index, an unknown version, a file over 128 MiB, or anything structurally inconsistent. It refuses the whole file with &lt;code&gt;BW-GIT-007&lt;&#x2F;code&gt; instead of half-reading it.&lt;&#x2F;li&gt;
&lt;li&gt;It has its own fuzz targets for both hash formats. PR builds fuzz for ten minutes, and a two-hour run goes every night.&lt;&#x2F;li&gt;
&lt;&#x2F;ul&gt;
&lt;p&gt;And if there is no usable index, nothing changes. The submodule stays unversioned and &lt;code&gt;BW-GIT-004&lt;&#x2F;code&gt; says so, as before. A checked-out &lt;code&gt;HEAD&lt;&#x2F;code&gt; still wins over the index.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;try-it-on-your-repository&quot;&gt;Try it on your repository&lt;&#x2F;h2&gt;
&lt;pre data-lang=&quot;sh&quot; class=&quot;language-sh &quot;&gt;&lt;code class=&quot;language-sh&quot; data-lang=&quot;sh&quot;&gt;git clone --depth 1 https:&amp;#x2F;&amp;#x2F;github.com&amp;#x2F;your-org&amp;#x2F;your-product.git
bomwerk scan your-product --warnings warnings.json
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;Look for &lt;code&gt;@&amp;lt;commit&amp;gt;&lt;&#x2F;code&gt; on each submodule in the SBOM, and for &lt;code&gt;BW-GIT-006&lt;&#x2F;code&gt; in &lt;code&gt;warnings.json&lt;&#x2F;code&gt;. The submodule&#x27;s own files are absent in this kind of clone. That only matters if you meant to scan inside them, and for that you check them out and pass &lt;code&gt;--include-submodule-contents&lt;&#x2F;code&gt;.&lt;&#x2F;p&gt;
&lt;p&gt;This is on &lt;code&gt;main&lt;&#x2F;code&gt; and ships with the next release.&lt;&#x2F;p&gt;
&lt;p&gt;Free repo scan: bomwerk.com&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>PHP2Shell Is Now Officially Exploited. Your First Hour as a Manufacturer.</title>
        <published>2026-11-05T00:00:00+00:00</published>
        <updated>2026-11-05T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://bomwerk.com/blog/php2shell-is-now-exploited/"/>
        <id>https://bomwerk.com/blog/php2shell-is-now-exploited/</id>
        
        <content type="html" xml:base="https://bomwerk.com/blog/php2shell-is-now-exploited/">&lt;p&gt;On 26 October, CISA (the US cybersecurity agency) added both PHP2Shell flaws to its KEV catalogue. KEV stands for Known Exploited Vulnerabilities. A week earlier, CISA had said it had not yet seen successful exploitation. Now it counts both as actively exploited.&lt;&#x2F;p&gt;
&lt;p&gt;If you read our first write-up on 22 October, this is the update.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;what-happened-in-order&quot;&gt;What happened, in order&lt;&#x2F;h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;17 Oct:&lt;&#x2F;strong&gt; AWS sees exploit attempts, before any public disclosure.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;21 Oct:&lt;&#x2F;strong&gt; PHP ships patches: 8.5.12, 8.4.27, 8.3.36 and 8.2.35.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;24 Oct:&lt;&#x2F;strong&gt; a researcher records 35 successful shell executions across three honeypots (decoy servers).&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;26 Oct:&lt;&#x2F;strong&gt; KEV listing. US federal agencies have until 29 October to patch.&lt;&#x2F;li&gt;
&lt;&#x2F;ul&gt;
&lt;p&gt;CVE-2026-109618 is a memory corruption bug in the PHP engine. CVE-2026-109619 is a stale request-state bug. A CVE (Common Vulnerabilities and Exposures) is a public ID for one flaw. Both score 9.2 on CVSS, a severity scale out of 10. An unauthenticated attacker can run code with crafted HTTP requests, and the vulnerable code goes back to PHP 5.4, from 2012. Delft University&#x27;s lab counted more than 50,000 exploit requests from over 600 IP addresses.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;why-a-manufacturer-cares&quot;&gt;Why a manufacturer cares&lt;&#x2F;h2&gt;
&lt;p&gt;Since 11 September, the EU Cyber Resilience Act (CRA) asks manufacturers for an early warning within 24 hours of learning that a vulnerability in their product is being actively exploited. KEV is one signal, not the legal trigger. Whether you must report is a call for you and your counsel.&lt;&#x2F;p&gt;
&lt;p&gt;What is certain: since 26 October, this one is documented as exploited. If PHP serves pages inside your gateway, appliance or device interface, one question has to be answerable in minutes. Which release ships which PHP?&lt;&#x2F;p&gt;
&lt;h2 id=&quot;the-first-hour&quot;&gt;The first hour&lt;&#x2F;h2&gt;
&lt;p&gt;The fixes map to branches:&lt;&#x2F;p&gt;
&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;Your branch&lt;&#x2F;th&gt;&lt;th&gt;Fixed in&lt;&#x2F;th&gt;&lt;&#x2F;tr&gt;&lt;&#x2F;thead&gt;&lt;tbody&gt;
&lt;tr&gt;&lt;td&gt;8.5&lt;&#x2F;td&gt;&lt;td&gt;8.5.12&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;8.4&lt;&#x2F;td&gt;&lt;td&gt;8.4.27&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;8.3&lt;&#x2F;td&gt;&lt;td&gt;8.3.36&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;8.2&lt;&#x2F;td&gt;&lt;td&gt;8.2.35&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;&#x2F;tbody&gt;&lt;&#x2F;table&gt;
&lt;p&gt;Look at how small the gap can be. A product on 8.2.34 is exactly one patch release from the fix, and 8.2.34 and 8.2.35 look the same to anyone who only knows &quot;PHP 8.2&quot;. Older branches need an upgrade or a vendor-supported fix. Check php.net for what exists for yours.&lt;&#x2F;p&gt;
&lt;p&gt;The work is four steps:&lt;&#x2F;p&gt;
&lt;ol&gt;
&lt;li&gt;List every product and release that contains PHP.&lt;&#x2F;li&gt;
&lt;li&gt;For each release, find the PHP and read its exact version.&lt;&#x2F;li&gt;
&lt;li&gt;Compare it with the table above.&lt;&#x2F;li&gt;
&lt;li&gt;Write down the decision and the date.&lt;&#x2F;li&gt;
&lt;&#x2F;ol&gt;
&lt;p&gt;For a release tree that carries PHP source, steps 1 and 2 are two commands:&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;sh&quot; class=&quot;language-sh &quot;&gt;&lt;code class=&quot;language-sh&quot; data-lang=&quot;sh&quot;&gt;bomwerk scan . -o sbom.cdx.json
jq -r &amp;#x27;.components[] | select(.name | test(&amp;quot;php&amp;quot;))
       | [.name, (.version &amp;#x2F;&amp;#x2F; &amp;quot;unknown&amp;quot;), .evidence.occurrences[0].location]
       | @tsv&amp;#x27; sbom.cdx.json

grep &amp;#x27;#define PHP_VERSION &amp;#x27; third_party&amp;#x2F;php-src&amp;#x2F;main&amp;#x2F;php_version.h
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;On a running device or container, &lt;code&gt;php -v&lt;&#x2F;code&gt; gives the same answer. Adjust the path to wherever your tree keeps the source.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;where-bomwerk-fits&quot;&gt;Where bomwerk fits&lt;&#x2F;h2&gt;
&lt;p&gt;The copy that gets missed is the vendored one: a PHP tree dropped into a repository for a web interface three years ago, with no manifest pointing at it. &lt;code&gt;bomwerk scan&lt;&#x2F;code&gt; walks a release tree and lists the vendored source it finds, PHP included, with its location. It writes one SBOM (Software Bill of Materials) per release in CycloneDX or SPDX, and the output is identical byte for byte on every run, so you can diff two releases. That turns &quot;which release ships PHP?&quot; into a lookup instead of an email thread.&lt;&#x2F;p&gt;
&lt;p&gt;Our paid extension, in preview, takes the next step: it registers what you shipped and drafts the CRA Article 14 report when a CVE lands.&lt;&#x2F;p&gt;
&lt;p&gt;PHP2Shell will not be the last one that asks this. The inventory is the part you build before the next listing, not after it.&lt;&#x2F;p&gt;
&lt;p&gt;Free repo scan: bomwerk.com&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>One Source Tree, Two Builds, Two Answers: What the 90-Second Video Shows</title>
        <published>2026-10-29T00:00:00+00:00</published>
        <updated>2026-10-29T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://bomwerk.com/blog/one-source-tree-two-builds-two-answers/"/>
        <id>https://bomwerk.com/blog/one-source-tree-two-builds-two-answers/</id>
        
        <content type="html" xml:base="https://bomwerk.com/blog/one-source-tree-two-builds-two-answers/">&lt;p&gt;On 27 October we published a short video of bomwerk 1.0.0-rc.2 running against nightmare, our open test repository. It lasts about a minute: https:&#x2F;&#x2F;youtu.be&#x2F;_T6Wko0zadw&lt;&#x2F;p&gt;
&lt;p&gt;This post explains the part that goes by fastest. What &lt;code&gt;observe&lt;&#x2F;code&gt; and &lt;code&gt;trim&lt;&#x2F;code&gt; do, and why the answer changes between two builds of the same files.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;the-problem-in-one-repository&quot;&gt;The problem in one repository&lt;&#x2F;h2&gt;
&lt;p&gt;Most SBOM (Software Bill of Materials) tools answer one question: what does this repository declare or contain? For a C project, that is everything in the tree. But a tree is not a product. A CMake preset can switch a library on or off, and two presets give two different binaries from identical files.&lt;&#x2F;p&gt;
&lt;p&gt;nightmare has two presets, &lt;code&gt;config-a&lt;&#x2F;code&gt; and &lt;code&gt;config-b&lt;&#x2F;code&gt;. It also vendors zlib 1.2.11, a version with known CVEs. (A CVE, short for Common Vulnerabilities and Exposures, is a public ID for one specific flaw.) So: does zlib 1.2.11 ship? That depends on the preset.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;how-it-asks-the-build&quot;&gt;How it asks the build&lt;&#x2F;h2&gt;
&lt;p&gt;&lt;code&gt;observe&lt;&#x2F;code&gt; wraps your build command and records what the compiler and linker touched. &lt;code&gt;trim&lt;&#x2F;code&gt; compares that record against an SBOM from &lt;code&gt;scan&lt;&#x2F;code&gt;. This is the sequence from the README:&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;sh&quot; class=&quot;language-sh &quot;&gt;&lt;code class=&quot;language-sh&quot; data-lang=&quot;sh&quot;&gt;bomwerk scan . -o sbom.cdx.json

bomwerk observe --trace config-a.jsonl -- cmake --preset config-a
bomwerk observe --trace config-a.jsonl -- cmake --build build&amp;#x2F;config-a
bomwerk trim sbom.cdx.json --trace config-a.jsonl --root . \
  -o sbom-trim-config-a.json
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;Repeat the last three commands with &lt;code&gt;config-b&lt;&#x2F;code&gt; and its own trace. Both the configure step and the build step run under &lt;code&gt;observe&lt;&#x2F;code&gt;, because configuring records which compiler the build will use.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;what-came-out&quot;&gt;What came out&lt;&#x2F;h2&gt;
&lt;p&gt;This is the committed result in nightmare&#x27;s &lt;code&gt;docs&#x2F;RESULTS.md&lt;&#x2F;code&gt;, generated with rc.2:&lt;&#x2F;p&gt;
&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;component&lt;&#x2F;th&gt;&lt;th&gt;config-a&lt;&#x2F;th&gt;&lt;th&gt;config-b&lt;&#x2F;th&gt;&lt;&#x2F;tr&gt;&lt;&#x2F;thead&gt;&lt;tbody&gt;
&lt;tr&gt;&lt;td&gt;cjson-prebuilt&lt;&#x2F;td&gt;&lt;td&gt;used (1 link input)&lt;&#x2F;td&gt;&lt;td&gt;UNUSED&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;freertos V11.1.0&lt;&#x2F;td&gt;&lt;td&gt;UNUSED&lt;&#x2F;td&gt;&lt;td&gt;used (1 source)&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;sqlite3 3.41.2&lt;&#x2F;td&gt;&lt;td&gt;used (1 link input)&lt;&#x2F;td&gt;&lt;td&gt;UNUSED&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;stb&lt;&#x2F;td&gt;&lt;td&gt;UNUSED&lt;&#x2F;td&gt;&lt;td&gt;UNUSED&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;uthash&lt;&#x2F;td&gt;&lt;td&gt;used (headers only)&lt;&#x2F;td&gt;&lt;td&gt;UNUSED&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;zlib 1.2.11&lt;&#x2F;td&gt;&lt;td&gt;used (10 sources)&lt;&#x2F;td&gt;&lt;td&gt;UNUSED&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;openssl&lt;&#x2F;td&gt;&lt;td&gt;UNUSED&lt;&#x2F;td&gt;&lt;td&gt;UNUSED&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;&#x2F;tbody&gt;&lt;&#x2F;table&gt;
&lt;p&gt;Seven components could be judged. Four are used in A and one in B. zlib is compiled from ten source files in A. In B, it sits in the tree and never reaches the binary.&lt;&#x2F;p&gt;
&lt;p&gt;So an advisory for zlib 1.2.11 is a real question for the A release. For B, the answer is that the build never compiled it. A static scan lists zlib in both and cannot tell them apart.&lt;&#x2F;p&gt;
&lt;p&gt;stb is in the tree and unused in both. OpenSSL is unused in both because building it is opt-in.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;what-this-does-not-tell-you&quot;&gt;What this does not tell you&lt;&#x2F;h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Used is not exploitable.&lt;&#x2F;strong&gt; &lt;code&gt;trim&lt;&#x2F;code&gt; says the code was compiled, linked or included. It does not say the vulnerable function can be reached.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;One synthetic repo.&lt;&#x2F;strong&gt; nightmare is built to be awkward, and I wrote its answer key by hand. On it, bomwerk finds 10 of 12 ground-truth components and over-reports 2.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;Declared-only components are skipped.&lt;&#x2F;strong&gt; Conan, vcpkg and npm entries have no place in the tree, so &lt;code&gt;trim&lt;&#x2F;code&gt; does not judge them.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;Toolchains.&lt;&#x2F;strong&gt; &lt;code&gt;observe&lt;&#x2F;code&gt; supports GCC and Clang on Linux and macOS today.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;Release state.&lt;&#x2F;strong&gt; rc.2 is a release candidate built from source. There are no prebuilt or signed binaries yet.&lt;&#x2F;li&gt;
&lt;&#x2F;ul&gt;
&lt;h2 id=&quot;why-a-manufacturer-cares&quot;&gt;Why a manufacturer cares&lt;&#x2F;h2&gt;
&lt;p&gt;Since 11 September 2026, the EU Cyber Resilience Act (CRA) asks manufacturers for an early warning within 24 hours once they learn that a vulnerability in their product is being actively exploited. The first thing you look up then is whether the component is in the release you shipped. If your SBOM lists only what each build used, that is a lookup. If it lists the whole tree, you start a discussion. Whether a given case needs a report is a legal call for you and your counsel.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;how-the-video-was-made&quot;&gt;How the video was made&lt;&#x2F;h2&gt;
&lt;p&gt;I did not want a demo you cannot check. The terminal is a real recording from a source build of the release candidate. The edit crops window chrome, cuts between shots, speeds up builds and holds a last frame. It never retypes or redraws terminal text. A small script types each command so there are no typos, but the output is whatever the binary printed. The narration is a synthetic voice. The video description lists what is not shown.&lt;&#x2F;p&gt;
&lt;p&gt;You can also skip the video. Clone nightmare and run &lt;code&gt;python3 tools&#x2F;compare_tools.py --bomwerk &#x2F;path&#x2F;to&#x2F;bomwerk --write&lt;&#x2F;code&gt;. It rebuilds the comparison from pinned tool versions.&lt;&#x2F;p&gt;
&lt;p&gt;Free repo scan: bomwerk.com&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>PHP2Shell Is a Version Question. Here&#x27;s What a Scan Answers Today, and What It Doesn&#x27;t.</title>
        <published>2026-10-22T00:00:00+00:00</published>
        <updated>2026-10-22T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://bomwerk.com/blog/php2shell-is-a-version-question/"/>
        <id>https://bomwerk.com/blog/php2shell-is-a-version-question/</id>
        
        <content type="html" xml:base="https://bomwerk.com/blog/php2shell-is-a-version-question/">&lt;p&gt;On 21 October the PHP project shipped fixes for two critical flaws, CVE-2026-109618 and CVE-2026-109619, now called PHP2Shell. Both score 9.2 on CVSS v4.0, according to &lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;socradar.io&#x2F;blog&#x2F;php2shell-cve-2026-109618-cve-2026-109619&#x2F;&quot;&gt;SOCRadar&#x27;s summary of the PHP security team&#x27;s rating&lt;&#x2F;a&gt;. They can let an unauthenticated attacker run code on a PHP server. The fixed releases are 8.5.12, 8.4.27, 8.3.36 and 8.2.35, with minimal source backports for 7.4, 8.0 and 8.1, per &lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;www.helpnetsecurity.com&#x2F;2026&#x2F;10&#x2F;21&#x2F;php2shell-php-vulnerabilities-patched-cve-2026-109618-cve-2026-109619&#x2F;&quot;&gt;Help Net Security&lt;&#x2F;a&gt;.&lt;&#x2F;p&gt;
&lt;p&gt;Amazon&#x27;s honeypot saw an exploitation attempt on 17 October, &lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;aws.amazon.com&#x2F;blogs&#x2F;security&#x2F;amazon-threat-intelligence-identifies-php2shell-exploitation-prior-to-public-disclosure-in-madpot&#x2F;&quot;&gt;four days before disclosure&lt;&#x2F;a&gt;, and Amazon now calls it broadly exploited. Other vendors are more cautious about how many public exploits actually work. Either way, nobody serious is waiting.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;why-this-lands-on-product-teams&quot;&gt;Why this lands on product teams&lt;&#x2F;h2&gt;
&lt;p&gt;Most coverage tells web admins to update PHP. That&#x27;s right, and it&#x27;s the easy case, because a web admin controls the server.&lt;&#x2F;p&gt;
&lt;p&gt;A manufacturer doesn&#x27;t. If PHP sits inside your firmware or appliance, behind an admin page or a device UI, the fix isn&#x27;t yours to apply on someone else&#x27;s hardware. You have to ship one. &lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;www.helpnetsecurity.com&#x2F;2026&#x2F;10&#x2F;22&#x2F;php2shell-vulnerability-fortinet-cisco-palo-alto-networks&#x2F;&quot;&gt;Help Net Security&#x27;s vendor roundup&lt;&#x2F;a&gt; shows what that looks like in practice: Palo Alto Networks says all PAN-OS and Panorama versions are affected and fixed releases are still on the way, while Cisco and Fortinet each had a list of products still under investigation. That&#x27;s three large vendors answering the same question, product by product, in public.&lt;&#x2F;p&gt;
&lt;p&gt;Since 11 September that question has a clock attached. A manufacturer who becomes aware of an actively exploited vulnerability in its product has 24 hours to send an early warning under the Cyber Resilience Act. Whether a given product triggers a report is a call for you and your counsel. What isn&#x27;t optional is being able to answer two things fast: do we ship PHP, and which version?&lt;&#x2F;p&gt;
&lt;p&gt;One more thing. As of SOCRadar&#x27;s 21 October write-up, neither CVE was in CISA&#x27;s Known Exploited Vulnerabilities list, even though Amazon had already seen attempts. If your process waits for that list to tell you something is exploited, you may be behind.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;what-we-tested&quot;&gt;What we tested&lt;&#x2F;h2&gt;
&lt;p&gt;We built bomwerk 1.0.0-rc.1 from the tag and pointed &lt;code&gt;scan&lt;&#x2F;code&gt; at four ways PHP ends up in a product. Two of them are the same tree at different versions: PHP source 8.2.34, which is vulnerable, and 8.2.35, which is fixed.&lt;&#x2F;p&gt;
&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;How PHP shows up&lt;&#x2F;th&gt;&lt;th&gt;What &lt;code&gt;scan&lt;&#x2F;code&gt; reported&lt;&#x2F;th&gt;&lt;&#x2F;tr&gt;&lt;&#x2F;thead&gt;&lt;tbody&gt;
&lt;tr&gt;&lt;td&gt;Vendored source tree, 8.2.34&lt;&#x2F;td&gt;&lt;td&gt;Found at &lt;code&gt;third_party&#x2F;php-src&lt;&#x2F;code&gt;, no version&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;Vendored source tree, 8.2.35&lt;&#x2F;td&gt;&lt;td&gt;Identical output&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;&lt;code&gt;FROM php:8.2.34-apache&lt;&#x2F;code&gt; in a Dockerfile&lt;&#x2F;td&gt;&lt;td&gt;Not detected&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;Yocto recipe &lt;code&gt;php_8.2.34.bb&lt;&#x2F;code&gt;&lt;&#x2F;td&gt;&lt;td&gt;Not detected&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;&lt;code&gt;composer.lock&lt;&#x2F;code&gt; with &lt;code&gt;&quot;platform&quot;: {&quot;php&quot;: &quot;&amp;gt;=8.1&quot;}&lt;&#x2F;code&gt;&lt;&#x2F;td&gt;&lt;td&gt;Lists the packages, not the PHP runtime&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;&#x2F;tbody&gt;&lt;&#x2F;table&gt;
&lt;pre data-lang=&quot;console&quot; class=&quot;language-console &quot;&gt;&lt;code class=&quot;language-console&quot; data-lang=&quot;console&quot;&gt;$ bomwerk scan . --no-vuln
bomwerk 1.0.0-rc.1, scanning .
scanned:         22510 files under .
components:      1
  - pkg:generic&amp;#x2F;php-src  [low]  third_party&amp;#x2F;php-src
coverage:        1 components, 0 matchable (0.0%), 1 unmatched: 0 unmapped-purl-type, 1 unversioned-purl, 0 no-identifier

$ grep &amp;#x27;#define PHP_VERSION &amp;#x27; third_party&amp;#x2F;php-src&amp;#x2F;main&amp;#x2F;php_version.h
#define PHP_VERSION &amp;quot;8.2.34&amp;quot;
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;Read that plainly. At rc.1, &lt;code&gt;scan&lt;&#x2F;code&gt; can tell you PHP source is in your tree and where. It can&#x27;t yet tell you whether that&#x27;s the vulnerable release or the fixed one, so the two trees produce identical component lists. It doesn&#x27;t read the version out of a Dockerfile or a Yocto recipe either, and a Composer platform constraint says &quot;8.1 or newer&quot;, which covers the vulnerable and the fixed releases alike.&lt;&#x2F;p&gt;
&lt;p&gt;The part that works as designed is the coverage line. Zero matchable means no vulnerability lookup was possible for that component, so &quot;no findings&quot; can&#x27;t be mistaken for &quot;checked and clean.&quot; That&#x27;s a small comfort when the real answer is &quot;unknown,&quot; but it&#x27;s the right kind of unknown.&lt;&#x2F;p&gt;
&lt;p&gt;These are gaps, and an event like this one is where they cost something. We&#x27;d rather show them here than have you find them during an incident.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;what-to-do-today&quot;&gt;What to do today&lt;&#x2F;h2&gt;
&lt;ol&gt;
&lt;li&gt;List every product you ship that bundles PHP, including management UIs, update services and anything with an admin page.&lt;&#x2F;li&gt;
&lt;li&gt;Read the version from what you actually ship, not from the repo. &lt;code&gt;php -v&lt;&#x2F;code&gt; on the target image, or the &lt;code&gt;PHP_VERSION&lt;&#x2F;code&gt; define as above for vendored source.&lt;&#x2F;li&gt;
&lt;li&gt;Check exposure. Imperva points to worker-based setups such as Apache prefork, OPcache and session upload progress, and suggests turning off &lt;code&gt;opcache.enable&lt;&#x2F;code&gt; and &lt;code&gt;session.upload_progress.enabled&lt;&#x2F;code&gt; as a stopgap, while noting that neither fully protects against either CVE. Test before you rely on it.&lt;&#x2F;li&gt;
&lt;li&gt;Start log review at 17 October, not 21 October. Amazon&#x27;s advice is to look for POST requests carrying &lt;code&gt;PHP_SESSION_UPLOAD_PROGRESS&lt;&#x2F;code&gt;.&lt;&#x2F;li&gt;
&lt;li&gt;Write down when you became aware. That timestamp is where your 24 hours start, and it&#x27;s much easier to write down now than to reconstruct later.&lt;&#x2F;li&gt;
&lt;&#x2F;ol&gt;
&lt;hr &#x2F;&gt;
&lt;p&gt;Presence is the first question and version is the second. Today we answer the first and hand you a &lt;code&gt;grep&lt;&#x2F;code&gt; for the second.&lt;&#x2F;p&gt;
&lt;p&gt;Free repo scan: bomwerk.com&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>How We Keep the Paid Code Out of the Open Repo, and How You Can Check</title>
        <published>2026-10-15T00:00:00+00:00</published>
        <updated>2026-10-15T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://bomwerk.com/blog/paid-code-stays-out-of-the-open-repo/"/>
        <id>https://bomwerk.com/blog/paid-code-stays-out-of-the-open-repo/</id>
        
        <content type="html" xml:base="https://bomwerk.com/blog/paid-code-stays-out-of-the-open-repo/">&lt;p&gt;&quot;Open core&quot; is easy to say and hard to verify. A company announces that the scanner is open source, keeps a paid layer on top, and asks you to believe the line between them sits where they say it does.&lt;&#x2F;p&gt;
&lt;p&gt;We&#x27;d rather you didn&#x27;t have to believe it. So here is where the line is, what enforces it, and how to check it yourself.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;two-repositories-one-direction-of-travel&quot;&gt;Two repositories, one direction of travel&lt;&#x2F;h2&gt;
&lt;p&gt;&lt;code&gt;bomwerk&#x2F;bomwerk&lt;&#x2F;code&gt; is the Community edition under Apache-2.0: &lt;code&gt;scan&lt;&#x2F;code&gt;, &lt;code&gt;observe&lt;&#x2F;code&gt;, &lt;code&gt;trim&lt;&#x2F;code&gt; and &lt;code&gt;binscan&lt;&#x2F;code&gt;. The paid extension lives in a separate private repository and is composed on top of the public one at build time. It isn&#x27;t copied in. If you point the build at a private source tree that sits inside the public checkout, CMake refuses.&lt;&#x2F;p&gt;
&lt;p&gt;Fixes only travel one way. A Community fix lands in the public repository first, and the private side picks it up later through a reviewed pin bump. Nothing flows back, and the private repository is never merged into the public one. A paid release names two commit ids, the Community one and its own, so you can always tell exactly what was composed.&lt;&#x2F;p&gt;
&lt;p&gt;A default Community build doesn&#x27;t compile or link any of the paid code, and the binary has no &lt;code&gt;monitor&lt;&#x2F;code&gt;, &lt;code&gt;registry&lt;&#x2F;code&gt;, &lt;code&gt;triage&lt;&#x2F;code&gt;, &lt;code&gt;license&lt;&#x2F;code&gt; or &lt;code&gt;report&lt;&#x2F;code&gt; command. Setting an environment variable called &lt;code&gt;BOMWERK_PRO&lt;&#x2F;code&gt;, editing a config file or supplying a license token can&#x27;t add a command that was never linked. That switch exists at configure time and nowhere else.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;the-history-is-the-risky-part&quot;&gt;The history is the risky part&lt;&#x2F;h2&gt;
&lt;p&gt;Most open-core leaks don&#x27;t happen in the current tree. They happen in the history. You delete the private directory, push, and the old commits still contain it. A published object stays fetchable by its id long after nothing points at it.&lt;&#x2F;p&gt;
&lt;p&gt;So we didn&#x27;t make the old repository public. The public history starts at one root commit, made from a reviewed source snapshot. None of the earlier development history was carried over, because it contained the paid source. It still exists privately, and nothing is ever cherry-picked from it into the public repo. Work from before the cut gets re-applied as a reviewed patch.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;two-checks-both-on-every-change&quot;&gt;Two checks, both on every change&lt;&#x2F;h2&gt;
&lt;p&gt;The first, &lt;code&gt;scripts&#x2F;audit_public_history.py&lt;&#x2F;code&gt;, looks at the whole repository: every ref, every commit, every object in the database, including ones a deleted branch left behind. The second, a CTest called &lt;code&gt;pro_boundary&lt;&#x2F;code&gt;, looks at the current checkout, the build&#x27;s compilation database, the CLI command tree, runtime flag behavior and the namespaces inside the final binary.&lt;&#x2F;p&gt;
&lt;p&gt;Both work from a positive allowlist. A path is fine because the public layout lists it, not because it failed to match a list of things we remembered to call secret. A new top-level folder or an unfamiliar &lt;code&gt;src&#x2F;&lt;&#x2F;code&gt; module is a finding by default. That choice matters, because a blocklist only catches what somebody thought of in advance.&lt;&#x2F;p&gt;
&lt;p&gt;You can run the history audit on your own clone:&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;console&quot; class=&quot;language-console &quot;&gt;&lt;code class=&quot;language-console&quot; data-lang=&quot;console&quot;&gt;$ git clone --depth 1 --branch v1.0.0-rc.1 https:&amp;#x2F;&amp;#x2F;github.com&amp;#x2F;bomwerk&amp;#x2F;bomwerk.git
$ cd bomwerk &amp;amp;&amp;amp; python3 scripts&amp;#x2F;audit_public_history.py .
public history audit: OK (1 commits, 828 objects, 1 refs)
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;That output is from a shallow clone of the rc.1 tag. A full clone reports bigger numbers, and the line to look for is the one that starts with &lt;code&gt;OK&lt;&#x2F;code&gt;.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;what-this-doesn-t-claim&quot;&gt;What this doesn&#x27;t claim&lt;&#x2F;h2&gt;
&lt;p&gt;Separation of code isn&#x27;t obfuscation, and it doesn&#x27;t make a binary on a customer&#x27;s machine tamper-proof. The same goes for the paid side&#x27;s license check: it&#x27;s an offline authorization control, not DRM. There&#x27;s no phone-home and no hardware lock, and we don&#x27;t pretend that signing makes software unmodifiable. The paid extension also isn&#x27;t generally available yet. It&#x27;s in preview, with no tagged release.&lt;&#x2F;p&gt;
&lt;p&gt;What the checks do give you is narrower and easier to test. The free binary contains no paid code, the public history contains no paid source, and both statements can be re-run by anyone with a terminal.&lt;&#x2F;p&gt;
&lt;hr &#x2F;&gt;
&lt;p&gt;If a vendor tells you their core is open, ask them for the command that proves it. We think that&#x27;s a fair thing to ask us, too.&lt;&#x2F;p&gt;
&lt;p&gt;Free repo scan: bomwerk.com&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>The Nightmare Repo Has Real Numbers. Now You Can Check Them Yourself.</title>
        <published>2026-10-07T00:00:00+00:00</published>
        <updated>2026-10-07T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://bomwerk.com/blog/nightmare-numbers-are-reproducible/"/>
        <id>https://bomwerk.com/blog/nightmare-numbers-are-reproducible/</id>
        
        <content type="html" xml:base="https://bomwerk.com/blog/nightmare-numbers-are-reproducible/">&lt;p&gt;&lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;github.com&#x2F;bomwerk&#x2F;nightmare&quot;&gt;bomwerk&#x2F;nightmare&lt;&#x2F;a&gt; is a small, deliberately nasty C repository: a vendored library with a known CVE, an uninitialized submodule, a forked dependency, prebuilt binaries with no manifest anywhere. It ships with &lt;code&gt;GROUND-TRUTH.md&lt;&#x2F;code&gt;, twelve components checked by hand, and a script, &lt;code&gt;tools&#x2F;compare_tools.py&lt;&#x2F;code&gt;, that scores any scanner against that list.&lt;&#x2F;p&gt;
&lt;p&gt;We&#x27;ve had numbers on that page for a while. What we didn&#x27;t have, until this week, was a way for anyone outside bomwerk to generate bomwerk&#x27;s own row themselves. The repo&#x27;s own README said as much: bomwerk wasn&#x27;t publicly downloadable, so its result was ours to claim, not yours to check. That gap mattered more than the numbers did.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;the-numbers&quot;&gt;The numbers&lt;&#x2F;h2&gt;
&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;tool&lt;&#x2F;th&gt;&lt;th&gt;ground-truth recall&lt;&#x2F;th&gt;&lt;th&gt;over-reported&lt;&#x2F;th&gt;&lt;th&gt;wall time&lt;&#x2F;th&gt;&lt;&#x2F;tr&gt;&lt;&#x2F;thead&gt;&lt;tbody&gt;
&lt;tr&gt;&lt;td&gt;bomwerk&lt;&#x2F;td&gt;&lt;td&gt;10&#x2F;12&lt;&#x2F;td&gt;&lt;td&gt;2&lt;&#x2F;td&gt;&lt;td&gt;0.3s&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;syft&lt;&#x2F;td&gt;&lt;td&gt;2&#x2F;12&lt;&#x2F;td&gt;&lt;td&gt;1&lt;&#x2F;td&gt;&lt;td&gt;1.2s&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;cdxgen&lt;&#x2F;td&gt;&lt;td&gt;2&#x2F;12&lt;&#x2F;td&gt;&lt;td&gt;2&lt;&#x2F;td&gt;&lt;td&gt;3.1s&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;sbom-tool&lt;&#x2F;td&gt;&lt;td&gt;0&#x2F;12&lt;&#x2F;td&gt;&lt;td&gt;0&lt;&#x2F;td&gt;&lt;td&gt;1.5s&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;&#x2F;tbody&gt;&lt;&#x2F;table&gt;
&lt;p&gt;Recall is how many of the twelve hand-verified components each tool actually found. Over-reported is how many extra, wrong components it claimed on top of that. bomwerk found ten of twelve and got two wrong. That&#x27;s not a clean sweep, and we&#x27;re not presenting it as one. Manifest-only scanners found two or zero, which is the expected result against a repo built specifically to hide things from manifests: vendored code, static archives, a forked SDK with a version string that no longer matches its contents.&lt;&#x2F;p&gt;
&lt;p&gt;sbom-tool&#x27;s zero isn&#x27;t a bug in sbom-tool so much as a demonstration of what &quot;manifest-only&quot; actually means when there&#x27;s no manifest to read.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;what-changed-this-week&quot;&gt;What changed this week&lt;&#x2F;h2&gt;
&lt;p&gt;The core went Apache-2.0 and public on 30 September. On 2 October, &lt;code&gt;bomwerk&#x2F;bomwerk&lt;&#x2F;code&gt; got its first tag, &lt;code&gt;v1.0.0-rc.1&lt;&#x2F;code&gt;: source only, no prebuilt binary, but buildable by anyone who wants to run &lt;code&gt;cmake&lt;&#x2F;code&gt; and wait. Put those two together and the &quot;bomwerk isn&#x27;t downloadable yet&quot; caveat on the nightmare README is no longer true. It just hasn&#x27;t been updated yet, which we&#x27;re fixing.&lt;&#x2F;p&gt;
&lt;p&gt;Running the comparison yourself looks like this:&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;console&quot; class=&quot;language-console &quot;&gt;&lt;code class=&quot;language-console&quot; data-lang=&quot;console&quot;&gt;$ git clone https:&amp;#x2F;&amp;#x2F;github.com&amp;#x2F;bomwerk&amp;#x2F;bomwerk.git &amp;amp;&amp;amp; cd bomwerk
$ git checkout v1.0.0-rc.1 &amp;amp;&amp;amp; cmake -B build &amp;amp;&amp;amp; cmake --build build
$ git clone https:&amp;#x2F;&amp;#x2F;github.com&amp;#x2F;bomwerk&amp;#x2F;nightmare.git ..&amp;#x2F;nightmare
$ cd ..&amp;#x2F;nightmare &amp;amp;&amp;amp; python3 tools&amp;#x2F;compare_tools.py --bomwerk ..&amp;#x2F;bomwerk&amp;#x2F;build&amp;#x2F;bomwerk
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;You&#x27;ll need syft, cdxgen, and sbom-tool installed separately if you want their rows too; the script only runs what it finds on your &lt;code&gt;PATH&lt;&#x2F;code&gt;. Nobody has to take our word for any row in that table anymore, including ours.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;what-this-doesn-t-prove&quot;&gt;What this doesn&#x27;t prove&lt;&#x2F;h2&gt;
&lt;p&gt;One synthetic repo with twelve hand-picked components is not a market benchmark. It&#x27;s a stress test built to surface one specific failure mode: tools that only read manifests, applied to a codebase designed to have none worth reading. A real C&#x2F;C++ project won&#x27;t look exactly like &lt;code&gt;nightmare&lt;&#x2F;code&gt;, and a scanner that does well here could still miss things nightmare didn&#x27;t think to test for. We built the repo, we wrote the ground truth, and that&#x27;s a conflict of interest worth naming plainly rather than hoping nobody notices.&lt;&#x2F;p&gt;
&lt;p&gt;What it does prove, now that it&#x27;s reproducible, is narrower and more honest: against this specific, adversarial, publicly inspectable test, bomwerk finds more of what&#x27;s actually there than three tools that read manifests for a living. Ten out of twelve, not twelve out of twelve. Two wrong, not zero.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;why-bother-publishing-a-benchmark-where-you-don-t-win-cleanly&quot;&gt;Why bother publishing a benchmark where you don&#x27;t win cleanly&lt;&#x2F;h2&gt;
&lt;p&gt;Because a 10&#x2F;12 you can rerun is worth more than a 12&#x2F;12 you have to trust. The two misses and two false positives are exactly the kind of detail that disappears from a chart in a sales deck and survives in a ground-truth file anyone can read. If a parser gets fixed and a number changes, the diff is public too.&lt;&#x2F;p&gt;
&lt;hr &#x2F;&gt;
&lt;p&gt;Clone the repo, run the script, and if your result doesn&#x27;t match this table, that&#x27;s a bug report, not a discrepancy to argue about.&lt;&#x2F;p&gt;
&lt;p&gt;Free repo scan: bomwerk.com&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>bomwerk Is Open Source Now. Here&#x27;s Exactly What That Means.</title>
        <published>2026-09-30T00:00:00+00:00</published>
        <updated>2026-09-30T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://bomwerk.com/blog/bomwerk-is-open-source-now/"/>
        <id>https://bomwerk.com/blog/bomwerk-is-open-source-now/</id>
        
        <content type="html" xml:base="https://bomwerk.com/blog/bomwerk-is-open-source-now/">&lt;p&gt;As of today, bomwerk&#x27;s core is public. Source, not just a pitch: &lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;github.com&#x2F;bomwerk&#x2F;bomwerk&quot;&gt;github.com&#x2F;bomwerk&#x2F;bomwerk&lt;&#x2F;a&gt;, Apache-2.0, clean history, no marketing layer between you and the code that decides what&#x27;s in your SBOM.&lt;&#x2F;p&gt;
&lt;p&gt;Here&#x27;s exactly what that gets you, and what it doesn&#x27;t, because the difference matters more than the announcement.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;what-s-actually-open&quot;&gt;What&#x27;s actually open&lt;&#x2F;h2&gt;
&lt;p&gt;&lt;code&gt;scan&lt;&#x2F;code&gt;, &lt;code&gt;observe&lt;&#x2F;code&gt;, &lt;code&gt;trim&lt;&#x2F;code&gt;, &lt;code&gt;binscan&lt;&#x2F;code&gt;, the vulnerability matching against OSV, all of it. Clone the repo, build it yourself on Linux or macOS, and point it at your own codebase. There&#x27;s no prebuilt binary yet, signed releases are still coming, so today this means building from source, not downloading an installer. If that&#x27;s a dealbreaker for you right now, it&#x27;s a fair thing to wait on, and I&#x27;d rather say that plainly than let you find out after cloning.&lt;&#x2F;p&gt;
&lt;p&gt;What you get for that effort is the whole evidence chain: a lockfile-and-manifest scan, a build-observed inventory that only counts what your compiler and linker actually touched, and outputs in CycloneDX 1.6 or SPDX 3.0.1 that are byte-identical across runs on the same input.&lt;&#x2F;p&gt;
&lt;p&gt;Getting from clone to a first SBOM looks like this:&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;console&quot; class=&quot;language-console &quot;&gt;&lt;code class=&quot;language-console&quot; data-lang=&quot;console&quot;&gt;$ git clone https:&amp;#x2F;&amp;#x2F;github.com&amp;#x2F;bomwerk&amp;#x2F;bomwerk.git
$ cd bomwerk &amp;amp;&amp;amp; cmake -B build &amp;amp;&amp;amp; cmake --build build
$ .&amp;#x2F;build&amp;#x2F;bomwerk scan ..&amp;#x2F;your-project --format cyclonedx -o sbom.json
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;No account, no API key, no network call beyond the OSV lookup for known vulnerabilities. The scan runs against your source tree, not a manifest file it hopes matches your source tree.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;what-s-still-commercial-and-still-in-preview&quot;&gt;What&#x27;s still commercial, and still in preview&lt;&#x2F;h2&gt;
&lt;p&gt;Registering releases over time, nightly monitoring against CISA KEV, recording for each finding whether a release is affected, and drafting the ENISA report itself, that&#x27;s the Pro extension, and it&#x27;s not open source. It&#x27;s also not generally available yet: it&#x27;s tested and usable from source, with no tagged release. If you want early access, ask, we&#x27;re not pretending it&#x27;s finished software.&lt;&#x2F;p&gt;
&lt;p&gt;Keeping that boundary honest matters to me more than it probably should to most people building a company. The open core isn&#x27;t a trial that expires or a crippled version designed to make you upgrade. It&#x27;s the actual evidence-generation engine, unencumbered, because the thing worth trusting is the part that decides what&#x27;s in your SBOM, not the part that emails you about it later.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;go-try-to-break-it&quot;&gt;Go try to break it&lt;&#x2F;h2&gt;
&lt;p&gt;We didn&#x27;t just publish the scanner. We published &lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;github.com&#x2F;bomwerk&#x2F;nightmare&quot;&gt;bomwerk&#x2F;nightmare&lt;&#x2F;a&gt; alongside it, a small C project built specifically to defeat manifest-only scanners: a vendored library with a known CVE, an uninitialized submodule, a forked dependency, prebuilt binaries with no manifest anywhere. It ships with a hand-written ground truth of what a correct scanner should find, and bomwerk is scored against that ground truth too, misses included.&lt;&#x2F;p&gt;
&lt;p&gt;We&#x27;re not publishing the full head-to-head numbers in this post, that&#x27;s a piece on its own, coming soon, and it deserves more than a paragraph here. What matters today is that the test exists, it&#x27;s public, and you don&#x27;t have to take our word for any of it. Run your current scanner against nightmare. Run bomwerk against it. The repository&#x27;s ground truth file tells you exactly what the right answer looks like.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;why-this-and-why-now&quot;&gt;Why this, and why now&lt;&#x2F;h2&gt;
&lt;p&gt;Every claim in the posts before this one, the deterministic output, the exit-code contract, the fuzzing, the signing, was true before today, but it was also unverifiable by anyone outside the company. That gap between &quot;we say this is how it works&quot; and &quot;you can check how it works&quot; is the whole reason open source exists as a trust mechanism, and it&#x27;s a gap that&#x27;s been open longer than it should have been.&lt;&#x2F;p&gt;
&lt;p&gt;It&#x27;s closed now, for the part that actually matters most: the code that decides what your SBOM says you ship.&lt;&#x2F;p&gt;
&lt;hr &#x2F;&gt;
&lt;p&gt;The source is public. The nightmare repo is public. Go read both, and if you want a second opinion on what your own repo looks like under this, that free scan is still on the table.&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>Four Feeds, But Only One Starts the Clock</title>
        <published>2026-09-22T00:00:00+00:00</published>
        <updated>2026-09-22T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://bomwerk.com/blog/four-feeds-one-clock/"/>
        <id>https://bomwerk.com/blog/four-feeds-one-clock/</id>
        
        <content type="html" xml:base="https://bomwerk.com/blog/four-feeds-one-clock/">&lt;p&gt;&quot;Matches against OSV, NVD, CISA KEV, and ENISA EUVD&quot; is a sentence that sounds like it needs a merge algorithm, some kind of weighted voting across four sources that all answer the same question. It doesn&#x27;t work that way, because the four feeds don&#x27;t answer the same question. Here&#x27;s what each one is actually for, and where the line between &quot;live today&quot; and &quot;not built yet&quot; actually sits.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;osv-is-the-default-and-it-s-the-only-one-queried-automatically&quot;&gt;OSV is the default, and it&#x27;s the only one queried automatically&lt;&#x2F;h2&gt;
&lt;p&gt;OSV (Open Source Vulnerabilities, Google&#x27;s database) is purl-native. A purl (Package URL, the &lt;code&gt;pkg:type&#x2F;name@version&lt;&#x2F;code&gt; string that names a package unambiguously) goes in, matching advisories come back, no fuzzy matching required. That precision is why it&#x27;s the primary path: every scan queries OSV by default, results get cached locally with ETags so the same purl isn&#x27;t re-fetched needlessly, and nothing else needs to run for most components to get a real answer.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;nvd-only-runs-if-you-ask-it-to&quot;&gt;NVD only runs if you ask it to&lt;&#x2F;h2&gt;
&lt;p&gt;NVD (the US National Vulnerability Database) predates purl-style identifiers. It indexes by CPE (Common Platform Enumeration), an older naming scheme that&#x27;s broader but noisier, the kind of match where &quot;close enough&quot; sometimes means &quot;wrong.&quot; Querying it by default for every component would trade OSV&#x27;s precision for NVD&#x27;s false-positive rate, so it doesn&#x27;t run unless you explicitly ask for it with a CPE fallback flag. It exists to fill gaps OSV doesn&#x27;t cover, not to double-check OSV&#x27;s work.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;cisa-kev-is-the-one-the-cra-actually-cares-about&quot;&gt;CISA KEV is the one the CRA actually cares about&lt;&#x2F;h2&gt;
&lt;p&gt;This is the feed most people would guess matters least, and it&#x27;s the one that matters most for compliance specifically. CISA&#x27;s KEV (Known Exploited Vulnerabilities) list isn&#x27;t a vulnerability database the way OSV and NVD are. It&#x27;s a curated list of vulnerabilities the US government has confirmed are being actively exploited in the wild, nothing more, nothing less.&lt;&#x2F;p&gt;
&lt;p&gt;That distinction is the whole story. The CRA&#x27;s 24-hour reporting clock, the one we&#x27;ve written about at length, doesn&#x27;t trigger on &quot;your product has a known vulnerability.&quot; Plenty of CVEs sit in a product for years without triggering anything. It triggers on &quot;actively exploited,&quot; and KEV is the closest thing to an authoritative, checkable answer to that specific question. A vulnerability can have a CVSS score of 9.8 and sit in OSV and NVD for months without ever landing on KEV. The day it does land there is the day the clock has a real chance of starting for you.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;enisa-euvd-isn-t-a-fourth-feed-yet&quot;&gt;ENISA EUVD isn&#x27;t a fourth feed yet&lt;&#x2F;h2&gt;
&lt;p&gt;Here&#x27;s the honest part. ENISA EUVD (the EU Vulnerability Database) gets named alongside the other three in our own materials because it belongs there conceptually, an EU-run equivalent matters for a regulation this EU-specific. But there&#x27;s no code path for it today. It&#x27;s a reserved row in the endpoint allowlist, not something bomwerk actually queries. Calling it a fourth feed before it exists would be exactly the kind of overclaiming we try not to do, so it isn&#x27;t one, not yet.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;the-binary-can-t-reach-anywhere-except-this-list&quot;&gt;The binary can&#x27;t reach anywhere except this list&lt;&#x2F;h2&gt;
&lt;p&gt;One more detail worth stating plainly, because it&#x27;s a real security property, not a slogan. bomwerk&#x27;s network layer isn&#x27;t a general HTTP client that happens to be pointed at a few feeds. Every outbound host is a fixed entry in an allowlist, enforced before a socket ever opens, not just documented in a doc a security reviewer has to trust. A flag prints that exact list, so what a customer&#x27;s security team is told and what the binary can actually reach can&#x27;t quietly drift apart from each other. Abridged, from the open-source CLI:&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;console&quot; class=&quot;language-console &quot;&gt;&lt;code class=&quot;language-console&quot; data-lang=&quot;console&quot;&gt;$ bomwerk --endpoints
bomwerk makes outbound HTTPS requests to these hosts, and to no others.

  OSV querybatch     https:&amp;#x2F;&amp;#x2F;api.osv.dev&amp;#x2F;v1&amp;#x2F;querybatch
  OSV query          https:&amp;#x2F;&amp;#x2F;api.osv.dev&amp;#x2F;v1&amp;#x2F;query
  NVD CVE API 2.0    https:&amp;#x2F;&amp;#x2F;services.nvd.nist.gov&amp;#x2F;rest&amp;#x2F;json&amp;#x2F;cves&amp;#x2F;2.0   (--cpe-fallback only)
  crates.io, PyPI, RubyGems version APIs                               (--license-fallback only)
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;CISA KEV isn&#x27;t in that list, because the open-source CLI never fetches it. The KEV catalog is pulled by the monitor in the Pro extension, whose build adds &lt;code&gt;www.cisa.gov&lt;&#x2F;code&gt; to the same allowlist and prints it the same way. There&#x27;s no entry for ENISA EUVD in either. That&#x27;s not an oversight in the printout, it&#x27;s the printout telling the truth.&lt;&#x2F;p&gt;
&lt;hr &#x2F;&gt;
&lt;p&gt;None of this is dramatic on its own. It&#x27;s four names that get said in the same breath doing four different jobs, and one honest gap in a list that could have quietly pretended otherwise.&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>AI Coding Tools Are Now a Primary Attack Target. bomwerk Never Calls One.</title>
        <published>2026-09-16T00:00:00+00:00</published>
        <updated>2026-09-16T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://bomwerk.com/blog/ai-coding-tools-attack-target/"/>
        <id>https://bomwerk.com/blog/ai-coding-tools-attack-target/</id>
        
        <content type="html" xml:base="https://bomwerk.com/blog/ai-coding-tools-attack-target/">&lt;p&gt;Google&#x27;s Threat Intelligence Group (GTIG) published a report on 8 September warning that AI-assisted coding tools have become a primary target for threat actors, and that this shift has already contributed to several large-scale software supply chain compromises. Worth reading directly if you haven&#x27;t: the group tracks a financially motivated actor, UNC6780, running credential-stealing malware called Dustmaker across PyPI, npm, and Docker Hub.&lt;&#x2F;p&gt;
&lt;p&gt;Two specific techniques stood out. Dustmaker pulls tokens out of GitHub Actions runner process memory, then uses them to publish compromised package versions that pass the automated trust checks AI coding tools rely on. And separately, it drops malicious files into hidden project workspace directories, the kind AI coding assistants use for their own configuration, specifically so the malware blends into normal developer &quot;noise&quot; instead of standing out.&lt;&#x2F;p&gt;
&lt;p&gt;That second technique is the one worth sitting with. Hidden and vendored directories are already where most inventory tools fall short, not because anyone&#x27;s hiding anything maliciously, just because a manifest-driven scanner looks for a manifest and finds none there. We&#x27;ve written about that gap before. What&#x27;s new is that attackers now have a specific, documented reason to put things there on purpose: it&#x27;s the same blind spot, just weaponized instead of accidental.&lt;&#x2F;p&gt;
&lt;p&gt;Google&#x27;s own analyst on the report, John Hultquist, put it plainly: at this point, you can assume every threat actor is using AI in some capacity, and their operations have benefited from it.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;where-bomwerk-sits-in-this-picture&quot;&gt;Where bomwerk sits in this picture&lt;&#x2F;h2&gt;
&lt;p&gt;bomwerk doesn&#x27;t call a cloud AI service to do anything. Identifying components is deterministic and heuristic, built on parsing manifests, reading archive headers, and walking directory structures, not on sending your source to a model somewhere and asking what it thinks is in there. The CLI runs fully on-prem, with an offline mode that contacts nothing and answers from a local advisory cache. That cache learns of no new CVEs until it is refreshed online.&lt;&#x2F;p&gt;
&lt;p&gt;To be explicit about the other half of that sentence, because the distinction is the whole point: we do use AI assistance internally, during development, the way most small engineering teams do in 2026. Every line it produces is reviewed before it ships, and the parts that decide what ends up in your SBOM are reviewed twice. That is a statement about how the code gets written. It is a different question from what the shipped binary does on your machine, which is the part that touches your attack surface, and there the answer is simply that bomwerk makes no AI calls at all.&lt;&#x2F;p&gt;
&lt;p&gt;That&#x27;s not a claim that bomwerk is safer than every cloud-based tool on the market, that&#x27;s a broader claim than the facts support, and we try not to make those. What&#x27;s specifically true is narrower and checkable: scanning your codebase with bomwerk doesn&#x27;t add a new cloud-AI dependency to your attack surface, doesn&#x27;t send your source to a third party, and isn&#x27;t the kind of tool the GTIG report is describing. It can&#x27;t leak your code into someone else&#x27;s model context, because there&#x27;s no model in the loop to begin with.&lt;&#x2F;p&gt;
&lt;p&gt;It also doesn&#x27;t fix the underlying problem the report describes. Nothing about bomwerk stops an attacker from targeting your CI pipeline or your other AI tooling. What it does is give you an honest inventory of what&#x27;s actually in your repository, including the vendored and hidden-directory code that&#x27;s exactly where this kind of malware is now designed to hide.&lt;&#x2F;p&gt;
&lt;hr &#x2F;&gt;
&lt;p&gt;The CRA already asks you to know what you ship. This is one more reason that inventory needs to include the corners a manifest-only scanner skips, because attackers have started checking whether you&#x27;re looking there too.&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>The Reporting Platform Is Live. Do You Know What You&#x27;re Reporting On?</title>
        <published>2026-09-11T00:00:00+00:00</published>
        <updated>2026-09-11T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://bomwerk.com/blog/the-platform-is-live/"/>
        <id>https://bomwerk.com/blog/the-platform-is-live/</id>
        
        <content type="html" xml:base="https://bomwerk.com/blog/the-platform-is-live/">&lt;p&gt;Today, ENISA turned on the &lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;portal.cra-srp.enisa.europa.eu&#x2F;&quot;&gt;Single Reporting Platform&lt;&#x2F;a&gt; (SRP), the actual online tool manufacturers now use to file Cyber Resilience Act vulnerability reports. This isn&#x27;t a rule taking effect somewhere in the background. It&#x27;s a live web application, and as of today, you&#x27;re expected to know how to use it.&lt;&#x2F;p&gt;
&lt;p&gt;The mechanics are genuinely simpler than they could have been. You file once. The CSIRT (Computer Security Incident Response Team) where your company is based receives it, forwards it automatically to every other CSIRT in a country where your product is sold, and ENISA gets a copy at the same time. &lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;digital-strategy.ec.europa.eu&#x2F;en&#x2F;policies&#x2F;cra-reporting&quot;&gt;One submission&lt;&#x2F;a&gt;, not twenty-seven.&lt;&#x2F;p&gt;
&lt;p&gt;The deadlines are the ones you&#x27;d expect by now: 24 hours for an early warning, 72 hours for a fuller notification, 14 days after a fix ships for the final report on an actively exploited vulnerability.&lt;&#x2F;p&gt;
&lt;p&gt;Here&#x27;s what the platform doesn&#x27;t solve. Filing is easy now. Knowing you need to file isn&#x27;t. The SRP has no idea what&#x27;s actually inside your product. It can&#x27;t tell you whether this morning&#x27;s CISA KEV (Known Exploited Vulnerabilities) entry names a library buried three directories deep in your vendored source. That question was always yours to answer. Today it matters more than any day before it, because now there&#x27;s a live form asking for an answer you might not have.&lt;&#x2F;p&gt;
&lt;p&gt;If your team can&#x27;t say, in minutes, whether an affected library shipped in a product from 2023, a simpler filing process doesn&#x27;t help you much. The bottleneck was never the paperwork. It&#x27;s visibility into what you actually ship.&lt;&#x2F;p&gt;
&lt;p&gt;That&#x27;s the part &lt;code&gt;bomwerk scan&lt;&#x2F;code&gt; addresses: an accurate inventory of every C&#x2F;C++ and multi-language dependency in your codebase, including the vendored copies and static archives a lockfile-only scanner won&#x27;t see. It won&#x27;t file your SRP report for you. It will tell you, quickly, whether you need to.&lt;&#x2F;p&gt;
&lt;hr &#x2F;&gt;
&lt;p&gt;The platform went live today. Whether you can actually answer its first question, &quot;are we affected,&quot; is still entirely up to you. &lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;bomwerk.com&#x2F;#scan&quot;&gt;Run a free scan&lt;&#x2F;a&gt; of your repo and find out before a KEV entry forces the question.&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>11 September: The 24-Hour Clock Starts. Here&#x27;s What Actually Changes.</title>
        <published>2026-09-10T00:00:00+00:00</published>
        <updated>2026-09-10T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://bomwerk.com/blog/tomorrow-the-clock-starts/"/>
        <id>https://bomwerk.com/blog/tomorrow-the-clock-starts/</id>
        
        <content type="html" xml:base="https://bomwerk.com/blog/tomorrow-the-clock-starts/">&lt;p&gt;Starting 11 September 2026, the Cyber Resilience Act&#x27;s vulnerability-reporting obligation is active for manufacturers of products with digital elements that fall within its scope. Scope depends on the product, role and placing on the EU market; having a European customer alone is not a complete legal test. Products placed on the market before the broader 2027 application date can still be relevant to these reporting duties.&lt;&#x2F;p&gt;
&lt;p&gt;I&#x27;m not going to re-explain the whole CRA here (an earlier post covers that ground). This one is about what actually changes on 11 September, and what needs to already exist before it does, because none of it can be built while an incident is running.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;the-clock-starts-at-awareness-not-disclosure&quot;&gt;The clock starts at awareness, not disclosure&lt;&#x2F;h2&gt;
&lt;p&gt;The obligation is a cascade: an early warning within 24 hours of awareness, a vulnerability notification within 72 hours of awareness, and a final report no later than 14 days after a corrective or mitigating measure becomes available. Reports go through the &lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;portal.cra-srp.enisa.europa.eu&#x2F;&quot;&gt;ENISA Single Reporting Platform&lt;&#x2F;a&gt; and are made available simultaneously to the coordinating CSIRT and ENISA.&lt;&#x2F;p&gt;
&lt;p&gt;That word, aware, is doing more work than it looks like. If a CISA KEV (Known Exploited Vulnerabilities) entry lands naming a library you ship, and nobody on your team sees it for six days because nobody&#x27;s watching that feed, your 24 hours didn&#x27;t start on day one. They started on day six, when someone actually noticed. The rule doesn&#x27;t punish you for a six-day gap you didn&#x27;t know about. It punishes you for the 24 hours after you did.&lt;&#x2F;p&gt;
&lt;p&gt;Which means the real risk isn&#x27;t the deadline itself. It&#x27;s discovering you&#x27;re affected late enough that the deadline becomes a scramble.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;a-worked-example&quot;&gt;A worked example&lt;&#x2F;h2&gt;
&lt;p&gt;Say a KEV entry goes public on a Tuesday morning naming a compression library. You ship that library, vendored, inside a product from 2023.&lt;&#x2F;p&gt;
&lt;pre&gt;&lt;code&gt;Tue 09:00  KEV entry published
Tue 09:00–?  Nobody on your team is watching this feed
Tue 09:00–?  Or: someone IS watching, checks it against your SBOM,
             confirms the affected version is in what you shipped
Tue 09:00 + 24h   Early warning due to ENISA and the national CSIRT
                  (Computer Security Incident Response Team)
Tue 09:00 + 72h   Fuller notification due
[+14 days from a fix becoming available]   Final report due
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;The only variable in that timeline you actually control is the gap between &quot;published&quot; and &quot;confirmed affected.&quot; Everything after that is fixed by regulation. So that gap is the only place readiness work can go.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;three-things-that-need-to-exist-before-not-during&quot;&gt;Three things that need to exist before, not during&lt;&#x2F;h2&gt;
&lt;p&gt;&lt;strong&gt;An SBOM (Software Bill of Materials) you can check quickly.&lt;&#x2F;strong&gt; Not eventually, not after someone spends an afternoon grepping through vendored directories. When a KEV entry names a library, you need to answer &quot;do we ship this, and which version&quot; in minutes, not days. That answer only comes quickly if you already have an accurate inventory, built before the question got asked.&lt;&#x2F;p&gt;
&lt;p&gt;&lt;strong&gt;A decided reporting path.&lt;&#x2F;strong&gt; Decide who declares awareness, who owns the submission through the ENISA platform, which coordinating CSIRT is appropriate, and how internal escalation works outside business hours.&lt;&#x2F;p&gt;
&lt;p&gt;&lt;strong&gt;A way to check exposure without waiting on a vendor.&lt;&#x2F;strong&gt; A rough version, if you don&#x27;t have automated feed matching yet, is checking a KEV export against your SBOM by hand:&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;console&quot; class=&quot;language-console &quot;&gt;&lt;code class=&quot;language-console&quot; data-lang=&quot;console&quot;&gt;$ curl -s https:&amp;#x2F;&amp;#x2F;www.cisa.gov&amp;#x2F;sites&amp;#x2F;default&amp;#x2F;files&amp;#x2F;feeds&amp;#x2F;known_exploited_vulnerabilities.json \
  | jq -r &amp;#x27;.vulnerabilities[].cveID&amp;#x27; &amp;gt; kev-ids.txt

$ jq -r &amp;#x27;.components[].cpe &amp;#x2F;&amp;#x2F; empty&amp;#x27; sbom.json | grep -oP &amp;#x27;cpe:2\.3:a:[^:]+:\K[^:]+&amp;#x27; \
  | sort -u &amp;gt; shipped-libs.txt
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;That&#x27;s not a real detection pipeline, and I wouldn&#x27;t pretend it is. It&#x27;s the manual version of the question you need an answer to, and doing it once, today, tells you a lot about how long the automated version would take to build.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;what-bomwerk-does-and-doesn-t-do-here-yet&quot;&gt;What bomwerk does and doesn&#x27;t do here yet&lt;&#x2F;h2&gt;
&lt;p&gt;To be direct about where things stand: the matching-and-alerting side is further along than a line on a roadmap, but it&#x27;s still not something you can run. Internally, a finding-state store now tracks when each finding was first and last seen per release, computes the 24-hour, 72-hour, and 14-day deadlines from that original first-seen time, enriches findings against the CISA KEV list, and can generate a deterministic draft of the ENISA Article 14 report. None of that is public. It lives on our development branch, it has its own test suite, and it won&#x27;t reach a public release until a licensing boundary between the open-source core and the paid pieces is finished, a real blocker we&#x27;re working through, not a formality. Right now the only part you can actually run is the open-source CLI, built from source: &lt;code&gt;bomwerk scan&lt;&#x2F;code&gt; and the build-evidence commands around it, the accurate SBOM part every other step in this post depends on.&lt;&#x2F;p&gt;
&lt;p&gt;That&#x27;s not a reason to wait on the SBOM. It&#x27;s the opposite. The inventory is the one piece of readiness that has to exist before any of the rest of this works, automated or manual, ours or anyone else&#x27;s.&lt;&#x2F;p&gt;
&lt;hr &#x2F;&gt;
&lt;p&gt;Nothing about 11 September is dramatic on its own. It&#x27;s a deadline that was always coming, and now it&#x27;s here. What matters is whether the three things above already exist, or whether they&#x27;re about to get built under pressure, during the first incident that actually needs them.&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>There&#x27;s No Database Server Behind bomwerk. On Purpose.</title>
        <published>2026-08-27T00:00:00+00:00</published>
        <updated>2026-08-27T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://bomwerk.com/blog/no-database-server-behind-bomwerk/"/>
        <id>https://bomwerk.com/blog/no-database-server-behind-bomwerk/</id>
        
        <content type="html" xml:base="https://bomwerk.com/blog/no-database-server-behind-bomwerk/">&lt;p&gt;A lot of security and compliance tools ask for more than you&#x27;d expect before you can run them. Stand up a Postgres instance. Open a port. Create a service account. Configure a connection string. And that&#x27;s before the tool does anything useful for you.&lt;&#x2F;p&gt;
&lt;p&gt;None of that is unreasonable on its own. It&#x27;s just a cost, and it&#x27;s a cost that shows up before day one, on infrastructure that isn&#x27;t the tool&#x27;s job to own.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;the-constraint-we-re-actually-solving-for&quot;&gt;The constraint we&#x27;re actually solving for&lt;&#x2F;h2&gt;
&lt;p&gt;bomwerk is built to run on-prem, and with &lt;code&gt;--offline&lt;&#x2F;code&gt; it contacts nothing at all, answering from a local advisory cache that is only as fresh as its last online refresh. No telemetry leaves the machine unless you turn something on and point it somewhere yourself. That&#x27;s not a marketing line, it&#x27;s a structural choice: the whole trust story falls apart if the tool phones home or needs a network path to function.&lt;&#x2F;p&gt;
&lt;p&gt;Given that constraint, asking someone to also run a database server changes the deployment story completely. Now there&#x27;s a second thing to patch, a second thing that can go down, a second thing security has to approve before it&#x27;s allowed anywhere near a build server. For a tool that&#x27;s supposed to make audits easier, that&#x27;s a strange thing to hand someone.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;what-we-chose-instead&quot;&gt;What we chose instead&lt;&#x2F;h2&gt;
&lt;p&gt;Local state, wherever bomwerk needs to keep any, lives in SQLite. One file. No server process, no listening port, no credentials to rotate. Copying it is a backup. Deleting it is a reset. It behaves identically on a developer&#x27;s laptop, inside a CI runner with no network access, or on an air-gapped machine in a secure facility, because there&#x27;s no difference between those environments as far as SQLite is concerned. It&#x27;s just a file on disk.&lt;&#x2F;p&gt;
&lt;p&gt;That matters more than it sounds like it should for a tool whose entire pitch is &quot;runs inside your infrastructure, doesn&#x27;t ask anything of it.&quot;&lt;&#x2F;p&gt;
&lt;p&gt;This is the design a forthcoming piece of bomwerk leans on directly: a registry that tracks SBOMs per product and version over time, so you can answer &quot;what did we ship in March versus June&quot; without re-scanning anything. That&#x27;s still ahead of us on the roadmap, not something you can run today. But when it lands, backing it up will look exactly this ordinary:&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;console&quot; class=&quot;language-console &quot;&gt;&lt;code class=&quot;language-console&quot; data-lang=&quot;console&quot;&gt;$ cp registry.db backups&amp;#x2F;registry-2026-08-27.db
$ sqlite3 backups&amp;#x2F;registry-2026-08-27.db &amp;quot;.tables&amp;quot;
components  products  scans  versions
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;No &lt;code&gt;pg_dump&lt;&#x2F;code&gt;, no connection string, no separate backup tooling. Just a file, copied like any other file.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;where-this-stops-being-the-right-call&quot;&gt;Where this stops being the right call&lt;&#x2F;h2&gt;
&lt;p&gt;SQLite isn&#x27;t built for a lot of concurrent writers hammering the same database at once. That&#x27;s a real limitation, and it&#x27;s not one we&#x27;re pretending away.&lt;&#x2F;p&gt;
&lt;p&gt;For a per-product registry watched by a single on-prem instance, that limitation doesn&#x27;t bite. One process is writing to it. But if bomwerk ever needs to serve a shared setup where many teams are writing to the same store at the same time, a directory of SQLite files stops being the right architecture. That&#x27;s exactly the door we left open on purpose: Postgres as a swap-in option for larger deployments is on the roadmap for a later Enterprise phase, not something we&#x27;re bolting on after the fact under pressure. The decision to keep it optional, not required, was made early, specifically so smaller deployments never have to carry infrastructure they don&#x27;t need.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;why-this-is-worth-a-whole-post&quot;&gt;Why this is worth a whole post&lt;&#x2F;h2&gt;
&lt;p&gt;Nobody chooses a security tool because of its storage engine. But plenty of tools get quietly uninstalled, or never make it past a security review, because of exactly this kind of operational weight nobody budgeted for. A database server is one more thing that has to survive a change advisory board, one more thing that needs patching on its own schedule, one more line item in whatever audit asks &quot;what runs in our environment and why.&quot;&lt;&#x2F;p&gt;
&lt;p&gt;A single file doesn&#x27;t have any of those problems. It&#x27;s not a clever trick. It&#x27;s just choosing not to create a dependency the tool didn&#x27;t actually need.&lt;&#x2F;p&gt;
&lt;hr &#x2F;&gt;
&lt;p&gt;The parts of a tool nobody asks about at the demo are often the parts that decide whether it&#x27;s still running in someone&#x27;s infrastructure a year later.&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>Never Crash Is a Promise. Here&#x27;s How We Test It.</title>
        <published>2026-08-20T00:00:00+00:00</published>
        <updated>2026-08-20T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://bomwerk.com/blog/never-crash-is-a-promise/"/>
        <id>https://bomwerk.com/blog/never-crash-is-a-promise/</id>
        
        <content type="html" xml:base="https://bomwerk.com/blog/never-crash-is-a-promise/">&lt;p&gt;Last week&#x27;s post said every parser in bomwerk returns a result instead of throwing, so one bad archive can&#x27;t take down a whole scan. That&#x27;s an easy thing to claim in a blog post. It&#x27;s a different thing to actually know it&#x27;s still true after the fortieth commit touches that code.&lt;&#x2F;p&gt;
&lt;p&gt;So here&#x27;s the part that doesn&#x27;t show up in a design doc: how we check it.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;a-diff-across-50-repos-not-a-handful-of-unit-tests&quot;&gt;A diff across 50 repos, not a handful of unit tests&lt;&#x2F;h2&gt;
&lt;p&gt;Unit tests check the pieces you thought to write a test for. They don&#x27;t catch what happens when a real project has a &lt;code&gt;Cargo.lock&lt;&#x2F;code&gt; with a dependency graph nobody would design by hand, or a vendored tree three levels deeper than any fixture we made up ourselves.&lt;&#x2F;p&gt;
&lt;p&gt;So alongside the unit tests, we keep a golden corpus: real, messy repositories, each with a snapshot SBOM checked into the test suite. Every CI run scans all of them fresh and diffs the output against the snapshot. Any byte of difference fails the build. Right now it&#x27;s a modest set. We&#x27;re growing it deliberately toward 50 by the time the harder milestones land. A corpus of five doesn&#x27;t tell you much about a scanner meant to run on someone else&#x27;s ten-year-old codebase.&lt;&#x2F;p&gt;
&lt;p&gt;The failure mode this catches is boring, and that&#x27;s exactly the point: a change to the npm parser that quietly shifts how a nested &lt;code&gt;node_modules&lt;&#x2F;code&gt; tree gets walked, three files down, in a project nobody on the team wrote.&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;console&quot; class=&quot;language-console &quot;&gt;&lt;code class=&quot;language-console&quot; data-lang=&quot;console&quot;&gt;$ ctest --test-dir build -R golden --output-on-failure
Test #12: golden.corpus-07 ......................... Passed  (0.41s)
Test #13: golden.corpus-08 ......................... Failed  (0.38s)
    --- expected&amp;#x2F;corpus-08.cdx.json
    +++ actual&amp;#x2F;corpus-08.cdx.json
    @@ component[41] @@
    -  &amp;quot;version&amp;quot;: &amp;quot;1.4.2&amp;quot;
    +  &amp;quot;version&amp;quot;: &amp;quot;unknown&amp;quot;
Total: 14 tests, 1 failed
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;That&#x27;s the kind of failure a human should look at before it ships. Either the parser genuinely regressed, or the expected snapshot needed updating on purpose. Either way, CI won&#x27;t let it pass silently.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;one-fuzz-target-per-parser&quot;&gt;One fuzz target per parser&lt;&#x2F;h2&gt;
&lt;p&gt;Golden corpus tests check known inputs. Fuzzing checks the inputs nobody wrote down: malformed archives, truncated lockfiles, a &lt;code&gt;.a&lt;&#x2F;code&gt; file with a symbol table that lies about its own size.&lt;&#x2F;p&gt;
&lt;p&gt;Every parser gets its own libFuzzer target, run for a short smoke pass on every pull request and for longer stretches overnight. When a fuzz run finds a crash, the crashing input becomes a permanent fixture. The bug gets fixed once; the input that found it keeps getting re-run on every future change, so the same class of bug can&#x27;t quietly come back.&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;console&quot; class=&quot;language-console &quot;&gt;&lt;code class=&quot;language-console&quot; data-lang=&quot;console&quot;&gt;$ .&amp;#x2F;build&amp;#x2F;fuzz_nuget -runs=1 crash-8f21ac
==41213==ERROR: AddressSanitizer: heap-buffer-overflow READ 1
    #0 bomwerk::parsers::nuget::read_nuspec_xml()  nuget.cpp:118
    #1 bomwerk::parsers::nuget::parse()            nuget.cpp:41
artifact_prefix=&amp;#x27;.&amp;#x2F;&amp;#x27;; Test unit written to .&amp;#x2F;crash-8f21ac
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;That&#x27;s AddressSanitizer (ASan), which is why the CI matrix runs a Linux job with ASan and UBSan (UndefinedBehaviorSanitizer) turned on. C++ will hand you a crash on a malformed input that a memory-safe language would just reject cleanly, and the crash isn&#x27;t always where the bug is. A one-byte overflow can corrupt memory that only shows symptoms three function calls later. The sanitizers are what turn &quot;the tool behaved strangely&quot; into a stack trace pointing at the actual line.&lt;&#x2F;p&gt;
&lt;p&gt;This matters more than it sounds like it should, because a scanner&#x27;s job is to read files it didn&#x27;t write, from repos it doesn&#x27;t control. Every parser is, in effect, reading untrusted input. Treating a parser bug as only a correctness issue, something to fix whenever, undersells what it actually is on a tool built to run in someone else&#x27;s CI.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;what-this-doesn-t-promise&quot;&gt;What this doesn&#x27;t promise&lt;&#x2F;h2&gt;
&lt;p&gt;None of this gets you to zero. A golden corpus only catches regressions on inputs already in the corpus; a repo shaped differently from anything in it can still surprise the scanner. A fuzz target only explores what it&#x27;s had time to explore. A target added last week has seen far fewer inputs than one that&#x27;s been running nightly for two months. New parsers start thin on both fronts and get more coverage as releases go by, not on day one.&lt;&#x2F;p&gt;
&lt;p&gt;What you actually get is smaller than that, and more honest about it: crashes we&#x27;ve already found don&#x27;t come back, and the categories of input most likely to break something (malformed, truncated, adversarial) get exercised automatically instead of only when a real customer&#x27;s weird repo happens to hit the same edge case in production.&lt;&#x2F;p&gt;
&lt;hr &#x2F;&gt;
&lt;p&gt;A tool that never crashes on your repo isn&#x27;t the same claim as a tool that&#x27;s always right about your repo. Testing for one doesn&#x27;t test for the other, and conflating them is how a scanner ends up with more confidence than it&#x27;s earned.&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>A Scanner Has Three Ways to End, Not Two</title>
        <published>2026-08-13T00:00:00+00:00</published>
        <updated>2026-08-13T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://bomwerk.com/blog/a-scanner-has-three-ways-to-end/"/>
        <id>https://bomwerk.com/blog/a-scanner-has-three-ways-to-end/</id>
        
        <content type="html" xml:base="https://bomwerk.com/blog/a-scanner-has-three-ways-to-end/">&lt;p&gt;Most CLI tools give you two exit codes. Zero, everything&#x27;s fine. One, something broke. That binary is usually enough. For a compiler, &lt;code&gt;1&lt;&#x2F;code&gt; means stop, fix the code, try again.&lt;&#x2F;p&gt;
&lt;p&gt;It isn&#x27;t enough for a scanner sitting in CI, deciding whether a build should fail. There are two genuinely different reasons a scan step can come back unhappy, and if your pipeline can&#x27;t tell them apart, it ends up treating both the same way, which is wrong for at least one of them.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;two-failures-not-one&quot;&gt;Two failures, not one&lt;&#x2F;h2&gt;
&lt;p&gt;Say &lt;code&gt;bomwerk scan&lt;&#x2F;code&gt; runs on a firmware repo and finds a &lt;code&gt;.a&lt;&#x2F;code&gt; archive it genuinely can&#x27;t identify: stripped, no symbols, no version string anywhere. Nothing&#x27;s broken there. The scanner is doing exactly what it should: telling you honestly that it doesn&#x27;t know. You probably want the build to keep going, with a warning surfaced somewhere a human will actually see it.&lt;&#x2F;p&gt;
&lt;p&gt;Now say the same command hits a filesystem permission error halfway through, or the path you gave it doesn&#x27;t exist. There&#x27;s no finding to report here. The tool simply didn&#x27;t run. You want that one to fail loud and immediately, before anyone reads the SBOM and mistakes an empty result for a clean one.&lt;&#x2F;p&gt;
&lt;p&gt;Collapse both into exit code 1 and your CI script can&#x27;t tell &quot;we found something worth a human&#x27;s attention&quot; from &quot;the scan never happened.&quot; Teams that go looking for that difference end up parsing log text, which breaks the next time someone rewords a message.&lt;&#x2F;p&gt;
&lt;p&gt;So bomwerk uses three:&lt;&#x2F;p&gt;
&lt;pre&gt;&lt;code&gt;0  clean run, nothing flagged
1  ran to completion, found something (unknown component, missing manifest, low-confidence match)
2  did not complete (bad args, unreadable path, internal error)
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;A pipeline can gate on exit code alone:&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;console&quot; class=&quot;language-console &quot;&gt;&lt;code class=&quot;language-console&quot; data-lang=&quot;console&quot;&gt;$ bomwerk scan . -o sbom.json
$ echo $?
1

$ if [ $? -eq 2 ]; then
    echo &amp;quot;scan didn&amp;#x27;t run, fix the invocation&amp;quot; &amp;gt;&amp;amp;2
    exit 1
  elif [ $? -eq 1 ]; then
    echo &amp;quot;scan ran, flagged something, see sbom.json&amp;quot; &amp;gt;&amp;amp;2
  fi
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;Code 1 is a finding to route somewhere. Code 2 is a tool problem to fix. Different owners, different urgency, and now the pipeline can express that without touching stdout.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;the-part-that-makes-the-contract-honest&quot;&gt;The part that makes the contract honest&lt;&#x2F;h2&gt;
&lt;p&gt;None of this works if a single bad input can take the whole process down. If one malformed archive out of four hundred in a repo throws an unhandled exception, you get a stack trace and zero output: no SBOM at all, clean components and broken one alike, all withheld because of a single file.&lt;&#x2F;p&gt;
&lt;p&gt;Every component producer inside bomwerk, one per package ecosystem or detection method, implements the same signature: &lt;code&gt;Result&amp;lt;std::vector&amp;lt;Component&amp;gt;&amp;gt; parse(const std::filesystem::path&amp;amp; root)&lt;&#x2F;code&gt;. Nothing throws across that boundary. A parser that can&#x27;t make sense of an input doesn&#x27;t crash the run. It logs a warning at that point and returns what it did find, and the run moves on to the next file.&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;console&quot; class=&quot;language-console &quot;&gt;&lt;code class=&quot;language-console&quot; data-lang=&quot;console&quot;&gt;$ bomwerk scan .&amp;#x2F;firmware
Scanned 412 files, 6 ecosystems.
WARN  vendor&amp;#x2F;mystery-codec&amp;#x2F;: no manifest, no recognisable version markers
WARN  build&amp;#x2F;lib&amp;#x2F;libimaging.a: 2 archive members with no symbol table
118 components identified, 2 flagged unknown.
Exit code: 1
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;You get 118 real components, two honest question marks, and a nonzero exit code telling CI to make sure someone looks at those two. That&#x27;s a materially different outcome from a crash that gives you nothing.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;why-we-didn-t-stop-at-warnings-in-the-log&quot;&gt;Why we didn&#x27;t stop at &quot;warnings in the log&quot;&lt;&#x2F;h2&gt;
&lt;p&gt;We could have kept exit codes binary and pushed all of this into log text instead. Some tools do exactly that. It works until someone builds automation on top of the tool, at which point log-scraping is what you&#x27;re left with, and log formats drift in ways exit codes don&#x27;t.&lt;&#x2F;p&gt;
&lt;p&gt;An exit code is the smallest interface a scanner can offer a machine. It survives a wrapper script rewrite. It survives someone piping stdout through &lt;code&gt;jq&lt;&#x2F;code&gt; and dropping the human-readable lines entirely. Keeping the machine-facing signal down to a three-value integer, and pushing everything else into structured output, is the boring choice, and boring is what you want from something a release pipeline depends on.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;where-this-doesn-t-help-you&quot;&gt;Where this doesn&#x27;t help you&lt;&#x2F;h2&gt;
&lt;p&gt;Three exit codes tell you &lt;em&gt;that&lt;&#x2F;em&gt; something needs attention. They don&#x27;t tell you &lt;em&gt;what&lt;&#x2F;em&gt;. For that you still read &lt;code&gt;sbom.json&lt;&#x2F;code&gt; or the warnings block. The exit code is a routing signal, not a report.&lt;&#x2F;p&gt;
&lt;p&gt;And it&#x27;s worth saying plainly: an unknown component isn&#x27;t a security finding by itself. It&#x27;s a gap in identification. Some of those gaps close with a better heuristic next release; some stay unknown because the archive genuinely carries no recoverable evidence. We report the difference as confidence levels rather than pretending every component is equally certain.&lt;&#x2F;p&gt;
&lt;hr &#x2F;&gt;
&lt;p&gt;None of this is dramatic. It&#x27;s a scanner returning the right number instead of the wrong one, and that&#x27;s most of what makes a tool safe to depend on in someone else&#x27;s pipeline.&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>Run Your Scanner Twice. Diff the Output.</title>
        <published>2026-08-06T00:00:00+00:00</published>
        <updated>2026-08-06T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://bomwerk.com/blog/run-your-scanner-twice/"/>
        <id>https://bomwerk.com/blog/run-your-scanner-twice/</id>
        
        <content type="html" xml:base="https://bomwerk.com/blog/run-your-scanner-twice/">&lt;p&gt;Try this on whatever tool you&#x27;re using now. Generate an SBOM (Software Bill of Materials). Generate it again, same commit, same machine, nothing touched in between. Now diff the two files.&lt;&#x2F;p&gt;
&lt;p&gt;You will probably get pages of noise. A generation timestamp that moved. A fresh UUID on every single component. Dependencies in a different order because the directory walk came back differently this time.&lt;&#x2F;p&gt;
&lt;p&gt;None of that matters on a Tuesday afternoon. It matters a lot the first time somebody asks you what changed.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;the-question-you-will-eventually-be-asked&quot;&gt;The question you will eventually be asked&lt;&#x2F;h2&gt;
&lt;p&gt;You shipped 4.2.1 in March. You shipped 4.2.2 in June. A customer&#x27;s security team wants to know what moved in the third-party code between those two builds. Not your code. Theirs — the vendored libraries, the SDK, the transitive pulls.&lt;&#x2F;p&gt;
&lt;p&gt;That should be a five-line answer. Two components bumped, one added, one dropped.&lt;&#x2F;p&gt;
&lt;p&gt;If your SBOMs aren&#x27;t stable, it&#x27;s a 3,000-line diff and you&#x27;re reading it by hand on a Friday. I&#x27;ve watched an engineer do exactly that, and the worst part wasn&#x27;t the time. It was that nobody could tell whether the diff was complete, because nobody could tell which changes were real and which were the generator being chatty.&lt;&#x2F;p&gt;
&lt;p&gt;There&#x27;s a regulatory edge to this too. Under the CRA (Cyber Resilience Act, Regulation (EU) 2024&#x2F;2847), market surveillance authorities can ask a manufacturer to hand over the software bill of materials for a product [VERIFY: Annex I Part II(1), and confirm the request power article — see the &lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;www.cyberresilienceact.eu&#x2F;regulation.html&quot;&gt;consolidated text&lt;&#x2F;a&gt;]. They ask about a product, and a product means a version. So you want per-release SBOMs you can actually compare, not a pile of files that happen to have been produced at different times.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;four-things-that-break-it&quot;&gt;Four things that break it&lt;&#x2F;h2&gt;
&lt;p&gt;&lt;strong&gt;Timestamps.&lt;&#x2F;strong&gt; Most generators stamp the metadata block with the moment the file was written. Every run differs by construction.&lt;&#x2F;p&gt;
&lt;p&gt;&lt;strong&gt;Random identifiers.&lt;&#x2F;strong&gt; CycloneDX wants a &lt;code&gt;bom-ref&lt;&#x2F;code&gt; per component. Generate it randomly and the same zlib you&#x27;ve shipped for three years gets a new identity every night, so nothing can be tracked across releases.&lt;&#x2F;p&gt;
&lt;p&gt;&lt;strong&gt;Ordering.&lt;&#x2F;strong&gt; Component order usually falls out of directory traversal or hash-map iteration. Change the filesystem, the OS, or the standard library, and the order changes with it.&lt;&#x2F;p&gt;
&lt;p&gt;&lt;strong&gt;Paths.&lt;&#x2F;strong&gt; Absolute build paths leak into fields. Now the SBOM says something different on the CI runner than on your laptop, and neither is wrong.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;what-we-do-about-it&quot;&gt;What we do about it&lt;&#x2F;h2&gt;
&lt;p&gt;&lt;code&gt;bomwerk scan&lt;&#x2F;code&gt; sorts everything before it writes, emits canonical JSON with fixed key order, and derives each component identifier as a UUIDv5 of its purl (Package URL — the &lt;code&gt;pkg:generic&#x2F;zlib@1.2.11&lt;&#x2F;code&gt; style string that names a package unambiguously). UUIDv5 is a hash, not a dice roll: same purl in, same UUID out, this year and next. Timestamps honour &lt;code&gt;SOURCE_DATE_EPOCH&lt;&#x2F;code&gt;, the reproducible-builds convention, so your CI can pin them.&lt;&#x2F;p&gt;
&lt;p&gt;The result is that two runs on the same inputs give you the same bytes, and a diff across two releases contains only things that actually changed.&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;console&quot; class=&quot;language-console &quot;&gt;&lt;code class=&quot;language-console&quot; data-lang=&quot;console&quot;&gt;$ bomwerk scan . -o &amp;#x2F;tmp&amp;#x2F;a.json &amp;amp;&amp;amp; bomwerk scan . -o &amp;#x2F;tmp&amp;#x2F;b.json
$ diff &amp;#x2F;tmp&amp;#x2F;a.json &amp;#x2F;tmp&amp;#x2F;b.json &amp;amp;&amp;amp; echo &amp;quot;identical&amp;quot;
identical

$ diff &amp;lt;(jq -r &amp;#x27;.components[]|&amp;quot;\(.name) \(.version)&amp;quot;&amp;#x27; sbom-4.2.1.json) \
       &amp;lt;(jq -r &amp;#x27;.components[]|&amp;quot;\(.name) \(.version)&amp;quot;&amp;#x27; sbom-4.2.2.json)
&amp;lt; mbedtls 2.28.3
&amp;gt; mbedtls 2.28.8
&amp;gt; tinycbor 0.6.0
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;That second block is the whole point. Two lines changed, one component added. You can put that in an email.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;while-we-re-here-it-shouldn-t-crash-either&quot;&gt;While we&#x27;re here: it shouldn&#x27;t crash either&lt;&#x2F;h2&gt;
&lt;p&gt;A related habit. Every component producer in bomwerk returns a result rather than throwing, and a parser that hits something it can&#x27;t read emits a warning and keeps going. You get partial output plus a list of what it couldn&#x27;t handle.&lt;&#x2F;p&gt;
&lt;p&gt;This sounds like a small design note. It isn&#x27;t. A scanner that dies on one malformed archive in a 400-directory tree hands you nothing at all, and in CI that means a red build and an engineer who starts thinking of the SBOM step as the flaky one. Degraded output beats no output, as long as the tool is honest about which parts are degraded. The CLI also separates &quot;ran fine but found problems&quot; from &quot;couldn&#x27;t run&quot; in its exit codes, so your pipeline can treat those differently instead of failing on both.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;where-this-stops-working&quot;&gt;Where this stops working&lt;&#x2F;h2&gt;
&lt;p&gt;Determinism is only about the tool. If your compiler version changes, or a flag changes, the content of a correct SBOM changes too, and it should.&lt;&#x2F;p&gt;
&lt;p&gt;Upgrading bomwerk itself can also shift results, because heuristic fingerprints improve and a component that came back as unknown last month may be identified this month. That&#x27;s an improvement, but it will show up in your diff as churn. Pin the scanner version in CI, record which version produced which SBOM, and upgrade deliberately rather than in the same commit as a release.&lt;&#x2F;p&gt;
&lt;p&gt;And the usual caveat: this is build-accurate with evidence and confidence levels attached, not 100% accuracy. Stable output makes errors easier to spot. It doesn&#x27;t make them go away.&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>Your Scanner Reads Manifests. Your Firmware Doesn&#x27;t Have One.</title>
        <published>2026-07-30T00:00:00+00:00</published>
        <updated>2026-07-30T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://bomwerk.com/blog/your-scanner-reads-manifests/"/>
        <id>https://bomwerk.com/blog/your-scanner-reads-manifests/</id>
        
        <content type="html" xml:base="https://bomwerk.com/blog/your-scanner-reads-manifests/">&lt;p&gt;Open-source scanners like Syft or Trivy do a great job with modern web stacks. Point them at a Node or Python project with a lockfile, and you’ll get a usable Software Bill of Materials (SBOM) in seconds. They’re reliable, well-maintained tools that usually give you everything you need.&lt;&#x2F;p&gt;
&lt;p&gt;Things get tricky when you run them against C or C++ firmware. The output isn’t wrong—it’s just thin. Most scanners rely on package manifests to prove what’s in a repo, and embedded codebases simply don&#x27;t have them&lt;&#x2F;p&gt;
&lt;p&gt;That blind spot starts costing real money on September 11, 2026. That’s when Article 14 of the Cyber Resilience Act (CRA, Regulation (EU) 2024&#x2F;2847) kicks in. From then on, manufacturers must report actively exploited vulnerabilities to ENISA (the EU Agency for Cybersecurity) and their national CSIRT on a strict clock: an early warning within 24 hours of becoming aware, a detailed notification within 72 hours, and a final report within 14 days of releasing a fix. The &lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;digital-strategy.ec.europa.eu&#x2F;en&#x2F;policies&#x2F;cra-reporting&quot;&gt;Commission’s own summary&lt;&#x2F;a&gt; breaks down this reporting cascade best. Crucially, products already on the market count. The bottom line is simple: you can&#x27;t report a vulnerability in a component you don&#x27;t even know you&#x27;re shipping.&lt;&#x2F;p&gt;
&lt;p&gt;Here are the three most common places those components go missing:&lt;&#x2F;p&gt;
&lt;h2 id=&quot;1-vendored-source-with-no-manifest&quot;&gt;1. Vendored source with no manifest&lt;&#x2F;h2&gt;
&lt;p&gt;A vendored dependency is a copy of upstream source sitting in &lt;code&gt;third_party&#x2F;&lt;&#x2F;code&gt;, &lt;code&gt;external&#x2F;&lt;&#x2F;code&gt;, or &lt;code&gt;components&#x2F;&lt;&#x2F;code&gt;. There is no manifest entry for it. Sometimes the version is in a comment. Sometimes it&#x27;s in a &lt;code&gt;CHANGELOG&lt;&#x2F;code&gt; nobody updated. Sometimes it is nowhere at all, and the only evidence is a version macro in a header.&lt;&#x2F;p&gt;
&lt;p&gt;A manifest-driven scanner looks for a manifest, finds none, and reports nothing. It is behaving correctly. The information it needs was never written down.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;2-static-archives&quot;&gt;2. Static archives&lt;&#x2F;h2&gt;
&lt;p&gt;A &lt;code&gt;.a&lt;&#x2F;code&gt; file is a container of ELF (Executable and Linkable Format) relocatable objects plus a symbol index. That&#x27;s it. No version field, no license field, no package name. Nothing in the format carries provenance.&lt;&#x2F;p&gt;
&lt;p&gt;So if you link &lt;code&gt;libimaging.a&lt;&#x2F;code&gt; and that archive internally bundled zlib during its own build, your shipped binary contains zlib and no file in your repo says so. The failure runs the other direction too: the linker pulls only the objects it actually needs, so a dependency your build system declares may never reach the binary at all. Both errors matter to an auditor. One understates what you ship, the other overstates it.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;3-forked-sdks&quot;&gt;3. Forked SDKs&lt;&#x2F;h2&gt;
&lt;p&gt;ESP-IDF, STM32Cube, Zephyr, Yocto layers — teams fork them, pin them, and patch them locally. The version string still reads &lt;code&gt;v4.4.2&lt;&#x2F;code&gt;. What you&#x27;re building is &lt;code&gt;v4.4.2&lt;&#x2F;code&gt; plus however many local commits.&lt;&#x2F;p&gt;
&lt;p&gt;Look up a CVE (Common Vulnerabilities and Exposures) record against &lt;code&gt;v4.4.2&lt;&#x2F;code&gt; and you get the upstream answer, which can be wrong in both directions. You may have already patched the issue locally. Or your fork diverged before an upstream fix you never pulled. Resolving this needs commit-level pinning, which is why we read git metadata directly rather than shelling out to &lt;code&gt;git&lt;&#x2F;code&gt; — &lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;bomwerk.com&#x2F;blog&#x2F;why-bomwerk-never-shells-out-to-git&#x2F;&quot;&gt;covered in an earlier post&lt;&#x2F;a&gt;.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;see-it-on-your-own-repo&quot;&gt;See it on your own repo&lt;&#x2F;h2&gt;
&lt;p&gt;You don&#x27;t need our tool to measure the gap. Three commands:&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;console&quot; class=&quot;language-console &quot;&gt;&lt;code class=&quot;language-console&quot; data-lang=&quot;console&quot;&gt;$ find . -type d \( -name third_party -o -name external -o -name vendor \) \
    -not -path &amp;#x27;*&amp;#x2F;.git&amp;#x2F;*&amp;#x27;
.&amp;#x2F;third_party
.&amp;#x2F;components&amp;#x2F;external

$ ar t build&amp;#x2F;lib&amp;#x2F;libimaging.a | head -4
jpeg_decode.o
png_read.o
zlib_inflate.o
tiff_dir.o

$ strings build&amp;#x2F;lib&amp;#x2F;libimaging.a | grep -iE &amp;#x27;(zlib|libpng|libjpeg) [0-9]&amp;#x27; | sort -u
zlib 1.2.11
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;Now compare that against your current SBOM. Every directory in the first result and every recognisable name in the third should appear in it. Count what doesn&#x27;t.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;what-we-do-about-it&quot;&gt;What we do about it&lt;&#x2F;h2&gt;
&lt;p&gt;&lt;code&gt;bomwerk scan&lt;&#x2F;code&gt; handles the lockfile ecosystems you’d expect—npm, PyPI, Go, Cargo, Maven, NuGet—and then keeps going where typical tools stop. It uses heuristics to fingerprint vendored trees through file layouts and version macros. It inspects binaries directly, searching static archives for embedded version strings and symbol patterns. And it leverages Git metadata to assign commit-level identity to forks.&lt;&#x2F;p&gt;
&lt;p&gt;Every component in the generated output comes with two crucial fields: where the evidence came from and our confidence level. Outputs are standard CycloneDX 1.6 or SPDX 3.0.1, the formats asked for by BSI TR-03183-2, the technical guideline from Germany&#x27;s Federal Office for Information Security and currently the most practical field-level spec published. They do not yet carry every field it requires. Dependency relationships between components are not recorded (each component is linked only to the product), and component hashes are SHA-256 where the guideline asks for SHA-512.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;limitations-stated-plainly&quot;&gt;Limitations, stated plainly&lt;&#x2F;h2&gt;
&lt;p&gt;Heuristic identification isn&#x27;t magic, and we won&#x27;t pretend it is. If an archive is completely stripped—with no version strings and no recognizable symbols—it might be unidentifiable. When that happens, we flag it as an unknown component rather than making wild guesses. If a fork has no recoverable upstream lineage, we report it as exactly that.&lt;&#x2F;p&gt;
&lt;p&gt;This tool provides build-accurate visibility backed by transparent evidence and confidence levels—not magic 100% accuracy. Any security vendor telling you they have 100% binary identification accuracy is selling you snake oil.&lt;&#x2F;p&gt;
&lt;p&gt;As for environment support: the CLI builds and runs on Linux and macOS today, from source. Prebuilt, signed binaries for Linux and macOS are planned but not built yet, and Windows binaries are not part of that plan; &lt;a href=&quot;&#x2F;docs&#x2F;#available-today&quot;&gt;what is available today&lt;&#x2F;a&gt; tracks that. The .NET and C# scanners already work on projects from any OS, because they read the project files, not the host.&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>Your SBOM Is One Artifact. The CRA Wants About a Dozen.</title>
        <published>2026-07-23T00:00:00+00:00</published>
        <updated>2026-07-23T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://bomwerk.com/blog/your-sbom-is-one-artifact/"/>
        <id>https://bomwerk.com/blog/your-sbom-is-one-artifact/</id>
        
        <content type="html" xml:base="https://bomwerk.com/blog/your-sbom-is-one-artifact/">&lt;h2 id=&quot;what-a-cyclonedx-file-actually-is&quot;&gt;What a CycloneDX File Actually Is&lt;&#x2F;h2&gt;
&lt;p&gt;Start with the file, because it&#x27;s the thing most teams already have and the thing most teams overestimate.&lt;&#x2F;p&gt;
&lt;p&gt;CycloneDX is a format for writing down what&#x27;s inside your software. It&#x27;s a JSON or XML file listing every component that ships in your product: name, version, license, supplier, and a package URL (purl) that uniquely identifies each one. It&#x27;s maintained by OWASP, the Open Worldwide Application Security Project, and version 1.6 was ratified as an Ecma International standard, ECMA-424, in June 2024. Version 1.7 became the 2nd Edition in December 2025.&lt;&#x2F;p&gt;
&lt;p&gt;The alternative format is SPDX (Software Package Data Exchange), maintained by the Linux Foundation and standardised as ISO&#x2F;IEC 5962. Both describe the same thing. No EU regulation currently mandates one over the other. Pick based on what your customers&#x27; tooling reads.&lt;&#x2F;p&gt;
&lt;p&gt;A CycloneDX file is a &lt;em&gt;software bill of materials&lt;&#x2F;em&gt;, or SBOM: the ingredient list for your product. Here&#x27;s a trimmed one:&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;json&quot; class=&quot;language-json &quot;&gt;&lt;code class=&quot;language-json&quot; data-lang=&quot;json&quot;&gt;{
  &amp;quot;bomFormat&amp;quot;: &amp;quot;CycloneDX&amp;quot;,
  &amp;quot;specVersion&amp;quot;: &amp;quot;1.6&amp;quot;,
  &amp;quot;components&amp;quot;: [
    {
      &amp;quot;type&amp;quot;: &amp;quot;library&amp;quot;,
      &amp;quot;name&amp;quot;: &amp;quot;zlib&amp;quot;,
      &amp;quot;version&amp;quot;: &amp;quot;1.3.1&amp;quot;,
      &amp;quot;purl&amp;quot;: &amp;quot;pkg:generic&amp;#x2F;zlib@1.3.1&amp;quot;
    }
  ]
}
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;That&#x27;s it. A list, in a format a machine can read.&lt;&#x2F;p&gt;
&lt;p&gt;Now the part that trips people up: having that file is not the same as complying with the Cyber Resilience Act. The CRA (Regulation (EU) 2024&#x2F;2847) treats the SBOM as one artifact among roughly a dozen. The file answers &quot;what&#x27;s in the product.&quot; The regulation also asks who to contact, what you did about a finding, how long you&#x27;ll support it, and whether you told anyone in time.&lt;&#x2F;p&gt;
&lt;p&gt;Here&#x27;s the rest of the list.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;in-the-repo-five-files-versioned-like-code&quot;&gt;In the Repo: Five Files, Versioned Like Code&lt;&#x2F;h2&gt;
&lt;p&gt;These live next to your source. A developer owns them and they change with each release.&lt;&#x2F;p&gt;
&lt;p&gt;&lt;strong&gt;SECURITY.md&lt;&#x2F;strong&gt; — your vulnerability-disclosure policy, in plain text at the root of the repository. Where to report a problem, how fast you&#x27;ll acknowledge it, and a safe-harbor statement promising you won&#x27;t take legal action against good-faith researchers. Without this, someone who finds a flaw in your firmware has no obvious way to tell you, and their next move is often a public post instead.&lt;&#x2F;p&gt;
&lt;p&gt;&lt;strong&gt;&#x2F;.well-known&#x2F;security.txt&lt;&#x2F;strong&gt; — the same information in a machine-readable form, defined by RFC 9116. About ten lines: a contact address, a link to your full policy, and an &lt;code&gt;Expires&lt;&#x2F;code&gt; date. Automated scanners look for this at a fixed path on your website. The &lt;code&gt;Expires&lt;&#x2F;code&gt; field is the one people forget; once it passes, the file signals that the contact may be stale.&lt;&#x2F;p&gt;
&lt;p&gt;&lt;strong&gt;sbom&#x2F;&amp;lt;product&amp;gt;.cdx.json&lt;&#x2F;strong&gt; — the CycloneDX file above, regenerated by CI (continuous integration, the server that builds your code on every commit) and attached to every release. Regenerated, not hand-maintained. An SBOM edited by hand drifts from the binary within two releases.&lt;&#x2F;p&gt;
&lt;p&gt;&lt;strong&gt;CHANGELOG&lt;&#x2F;strong&gt; — release notes that name fixed vulnerabilities by their CVE ID. CVE stands for Common Vulnerabilities and Exposures: a public catalogue that gives every known flaw a unique identifier like CVE-2018-11235, so two companies discussing the same bug know they mean the same bug. Writing &quot;security fixes&quot; instead of the identifier means your customers cannot tell whether the one they&#x27;re worried about is handled.&lt;&#x2F;p&gt;
&lt;p&gt;&lt;strong&gt;Signed release artifacts&lt;&#x2F;strong&gt; — a checksum and a cryptographic signature on what ships, so someone downloading your firmware can verify it came from you and arrived unmodified.&lt;&#x2F;p&gt;
&lt;p&gt;Together these are roughly an afternoon of work. That estimate is honest for the repo files and dishonest if you extend it to what follows.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;per-product-the-part-that-takes-longer&quot;&gt;Per Product: The Part That Takes Longer&lt;&#x2F;h2&gt;
&lt;p&gt;These are company-level and mostly internal. They&#x27;re where teams stall, because no single engineer owns them.&lt;&#x2F;p&gt;
&lt;p&gt;&lt;strong&gt;Technical File (Annex VII)&lt;&#x2F;strong&gt; — the evidence dossier: product description, risk assessment, the SBOM, test evidence, a description of how you deliver updates, and your coordinated vulnerability disclosure (CVD) policy. Article 31 requires you to keep it, and the EU declaration of conformity, available to market surveillance authorities for at least ten years after the product is placed on the market, or the length of the support period, whichever is longer.&lt;&#x2F;p&gt;
&lt;p&gt;&lt;strong&gt;Support period and end-of-life date&lt;&#x2F;strong&gt; — how long you guarantee security updates. Market surveillance authorities are required to monitor how manufacturers set this, and the regulation&#x27;s administrative cooperation group publishes statistics on average support periods by product category. A five-year period is a common practical floor for industrial hardware, not a number the regulation states.&lt;&#x2F;p&gt;
&lt;p&gt;&lt;strong&gt;Vulnerability register&lt;&#x2F;strong&gt; — every finding logged with its source, the decision made, and the dates. This is the unglamorous one, and it&#x27;s the one that decides whether you make the reporting deadline. It&#x27;s also the thing that turns &quot;are we affected?&quot; from a week of archaeology into a query.&lt;&#x2F;p&gt;
&lt;p&gt;&lt;strong&gt;VEX statements&lt;&#x2F;strong&gt; — Vulnerability Exploitability eXchange. The structured way to say &quot;CVE-X is present in product Y but not exploitable, because the affected function is never called.&quot; Without VEX, every CVE in a dependency becomes a customer email you answer by hand.&lt;&#x2F;p&gt;
&lt;p&gt;&lt;strong&gt;User information (Annex II)&lt;&#x2F;strong&gt; and, from 11 December 2027, an &lt;strong&gt;EU Declaration of Conformity&lt;&#x2F;strong&gt; plus &lt;strong&gt;CE marking&lt;&#x2F;strong&gt; — the conformity mark already on European electronics. Default-class products are self-assessed. Higher-risk categories need a notified body, an independent accredited assessor. Worth knowing: as of mid-2026, no notified bodies had yet been designated for the CRA in the Commission&#x27;s NANDO database, though the rules for designating them started applying on 11 June 2026.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;the-concrete-case&quot;&gt;The Concrete Case&lt;&#x2F;h2&gt;
&lt;p&gt;You ship firmware v2.3.1 for an industrial gateway built on Zephyr. Three weeks later a library you vendored two years ago, not something you wrote or watch, gets a CVE added to CISA&#x27;s Known Exploited Vulnerabilities (KEV) catalogue: the US agency&#x27;s list of flaws confirmed to be exploited in the wild, not merely theoretical.&lt;&#x2F;p&gt;
&lt;p&gt;The CRA clock starts when you become &lt;em&gt;aware&lt;&#x2F;em&gt; that a vulnerability in your product is being actively exploited. Not when it&#x27;s published, not when you patch. From that moment: 24 hours for an early warning to your national CSIRT (Computer Security Incident Response Team) and ENISA, the EU&#x27;s cybersecurity agency, through the Single Reporting Platform. 72 hours for a fuller notification. 14 days after a fix exists for a final report.&lt;&#x2F;p&gt;
&lt;p&gt;If your vulnerability register doesn&#x27;t already know that library is in your shipped binary, you learn about the deadline after it passed.&lt;&#x2F;p&gt;
&lt;p&gt;This is what build-accurate means in practice: an SBOM derived from what the build actually produced, rather than inferred from a manifest, so a vendored &lt;code&gt;.a&lt;&#x2F;code&gt; archive appears whether or not anyone remembers adding it.&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;bash&quot; class=&quot;language-bash &quot;&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;$ bomwerk scan . --format cyclonedx -o sbom&amp;#x2F;gateway-fw-2.3.1.cdx.json
[bomwerk] scanning . (vcpkg.json + 3 vendored libs)
[bomwerk] resolved 214 components
[bomwerk] diff vs sbom&amp;#x2F;gateway-fw-2.3.0.cdx.json: +2 components, 1 version bump
[bomwerk] wrote sbom&amp;#x2F;gateway-fw-2.3.1.cdx.json (CycloneDX 1.6)
exit 0
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;Exit 0 means the scan completed and nothing on the KEV catalogue is unresolved. Exit 1 or 2 means stop: a component didn&#x27;t resolve, or a KEV hit has no VEX decision. The same check a human runs down the checklist by hand, except it runs every time rather than when someone remembers.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;two-dates-and-who-enforces-them&quot;&gt;Two Dates, and Who Enforces Them&lt;&#x2F;h2&gt;
&lt;p&gt;The reporting duty starts &lt;strong&gt;11 September 2026&lt;&#x2F;strong&gt;, and it applies to products already on the market, not only new ones. The rest, conformity assessment, technical documentation, CE marking, applies from &lt;strong&gt;11 December 2027&lt;&#x2F;strong&gt;.&lt;&#x2F;p&gt;
&lt;p&gt;Enforcement is national. Article 52 requires each member state to designate one or more market surveillance authorities, working under the existing Market Surveillance Regulation (EU) 2019&#x2F;1020 for inspections and corrective measures. Germany has designated the BSI, its federal information security office. Several other states had not published a designation as of mid-2026. The rules are identical everywhere, because the CRA is a regulation rather than a directive; who knocks on your door differs by country.&lt;&#x2F;p&gt;
&lt;p&gt;Customers regulated under NIS2, the EU&#x27;s directive covering operators of essential services, are already asking suppliers for SBOMs and CVD policies, ahead of both dates.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;where-bomwerk-fits-honestly&quot;&gt;Where bomwerk Fits, Honestly&lt;&#x2F;h2&gt;
&lt;p&gt;&lt;code&gt;bomwerk scan&lt;&#x2F;code&gt; produces a build-accurate SBOM today, in CycloneDX or SPDX. It does not yet scaffold SECURITY.md or security.txt for you; that&#x27;s planned, not shipped. Everything in the per-product section above is still your paperwork, not something a scanner generates.&lt;&#x2F;p&gt;
&lt;p&gt;If you want to know what your own repository actually contains, that&#x27;s the part we handle. We&#x27;ll scan one repository free and show you the real inventory, gaps and low-confidence entries included. For the regulation itself rather than our reading of it, start with &lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;eur-lex.europa.eu&#x2F;eli&#x2F;reg&#x2F;2024&#x2F;2847&#x2F;oj&#x2F;eng&quot;&gt;Regulation (EU) 2024&#x2F;2847 on EUR-Lex&lt;&#x2F;a&gt; and the &lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;digital-strategy.ec.europa.eu&#x2F;en&#x2F;policies&#x2F;cra-summary&quot;&gt;Commission&#x27;s own summary&lt;&#x2F;a&gt;. If the CRA itself is new to you, our &lt;a href=&quot;&#x2F;blog&#x2F;what-is-the-cyber-resilience-act&#x2F;&quot;&gt;plain-English guide to the regulation&lt;&#x2F;a&gt; covers scope, fines, and the reporting clock in more detail.&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>Why bomwerk never shells out to git</title>
        <published>2026-07-16T00:00:00+00:00</published>
        <updated>2026-07-16T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://bomwerk.com/blog/why-bomwerk-never-shells-out-to-git/"/>
        <id>https://bomwerk.com/blog/why-bomwerk-never-shells-out-to-git/</id>
        
        <content type="html" xml:base="https://bomwerk.com/blog/why-bomwerk-never-shells-out-to-git/">&lt;h2 id=&quot;the-problem&quot;&gt;The Problem&lt;&#x2F;h2&gt;
&lt;p&gt;A software bill of materials, or SBOM, is the inventory of everything that actually ships inside a product: every library, every version, every dependency. Building an accurate one for a C&#x2F;C++ project means answering a very ordinary question: which exact commit is each vendored library pinned to?&lt;&#x2F;p&gt;
&lt;p&gt;That sounds like something a computer should be able to tell you in a fraction of a second. It can. The complication isn&#x27;t finding the answer, it&#x27;s finding it safely when the code under inspection came from someone else, which is the entire point of a scanning tool.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;the-obvious-solution&quot;&gt;The Obvious Solution&lt;&#x2F;h2&gt;
&lt;p&gt;Git already knows the answer, so the natural move is to ask it directly:&lt;&#x2F;p&gt;
&lt;pre data-lang=&quot;bash&quot; class=&quot;language-bash &quot;&gt;&lt;code class=&quot;language-bash&quot; data-lang=&quot;bash&quot;&gt;$ git submodule status
 4c1f8ae0e6b5d7f2a91c3b8e7d4f6a2c9b1e5d80 vendor&amp;#x2F;zlib (v1.3.1)
 a91c3b8e7d4f6a2c9b1e5d804c1f8ae0e6b5d7f2 vendor&amp;#x2F;mbedtls (heads&amp;#x2F;main)
&lt;&#x2F;code&gt;&lt;&#x2F;pre&gt;
&lt;p&gt;Split each line on whitespace, keep the first column, done. Fifteen minutes of work including a test. It runs the &lt;code&gt;git&lt;&#x2F;code&gt; program as a subprocess, meaning your scanner hands off the work to another already-running program instead of doing it itself, and reads back whatever that program prints. It works perfectly on your own repositories, on your own laptop, which is exactly the setting where nothing is wrong yet.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;why-the-obvious-solution-doesn-t-work-at-all&quot;&gt;Why the Obvious Solution Doesn&#x27;t Work at All&lt;&#x2F;h2&gt;
&lt;p&gt;Here&#x27;s what changes the moment that repository didn&#x27;t come from you: when you run &lt;code&gt;git&lt;&#x2F;code&gt; inside a directory, git doesn&#x27;t just report facts. It reads that directory&#x27;s own settings file, &lt;code&gt;.git&#x2F;config&lt;&#x2F;code&gt;, and follows instructions written inside it. Not your settings. Whatever settings the folder came with.&lt;&#x2F;p&gt;
&lt;p&gt;Git&#x27;s config format documents several settings that name an external program for git to run automatically during ordinary operations, things like &lt;code&gt;core.fsmonitor&lt;&#x2F;code&gt;, &lt;code&gt;core.pager&lt;&#x2F;code&gt;, and &lt;code&gt;diff.external&lt;&#x2F;code&gt;. A &lt;code&gt;.git&#x2F;config&lt;&#x2F;code&gt; file can legitimately contain a line that runs a script the moment you type an everyday git command, and that script runs with your permissions, not the repository author&#x27;s.&lt;&#x2F;p&gt;
&lt;p&gt;This isn&#x27;t theoretical. It&#x27;s been the exact mechanism behind real, patched vulnerabilities:&lt;&#x2F;p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;nvd.nist.gov&#x2F;vuln&#x2F;detail&#x2F;CVE-2018-11235&quot;&gt;CVE-2018-11235&lt;&#x2F;a&gt; let a malicious submodule name contain a directory-traversal sequence, so cloning a booby-trapped repository could run arbitrary code on the machine that cloned it.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;nvd.nist.gov&#x2F;vuln&#x2F;detail&#x2F;cve-2022-24765&quot;&gt;CVE-2022-24765&lt;&#x2F;a&gt; showed that on a shared machine, git could be tricked into reading and trusting configuration from a directory it had no business trusting, simply because it happened to look like a git repository.&lt;&#x2F;li&gt;
&lt;&#x2F;ul&gt;
&lt;p&gt;Different exact mechanisms, same root cause: git, by default, extends a surprising amount of trust to the directory it&#x27;s currently sitting in. A scanning tool&#x27;s whole job is inspecting code it did not write and has no reason to trust, so inheriting that trust automatically is exactly backwards.&lt;&#x2F;p&gt;
&lt;p&gt;A fair objection: cloning from a URL never hands you a hostile &lt;code&gt;.git&#x2F;config&lt;&#x2F;code&gt;, so who&#x27;s actually at risk? Anyone who hands over a folder instead of a link. A vendor&#x27;s source drop. A customer&#x27;s tarball you unzip to scan. A CI cache restored from somewhere you didn&#x27;t build. bomwerk exists specifically to scan exactly those, so treating any of them as automatically trustworthy isn&#x27;t an option.&lt;&#x2F;p&gt;
&lt;p&gt;There&#x27;s a duller, less dramatic reason too: shelling out to git means git has to be installed, at a compatible version, with output stable enough to parse reliably. Plenty of CI build agents don&#x27;t have git installed at all. bomwerk runs on machines we don&#x27;t get to choose.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;what-bomwerk-does-instead&quot;&gt;What bomwerk Does Instead&lt;&#x2F;h2&gt;
&lt;p&gt;Git&#x27;s on-disk layout is a documented, stable file format, so instead of running the &lt;code&gt;git&lt;&#x2F;code&gt; program, bomwerk reads those files directly, the same way you&#x27;d open a text file.&lt;&#x2F;p&gt;
&lt;p&gt;To find the commit a submodule is pinned to: read &lt;code&gt;&amp;lt;submodule&amp;gt;&#x2F;.git&lt;&#x2F;code&gt;, which is a folder in a normal checkout or a one-line pointer file inside a submodule, follow it to git&#x27;s internal directory, then read the &lt;code&gt;HEAD&lt;&#x2F;code&gt; file inside that directory. If &lt;code&gt;HEAD&lt;&#x2F;code&gt; holds a commit id directly (git calls this a detached HEAD, meaning it&#x27;s pointing straight at a commit instead of a named branch), that&#x27;s the answer. If &lt;code&gt;HEAD&lt;&#x2F;code&gt; instead points at a named reference, such as &lt;code&gt;refs&#x2F;heads&#x2F;main&lt;&#x2F;code&gt;, bomwerk reads that small file too, and falls back to a compact index file called &lt;code&gt;packed-refs&lt;&#x2F;code&gt; if the reference has been archived there.&lt;&#x2F;p&gt;
&lt;p&gt;No subprocess ever runs. &lt;code&gt;.git&#x2F;config&lt;&#x2F;code&gt; is never opened. Git doesn&#x27;t even need to be installed on the machine.&lt;&#x2F;p&gt;
&lt;p&gt;Four rules keep this honest:&lt;&#x2F;p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Every read has a size cap.&lt;&#x2F;strong&gt; A crafted repository can&#x27;t make bomwerk read an unbounded amount of data just by placing an oversized file where a small one is expected.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;Nothing resolves outside the repository being scanned.&lt;&#x2F;strong&gt; If a pointer file tries to lead somewhere outside the folder under scan, bomwerk refuses to follow it and reports that submodule as not checked out instead. This directly closes the path-traversal shape behind CVE-2018-11235.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;No &lt;code&gt;..&lt;&#x2F;code&gt; path segments, ever&lt;&#x2F;strong&gt;, in a submodule path or an internal reference. Git itself never produces &lt;code&gt;..&lt;&#x2F;code&gt; in its own internal references, so rejecting one can only ever catch a tampered file, never a legitimate one.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;Never crash, never guess.&lt;&#x2F;strong&gt; A submodule that&#x27;s declared but not actually checked out still shows up in the output, marked low confidence with a warning, instead of either crashing the scan or silently vanishing.&lt;&#x2F;li&gt;
&lt;&#x2F;ul&gt;
&lt;h2 id=&quot;what-it-actually-cost-us&quot;&gt;What It Actually Cost Us&lt;&#x2F;h2&gt;
&lt;p&gt;We rebuilt a slice of git&#x27;s own internal logic by hand, and hand-rebuilding a mature tool&#x27;s internals is exactly how bugs that tool fixed years ago get reintroduced. We keep a growing library of real and deliberately hostile test repositories specifically because of that risk. We also don&#x27;t yet support every internal storage format git can use; a newer layout called &quot;reftable&quot; isn&#x27;t handled today. And this whole approach only works because git&#x27;s file layout happens to be documented and stable. If it weren&#x27;t readable as plain files, we&#x27;d have to skip that case rather than fall back to running git anyway.&lt;&#x2F;p&gt;
&lt;p&gt;That&#x27;s the trade, stated plainly. A scanner that only reads files is something you can audit line by line. A scanner that executes another program is a dependency you didn&#x27;t choose to take on, sitting inside the very tool you bought to find dependencies you didn&#x27;t choose to take on.&lt;&#x2F;p&gt;
&lt;hr &#x2F;&gt;
&lt;p&gt;If your current SBOM tool runs on C&#x2F;C++ repositories today, it&#x27;s worth asking whether it shells out to git, and what it does with a submodule that&#x27;s declared but never checked out. Curious how this connects to the &lt;a href=&quot;&#x2F;blog&#x2F;what-is-the-cyber-resilience-act&#x2F;&quot;&gt;EU Cyber Resilience Act reporting clock&lt;&#x2F;a&gt;? An accurate inventory like this is what makes &quot;are we affected?&quot; answerable in minutes. Or skip ahead: we&#x27;ll scan one repository free and show you what your current tool reports versus what&#x27;s actually pinned in your tree.&lt;&#x2F;p&gt;
</content>
        
    </entry>
    <entry xml:lang="en">
        <title>What Is the Cyber Resilience Act? Could You Actually Be Fined?</title>
        <published>2026-07-09T00:00:00+00:00</published>
        <updated>2026-07-09T00:00:00+00:00</updated>
        
        <author>
          <name>
            
              Unknown
            
          </name>
        </author>
        
        <link rel="alternate" type="text/html" href="https://bomwerk.com/blog/what-is-the-cyber-resilience-act/"/>
        <id>https://bomwerk.com/blog/what-is-the-cyber-resilience-act/</id>
        
        <content type="html" xml:base="https://bomwerk.com/blog/what-is-the-cyber-resilience-act/">&lt;p&gt;Short answer: the Cyber Resilience Act, usually shortened to CRA, is an EU law that says software and connected devices sold in the EU must be reasonably secure, and that manufacturers must tell the authorities quickly when something goes wrong. It applies whether your company is based in Berlin, Madrid, or Amsterdam, and it applies just as much if you&#x27;re outside the EU and simply sell into it. The rest of this guide is the detail behind that sentence: what counts as &quot;connected,&quot; what &quot;quickly&quot; means in hours, and what happens if you miss it.&lt;&#x2F;p&gt;
&lt;p&gt;This is not legal advice. It&#x27;s our honest reading of the regulation, written for people who have a product to ship, not a law degree. Where a number matters, we link the source so you can check it yourself.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;who-actually-has-to-comply-with-the-cra&quot;&gt;Who Actually Has to Comply With the CRA&lt;&#x2F;h2&gt;
&lt;p&gt;The CRA covers &quot;products with digital elements,&quot; a deliberately broad category: hardware or software placed on the EU market that can connect, directly or indirectly, to another device or network. That includes a smart thermostat, a fitness app, a factory sensor, a payment terminal, and a code library your customers install. If it runs code and it talks to something else, it is very likely in scope.&lt;&#x2F;p&gt;
&lt;p&gt;Two categories are carved out because other rules already cover them in detail: medical devices and cars have their own sector-specific security regulations, so the CRA doesn&#x27;t double-regulate them.&lt;&#x2F;p&gt;
&lt;p&gt;A useful comparison is a food ingredients label. Buy packaged food in the EU and by law you get a list of what&#x27;s in it. Buy a router or a building-access controller, and until now you usually got a marketing brochure instead of an ingredients list. The CRA is the EU closing that gap for software.&lt;&#x2F;p&gt;
&lt;p&gt;Higher-risk product categories, called &quot;important&quot; or &quot;critical&quot; under the regulation, need an independent check before they can be sold: a notified body, meaning a certification organization accredited by a member state, has to review the product and confirm it meets the requirements before it can carry CE marking, the compliance mark you already see on European electronics and toys.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;the-two-cra-deadlines-that-actually-matter&quot;&gt;The Two CRA Deadlines That Actually Matter&lt;&#x2F;h2&gt;
&lt;p&gt;The regulation has dozens of dates buried in it, but only two change what you have to do:&lt;&#x2F;p&gt;
&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;Date&lt;&#x2F;th&gt;&lt;th&gt;What happens&lt;&#x2F;th&gt;&lt;&#x2F;tr&gt;&lt;&#x2F;thead&gt;&lt;tbody&gt;
&lt;tr&gt;&lt;td&gt;&lt;strong&gt;11 September 2026&lt;&#x2F;strong&gt;&lt;&#x2F;td&gt;&lt;td&gt;Reporting obligations start. If you have an actively exploited vulnerability or a severe incident, the reporting clock described below applies from this date.&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;&lt;strong&gt;11 December 2027&lt;&#x2F;strong&gt;&lt;&#x2F;td&gt;&lt;td&gt;Full application. Conformity assessment, technical documentation, and CE marking: the whole regulation is in force.&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;&#x2F;tbody&gt;&lt;&#x2F;table&gt;
&lt;p&gt;Everything else, your software bill of materials, your vulnerability-handling process, your update policy, needs to already exist by the time these dates land, because building it in the two weeks before a deadline isn&#x27;t realistic for most teams.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;the-cra-reporting-clock-24-hours-72-hours-14-days&quot;&gt;The CRA Reporting Clock: 24 Hours, 72 Hours, 14 Days&lt;&#x2F;h2&gt;
&lt;p&gt;This is the part that surprises people, so it&#x27;s worth being precise about it.&lt;&#x2F;p&gt;
&lt;p&gt;The clock doesn&#x27;t start when a vulnerability is published, when it receives a CVE (Common Vulnerabilities and Exposures) identifier from the &lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;www.cve.org&#x2F;&quot;&gt;public catalog of known security flaws&lt;&#x2F;a&gt;, or when a researcher writes about it. It starts the moment you, the manufacturer, become aware that a vulnerability in your product is being actively exploited, or that a severe incident has affected it. Awareness is the trigger, not disclosure and not publication.&lt;&#x2F;p&gt;
&lt;p&gt;From that moment:&lt;&#x2F;p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;24 hours&lt;&#x2F;strong&gt;: an early-warning notification to your national CSIRT (Computer Security Incident Response Team, the government cybersecurity response office in each member state) and to ENISA, the EU&#x27;s cybersecurity agency, submitted through the CRA Single Reporting Platform. At this stage you&#x27;re allowed to say you don&#x27;t have all the details yet.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;72 hours&lt;&#x2F;strong&gt;: a fuller notification covering what you know so far and, if relevant, what you&#x27;re doing about it.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;14 days after a fix or mitigation exists&lt;&#x2F;strong&gt;: a final report closing out the vulnerability. Severe incidents that aren&#x27;t tied to a specific vulnerability follow a similar path, with a one-month final report instead.&lt;&#x2F;li&gt;
&lt;&#x2F;ul&gt;
&lt;p&gt;A car recall is a useful comparison. If a manufacturer learns their brakes are failing in the field, they don&#x27;t get to wait for a journalist to notice before telling the regulator. The CRA applies that same logic to software: once you know something is being actively exploited, staying quiet is itself the violation.&lt;&#x2F;p&gt;
&lt;p&gt;In practice, this means &quot;we&#x27;ll figure out our exposure when it happens&quot; isn&#x27;t a plan. You need to already know what&#x27;s in your product, which is the entire point of a software bill of materials (SBOM), a machine-readable inventory of every component that ships. When a new CVE lands, answering &quot;are we affected?&quot; should take minutes, not a week of digging through old build logs.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;could-you-actually-be-fined-under-the-cra&quot;&gt;Could You Actually Be Fined Under the CRA?&lt;&#x2F;h2&gt;
&lt;p&gt;Yes, and the ceiling isn&#x27;t small. Article 64 of the regulation sets three tiers, and the fine is whichever is higher between a flat euro amount and a percentage of your company&#x27;s total worldwide annual turnover, the same structure GDPR uses if that comparison is familiar to you:&lt;&#x2F;p&gt;
&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;Tier&lt;&#x2F;th&gt;&lt;th&gt;Maximum fine&lt;&#x2F;th&gt;&lt;th&gt;What it&#x27;s for&lt;&#x2F;th&gt;&lt;&#x2F;tr&gt;&lt;&#x2F;thead&gt;&lt;tbody&gt;
&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Top tier&lt;&#x2F;strong&gt;&lt;&#x2F;td&gt;&lt;td&gt;€15 million, or 2.5% of worldwide turnover&lt;&#x2F;td&gt;&lt;td&gt;Failing the essential cybersecurity requirements, or failing the vulnerability-handling and reporting obligations described above&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Middle tier&lt;&#x2F;strong&gt;&lt;&#x2F;td&gt;&lt;td&gt;€10 million, or 2% of worldwide turnover&lt;&#x2F;td&gt;&lt;td&gt;Various conformity, documentation, and procedural obligations, including registration, technical files, and cooperating with authorities&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Lower tier&lt;&#x2F;strong&gt;&lt;&#x2F;td&gt;&lt;td&gt;€5 million, or 1% of worldwide turnover&lt;&#x2F;td&gt;&lt;td&gt;Giving notified bodies or market surveillance authorities incorrect, incomplete, or misleading information&lt;&#x2F;td&gt;&lt;&#x2F;tr&gt;
&lt;&#x2F;tbody&gt;&lt;&#x2F;table&gt;
&lt;p&gt;Two exceptions matter for smaller teams:&lt;&#x2F;p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Microenterprises and small enterprises&lt;&#x2F;strong&gt; can&#x27;t be fined specifically for missing the 24-hour early-warning deadline. That doesn&#x27;t exempt you from the CRA&#x27;s other obligations; the 72-hour notification and the final report still stand, and you still have to build a secure product and handle vulnerabilities properly. It just removes the fine for a late early warning.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;strong&gt;Open-source software stewards&lt;&#x2F;strong&gt;, meaning non-commercial foundations and maintainers broadly, are exempt from CRA fines entirely. They have separate, lighter obligations under a different part of the regulation.&lt;&#x2F;li&gt;
&lt;&#x2F;ul&gt;
&lt;h2 id=&quot;does-the-cra-apply-the-same-way-in-every-eu-country&quot;&gt;Does the CRA Apply the Same Way in Every EU Country?&lt;&#x2F;h2&gt;
&lt;p&gt;Mostly yes, and understanding why answers the question for any pair of countries you care about, whether that&#x27;s Spain and the Netherlands or Portugal and France. The CRA is a regulation, not a directive. A directive sets a goal and each country writes its own national law to reach it, which is why something like data-retention rules can vary from country to country. A regulation applies directly, word for word, on the same day, in every member state. A company in Spain and a company in the Netherlands are reading the exact same Article 64. So are companies in Portugal and France.&lt;&#x2F;p&gt;
&lt;p&gt;What does vary by country is enforcement. Each member state has to designate its own market surveillance authority, the body that actually investigates and imposes fines locally. As of this writing, we couldn&#x27;t find a public, confirmed list of which specific authority any of these four countries has designated for that role. The EU&#x27;s own implementation tracker doesn&#x27;t have it filled in yet either. If you need to know who to talk to in your country, check the &lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;digital-strategy.ec.europa.eu&#x2F;en&#x2F;factpages&#x2F;cyber-resilience-act-implementation&quot;&gt;European Commission&#x27;s implementation page&lt;&#x2F;a&gt; as designations land, rather than trusting a name in a blog post that may already be out of date by the time you read it.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;frequently-asked-questions-about-the-cyber-resilience-act&quot;&gt;Frequently Asked Questions About the Cyber Resilience Act&lt;&#x2F;h2&gt;
&lt;p&gt;&lt;strong&gt;Does the CRA apply to software, or only physical devices?&lt;&#x2F;strong&gt;
Both. &quot;Products with digital elements&quot; covers standalone software, such as a library or an app, as well as hardware that runs software and connects to a network.&lt;&#x2F;p&gt;
&lt;p&gt;&lt;strong&gt;What is a software bill of materials, and do I need one?&lt;&#x2F;strong&gt;
A software bill of materials, or SBOM, is a list of every component inside a product: every library, every dependency, every version. You need one in practice even though the CRA doesn&#x27;t use that exact word in every article, because you cannot answer &quot;are we affected by this CVE&quot; quickly without already knowing what&#x27;s inside your own product.&lt;&#x2F;p&gt;
&lt;p&gt;&lt;strong&gt;Is the CRA the same law as NIS2?&lt;&#x2F;strong&gt;
No. NIS2 sets cybersecurity obligations for operators of essential services and critical infrastructure. The CRA regulates the products themselves, wherever they&#x27;re sold in the EU. Many companies will need to think about both.&lt;&#x2F;p&gt;
&lt;p&gt;&lt;strong&gt;My company is small. Am I exempt from the CRA?&lt;&#x2F;strong&gt;
Not entirely. Microenterprises and small enterprises get relief from one specific fine, the one tied to missing the 24-hour early-warning deadline, but the other reporting deadlines and the underlying security and documentation obligations still apply.&lt;&#x2F;p&gt;
&lt;h2 id=&quot;read-the-actual-cra-text&quot;&gt;Read the Actual CRA Text&lt;&#x2F;h2&gt;
&lt;p&gt;We&#x27;ve tried to be precise above, but we&#x27;re a scanning-tool company, not a law firm. For anything you&#x27;re making a real compliance decision on, go to the source:&lt;&#x2F;p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;eur-lex.europa.eu&#x2F;eli&#x2F;reg&#x2F;2024&#x2F;2847&#x2F;oj&#x2F;eng&quot;&gt;The regulation itself, Regulation (EU) 2024&#x2F;2847&lt;&#x2F;a&gt;, on EUR-Lex, the EU&#x27;s official legal database.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;digital-strategy.ec.europa.eu&#x2F;en&#x2F;policies&#x2F;cra-summary&quot;&gt;The European Commission&#x27;s own plain-language summary&lt;&#x2F;a&gt;.&lt;&#x2F;li&gt;
&lt;li&gt;&lt;a rel=&quot;noopener noreferrer&quot; target=&quot;_blank&quot; href=&quot;https:&#x2F;&#x2F;www.cyberresilienceact.eu&#x2F;&quot;&gt;cyberresilienceact.eu&lt;&#x2F;a&gt;, an independent reference site that tracks the regulation article by article.&lt;&#x2F;li&gt;
&lt;&#x2F;ul&gt;
&lt;hr &#x2F;&gt;
&lt;p&gt;If you&#x27;re trying to answer &quot;what&#x27;s actually in our product&quot; as a first step toward any of this, that&#x27;s the part we handle. See how it works in practice in &lt;a href=&quot;&#x2F;blog&#x2F;why-bomwerk-never-shells-out-to-git&#x2F;&quot;&gt;our post on why bomwerk never runs git on a repo it&#x27;s scanning&lt;&#x2F;a&gt;, or skip ahead: we&#x27;ll scan one repository free and show you what a real SBOM looks like, gaps included.&lt;&#x2F;p&gt;
</content>
        
    </entry>
</feed>
