Skip to main content
TruStacks
← All posts

Don't take our word for it. Verify our software.

TruStacks7 min read

To verify a vendor's container image, run cosign verify against two strings the vendor publishes: the certificate identity of the release workflow allowed to sign, and the OIDC issuer that vouched for it. A green result means that workflow signed that exact digest and nothing has changed since. A signature proves who built an artifact, not that its delivery followed your rules; that takes policy evaluated before review.

We build software that operates inside engineering environments, reads repositories, and proposes changes to the systems responsible for delivering applications.

That's a significant level of trust to ask from a customer.

And frankly, you shouldn't grant it because our website says we're secure.

You should be able to verify what you're installing, where it came from, and whether it has changed since it was published.

Without scheduling a call with our security team.

Without opening a support ticket.

And without taking our word for it.

That's the standard we believe software vendors should be held to, including TruStacks.

Trust is important. Verification is better.

Modern software delivery depends on an enormous collection of third-party components.

Container images, build tools, package managers, CI/CD actions, deployment controllers, and security scanners all participate in getting applications from code to production.

Most are consumed automatically.

But how much do we actually know about what we're running?

Consider a container image.

You can see its name. You can see its tag. You can pull it from a registry.

But those things alone don't establish who produced it, which build created it, or whether the content matches what the publisher intended to release.

A tag isn't a security guarantee.

And a vendor saying "our images are signed" isn't especially useful unless customers can independently verify those signatures.

What we do at TruStacks

TruStacks uses Sigstore-based keyless signing for its published container images and signed policy artifacts.

Rather than depending on a long-lived private signing key held by our team, the signing process uses the identity of an authorized release workflow.

The resulting signature and certificate allow customers to verify the identity associated with the release and the integrity of the signed artifact.

The distinction matters.

You're not simply accepting that a signature exists.

You're checking whether the artifact was signed through the expected release process.

And you can perform that verification using standard tools such as cosign. For a TruStacks image:

cosign verify \
  --certificate-identity-regexp \
    'https://github.com/TruStacks/trustacks-mvp/.github/workflows/publish-images.yml@refs/tags/v[0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z.-]+)?$' \
  --certificate-oidc-issuer https://token.actions.githubusercontent.com \
  ghcr.io/trustacks/runner:latest

For the constitution policy bundle, which is built and signed in our public trustacks-policy repository:

cosign verify \
  --certificate-identity-regexp \
    'https://github.com/TruStacks/trustacks-policy/.github/workflows/publish.yml@refs/tags/v[0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z.-]+)?$' \
  --certificate-oidc-issuer https://token.actions.githubusercontent.com \
  ghcr.io/trustacks/policy/constitution:latest

There's no --key flag because there's no key. The two strings name the only identity allowed to sign: one release workflow, run from a version tag, vouched for by GitHub Actions. We last ran both on 23 October 2026, with cosign v3.0.6 and no registry login, and both came back green.

Our security page and the supply-chain verification reference carry the same commands and published identities.

You don't need access to our private application repository to inspect the released software's public verification evidence.

But a signed artifact can still be wrong

This is where software supply-chain security becomes more interesting.

A valid signature doesn't mean an artifact is secure.

It doesn't prove the application is free from vulnerabilities.

It doesn't guarantee a container follows your organization's runtime requirements.

And it certainly doesn't prove a deployment satisfies your company's change-management process.

Imagine a perfectly signed container image being deployed through a pipeline that bypasses a required production approval.

The image provenance might be valid.

The deployment process still violated policy.

Or consider a pipeline that correctly builds and signs an application but never checks the required ServiceNow change record before deploying it.

The build is trustworthy in one respect.

The delivery process is not acceptable to that organization.

Artifact integrity and delivery governance are different problems. Both matter.

Three checks you can run against a TruStacks image, and what each one proves. First, cosign verify: our release workflow, run from a release tag, signed this exact digest, with GitHub Actions vouching for the workflow, a certificate authority that is not us issuing the certificate, and the signing event in the public Rekor transparency log. Second, docker buildx imagetools inspect: the digest you pull is the one that was signed, and changing a byte in any image or attestation it names breaks the signature. Third, reading the SBOM and provenance from the same index: what is inside, as an SPDX document, and which commit was built, matching the commit in the signing certificate. None of it proves our code is free of vulnerabilities, lets you read the workflow, which lives in a private repository, or carries a SLSA build level, which we have not published.

What each check proves

  1. Check the signature

    cosign verify

    Proves

    Our release workflow, run from a release tag, signed this exact digest. GitHub Actions vouched for the workflow, a certificate authority that is not us issued the certificate, and the signing event is in the public Rekor transparency log.

  2. Check the digest you pull

    docker buildx imagetools inspect

    Proves

    The signature covers what you are about to run. The digest is an index naming each platform image and attestation manifest by its own digest; change a byte in any of them and the signature no longer matches.

  3. Read the SBOM and provenance

    imagetools inspect · .SBOM · .Provenance

    Proves

    What is inside, as an SPDX document for your own scanner, and which commit was built. The provenance and the signing certificate name the same commit: two independent records agree.

