The attacks that made this a budget line were not clever exploits of your code. They were ordinary use of the systems that build and ship it.
A build server was compromised and inserted a backdoor into an artefact that was otherwise legitimately signed. A widely used package took an update that ran a script at install time. A maintainer account was taken over and published a version that nobody reviewed. A base image contained a vulnerable library that nothing in the application ever called, and the team spent a week on it anyway while the real risk sat elsewhere.
What these have in common is that the code review was fine. The problem was everything between a developer’s commit and a running process: which dependencies got resolved, what the build machine did, what got signed, and whether anyone could verify after the fact that the artefact in production came from the source that was reviewed.
That is the supply chain, and securing it is four separable jobs. Know what is in your artefacts. Prove where they came from. Control what enters from outside. And verify all of it at the point of deployment rather than in a report nobody opens.
Key takeaways
- SLSA is a framework of requirements on your build system, not a product and not a scanner. Its levels describe how hard it is to tamper with a build, not how few vulnerabilities you have.
- SPDX and CycloneDX both describe components, but they were designed for different primary purposes, licence compliance and security respectively, and converting between them loses information.
- Provenance is the piece that makes everything else verifiable. Without a signed statement naming the source commit and the builder, an SBOM is an unverified claim about an artefact you cannot trace.
- Dependency pinning by content digest, enforced at install time, is the highest-value control in this whole category and the one most teams have not turned on.
SLSA: a framework, not a product
SLSA is a set of requirements you apply to your build system. Nothing implements SLSA as a feature; a build platform either satisfies the requirements or does not, and you assess it against them.
The current version organises requirements into tracks, with the Build track the one people mean when they cite a level.
Build Level 1 asks that the build process be automated and that it produce provenance describing how the artefact was built. It is an honesty requirement. It does not defend against a determined attacker, and it is deliberately easy so that organisations can start.
Build Level 2 adds that provenance must be signed by a build service rather than generated by the build itself, and that the service authenticates. The distinction matters: provenance a build step writes about itself can be written by anything running in that build step. Provenance the platform signs is a statement by something the build cannot forge.
Build Level 3 adds that the build runs in an isolated, ephemeral environment where one build cannot influence another or reach the signing material. This is the level that defends against a compromised build actually tampering with the provenance, and it is where most of the engineering effort lives.
The practical translation of that last level: no persistent runners shared between jobs, no cache that one build can poison for another, and signing keys the build itself cannot read.
What it gives you
A shared vocabulary that means the same thing across organisations, which is the main reason it exists. A ladder that lets you make partial progress and know where you are, rather than facing security as a binary. A clear separation between claims a build makes about itself and claims a platform makes about the build, which is the distinction that actually stops tampering. And a way to state requirements on suppliers, since asking for a specific build level is more precise than asking whether they are secure.
What it does not do
It says nothing about whether your dependencies are vulnerable. A perfectly tamper-proof build of insecure code satisfies every requirement. It says nothing about code review, or who is allowed to merge. It is not a certification with an auditor, so a claimed level is a self-assessment unless something in your pipeline actually produces and verifies the evidence. And it does nothing at all unless someone verifies the provenance at deployment time, which is the step that converts a document into a control.
SPDX and CycloneDX: SBOM formats, not products
An SBOM is a document listing the components in an artefact. Two formats dominate, they are both open standards maintained by neutral bodies, and they are not interchangeable in the way people assume.
SPDX began as a licence compliance format and became an international standard. Its model is thorough about licensing: declared versus detected licences, copyright text, file-level detail, and relationships between packages and the files they contain. Recent versions broadened it well beyond licensing, including into AI and dataset descriptions, but its centre of gravity is still provenance of rights.
CycloneDX was designed for security use from the start, under OWASP. Its model centres on components, their identifiers, their dependency relationships, and the security metadata attached to them. It carries vulnerability information and exploitability statements natively, so a single document can say both what is present and which of those things actually affect you.
Both can describe the same artefact. Converting between them loses whatever the target format does not model, which is why round-tripping degrades a document. Pick the one that matches your primary consumer and generate the other only where a specific recipient demands it.
What it gives you
An inventory that is machine-readable, so vulnerability matching, licence checking and policy evaluation can be automated rather than done by a person reading a dependency file. A record that survives the build, so when an advisory lands months later you can answer which artefacts contained the affected component without rebuilding anything. A standard shape that customers, auditors and procurement can consume without bespoke integration. And, in CycloneDX specifically, the ability to attach an exploitability statement so that a component being present is not automatically a finding.
What it does not do
An SBOM does not find vulnerabilities. It is an inventory; matching it against advisories is a separate step done by a separate tool with its own quality problems.
It does not guarantee completeness. Generated at build time from a lockfile, it misses things vendored into the source tree, statically linked, or downloaded by a build script. Generated by scanning a final image, it catches installed packages but may miss the provenance of a binary that was compiled and copied in. Different generators produce different documents from the same artefact, and the difference is usually not a bug in either.
It carries no authenticity of its own. An SBOM is a text file until it is signed and attached to the artefact it describes, and an unsigned SBOM sitting in a build directory proves nothing.
And it does not tell you whether a vulnerable component matters. Presence is not reachability, and that gap is why unfiltered SBOM-driven findings overwhelm teams.
The Rekor transparency log format: a standard, not a product
The signing story in this category rests on an append-only, publicly verifiable log, and its record format is an open specification rather than a product.
The problem it solves is subtle. Short-lived signing certificates are the right answer to key management, since a certificate that lives for minutes cannot be stolen usefully. But a signature made with a certificate that has since expired cannot be verified later by checking whether the certificate is currently valid. You need evidence that the signature existed while the certificate was valid.
A transparency log provides that. When a signature is created, the signature, the certificate and a timestamp are submitted to an append-only log built on a Merkle tree. The log returns an inclusion proof. Verification later checks the signature, checks the certificate chain, and checks that the log contains the entry, which establishes that it was made during the certificate’s validity window.
What it gives you
Verification of signatures long after the signing certificate expired, which is what makes keyless signing workable at all. Tamper evidence, because the tree structure means entries cannot be modified or removed without detection. Discoverability, since anyone can query the log for entries relating to an artefact, so an unexpected signing event is publicly visible rather than silent. And a timestamp anchored to something other than the signer’s own clock.
What it does not do
It does not vouch for the content. Anyone can log a signature of anything; the log records that it happened, not that it should have.
It does not decide trust. You still need a policy saying which identities may sign which artefacts, and without that policy an entry in the log is a fact with no consequence.
It is a public record, which means the artefact digests and signer identities you log are visible. For most organisations that is fine and even desirable. For some, publishing the existence and cadence of internal builds is itself information, and those teams run a private log instead.
And it requires availability at verification time unless you have cached the inclusion proof, which is a real consideration for air-gapped deployment.
Dependency pinning, the control nobody enforces
Of everything in this article, the control with the best ratio of risk reduction to effort is pinning dependencies by content and enforcing it at install time. Most teams have done half of it and get much less benefit than they think.
A version range is not a pin. A range means the resolved version depends on when you built. Two builds of the same commit can differ, which breaks reproducibility and means a compromised release reaches you automatically.
A lockfile is most of a pin. It records exact versions and usually integrity hashes. The gap is enforcement: many package managers will happily resolve a fresh dependency graph if invoked with the wrong command, and CI configurations frequently use the resolving command rather than the strict one. The fix is one word in the install command, and it should fail the build if the lockfile and manifest disagree rather than quietly updating.
A tag is not a pin for containers or actions. A tag is a mutable pointer. A base image referenced by tag can be a completely different set of bytes tomorrow. A CI action referenced by a branch or a version tag can be changed by whoever controls the tag, and that is exactly the attack that has been used repeatedly against build pipelines. Reference images and actions by content digest.
Install scripts run arbitrary code. Several ecosystems execute lifecycle scripts at install, which means adding a dependency executes that dependency’s code on the developer machine and the build machine before any of your tests run. Where the package manager supports disabling scripts, disable them and allowlist the few packages that genuinely need them.
Pinning stops you getting updates, which is the point and the problem. A pinned dependency does not receive a security fix automatically, so pinning only works alongside a bot that proposes updates on a schedule and a test suite you trust enough to merge them. Pinning without an update mechanism produces an estate that is reproducible and out of date, which is a different failure.
The four checks worth adding to CI today: fail if the lockfile is not in sync with the manifest, fail if any base image or action is referenced by tag rather than digest, fail if install scripts are enabled where you disabled them, and fail if a dependency was added without a corresponding lockfile change.
Needs first-hand data: Audit your pipelines for three counts: base images referenced by mutable tag, CI actions referenced by tag or branch rather than digest, and package installs using the resolving command rather than the strict lockfile command. Each count is a list of concrete, small fixes, and together they are the cheapest risk reduction available in this category.
Sigstore

