Supply chain and releases

Supply chain: SBOM, licences, advisories, vetting, reproducibility

In reviewUpdated 2026-11-15Trust Center

In review. This record, and the tools and files it cites, are on a review branch. They are not in the main source tree yet, so you cannot check them in a copy of the main source today.

Everything here is produced by scripts under tools/trust/ that run inside one pinned docker image. One command runs it all: tools/trust/check.sh (the future CI job). It writes tools/trust/out/summary.json; a dated snapshot of a real run is committed as docs/trust/supply-chain-status.json (this is what the trust website displays). Release signing and verification are in Releases: signing, provenance and verification.

The Aster SDK and examples are MIT licensed and the runtime is under the Aster Runtime EULA. The records here describe what is inside a release: components, hashes, licences and known advisories.

Headline numbers of the recorded run: 19 workspaces; 799 SBOM components (701 third-party entries, 277 distinct crate versions, all with SHA-256 and a licence; 192 entries vendored, 0 vendored files failing verification; schema-valid CycloneDX 1.5); 16 distinct licence expressions, all permissive; cargo-deny 19/19 pass; RustSec 0 vulnerabilities, 0 warnings over 799 locked dependencies (1 yanked-check lookup failed, recorded); vet as in section 6; reproducible builds not completed (section 7).

Numbers below are from the run recorded in supply-chain-status.json (see its generated and commit fields); every figure in that file comes from a tool run, none is typed in.

1. Tooling image

tools/trust/Dockerfile derives the trust-tools image from the project's Rust 1.98.0 toolchain image and installs, pinned with --locked: cargo-deny 0.20.2, cargo-audit 0.23.0, cargo-cyclonedx 0.5.10, cargo-vet 0.10.3, cargo-about 0.9.3, rsign2 0.6.7 (minisign-compatible), the wasm32-unknown-unknown target, plus jq and openssh-client. Build it once:

Shell
docker build -t aster-trust-tools:L1 -f tools/trust/Dockerfile tools/trust

The image id is recorded in the provenance (build environment) and in summary.json.

2. Workspaces covered

