skip to content

Five releases went out under your identity the week your publishing service was breached — which do consumers distrust?

level: seniorimportance: must knowfreq 52%

answer

  1. all five verify — that is the problem
  2. signatures say who vouched, not who authored
  3. evidence from outside the credential's reach
  4. window runs last-corroborated to cutoff
  5. rebuild and compare digests

basics

~20 s

All five, until evidence from outside the compromised credential clears them. Signatures prove the credential signed, not who authored the content, so every release verifies. Default to the whole window from your last corroborated release to the cutoff, and narrow it only with independent proof.

solid answer

~50 s

Start from the fact that verification decides nothing here: the attacker signed as you, so all five verify. The evidence that separates them must come from outside the compromised credential's reach — your build system's run records, the tag and approval trail, and best of all a rebuild from source whose output matches the published artifact bit for bit. Default to distrusting the entire window, running from the last release you can independently corroborate through to the moment the credential was cut off, and narrow it only where that outside evidence clears a specific version. If the breached thing is the publishing service itself, its own logs sit inside the blast radius and cannot be your only proof. The cost asymmetry justifies the wide default: over-distrusting costs your users a forced upgrade, under-distrusting costs them a compromise. Then republish the good content as new versions, so nobody is told to pin backwards into the same window.

go deeper

for a junior

Know that a valid signature only shows a key was used, so after a credential theft it cannot tell a genuine release from the attacker's.

for a middle

Explain how the window is bounded — last independently corroborated release to confirmed revocation — and which records survive the breach as evidence.

for a senior

Show the wide-then-narrow discipline and the cost asymmetry behind it, and be specific about clearing a version by reproducing its digest from tagged source.

for a principal

Own what you owe downstream: a published suspect list, the clearing basis for each version, replacement releases, and honest handling of a vendor whose timeline you cannot verify.

## Why "it verifies" is worthless evidence here A signature answers one question: *who vouched for this artifact*. During the breach the answer was, truthfully, "whoever held the publishing identity", and that was the attacker as well as you. Every release in the window therefore verifies, and a consumer running strict verification would have installed all five happily. The same applies to any attestation produced with the same identity — an SBOM or a provenance statement generated by the compromised pipeline tells you what the attacker's build claimed, not what happened. Non-repudiation is the asset that was actually stolen: you can no longer prove which statements made in your name were yours. ## Build the window from corroborated endpoints The window has two ends and only one of them is easy. - **The late end** is when the credential stopped working: revocation time, confirmed by testing that a publish now fails. - **The early end** is the last release you can independently corroborate. Not the last release you *remember* making — the last one for which evidence exists outside the compromised system. Everything between those points is suspect by default. Investigators consistently underestimate the early end, because the first malicious action is usually quiet: an attacker who obtains publishing rights often does nothing for a while, or publishes something benign to test the path. ## What counts as independent evidence Rank evidence by whether the attacker could have produced or altered it: | Evidence | Independent of the compromised credential? | | --- | --- | | A rebuild from the tagged source that reproduces the published artifact | Yes — strongest available | | Your build system's run records, with the commit each ran on | Usually, if the build system is outside the breach | | Signed commits and tags from developer keys | Yes, if those keys were not in scope | | Ticket, approval and release-checklist trail | Yes, and cheap | | The publishing service's own audit log | **No**, when the publishing service is what was breached | | The signature or attestation on the artifact | No — the attacker held the key | The last two rows are where responses go wrong. Using a breached system's logs as your source of truth means the attacker's own view of events defines your incident boundary. Where the compromise is of a managed publishing service you do not operate, you also have a vendor-trust problem: their timeline is an input to your decision, not a substitute for it, and you should ask specifically what parts of their logging sit inside or outside the compromised component. ## The asymmetry that sets the default The two errors do not cost the same. Distrusting a version that was actually fine costs your consumers an unnecessary upgrade and costs you credibility. Trusting a version that was actually malicious costs them a compromise inside their own systems, in code you asked them to run. That asymmetry is why the professional default is wide-then-narrow: publish the whole window as suspect, then clear versions individually as evidence arrives, and say publicly when you do. The opposite order — announcing a narrow set and widening it twice — is the pattern that destroys trust, because each widening tells consumers your first answer was a guess. ## Narrowing honestly A reproducible rebuild is the cheapest genuine clearance: rebuild the tagged source and compare the digest of your output against the digest of the published artifact. If they match, the published bytes came from that source, regardless of who pressed publish. Where builds are not reproducible, you fall back to weaker corroboration — matching commit to build run to publish timestamp — and you should describe that as "consistent with" rather than "cleared". ## Give people a forward path, not a backward one The reflex advice "pin to the last known-good version" fails here, because the last known-good version is often inside the window too. The remediation is a set of freshly published versions built from corroborated source under a credential you now control, each superseding one of the suspect releases, so consumers move forward rather than backwards. State the suspect set as an explicit version list and range, because that list is what goes into the advisory data their tooling consumes. ## What you owe downstream afterwards When you are the upstream, the deliverable is not just a fix but the evidence trail: which versions were published in the window, which have been cleared and on what basis, what the replacement version is for each, and the digest of every artifact you now assert is yours. Consumers with their own regulated customers will be asked these questions in turn, and the quality of your list determines whether their answer is hours of work or weeks.

  • What single piece of evidence most cheaply clears one of those versions?
    A rebuild from the tagged source whose output digest matches the published artifact. It is independent of the stolen credential and of the breached publishing service, and it answers the actual question — did these bytes come from this source — rather than the question a signature answers, which is who pressed publish.
  • The provider says their logs show only one anomalous publish. Do you narrow to that one?
    Not on that basis alone. If the breached component is inside the system producing those logs, its account of events is an input, not proof. Ask which parts of their logging are outside the compromised boundary, corroborate against your own build records, and keep the wide window publicly until independent evidence clears the rest.
  • Why not tell consumers to pin to the last release before the breach?
    Because the early end of the window is usually earlier than you think, so that release may itself be inside it. Backward pinning also strands consumers on an unmaintained version. Publish freshly built replacements from corroborated source and move people forward instead.

A forged signature in a genuine cheque book. Every cheque clears the bank's check, so the only way to find the forgeries is to go back to your own stubs.

saying these in an interview costs you the question

  • Trusts the four that verify and pulls only the odd one
  • Uses the breached service's own logs as sole proof
  • Distrusts only versions with reported symptoms
  • Tells users to pin backwards into the same window
  • Claims an SBOM on the release proves it is yours
  • Announces a narrow set, then widens it twice

context