Sigstore is the project behind keyless signing: cosign for signing and verifying artefacts, a certificate authority that issues short-lived certificates bound to an OIDC identity, and the transparency log that records what was signed. The result is that a build can sign an artefact using its workload identity, with no key to store or rotate, and anyone can verify that signature later against a named identity.
Pros
- Removes signing key management entirely, which is the reason most signing programmes previously failed
- Signatures bind to a workload identity, so verification policy can require a specific repository and workflow
- Stores signatures and attestations as OCI artefacts, so any conformant registry can carry them
- Open source under foundation governance with broad ecosystem adoption, so verification tooling is widely available
Cons
- The public infrastructure is a dependency, and air-gapped environments must run their own instances of it
- Signing without a verification policy at admission time achieves nothing, and that policy is the part teams skip
- Public log entries expose artefact digests and signer identities, which some organisations cannot accept
- Registries that do not implement the referrers API force fragile tag-based conventions instead
Best for: Any team that wants artefacts signed and verified without managing signing keys, particularly those already using OIDC identity in CI.
Pricing: Free and open source with no vendor and no bill. Public infrastructure is community operated; running private instances costs your own infrastructure and operational time.
Chainguard

Chainguard sells minimal, continuously rebuilt container base images with provenance and SBOMs attached. The approach attacks the problem from the other end: instead of scanning a bloated base image and triaging hundreds of findings in packages your application never uses, start from an image that contains almost nothing. Fewer packages means fewer advisories, and the images are rebuilt as fixes land upstream rather than on a release cadence.
Pros
- Minimal images dramatically reduce the number of packages that can generate findings in the first place
- Continuous rebuilds mean patched components arrive without waiting on a distribution release cycle
- Signed provenance and SBOMs ship with the images, so your inventory starts complete rather than reconstructed
- Smaller images also pull faster, which is a real delivery benefit alongside the security one
Cons
- Minimal images lack a shell and common debugging tools, which changes incident response habits significantly
- Migration from a general-purpose base image is real work, since anything your build assumed is present may not be
- A commercial dependency in your base layer, which is a supplier relationship to manage
- Free image variants and commercial ones differ in version availability, which matters when you need to pin
Best for: Teams drowning in base-image vulnerability findings who would rather remove the packages than triage them.
Pricing: A catalogue of freely available images alongside a commercial subscription providing version-pinned images, longer support windows and enterprise agreements.
Snyk