tools/trust/lib.sh discovers every tracked Cargo.toml that contains a [workspace] table, excluding vendor trees and the frozen qualification probe snapshots under docs/ (experiment records, not shipped code). Today that is 19 workspaces: rust/ (the CPU core), native/ (host windows and the aster-runtime C ABI library + aster CLI), web/ (browser wasm), gpu/ (optional GPU layer), and 15 stand-alone tools under tools/*.

Where third-party code comes from, per workspace: rust/ and web/ build only from the vendored copy in rust/vendor (47 crates, checked by cargo against .cargo-checksum.json on every build); gpu/ builds from gpu/vendor (127 crates); native/ and most tools have no vendor directory and fetch from crates.io at build time (pinned by Cargo.lock checksums). The shipped aster-runtime is built from native/, so vendoring native/ (and building release artifacts offline) is the single biggest supply-chain hardening still open; see section 9.

3. SBOM (tools/trust/sbom.sh)

Output: out/sbom/<workspace>.cdx.json (CycloneDX 1.5 JSON) plus out/sbom/index.json (counts and SHA-256 of each file). cargo-cyclonedx lists every member and all dependencies for all target platforms (--target all, so Windows/macOS/wasm-only crates are included); sbom_merge.py merges the member documents into one SBOM per workspace and adds the data NTIA/CISA ask for.

Vendored crates. Every crate that the workspace actually builds from a vendor directory carries aster:vendored=true, its path (rust/vendor/<crate>-<version>), its exact version, its SHA-256 (the crates.io package checksum recorded in Cargo.lock and in the crate's .cargo-checksum.json), and aster:vendor-files-verified=true|false: the result of re-hashing every file in the vendored directory against .cargo-checksum.json (so a locally edited vendored crate is detected). First-party crates have no hash (they are the source tree itself, identified by the git commit in the document's root component).

NTIA / CISA minimum elements

element (NTIA 2021 minimum; CISA 2025 additions marked +)where it is in the SBOM
Supplier namesupplier.name on every component (crate authors from the package metadata; "Barnyard Greens LLC" for first-party) and metadata.supplier
Component namecomponents[].name
Versioncomponents[].version (exact, as locked)
Other unique identifierscomponents[].purl (pkg:cargo/<name>@<version>), bom-ref
Dependency relationshipdependencies[] (direct edges from the root to the workspace members and between components, resolved by cargo)
Author of SBOM datametadata.authors, metadata.tools (cargo-cyclonedx 0.5.10 + tools/trust/sbom_merge.py at the commit)
Timestampmetadata.timestamp: the commit time (SOURCE_DATE_EPOCH), so the same commit gives the same document
+ Component hashcomponents[].hashes (SHA-256 of the crate archive)
+ Licencecomponents[].licenses (SPDX expression as declared by the crate)
+ Tool namemetadata.tools
+ Generation contextmetadata.lifecycles: build (generated from the resolved build graph, not from a running binary)
Automation supportmachine-readable CycloneDX JSON, validated by CycloneDX tooling
Practices: frequency, depth, known unknownsregenerated by check.sh on every run/release; depth is the full transitive graph for all targets; known unknowns: crates without a declared licence are counted (without_license, currently 0), non-Cargo assets are covered by the licence inventory (section 4) and are not in the SBOM; native OS libraries (libc, system fonts, GPU drivers) are not listed because Aster does not bundle them
Practices: distribution, access control, mistakesSBOMs ship in the release (RELEASES.md), signed through SHA256SUMS; corrections are issued as a new release with a new SBOM, never edited in place

Honest limits: the SBOM describes the dependency graph resolved from Cargo.lock for a target, not a scan of the final binary; and for workspaces without a vendor directory the hash is the crates.io checksum, not a hash of source we hold.

4. Licences (tools/trust/licenses.sh)

Output: out/licenses/licenses.md and .json. Cargo licences come from the SBOMs; fonts and other assets come from tools/trust/assets-licenses.json, a rule list that must cover every tracked font and binary asset: an unlisted font fails the check. It names every work covered by THIRD-PARTY-NOTICES.md (Inter, Martian Mono, Unbounded) and the works that file does not mention.

Policy (deny.toml in each workspace, enforced by tools/trust/deny.sh = cargo deny check licenses bans sources): permissive licences only, limited to those present today (MIT, Apache-2.0 [+ LLVM exception], BSD-2/3-Clause, ISC, Zlib, Unicode-3.0, Unlicense); private.ignore for first-party crates; unknown registries and git sources denied; wildcard versions denied; openssl, native-tls, reqwest, hyper, curl banned from the graph (the core must not grow a TLS/HTTP stack by accident); duplicate versions are warnings. A new licence in a dependency update fails the check until a human decides. Result: all 19 workspaces pass (out/deny/summary.json). The only remaining exception is documented inside the file: tools/renderer-resize-profile/deny.toml (the tool crate has no publish = false, so its path dependencies are downgraded from an error to a warning).

Incompatibilities with the licences we ship under (SDK MIT, runtime EULA): none found in the dependency graph: every third-party crate is permissive and its notice is carried in THIRD-PARTY-NOTICES (by_class in summary.json). Two crates (r-efi) offer an LGPL-2.1-or-later option alongside MIT and Apache-2.0; we elect MIT/Apache, so no copyleft obligation applies. Findings that need a decision are listed in licenses.md under "Flags" and in ~/handoffs/aster-trust-20261111/NOTES.md; in short:

  1. DejaVu fonts (Bitstream Vera licence, glyphs from Arev) were embedded without being named in THIRD-PARTY-NOTICES.md. Fixed on this branch: the notice now names them and points at the licence texts (the inventory rule is updated accordingly).
  2. Decision 2026-11-15: native/runtime declares LicenseRef-Aster-Runtime-EULA again (private source); the nine crates that declared no licence now declare the SDK or runtime licence as appropriate.
  3. Authorship of the Windows Store logo images (tools/windows-store/Assets) is not recorded in the repository.

5. Advisories and VEX (tools/trust/audit.sh)

cargo audit runs over every Cargo.lock against the RustSec advisory database (fetched from GitHub at run time; the DB commit and date are recorded). Output: out/audit/<workspace>.json, out/audit/summary.json, and two VEX documents:

  • out/vex/aster.openvex.json: OpenVEX 0.2.0, one statement per (advisory, package@version) finding;
  • out/vex/aster.cdx-vex.json: the same as a CycloneDX 1.5 vulnerabilities[] section.

Triage is explicit and conservative: a finding stays under_investigation unless tools/trust/vex-triage.json contains a reviewed entry for that advisory (not_affected with a justification such as vulnerable_code_not_in_execute_path, affected, or fixed). Nothing is ever marked "not affected" automatically. An affected entry fails check.sh.

Result of the recorded run: see audit in supply-chain-status.json (database commit, advisory count, dependencies scanned, findings). At the time of writing the run found 0 vulnerabilities and 0 warnings (unmaintained/unsound/yanked) across all 19 lockfiles, so the VEX documents are valid and empty (zero statements): an empty VEX is a statement of "nothing matched this database on this date", not a blanket claim of "not affected". Known limit: yanked checks need the crates.io index and are recorded as yanked_check_errors when it is unreachable.

Four tool-workspace lockfiles are stale (cargo would add entries; cargo build --locked fails there): tools/blueprint-native, tools/blueprint-profile, tools/pointer-invalidation-profile, tools/renderer-resize-profile. They are reported, not fixed (code owned elsewhere).

6. cargo-vet (tools/trust/vet.sh)

vet.sh init creates one store per workspace in supply-chain/<workspace>/ (cargo vet init), imports the public audit sets listed in tools/trust/vet-imports.txt (Mozilla, Google, Bytecode Alliance, Zcash, Embark, ISRG; all six resolved), and runs cargo vet regenerate exemptions so that only dependencies not covered by an imported audit remain exempted. vet.sh check runs cargo vet and writes the covered-versus-exempted counts to out/vet/summary.json (and into the status file).

Meaning, honestly: an exemption is "we have not audited this crate"; it is the starting position of every cargo-vet adoption, not a claim of review. A dependency is covered when one of the imported organisations has published an audit for that exact version (or a delta chain to it). The numbers are in supply-chain-status.json under vet.totals (fully_audited + partially_audited = covered by an import; exempted = not yet audited). Recorded numbers (run of 2026-11-12, see the status file): across the 19 workspaces cargo vet passes on all of them; 277 distinct third-party crate versions, of which 54 are covered by an imported audit (about 19%) and 223 are exempted (not audited); summed per workspace that is 125 covered and 576 exempted of 701 entries (the same crate appears in several workspaces). All six audit sets resolved. Reducing exemptions is ongoing work: the plan is to audit the vendored rust/vendor crates first (they are the ones in the core) and to record our own audits in supply-chain/*/audits.toml.

