Don't take our word for it. Verify our software.
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.
What each check proves
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.
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.
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.
- supply chain security
- Sigstore
- cosign
- SBOM
- AI delivery governance