Snyk is the broad commercial platform in this space: dependency scanning across many ecosystems, container scanning, infrastructure as code scanning, and static analysis, integrated into repositories, pipelines and developer tooling. Its differentiators are a curated vulnerability database rather than purely public feeds, reachability analysis in supported languages, and automated fix pull requests that propose the specific upgrade that resolves a finding.
Pros
- Curated advisory data with earlier and richer entries than relying purely on public feeds
- Reachability analysis in supported languages cuts noise by distinguishing present from actually callable
- Automated fix pull requests turn a finding into a reviewable change rather than a ticket
- Covers dependencies, containers, infrastructure code and source in one product with one policy model
Cons
- Pricing scales with developers and tested projects, and grows quickly in a monorepo or microservice estate
- Breadth means variable depth, and coverage quality differs noticeably between ecosystems
- Proprietary database means you cannot fully reproduce or audit findings outside the product
- Default configurations surface a lot, and tuning to a signal you will act on takes deliberate work
Best for: Organisations that want one commercial platform across dependencies, containers and infrastructure code, with developer-facing fixes rather than security-team reports.
Pricing: Free tier with limited monthly tests, then per-developer subscription tiers with product bundles and enterprise agreements.
Socket
Socket addresses a different threat: not known vulnerabilities in dependencies, but dependencies that are behaving maliciously. It analyses package behaviour, whether a new version added install scripts, started making network calls, began reading environment variables or filesystem paths, or shows signs of maintainer takeover. That is the class of attack that advisory-based scanning cannot see, because a malicious package has no advisory until somebody notices.
Pros
- Detects behavioural change in dependencies, which is the actual shape of recent supply chain attacks
- Flags install scripts, unexpected network access and obfuscated code before an advisory exists
- Reviews arrive as pull request comments at the moment a dependency is added, which is when the decision is made
- Complements rather than duplicates traditional scanning, so it adds signal rather than volume
Cons
- Behavioural analysis produces false positives, since legitimate packages sometimes genuinely need network access
- Ecosystem coverage is narrower than the broad commercial scanners
- Does not replace known-vulnerability scanning, so it is an additional tool and an additional cost
- Effectiveness depends on developers reading and acting on the pull request feedback
Best for: Teams with fast-moving dependency graphs in supported ecosystems who want protection against malicious packages rather than only against known vulnerabilities.
Pricing: Free for open source projects, with paid per-developer tiers for private repositories adding policy enforcement and organisation controls.
Dependabot
Dependabot is the dependency update bot built into the largest source platform, and its value is that it is already there and costs nothing to enable. It opens pull requests for outdated dependencies on a schedule and for dependencies with known advisories immediately, updates lockfiles correctly per ecosystem, and can be scoped by ecosystem, directory and update type.
Pros
- Built in and free, so the barrier to having any update process at all is essentially zero
- Security updates are raised separately from routine version updates, which lets you treat them differently
- Understands lockfile semantics per ecosystem, so the generated changes are correct rather than naive
- Can update container base images and CI action references, not just language dependencies
Cons
- Grouping and scheduling control is coarser than dedicated tools, so large estates get pull request floods
- Limited ability to express custom rules about which updates are acceptable without human review
- Ties you to one platform’s ecosystem
- Raises updates but does nothing about whether the new version is trustworthy
Best for: Teams on the platform who want automated dependency updates working today with no configuration effort.
Pricing: Free and included with the hosting platform, with no separate meter.
Renovate