7. Reproducible builds

Reproducible builds are an internal check (docs/internal/REPRO-BUILDS.md). The latest result is reproducible_builds in supply-chain-status.json.

8. Provenance, signing, one entry point

  • provenance.sh (SLSA v1 in-toto statement), sign.sh / verify.sh (minisign-compatible, or ssh-keygen -Y zero-install fallback): see Releases: signing, provenance and verification for the SLSA level (Build L1; L2/L3 not reached, and what they would need), the key ceremony and the customer verification steps. check.sh runs a signing self-test with a throw-away key in a temp directory (and proves tampering is detected); no private key is ever written into the repository (tools/trust/.gitignore; sign.sh refuses keys inside the checkout).
  • check.sh [--quick] [--snapshot]: runs sbom, licenses, deny, audit, vet, repro and the signing self-test, and writes tools/trust/out/summary.json (schema aster-supply-chain-status/1, gitignored). --quick skips the two release builds. --snapshot also writes docs/trust/supply-chain-status.json. Exit status is 0 only if nothing failed.

Environment knobs: ASTER_TRUST_IMAGE, ASTER_TRUST_CACHE (cargo home and target dir live here, never in the checkout), ASTER_AUDIT_NO_FETCH=1, REPRO_SKIP_WASM=1, REPRO_SKIP_NATIVE=1.

9. Open items (stated, not hidden)

  1. native/ (the shipped runtime) and most tools/* resolve crates from crates.io at build time. Vendor native/ and build releases offline.
  2. Four stale lockfiles in tool workspaces (section 5).
  3. cargo-vet: most dependencies are still exempted rather than audited (section 6, numbers in the status file).
  4. Reproducibility is not yet demonstrated at all (section 7: run B never ran); when it is, it covers Linux x86_64 and wasm only; Windows (.dll) and macOS (.dylib) release builds are not yet covered.
  5. SLSA Build L2/L3 need a hosted, isolated build service that signs provenance (RELEASES.md section 6). The release key does not exist yet.
  6. Authorship of the Windows Store images (section 4).
  7. The VEX is empty because nothing matched; it will fill as advisories appear. A triage owner and a response time are a policy matter (see the vulnerability policy; reports go to [email protected]).

Latest supply-chain run · 3bd253753 · 2026-11-12

Snapshot
stale taken at 3bd253753 on 2026-11-12; 37 dependency or licence files changed since (THIRD-PARTY-NOTICES.md, fuzz/core/Cargo.lock, fuzz/core/Cargo.toml, fuzz/native/Cargo.lock, …). The figures below describe that commit, not this build.
Overall
pass
SBOM
19 CycloneDX SBOMs (CycloneDX 1.5), 799 components, 701 with sha256
Licences
277 third-party crates, 16 licence expressions, verdict flagged
cargo-deny
pass in 19 workspaces, 33 warnings
RustSec audit
0 vulnerabilities, 0 warnings across 19 lockfiles
cargo-vet
dependencies 701, fully_audited 122, partially_audited 3, exempted 576, failed 0, covered_by_audits 125, distinct_crate_versions 277, distinct_covered_by_audits 54, distinct_exempted_only 223
Reproducible build
unproven not run in this snapshot (step skipped); no claim is made until a two-build comparison passes
Signing self-test
ok
SLSA
Build L1 (provenance generated and signed by the build operator)

From docs/trust/supply-chain-status.json, written by tools/trust/check.sh --snapshot.

Source docs/trust/SUPPLY-CHAIN.mdlast changed 2026-11-15

More records

Every record in the Trust Center is public.