skip to content

How do you set provenance expectations for a sole-source vendor you cannot audit?

level: principalimportance: should knowfreq 34%

answer

  1. where did the expected values come from?
  2. derived expectations cannot fail
  3. tripwire, not assurance
  4. verify across a trust boundary
  5. decide the failure path in advance

basics

~20 s

Source the expected builder, repository, ref and entry point from outside the artifact — the vendor's documented release process, confirmed in writing — record them with a named owner, and decide in advance who is allowed to change them and what a mismatch stops.

solid answer

~50 s

The trap is derived expectations: run the verify, see what the vendor's attestation says, paste that into the policy. The gate now cannot fail on day one and only ever detects later change — which is worth something, but it is change detection dressed up as assurance. Do the opposite: get the expected builder, source repository, ref pattern and entry point from the vendor's release documentation or in writing from their engineering contact, record them as a change-controlled artifact with an owner, and note the date and channel they came from. Then decide the hard part before you need it: a sole-source clinical dependency failing verification is a clinical availability decision, not a security-team decision. Agree in advance who is paged, who can authorise a temporary acceptance, and that the default is to hold the rollout and confirm the change out of band — because "update the expectation and retry" is how a real compromise gets waved through.

go deeper

for a junior

Understand that the values you compare against have to come from somewhere other than the file you are checking, and that they should be written down.

for a middle

Explain why expectations copied from the artifact under test can only detect later change, and what independent sourcing of those values looks like.

for a senior

Show how you would run this for a real third party: onboarding record, named owner, out-of-band confirmation, and a mismatch response that is not widening the rule.

for a principal

Own the availability-versus-integrity call on a sole-source dependency: who can accept the risk, how exceptions are time-boxed, and how the practice scales past the first vendor.

## The situation A hospital integration team is adopting a vendor's Python wheel that handles patient records. There is one vendor; switching is a multi-year procurement. The vendor publishes build provenance, which is more than most do. You have no ability to audit their build system, no leverage to change it, and you cannot walk away. This is a **principal-level question** because the technical part is easy and the organisational part decides whether any of it is worth anything. ## Failure one: expectations derived from the artifact The overwhelmingly common adoption path is: install the tooling, run a verification against the vendor's latest release, read what came back, and write those values into the expectation record. The gate is green immediately, which feels like success. Think about what such a gate can detect. It compares the vendor's artifacts against values taken from a vendor artifact. On the day of onboarding it cannot fail — the expectation was defined as "whatever we saw". If the vendor's build system was already compromised at that moment, you have enshrined the compromised builder as your trusted one, permanently, and every future release from the compromised builder verifies. What it *can* do is detect change over time, and that is genuinely useful: an attacker who takes over the vendor's release process later has to either reuse the exact original builder and repository or trip your gate. So derived expectations are not worthless — they are a **tripwire, not an attestation of trust**, and you should say that out loud rather than let the organisation believe otherwise. ## Doing it properly: independent sourcing The expected values must come down a different path from the artifact: - The vendor's published release documentation, which names the build system, the source repository and the release ref convention. - Written confirmation from a named engineering or security contact — a support ticket, a signed questionnaire response, an architecture review. - A onboarding review that records **the date, the channel and the person**, so the answer to "why do we trust this builder?" is a record and not folklore. Agree, when you have any purchasing leverage at all, that the vendor announces changes to the build system, source repository or release process ahead of time. Even without leverage, asking establishes that an unannounced change is anomalous. ## Failure two: the tautological gate The same defect appears inside your own walls. A pipeline that builds an artifact and then, in a later step of that same pipeline, verifies the artifact's provenance against the builder that just produced it has built a check that cannot fail. If the build system is compromised, the compromised system generated the statement, and the compromised system evaluated it. The check consumes evidence produced by the thing it is supposed to be checking. Verification earns its value at a **trust boundary**: a different party, a different stage with independently held expectations, a deployment gate whose expectations the build cannot edit. When you review a verification design, the first question is not "what does it check?" but "who holds the expectations, and could the thing being verified change them?" ## Deciding the failure path before it fires For a sole-source dependency in a safety-relevant setting, the response to a mismatch is a business decision that must be made while nobody is under pressure: - **Default: hold and confirm.** Stop the rollout, contact the vendor through the channel you already established, and confirm whether the change was intentional. Most mismatches are a vendor migrating build systems and forgetting to tell anyone — but you learn that by asking them, not by assuming it. - **Never auto-update.** A policy that rewrites the expectation on mismatch is not a gate. If the update is legitimate, it goes through the same review that set the original values. - **Name the decider.** For a clinical dependency, blocking a release has patient-facing consequences. Security cannot unilaterally hold it and clinical operations cannot unilaterally wave it through; the escalation path and the person who can accept the risk in writing are agreed in advance. - **Bound the exception.** If an acceptance is granted, it is time-boxed and tracked, not a permanent widening of the expectation. ## What to say in the interview Name the derived-expectation trap and the fact that it degrades the gate to change detection. Say where independent values come from and that the record has an owner. Name the tautology — a verifier fed by the thing it verifies. Then talk about the failure path and who decides, because a principal-level answer here is about **who owns the values and who can override the outcome**, not about which fields get compared.

  • A pipeline verifies the provenance of the artifact it just built. What does that gate prove?
    Close to nothing. The statement and the expectations both originate inside the build system, so a compromised build produces the artifact, the attestation and the verdict. Verification is worth something at a trust boundary — a later stage, another team, a deployment gate holding expectations the build cannot edit. If the verified party can change the expectations, there is no gate.
  • Are derived expectations completely worthless then?
    No, and overstating it costs you credibility. Expectations copied from the first observed attestation still detect later change: a takeover of the vendor's release process that switches builder, repository or entry point trips them. What they cannot do is tell you the state on day one. Deploy them if that is all you have, and label them as change detection rather than trust.
  • Verification fails on a sole-source clinical dependency the night before a scheduled rollout. What do you do?
    Hold the rollout and confirm out of band through the vendor contact established at onboarding. Do not update the expectation to match. If the vendor confirms a legitimate build-system change, put the new values through the same review that set the originals. If a time-boxed acceptance is needed to ship, the named clinical owner signs it, not the security team alone.
  • How do you keep this from being a one-off for one vendor?
    Make the expectation record part of onboarding for every third-party artifact that reaches production, with the same fields, the same named owner and the same review. The cost of the first vendor is understanding; the cost of the twentieth is filling in a form. Vendors that publish no provenance get recorded as such, so the gap is visible rather than invisible.

Checking a passport against the details the traveller wrote on the form they just handed you is not identity verification. The reference has to come from somewhere the traveller does not control.

saying these in an interview costs you the question

  • Copies observed attestation values straight into the expectations
  • Treats a first-run pass as proof the vendor is clean
  • Auto-updates expectations when verification fails
  • Has the build system verify its own output
  • Leaves nobody accountable for the expected values

context