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:
docker build -t aster-trust-tools:L1 -f tools/trust/Dockerfile tools/trustThe 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 name | supplier.name on every component (crate authors from the package metadata; "Barnyard Greens LLC" for first-party) and metadata.supplier |
| Component name | components[].name |
| Version | components[].version (exact, as locked) |
| Other unique identifiers | components[].purl (pkg:cargo/<name>@<version>), bom-ref |
| Dependency relationship | dependencies[] (direct edges from the root to the workspace members and between components, resolved by cargo) |
| Author of SBOM data | metadata.authors, metadata.tools (cargo-cyclonedx 0.5.10 + tools/trust/sbom_merge.py at the commit) |
| Timestamp | metadata.timestamp: the commit time (SOURCE_DATE_EPOCH), so the same commit gives the same document |
| + Component hash | components[].hashes (SHA-256 of the crate archive) |
| + Licence | components[].licenses (SPDX expression as declared by the crate) |
| + Tool name | metadata.tools |
| + Generation context | metadata.lifecycles: build (generated from the resolved build graph, not from a running binary) |
| Automation support | machine-readable CycloneDX JSON, validated by CycloneDX tooling |
| Practices: frequency, depth, known unknowns | regenerated 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, mistakes | SBOMs 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:
- 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). - Decision 2026-11-15:
native/runtimedeclaresLicenseRef-Aster-Runtime-EULAagain (private source); the nine crates that declared no licence now declare the SDK or runtime licence as appropriate. - 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.5vulnerabilities[]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, orssh-keygen -Yzero-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.shruns 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.shrefuses keys inside the checkout).check.sh [--quick] [--snapshot]: runs sbom, licenses, deny, audit, vet, repro and the signing self-test, and writestools/trust/out/summary.json(schemaaster-supply-chain-status/1, gitignored).--quickskips the two release builds.--snapshotalso writesdocs/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)
native/(the shipped runtime) and mosttools/*resolve crates from crates.io at build time. Vendornative/and build releases offline.- Four stale lockfiles in tool workspaces (section 5).
- cargo-vet: most dependencies are still exempted rather than audited (section 6, numbers in the status file).
- 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. - SLSA Build L2/L3 need a hosted, isolated build service that signs provenance (RELEASES.md section 6). The release key does not exist yet.
- Authorship of the Windows Store images (section 4).
- 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 me@barnyak.com).
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)