A vendor's SLSA provenance carries a buildType URI you have never seen — do you accept it?
answer
- the URI that gives the fields meaning
- a contract, not a pointer to source
- authenticated is not verified provenance
- allowlist the build types you read
- changed semantics need a new URI
basics
~20 sNot as provenance. buildType is the document defining which parameters exist and which a caller controls, so without it you cannot tell whether matching repository and ref pins the build. You have authenticity from the signature, not verified provenance.
solid answer
~50 s`buildType` is a URI that defines the meaning of the whole `buildDefinition` — which `externalParameters` this kind of build accepts, what each one does, and which of them an outsider can influence. If nobody in your organisation has read that document, you cannot judge whether checking `repository` and `ref` is sufficient, because some other parameter may select an arbitrary script or an alternate source. So the honest stance is that the artifact is authenticated — you know who signed it — but not provenance-verified. From there it is an organisational call: block and stop a shipment, accept with the artifact flagged as builder-trust-only and compensate with a staged rollout and tighter runtime controls, or time-box a request to the vendor for the buildType documentation. What you should not do is quietly widen the expectation to whatever the document contains, because that makes every future parameter the vendor adds automatically acceptable.
go deeper
Know that buildType is a URI describing what kind of build produced the artifact, and that it is what makes the other field names interpretable rather than a link to the source code.
Be ready to explain why an unknown build type undermines a check on repository and ref: you cannot show those two fields determine the result if other parameters may exist.
Demonstrate that you separate authenticity from provenance verification, and that you would record the weaker outcome accurately rather than marking the artifact verified because the signature passed.
Own the decision framework: an allowlist of build types you have read, a defined consequence for anything outside it, and the reciprocal obligation to version your own buildType URI when a parameter's meaning changes.
## Why buildType is the load-bearing field A provenance predicate is mostly a bag of names and values. `buildType` is the URI that tells you what those names mean. It is a contract, and it is supposed to specify at least: the complete set of `externalParameters` this kind of build accepts, the semantics of each one, which of them are under an external caller's control, and what the platform guarantees about the process. Without it you are reading JSON by intuition. A field called `configPath` might reference a file inside the repository you already pinned by ref — harmless. Or it might accept an absolute URL to a config fetched at build time — in which case pinning `repository` and `ref` pins nothing, and someone who can trigger a build with a different `configPath` controls the artifact. The two possibilities look identical in the document. This is the gap: not a forged field, not a failed signature, simply a contract nobody published. ## What you actually still have Be precise about what survives. The signature still verifies, so you know an identity you recognise vouched for this artifact. That is **authenticity**, and it is not nothing — it gives you non-repudiation and a party to go back to. What you have lost is the part that made provenance worth collecting: the ability to say *this artifact came from the source and process I expected*, because you cannot map recorded inputs onto expectations you can defend. Grading yourself honestly here matters more than the outcome. Teams that record "provenance verified" in a compliance system when they only checked a signature have created a fiction that someone will later rely on. ## The three real options **Block.** Defensible when the artifact sits somewhere consequential — in a build of your own product, in a base image, anywhere it inherits privilege. The cost is a stopped shipment and a conversation with a vendor who will point out that their artifact is signed and their competitors do less. **Accept, downgraded and compensated.** Record the artifact as builder-trust-only rather than provenance-verified, and buy back assurance elsewhere: a staged rollout, tighter runtime restrictions, closer monitoring of the first deployments, a narrower blast radius. This is usually the right answer under a real deadline, and it is only honest if the downgrade is recorded somewhere a future auditor sees, not just in someone's head. **Ask, time-boxed.** Vendors frequently have the document and have simply not linked it. A dated request with a decision date attached converts an open question into a scheduled one. Without the date it becomes a permanent exception. ## The allowlist as the durable answer The scaling answer is a small list of `buildType` URIs your organisation has actually read and written expectations for. An unknown one then has a defined consequence instead of prompting a fresh argument each time. This also reframes the vendor conversation usefully: you are not asking them to change their build, only to publish what it already does. The cost is honest to state: someone has to read each new build type, and that person is a bottleneck. In practice you accept a short list and treat everything else as builder-trust-only, rather than pretending you will document the world. ## The obligation when you are the emitter The symmetry is worth owning, because a lead is usually on both sides. If your platform defines a `buildType`, that URI is a promise to strangers. Publish the parameter list and say which values a caller controls. And when the meaning of a parameter changes — not just its default, but what it selects or who can set it — mint a **new** URI rather than editing the document behind the old one. Consumers pinned their expectations to the old semantics; silently changing what those names mean invalidates their verification without anything visibly failing, which is the worst way for a control to break. ## What a weak answer looks like "The signature checks out and the repository matches, so it is fine." That answer assumes the two fields it looked at determine the build — which is exactly the thing the missing document would have told it. The senior version names the assumption; the principal version decides what the organisation does with artifacts where the assumption cannot be checked, and writes that decision down.
- Why not just check repository and ref and ignore the unknown buildType?Because those two fields only pin the build if no other parameter can alter it, and whether that holds is precisely what the buildType document would tell you. A parameter that selects a config from an arbitrary location, overrides an entry point or adds a step would leave your two checks passing while the artifact varies. Checking a subset you cannot prove is sufficient produces a green result with no meaning behind it.
- If you define a buildType, what do you owe the people verifying against it?A stable URI, a published document listing every external parameter with its semantics, an explicit statement of which values a caller controls, and what the platform guarantees. When a parameter's meaning changes, mint a new URI instead of editing the old document — consumers wrote expectations against the old semantics, and changing them silently breaks verification without anything appearing to fail.
- How would you record the downgraded decision so it does not quietly become permanent?Attach it to the artifact's own record rather than a ticket: mark it builder-trust-only with the reason, the compensating controls applied, and a review date. That way anyone later asking whether provenance was verified gets the truthful answer, and the exception surfaces on its own schedule instead of relying on someone remembering the conversation.
saying these in an interview costs you the question
- Says a valid signature makes the provenance verified
- Assumes repository and ref always determine the artifact
- Treats an unknown buildType as evidence of tampering
- Edits the document behind an existing buildType URI when semantics change
- Records provenance-verified in compliance records after checking only a signature