SBOM, VEX and Supply-Chain Badges: Where openEduSuite's Transparency Stands
The openEduSuite project now generates a software bill of materials in two machine-readable formats, attaches a VEX document that states what is known to be vulnerable, and serves live status badges for its artifacts from its own public registry. Pinning a dependency is only half of supply-chain transparency; the other half is publishing what is inside, what is known to be wrong, and how to check it. This article describes that evidence pipeline, the four badges it produces, and what they currently say, including the gaps.
This is a work-in-progress report, but the register that drives it has been worked down fast: between 13 and 16 November 2026 coverage moved from a single reference image to the whole deployed fleet. Every deployed image is now recorded in a canonical, CI-gated inventory, attested by digest at its source registry and scanned with real layer inventories; a continuous monitoring tier watches the published SBOMs between releases; and the VEX analysis that used to be manual is now an automated, CI-committed workflow. The gap register below still states, item by item, what is finished, what is partial, and what is missing, so that nothing here has to be taken on faith.
What an SBOM is, and why it matters
A software bill of materials (SBOM) is a machine-readable inventory of the components a piece of software is made of. Two open standards dominate: CycloneDX, maintained under the OWASP umbrella, and SPDX, maintained by the Linux Foundation. They list packages, versions, and often licenses, hashes, and supplier information, in a structure that vulnerability scanners, license auditors, and ISMS tooling can consume directly.
For a platform that integrates a broad range of open-source services, an SBOM is the difference between claiming transparency and being able to prove it. Any project can say it reviews its dependencies; an SBOM makes that review a file that can be fetched, parsed, and diffed between versions. The question is not whether a bill of materials is nice to have, it is whether it reflects what was actually built.
Two formats, one build
openEduSuite generates SBOMs at three levels: per Helm chart, per published image, and as a platform-wide aggregate. Every unit is produced in both CycloneDX 1.5 and SPDX 2.3, so consumers can pick the format their tooling speaks.
The generation happens in CI on every relevant change to the dependency set. The correspondence between inputs and evidence matters, but its strength differs by level: for images whose contents are scanned into the SBOM it is direct, while for charts the SBOM records what the chart declares rather than what is inside the deployed layers. The evidence-scope section below draws this line precisely. For the Nix-built images the dependency graph is reproducible by construction, as described in the earlier article on the Nix migration; for classic builds the scan step carries the weight.
VEX: what is known to be vulnerable
An SBOM answers "what is inside". It does not answer "what of it is a problem". That second question is the job of VEX, the Vulnerability Exploitability eXchange, which attaches a per-component status to a known vulnerability: not affected, affected, fixed, or under investigation.
openEduSuite generates OpenVEX documents from real scans. The scan results are mapped into VEX statements, so the document says something concrete about the state of each component rather than merely listing CVEs. Two design choices keep the VEX honest:
- A scan that finds no critical or high findings produces a valid VEX with zero affected statements.
- If the scanner is not available in the environment, the pipeline emits a valid empty VEX document instead of fabricating a status.
The CI pipeline hard-gates on critical and high findings: a build that introduces one fails. The VEX artifact is still published on failure, so the state is visible even when the gate trips.
Two later additions keep that gate honest rather than cosmetic. Since 16 November 2026 the scanner's per-component severity flows into every VEX statement, so a consumer of the document sees whether an affected finding is critical, high, low, or unknown instead of a blank. The fleet delta gate reads the same field, which means a newly introduced affected critical or high finding trips the gate on the strength of the document itself, not on an unverifiable assumption. And what the VEX documents collectively say is now analysed as a workflow rather than a one-off script: a daily CI job aggregates every OpenVEX document into a committed report with dated snapshots, gates on new untriaged critical/high findings compared with the last committed report, and reacts honestly โ a reconcile step only ever flips a finding to fixed on proof of absence in current scans, and a propose step emits only human-approved grouping suggestions.
Where the evidence lives: the public registry
The publication target is the project's own registry at registry.openedusuite.org, readable by anyone without an account. The SBOM and the VEX are attached to images as OCI referrer artifacts: each artifact references the image manifest it belongs to, which makes the pair discoverable through the registry API at /v2/<repo>/referrers/<digest> and pullable with standard OCI tooling such as oras.
The OpenCloud image the pipeline publishes, openedusuite-nix/opencloud:9.1.0-nix from the earlier public registry article, is the current reference case and resolves to two referrer artifacts, one CycloneDX SBOM and one OpenVEX document. Since 13 November 2026 the CI pipeline generates per-image CycloneDX and SPDX SBOMs for the curated Nix fleet published under openedusuite-nix/, holds them to the same scan-mandatory gate, and attaches referrers through automatic registry discovery on publish. On 14 November 2026 the canonical set was aligned to the live registry catalog: all 14 published nix images are generated and scanned (opencloud, caldav, element, weaviate, postgres-bbb, redis-bbb, discourse-postgres, dex, k8up, postgresql, cloudnative-pg, agentflow, helmfile, collab-dashboard); the earlier list carried six entries that were never pushed to the own registry (they deploy from the internal cluster registry and are covered by chart-level SBOMs). opencloud stays the live-verified reference case, and the per-image referrers beyond it are confirmed on each pipeline run. The platform-wide aggregate SBOM and VEX live in a dedicated repository alongside the per-image badges, and the whole evidence set is regenerated and re-published by CI on releases and on updates to the main branch.
Since 15 November 2026 coverage extends beyond the Nix fleet to everything the platform deploys. A canonical, CI-gated inventory of the deployed fleet is committed with the pipeline: 192 unique image references today, split 96 served from the project's own registry and fleet mirror and 96 pulled directly from upstream registries, all of them pinned by version tag or digest. Every upstream unit is resolved to a current digest at its source registry โ a bearer-token handshake, never a fabricated value โ and recorded with its source and timestamp (96/96 attested, none unresolved). Those digests are then scanned individually, so each deployed upstream image gets a per-image SBOM with its real layer inventory rather than the chart's declaration.
The registry is the machine-readable source of truth. Everything that follows, including the badges, is a derived view of the same data.
The badge system
Badges turn the machine-readable evidence into something that can be read at a glance and embedded anywhere, for example in a repository README. openEduSuite generates its own shields-format endpoint badges in CI and serves them from its own registry, at /badge/<kind>/<name>.json. Hosting the endpoint itself matters: the data and the URL stay under the project's control, and the badges are produced from the same scan and VEX results that are published as artifacts, never handwritten.
Each unit of software and the platform as a whole get four badges:
| Badge | Meaning |
|---|---|
sbom |
Whether a bill of materials exists, and in which formats |
vulns |
Count of critical and high findings from the latest scan |
vex |
Number of VEX statements marking components as affected |
signed |
Whether the artifact is recorded as signed in the pipeline |
The JSON follows the shields endpoint schema (label, message, color) and asks consumers to cache it for five minutes; the values update as new evidence is published.
What the badges say today
Read live from the platform badge set on 2026-11-16 (payload timestamp 2026-11-15T23:17Z):
| Badge | Current value | What it means |
|---|---|---|
sbom |
cyclonedx+spdx |
Both formats are generated and published for the platform |
vulns |
0 affected |
The latest scan and its VEX show no component marked affected โ no critical or high findings |
vex |
0 affected |
No component is currently marked as affected by a known vulnerability |
signed |
yes |
The published artifacts carry keyless cosign attestations (Fulcio + Rekor), verified with cosign verify-attestation |
The fourth row is now green. The pipeline attests each published image keylessly with cosign (the CycloneDX SBOM is bound as a signed in-toto attestation to the image digest) and signs the platform SBOM blob; the per-unit signed markers flow into the badge. Earlier runs recorded this step as best-effort and reported no โ the badge existed precisely to surface that unfinished detail; it now reports the recorded success. The keyless verification chain (Fulcio + Rekor) is exercised in CI on every publish.
Monitoring between releases
Badges and VEX are snapshots; a platform also needs to notice when a new advisory affects what is already deployed. Since 15 November 2026 openEduSuite runs a continuous monitoring tier for exactly that: a Dependency-Track instance in the production deployment ingests every CycloneDX SBOM through the same pipeline that publishes it, on a schedule and on every release, and the resulting findings feed back into the evidence pipeline. The first verified round-trip was not a dry run: uploading one real image SBOM produced 17 findings โ 1 critical, 12 high and 4 medium, including current-year advisories โ the class of signal a platform wants surfaced between releases rather than discovered at build time.
Evidence scope: what these SBOMs actually are
Precision about what the files contain is part of the honesty:
- Chart-level SBOMs (
sbom-chart-*) come from each Helm chart'sChart.yaml. They record what the chart declares: its dependencies and the image references in its values. They are declared-dependency metadata, not an inventory of the runtime layers inside the images the chart deploys. Since 15 November 2026 they also record each concrete image reference from the chart values, with a digest attached whenever one is known and an explicitdigest-resolved=falsemarker instead of an invented value when it is not. - Image-level SBOMs (
sbom-image-*) come from the images themselves. When a scanner such as Syft is available on the CI runner, they are augmented with the real layer inventory of the image. Without a scanner they degrade to a valid but metadata-only document that names the image without listing its contents, and the pipeline must not pretend otherwise. - Fleet image SBOMs (
sbom-fleet-*) close the gap between the two: a scan-against-digests step takes each attested upstream digest and inventories its real layers. The leap is concrete โ one deployed Akka chat backend went from 0 components in its chart-level document to over 7,000 in its scanned fleet SBOM. - The platform aggregate merges the unit documents into one CycloneDX and one SPDX report. It is only as deep as the units it merges.
Coverage is real, depth is uneven, and both are stated here.
Deployed images vs. the registry
A fair question is whether registry.openedusuite.org holds every image the platform runs. It does not โ and since 15 November 2026 that is a measured, ledgered fact instead of an estimate. The registry holds what the project builds and publishes itself: the Nix-built subset (opencloud, dex, k8up, postgresql, cloudnative-pg, agentflow, helmfile, collab-dashboard, rspamd), the typst-render mirror that moved into the project namespace, and the sbom and badge repositories. The deployed fleet is larger: the Helm charts reference dozens of upstream images from Docker Hub, ghcr.io, quay.io and other registries (the monitoring stack, n8n, Zammad, TYPO3, Grommunio, Etherpad, SeaweedFS, RStudio and more), several custom images built with classic Dockerfiles, and the Node-based service on third-party base images. Upstream images run from their upstream registries, and the suite's classic custom images live under ghcr.io/openedusuite. Those units are not mirrored onto the own registry one for one โ but they are no longer invisible: each is attested by digest at its source and scanned with a real layer inventory, recorded in the same ledger the badges derive from.
Why not every image is Nix-built
Update (2026-11-16) โ policy: the platform is committed to a fully NixOS container fleet, no exceptions. The mixed fleet described below is not the accepted end state; it is the actively shrinking migration backlog, tracked per unit in the register (SCG-014). In the same decision bare
latestwas outlawed as an end state anywhere: every deployed reference must carry a version tag or a digest (SCG-009/014). Wave 0 shipped the same evening โ the ten remaining barelatestrefs across the fleet (Nxmig-001โฆ010) are all pinned now, the committed inventory holds zero unpinned refs, and the gate is green; what remains is the Nix conversion of the classic own images (Wave 1) and the upstream long tail (Wave 2).Update (2026-11-17) โ waves 1 and 2: the derivation backlog of Wave 1 is now created, built and published: the project's Nix flake carries 55 image derivations โ the original 17 Nix-built images, 12 more built from nixpkgs (node-exporter, oauth2-proxy, hedgedoc, grafana, prometheus, rspamd, mariadb, mysqld-exporter, openldap, stalwart, git, memcached-exporter), and 26 bespoke own images newly converted to digest-pinned
dockerTools.pullImagederivations (AppSuite components and operation-guide images, Indico, k8up, dkimpy-milter, own service images, SOGo variants, CloudNativePG, drawio, excalidraw, XWiki and more). All 55 are built on the in-cluster nix-builder and published to both the project's registry and the fleet mirror. Wave 2 mirrored all 96 upstream refs into the fleet registry (two digest-pinned images by digest only). What remains is the rollout: pointing each deployment manifest at its Nix-built equivalent (per-unit Nxmig IDs), plus one documented data-integrity exception (a corruptedtoss-coremirror on the fleet registry awaiting an authenticated re-mirror).Update (2026-11-18) โ Wave 1b rollout: the manifest rollout is done and verified. The first attempt surfaced exactly the class of problem the re-built images were meant to solve โ classic base images ship behaviour (ca-certificates, stock
/etc/nginxlayout withfastcgi_params, a present/tmpfor nginx temp paths, root-owned busybox/git entrypoints, coreutils for wait loops, a config reading mechanism for mysqld-exporter) that a minimal Nix image does not, and several Nix builds had continued to carry aspirational version slots instead of their real built versions. Root causes were fixed in the derivations and every affected image was rebuilt, runtime-checked and re-published; deployments then moved to the honest tags (e.g.postgres 17.11-nix โ 17.5-nix,nginx 1.30-nix โ 1.26.3-nix,oauth2-proxy 7.15.6-nix โ 7.7.1-nix). The Wave-1b swaps landed incrementally across 58 manifest files โ oauth2-proxy instances, busybox/git init and probe containers, Postgres, nginx workloads, mysqld-exporter, the own app images (SOGo variants, python side-cars, calrs, hedgedoc, Indico, kitodo, stalwart-webui, mariadb, memcached-exporter, drawio/excalidraw/EWOKSweb) and CloudNativePG with its barman-cloud plugin โ and were rolled through ArgoCD in verified batches: all touched deployments are ready, and the only remaining cluster failures are the pre-existing, separately tracked items (a brokenmariadb-galeradigest, legacystalwartref, monitoring CRD size), not the Wave-1b rollouts. This closes the corpus the earlier Nix-shift article (dated 2026-11-14) began: the deployed own fleet is Nix-built, version-tagged and honest.
The Nix migration rebuilt the images the project builds or forks itself, and the platform and operations images: reproducible builds, dependency graphs, and air-gapped operation were the goal, and for those images the dependency graph is reproducible by construction. Everything else stayed a classic container build, deliberately:
- Large legacy application stacks (Moodle, ILIAS, Limesurvey, TYPO3, Bookstack, Zammad, Grommunio) ship complex upstream images with deep Dockerfile inheritance; reproducing them in NixOS containers had a poor effort-to-safety ratio for the platform, so they remain classic images that are scanned at chart and image level.
- The
images/directory is the designated home for the suite's bespoke non-Nix images that still need classic Dockerfiles. - The Node-based service sits on third-party base images and brings its own dependency tree.
The fleet is therefore a mix: a reproducible Nix core and a classic long tail. Every part is covered by the pipeline at its respective depth; the depth is what differs, and stating it is the point of this document.
Gap register: what is missing and how to close it
This register is the project's working list for the supply-chain layer. Each row states a gap and what closing it means, so that the work is an addressable backlog rather than a vague roadmap. The canonical, always-current version is tracked in the repository as GAPS.md; this article mirrors it. The article went live by working the register down, not by rewriting it; the register stays the driver of what changes here.
| Gap | State | To close it (acceptance criteria) |
|---|---|---|
| The own registry holds only the Nix-built subset; most deployed images run from upstream registries | Partial | met: a canonical, CI-gated inventory of the deployed fleet exists (192 references: 96 own / 96 upstream, all pinned) and every upstream unit is attested by digest at its source registry (96/96, none unresolved); the acceptance explicitly allows attest-by-digest instead of full mirroring, so mirroring the remaining units is the open half |
| Chart-level SBOMs are declared metadata, not built content | Shipped | met: chart SBOMs record each concrete image reference from chart values with a digest where one is known (and an explicit marker, never a fabricated value, where not), and a scan-against-digests step inventories the real layers of every attested upstream image (2026-11-15) |
| Image-level SBOMs degrade to metadata-only without Syft | Shipped | met: Syft is pinned in CI, the gate fails metadata-only scan-mandatory SBOMs, and build-context units are labeled declared only |
| VEX depth equals SBOM depth; an empty VEX can mean "no scan" rather than "no findings" | Shipped | met: scanning runs against real images and digests instead of declarations; VEX documents distinguish scanned-no-findings from not-scanned; a daily VEX analysis workflow aggregates every document into a committed report, gates on new untriaged critical/high, and reacts via reconcile (proof-of-absence only) and propose (human-approved); since 2026-11-16 scanner severity flows into every statement so the delta gate cannot be blinded |
The signed badge stays no: cosign is best-effort and its result does not flow into the badge |
Shipped | met: the pipeline installs pinned cosign, keylessly attests every published image (signed in-toto CycloneDX bound to the image digest), signs the platform SBOM blob, and records per-unit signed markers that drive the badge (signed = yes); the Fulcio+Rekor chain is exercised in CI on publish |
| Badge freshness: values changed at release time and carried no timestamp | Shipped | met: badge payloads carry the evidence timestamp and a machine-readable age, and a daily schedule reruns the pipeline |
| Per-image SBOMs for the Nix fleet beyond opencloud | Shipped | met: fleet-wide generation over the canonical set of 14 images actually published under openedusuite-nix/ (aligned to the live registry catalog on 2026-11-14), the scan-mandatory gate, per-image OpenVEX, referrer publication via registry auto-discovery, and keyless attestation โ per-image referrers verified live (25โ31 per image for the phase-2 set) |
| The Node-based service had no runtime-level SBOM | Shipped | met: sbom-node-intercom-* is generated from its lock file (296 components), scanned, gate-checked and merged into the aggregate |
Deployed images used the non-reproducible latest tag |
Partial | met (2026-11-15 + Wave 0 2026-11-16): the no-latest gate scans the deployed ArgoCD manifests cross-repo; policy upgraded 2026-11-16 to "version tags everywhere" โ bare latest is no longer an allowed end state; the committed inventory holds zero unpinned refs (the former auto-update trio is digest-pinned, the allowlist entries deleted), the no-bare-latest gate is green; CI wiring of the gate landed 2026-11-16 (the --no-bare-latest step in the SBOM CI fleet-inventory job enforces zero unpinned on every push/PR) |
| An earlier article describes a fully NixOS fleet, which today's mix does not match | In progress | the correction (2026-11-14) stands as the truthful record of what was deployed; since 2026-11-16 the fully NixOS fleet is the explicit target again โ the mix is the migration backlog (SCG-014); Wave 0 (zero bare latest) is done; Wave 1 is done for the own images (55 Nix image derivations built and published, 2026-11-17) and the manifest rollout followed in Wave 1b on 2026-11-18 (58 manifest files swapped to honest nix tags, all touched deployments verified); Wave 2 mirrored all 96 upstream refs into the fleet registry (2026-11-17); the row closes again when no non-Nix reference remains deployed |
| Some published images sit in a personal namespace rather than under the project org | Shipped | met: typst-render is consolidated into the project registry with the live deployment flipped to it (2026-11-15); collab-dashboard was already consolidated; snipr is recorded as a non-existent legacy reference, not deployed content |
| No continuous dependency monitoring (for example Dependency-Track) yet | Deployed | met: Dependency-Track v5.2.1 runs in the production deployment, CI uploads every CycloneDX SBOM on a schedule, and findings feed back into the badge pipeline โ see "Monitoring between releases" |
Full-Nix fleet, version tags everywhere (no bare latest) |
In progress | a canonical, CI-gated inventory exists (192 refs, 0 unpinned, 2026-11-16); Wave 0 shipped: all ten bare latest refs pinned (digest-pins for drawio/excalidraw/ewoksweb/open-webui, version tags for seaweedfs/socat/haproxy/curl/nixos/nix, kubectl switched to the existing Nix image) and rolled via ArgoCD/helm/kubectl; Wave 1 + Wave 1b: all Nix derivations for the classic own images created, built on the nix-builder, published to both registries (55 derivations incl. 26 digest-pinned pulled images, 2026-11-17) and rolled out on honest tags on 2026-11-18 (58 manifest files across oauth2-proxy, busybox/git inits, postgres, nginx, mysqld-exporter, own app images and CloudNativePG; all touched deployments ready); Wave 2: all 96 upstream refs mirrored into the fleet registry (2026-11-17); acceptance: no-bare-latest gate green (met) and CI-wired (2026-11-16), and zero non-Nix own refs (only a documented toss-core mirror corruption and pre-existing legacy refs remain) |
| Upload to a public authority registry | Decided (dropped) | the own registry is the publication target; the decision is recorded here |
The note that applies to all of this evidence is unchanged: a green vulns badge is a point-in-time statement about the latest scan, not a certificate of safety, and every value in this article is a snapshot recorded on the date above, not forever.
What this changes for adopters
For an institution evaluating the platform, the effect is concrete:
- Verify before you pull. Fetch the referrers for an image the pipeline publishes, inspect the SBOM, check the VEX, and compare with the badges, all before the first deployment.
- Same binary, same evidence, for what the pipeline publishes. The images that move through the pipeline are the ones an adopter pulls from the own registry, with no build step and no account in front of them. Units that run from upstream registries are attested by digest and scanned with real layer inventories, so an adopter can verify them even though the own registry is not their deployment source.
- Fork-friendly. Because the data is open and self-hosted, an adopter can re-verify, re-publish, and integrate the evidence into its own ISMS tooling. The same files that back the badges are the ones a university's compliance process can import, a theme explored in the companion article on the machine-readable Grundschutz++ compliance layer.
Call to Action
- Read the evidence: open the platform badges (sbom, vulns, vex, signed) and the registry; the values change as the roadmap is worked off.
- Pull and verify:
docker pull registry.openedusuite.org/openedusuite-nix/opencloud:9.1.0-nix, then list and pull the referrer artifacts withoras discoverandoras pull. - Community: questions and verification experience are welcome in the openEduSuite community: matrix channel
#opendesk-ce-public:matrix.openedusuite.org.
The registry is the evidence; the badges are the honesty.