Renovate is the configurable alternative, available as a hosted app, a self-hosted service or a CI job, and working across many source platforms. Its advantage is control: grouping related updates into one pull request, scheduling updates to quiet periods, automatically merging updates that pass tests and meet a stability age requirement, and expressing per-dependency rules. On a large estate that configurability is the difference between a working update programme and a wall of ignored pull requests.
Pros
- Fine-grained grouping, scheduling and automerge rules turn update volume into something a team can absorb
- Works across source platforms and self-hosts, so it fits estates that are not on one vendor
- Minimum release age rules let you avoid installing a version published minutes ago, which blunts fast-moving attacks
- Very broad ecosystem support, including container images, CI definitions and infrastructure code references
Cons
- Configuration is powerful and genuinely complex, and a poor configuration is worse than the simple alternative
- Self-hosting adds a service to operate, and hosted use means granting broad repository access
- Automerge is where the value is and also where an unreviewed compromised update gets in, so test quality becomes load bearing
- Initial onboarding on a large estate produces a large burst of pull requests that needs planning
Best for: Organisations with many repositories that need update automation shaped to their review capacity rather than a fixed schedule.
Pricing: Open source and free to self-host with no vendor bill; a hosted application is free for common use with commercial tiers for enterprise support.
Syft
Syft generates SBOMs. It inspects container images, filesystems and archives, identifies packages across many ecosystems, and emits SPDX or CycloneDX. It does one job, it is scriptable, and it makes no attempt to be a platform, which is why it appears inside so many other tools and pipelines.
Pros
- Emits both major SBOM formats from one scan, so you are not locked into a consumer’s choice
- Works against images, directories and archives, so the same tool covers build output and final artefacts
- Small, scriptable and fast enough to run on every build without thinking about it
- Widely embedded in other tooling, so its output is broadly understood
Cons
- Detects packages, so anything vendored, statically linked, or fetched by a build script can be missed
- Generates inventory only, with no vulnerability matching or policy of its own
- Output quality varies by ecosystem, and sparse entries for less common package types need checking
- No storage, history or comparison, so keeping and querying SBOMs over time is entirely your build
Best for: Any pipeline that needs SBOM generation as a step, particularly alongside its companion scanner.
Pricing: Free and open source with no vendor and no bill. Cost is the build time it consumes and the storage for the documents it produces.
Grype
Grype is the matching half: it takes an SBOM or an image and matches components against vulnerability databases. Pairing it with a separate generator is the design point, because generating the inventory once and matching it repeatedly as new advisories land is exactly the workflow you want, rather than rescanning artefacts you no longer build.
Pros
- Consumes an existing SBOM, so you can re-evaluate an old artefact against today’s advisories without rebuilding
- Multiple advisory sources including distribution-specific trackers, which reduces backported-fix false positives
- Simple output and exit codes make policy gates in CI straightforward to express
- Same project family as the generator, so the two compose without integration work
Cons
- No reachability analysis, so findings are presence-based and need triage
- Quality depends entirely on the inventory it was given, so a weak SBOM produces a confident but incomplete result
- No workflow, tracking or suppression management beyond configuration files you maintain yourself
- Database updates must be handled deliberately in air-gapped or offline builds
Best for: Teams who want open source vulnerability matching that separates inventory generation from advisory matching.
Pricing: Free and open source with no vendor and no bill. Cost is the build time and the effort of maintaining your own triage process.
Trivy