What none of it proves

  • That our code is free of vulnerabilities.

    A signature establishes who built something and that it was not altered, not whether it was built well. That is what the SBOM is for.

  • What the workflow says.

    The repository the certificate names is private. You can check the signature was issued to that workflow; you cannot read it.

  • A SLSA build level.

    The provenance is there to read. We have not published a level, and will not until we can stand behind the number.

Who built it, and that it was not altered. Those are the claims the chain supports. Whether it was built well is a different claim, and the SBOM is how you test it yourself.

The delivery workflow is part of the supply chain

We tend to think of software supply-chain security in terms of packages, dependencies, images, and build provenance.

Those are critical.

But the automation connecting source code to production deserves the same scrutiny.

CI/CD pipelines determine which tests run, which images get built, which scanners execute, and which credentials or deployment mechanisms are used.

GitOps configuration determines what gets deployed, where it goes, and how changes reach runtime environments.

These aren't administrative details.

They're part of the system responsible for delivering software safely.

And they shouldn't be assembled from unreviewed fragments of old YAML simply because that's what worked last time.

Generate the path. Then govern it.

This is one of the reasons we built TruStacks around generated delivery artifacts.

The system discovers the application and its declared environment, then generates the CI/CD, GitOps, and platform-engineering configuration that fits the stack.

Before an agent-generated delivery proposal reaches a reviewer, the relevant policies are evaluated: the TruStacks constitution, the applicable policy packs, and, where you've configured them, your own overlays.

A failed policy check identifies the rule that blocked the proposal.

A passing proposal becomes a reviewable pull request.

Humans retain approval and merge authority.

That separation matters because we're not asking customers to trust the judgment of an AI agent.

We're giving the agent bounded work and evaluating its output against deterministic rules.

Your organization defines what acceptable delivery means

Every organization has requirements that go beyond baseline security.

One company might require an approved container registry.

Another might require a specific vulnerability scanner.

A financial institution may require additional production approvals.

A healthcare organization may have environment-specific restrictions.

And some organizations require an approved change record before production deployment.

Where a requirement calls for an execution-time control, the delivery workflow needs an actual check or integration that enforces it.

A comment in the pipeline saying "verify change approval" isn't sufficient.

An AI prompt reminding the model to include the correct step isn't sufficient either.

The requirement needs to be represented in the workflow, evaluated against policy, and enforced by the system performing the deployment.

That's how governance becomes part of delivery rather than documentation alongside it.

Make the evidence available

The same principle applies to verification.

Security teams should be able to inspect the provenance of the software they run. For a TruStacks image, the software bill of materials and the build record ride inside the signed image index, and you read them straight from the registry:

# The SBOM: an SPDX document for your own scanner
docker buildx imagetools inspect ghcr.io/trustacks/runner:latest \
  --format '{{ json .SBOM }}'

# The build provenance, including the commit that was built
docker buildx imagetools inspect ghcr.io/trustacks/runner:latest \
  --format '{{ json .Provenance }}'

These are BuildKit attestations rather than cosign attestations, so cosign download sbom won't find them. The commit in the provenance matches the commit named in the signing certificate: two independent records agreeing on what was built.

Reviewers should be able to understand why generated delivery changes satisfy policy.

Auditors should be able to trace the approvals and controls associated with a release.

Those are different kinds of evidence, and no single signature or policy result answers every question.

TruStacks brings together signed release artifacts, versioned policy, policy-backed proposals, and human-controlled Git changes.

Customers should still evaluate those mechanisms using their own security tools and operational controls.

The goal is not to replace due diligence.

It's to make due diligence practical.

What happens when verification fails?

The answer should be simple.

Don't deploy the unverified artifact.

Investigate the mismatch.

A signature failure might indicate an incorrect expected identity, a changed artifact, or a configuration error. Whatever the cause, it shouldn't be ignored merely because the image came from a familiar registry.

The most common cause is self-inflicted. The identity is case-sensitive, and the certificate records the organization as TruStacks. Type it in lowercase and cosign refuses:

Error: no matching signatures: none of the expected identities matched what was in the certificate

If you run the commands above with the correct strings and still don't get a green result, tell us through our contact form, the route our security.txt publishes for security reports.

The same thinking applies to delivery policies.

If a proposal violates a required rule, it shouldn't quietly proceed to approval.

The system should identify the failure and stop the proposal until it's corrected.

A failed check is useful information.

Not an inconvenience to work around.

Security claims should come with evidence

We believe customers should expect more from software vendors than architecture diagrams, badges, and assurances.

Especially when a product operates near critical delivery infrastructure.

Show us who produced the artifact.

Show us its dependencies.

Show us the policy that governed the proposed change.

Show us the approval.

And give us a way to verify those things independently.

At TruStacks, our delivery model follows a simple principle:

Agents propose. Policy decides. Humans approve.

Our supply-chain philosophy follows another:

We publish. You verify. You decide whether to trust what you're running.

Review TruStacks security and verification

  • supply chain security
  • Sigstore
  • cosign
  • SBOM
  • AI delivery governance

See it open a pull request.

The crew reads a real repository and proposes a policy-checked pull request you review yourself. The hosted Beta is open to the first 50 teams. Sign up with the Beta link and it's free for 45 days, with no card needed. The hosted quickstart walks you to your first governed pull request.