Sigstore verification failed: {} Aborting update due to sec

Error message

Sigstore verification failed: {}

Aborting update due to security check failure.

What it means

verify_provenance loops over every attestation bundle for the downloaded archive; each failure is stored and, when none pass, this final error aborts the update. It is goose's fail-closed SLSA provenance gate: the embedded detail (bundle parse failure, verify failure, or missing identity) names the last bundle's cause. Seeing it means the archive could not be proven to come from the official build workflow.

Source

Thrown at crates/goose-cli/src/commands/update.rs:234

    // One passing attestation is sufficient.
    let mut last_err = None;
    for bundle_json in &bundles {
        match verify_bundle(
            bundle_json,
            artifact_digest,
            &policy,
            &trusted_root,
            workflow,
        ) {
            Ok(()) => {
                println!("Sigstore provenance verification passed.");
                return Ok(());
            }
            Err(e) => last_err = Some(e),
        }
    }

    Err(anyhow::anyhow!(
        "Sigstore verification failed: {}\n\nAborting update due to security check failure.",
        last_err.unwrap()
    ))
}

/// Update the goose binary to the latest release.
///
/// Downloads the platform-appropriate archive from GitHub releases, verifies
/// its SLSA provenance via Sigstore, extracts it with path-traversal
/// hardening, and replaces the current binary in-place.
pub async fn update(canary: bool, reconfigure: bool) -> Result<()> {
    #[cfg(feature = "disable-update")]
    {
        bail!("Update is disabled in this build.");
    }

    #[cfg(not(feature = "disable-update"))]
    {

View on GitHub (pinned to 3810898a74)

Solutions

Re-run `goose update` on a clean, trusted network (transient corruption is most common)
Upgrade goose through your package manager first so trusted roots and bundle support are current
Optionally verify manually: download the archive + attestation and run slsa-verifier with the expected workflow identity
If verification still fails, report the tag — do not attempt to skip the check

Defensive patterns

Strategy: retry

Validate before calling

let digest_a = sha256_hex(&download_release_asset(tag).await?);
let digest_b = sha256_hex(&download_release_asset(tag).await?);
if digest_a != digest_b {
    anyhow::bail!("unstable download (digest changed between fetches); network is unreliable or intercepted");
}

Try / catch

match update(canary, reconfigure).await {
    Err(e) if e.to_string().contains("Sigstore verification failed") => {
        // one clean re-download, then stop: never bypass or auto-retry past this
        update(canary, reconfigure).await
    }
    other => other,
}

Prevention

Never disable or skip provenance verification when an update fails it
Download only from official GitHub releases; exclude them from proxies/mirrors
Keep goose itself updated so its trusted roots and verification policy stay current
On persistent failure, verify manually with slsa-verifier and report the tag

When it happens

Trigger: Corrupted or tampered release download; proxy/mirror serving altered artifacts; a release published without valid provenance; an outdated goose whose trusted root/policy rejects the current signing setup.

Common situations: Corporate proxies caching or rewriting GitHub assets; resumed/interrupted downloads; very old goose versions updating across a provenance migration; genuinely compromised artifact (rare, but the gate exists for it).

Related errors

AI-assisted analysis of aaif-goose/goose@3810898a74 (2026-08-16). Data as JSON: /api/errors/25d9b461d1ebad5c. Report an issue: GitHub.