Trivy is the broad open source scanner that covers most of this category in one binary: container images, filesystems, repositories, Kubernetes clusters, infrastructure as code, and secrets, plus SBOM generation and consumption. It is the pragmatic default for teams who want one open source tool in the pipeline rather than several, and it is embedded as the scanning engine inside several other products.
Pros
- One tool covering images, dependencies, infrastructure code, Kubernetes and secret detection
- Fast enough and simple enough to add to every pipeline without a configuration project
- Generates and consumes both major SBOM formats, so it fits either direction of workflow
- Actively maintained with broad ecosystem coverage and wide adoption as an embedded engine
Cons
- Breadth means less depth than specialised tools in any single area, particularly reachability
- No management layer, so triage, suppression and tracking across many repositories are your problem
- Default output volume is high, and a policy gate without tuning will either block constantly or be ignored
- Offline and air-gapped operation requires deliberate database handling
Best for: Teams who want one free scanner covering images, dependencies and infrastructure code in the pipeline without a commercial contract.
Pricing: Free and open source with no vendor and no bill. The maintaining company sells a commercial platform around it with management and reporting, priced separately.
GitHub Artifact Attestations
GitHub Artifact Attestations generates signed provenance for artefacts built in the platform’s own pipelines, using the keyless signing infrastructure underneath and the workflow’s own identity. The reason it matters is adoption cost: producing verifiable provenance is a small number of lines in a workflow rather than a signing project, and verification is a single command that checks the artefact came from a specific repository and workflow.
Pros
- Provenance generation is a few lines in an existing workflow rather than a separate initiative
- Signed by the platform using the workflow identity, which is a stronger claim than a build describing itself
- Verification checks the artefact against a named repository and workflow, which is the policy you actually want
- Works for container images and for file artefacts, not only for images
Cons
- Tied to one platform, so it does not cover artefacts built anywhere else in your estate
- Verification only helps if something enforces it at deployment, which the feature does not do for you
- Achieving the higher build levels still requires the surrounding isolation properties, which this alone does not give you
- Attestation storage and discoverability depend on the registry implementing the referrers API
Best for: Teams already building on the platform who want signed provenance immediately without standing up signing infrastructure.
Pricing: Included with the hosting platform at no separate charge; compute is billed as ordinary pipeline usage.
How to choose
Do these in order. Each step is worth more than the one after it, and most teams try to start three steps down.
One: pin and enforce. Digest-pin base images and CI actions, use the strict lockfile install command everywhere, and disable install scripts where the ecosystem allows. This is free, takes a day, and removes the most commonly exploited paths. Pair it with Dependabot or Renovate so pinning does not mean stagnation.
Two: generate and keep SBOMs. Syft or Trivy in every build, output stored and attached to the artefact. You want these existing before the advisory that makes you need them. Choose CycloneDX if your consumer is security, SPDX if it is licence compliance, and generate both only where a recipient requires it.
Three: sign and verify. Sigstore, or the platform’s built-in attestations if you build there. Then, and this is the step that is usually skipped, enforce verification at deployment so an unsigned or wrongly signed artefact is refused. Signing without verification is paperwork.
Four: match and triage. Grype or Trivy for open source, or a commercial platform if you want reachability analysis and managed triage. Re-evaluate stored SBOMs on a schedule rather than only at build time, because the advisory that matters usually lands after the build.
Five: reduce the surface. Minimal base images remove findings instead of triaging them, which is the only approach that gets better over time rather than worse.
Six: add behavioural analysis if your dependency graph moves fast in a supported ecosystem, because advisory-based scanning cannot see a malicious package that nobody has reported yet.
| Tool or standard | Job | Type | Picks itself when |
|---|---|---|---|
| SLSA (standard, not a product) | Build integrity requirements | Framework | You need to state or assess build guarantees |
| SPDX (standard, not a product) | Component inventory format | Format | Licence compliance is the primary consumer |
| CycloneDX (standard, not a product) | Component inventory format | Format | Security tooling is the primary consumer |
| Rekor log format (standard, not a product) | Signature transparency | Format | Keyless signing needs later verification |
| Sigstore | Signing and attestation | Open source | You want signing without key management |
| Chainguard | Minimal base images | Commercial | Base image findings dominate your triage queue |
| Snyk | Broad scanning and fixes | Commercial | One platform with developer-facing fixes |
| Socket | Malicious package detection | Commercial | Fast-moving dependencies in supported ecosystems |
| Dependabot | Dependency updates | Platform feature | You want updates working today, free |
| Renovate | Dependency updates | Open source | Update volume needs shaping across many repositories |
| Syft | SBOM generation | Open source | Every build should emit an inventory |
| Grype | Vulnerability matching | Open source | Re-matching stored SBOMs as advisories land |
| Trivy | Broad open source scanning | Open source | One free scanner across images and infrastructure |
| GitHub Artifact Attestations | Provenance generation | Platform feature | You build on the platform and want provenance now |
Needs first-hand data: Generate an SBOM for the same production image with two different generators and diff the component lists. Then match both against advisories with two different matchers and diff the findings. The four-way difference tells you how much of your current vulnerability posture is a property of your tooling rather than your software, and it is usually a larger fraction than anyone expects.
Needs first-hand data: Count how many deployments in the last month would have been blocked by a policy requiring a valid signature from your own build identity. If the answer is all of them, you are not verifying. If the answer is none, verification is already working and you should tighten the identity condition next.
Frequently asked questions
Do I need SPDX or CycloneDX?
Choose by consumer. If the document is going to procurement, legal or a customer asking about licences, SPDX is the better fit and is an international standard, which matters in formal contexts. If the document feeds vulnerability management and policy tooling, CycloneDX models security metadata natively, including exploitability statements that let you record that a present component is not actually exploitable. Generating both is cheap with modern tooling, so generate the one you use and produce the other on demand rather than converting stored documents, since conversion loses whatever the target format does not model.
What SLSA level should we target?
Build Level 2 is the realistic near-term target for most organisations, because it mainly requires that provenance is generated and signed by the build platform rather than by the build itself, and the major hosted platforms provide that. Level 3 requires isolated ephemeral build environments where one build cannot influence another or reach signing material, which usually means retiring persistent shared runners. Aim at Level 2 with real verification at deployment before aiming at Level 3 without it, because unverified higher-level provenance is worth less than verified lower-level provenance.
Is an SBOM useful if nobody reads it?
Only if something automated consumes it. An SBOM stored and never queried is a compliance artefact. An SBOM that is matched against new advisories on a schedule answers the question that actually gets asked, which is whether a newly disclosed vulnerability affects anything you are running, without rebuilding or rescanning. Store SBOMs attached to their artefacts, keep them for as long as the artefact might be running, and run the matching regularly rather than only at build time.
How do I stop a compromised dependency from running in my build?
Layer three controls. Pin by content so you get exactly the bytes you reviewed, disable install scripts so adding a dependency does not execute its code, and run builds in ephemeral isolated environments so a compromised build cannot reach credentials or poison the next one. Behavioural analysis on new dependency versions adds a fourth layer for the case where the malicious version is genuinely new. No single control is sufficient, and the first two are free.
Does signing images actually help if my pipeline is compromised?
Not against that specific attacker, and it is important to be honest about it. A compromised pipeline signs malicious artefacts with your legitimate identity. What signing gives you is that nothing outside the pipeline can produce an artefact your cluster will accept, which eliminates registry compromise, artefact substitution in transit and rogue manual pushes. Defending the pipeline itself is what the build isolation requirements are for, and the secrets side of it is covered in secrets management for CI/CD pipelines.
Where should these controls run in the pipeline?
Generation at build time, because that is when you have the full dependency graph. Matching both at build time as a gate and on a schedule afterwards, because advisories arrive after the build. Signing immediately after the artefact is produced, by the platform rather than by a build step. And verification at deployment, which is the only place that turns all of it into an actual control. Wiring these into your CI/CD platform as required steps rather than optional jobs is what makes them stick.
Related reading
- Best CI/CD platforms — where build isolation and provenance generation actually happen.
- Best container registries — storing signatures and attestations alongside the images they describe.
- Best secrets management for CI/CD pipelines — the identity that signs, and keeping a compromised build from reaching credentials.
- Best GitOps tools — the deployment gate where signature verification belongs.
- Best self-hosted CI/CD tools — ephemeral runners, which is what the higher build levels require.
- Best API security testing tools — the runtime half of the same security programme.