Executive summary
Modern CI/CD pipelines are now software supply chains. Trust is established through evidence such as signed provenance, commit signatures, and controlled environments. The SLSA specification (v1.2) defines four build‑track levels, while NIST SP 800‑218 (SSDF) groups practices into preparation, protection, production, and response. By aligning internal platforms with these standards, organizations can automate compliance, enforce separation of duties, and move from a ticket‑queue model to a self‑service golden‑path model.
Introduction
Continuous integration and continuous delivery have matured from ad‑hoc scripts to orchestrated, multi‑tenant platforms. When a pipeline delivers code to production, every artifact is the product of a series of identities, build steps, and stored binaries. That chain must be trustworthy, not because a checklist was completed, but because verifiable evidence demonstrates that the claimed process actually occurred. Two public specifications provide the foundation for that evidence: the Supply‑Chain Levels for Software Artifacts (SLSA) build‑track (v1.2) and NIST’s Secure Software Development Framework (SSDF) in Special Publication 800‑218. This article explores how those specifications translate into a secure DevSecOps pipeline, what changes when delivery stops being a queue of tickets, and how automated compliance can be baked into the platform.
Technical fundamentals
SLSA build‑track basics
SLSA version 1.2 organizes requirements into tracks; the build track answers the question how much trust can a consumer place in the claim that a stated build process produced a stated artifact from stated inputs (source: https://slsa.dev/spec/v1.2/build-track-basics). Provenance is that claim. Four levels exist:
- Level 0 – No claim – No provenance is produced.
- Level 1 – Unsigned provenance – A provenance record exists but may be incomplete or unsigned.
- Level 2 – Signed provenance on a hosted platform – The platform signs the provenance, preventing silent tampering after the build.
- Level 3 – Hardened platform – Build runs are isolated, and the signing secret is inaccessible to user‑defined steps, resisting tampering even by a tenant who submits malicious build instructions.
The specification also introduces a separate source track that focuses on how a revision was created, requiring repository owners to define processes and consumers to review attestations.
NIST SSDF (SP 800‑218)
NIST SP 800‑218 is an outcome‑focused framework that does not prescribe a particular vendor pipeline (source: https://csrc.nist.gov/pubs/sp/800/218/final). It groups practices into four areas:
- Prepare the Organization – Separate development, build, test, and distribution environments; apply least‑privilege access; limit human interaction with build services.
- Protect the Software – Store code in version control, sign commits, enforce code‑owner reviews, and sign release artifacts.
- Produce Well‑Secured Software – Execute the build under the controls defined in the previous stages, generate signed provenance, and enforce immutable build environments.
- Respond to Vulnerabilities – Detect, assess, and remediate weaknesses in dependencies or artifacts, with evidence that the response was timely and effective.
These practices map directly to the evidence required by SLSA: provenance for the build track and signed commits for the source track.
Architecture and components
A typical secure CI/CD platform consists of the following components:
- Source Repository – Version‑controlled code with signed commits and protected branches.
- Identity Provider – Issues short‑lived identities for developers, build services, and deploy agents.
- Hosted Build Service – Provides the hardened environment required for SLSA Level 3, isolates builds, and holds the signing secret.
- Artifact Registry – Stores signed binaries and associated provenance metadata.
- Policy Engine – Evaluates evidence (signatures, provenance, code‑owner approvals) before allowing promotion.
- Vulnerability Scanner – Continuously monitors dependencies and artifacts for known weaknesses.
- Compliance Automation – Emits and verifies attestation documents, failing releases that lack required evidence.
Below is a simple text diagram that captures the flow of a revision through these components.
[Developer] → Commit (signed) → [Source Repo]
│ │
▼ ▼
[Code‑Owner Review] Pull Request
│ │
▼ ▼
[Trigger] → Build Service (isolated) → Signed Provenance
│ │
▼ ▼
[Artifact Registry] ← Store Artifact + Provenance
│
▼
[Policy Engine] → Allow Promotion → Production
Detailed implementation approach
- Establish golden paths – Define a set of approved pipelines that automatically apply the required controls. Developers are encouraged to use these paths rather than creating custom workflows.
- Configure repository protection – Enable signed commits, branch protection rules, and required code‑owner approvals. This satisfies the Protect the Software practice.
- Provision a hardened build platform – Use a hosted service that isolates each build and stores the signing secret outside of the build container. This meets SLSA Level 3 requirements.
- Generate signed provenance – The build platform emits a JSON‑LD provenance document that includes the builder identity, inputs, and output artifact hash, then signs it with the platform’s secret.
- Publish artifact and provenance – Push the binary and its provenance to an artifact registry that enforces immutability.
- Policy enforcement – A policy engine (for example, Open Policy Agent) checks that:
- The provenance is signed and matches the expected level.
- The commit signatures are valid and the change passed code‑owner review.
- No high‑severity vulnerabilities exist in the dependency graph.
- Automated compliance checks – If any check fails, the release is automatically rejected. No manual gatekeeping is required.
- Vulnerability response automation – When a new CVE is disclosed, the scanner flags affected artifacts, and a predefined workflow creates a remediation branch, signs the new commit, rebuilds, and re‑publishes the artifact.
A short configuration example for a policy rule that requires SLSA Level 2 or higher provenance might look like this (excerpt from a typical OPA policy):
allow {
input.provenance.level >= 2
input.provenance.signature_verified
input.commit.signature_verified
input.commit.review_approved
}
Architecture and data‑flow
The data‑flow diagram below expands on the earlier text diagram, showing the provenance lifecycle and where evidence is stored.
flowchart TD
A[Developer] -->|Signed Commit| B[Git Repository]
B -->|Pull Request| C[Code‑Owner Review]
C -->|Merge| D[Build Trigger]
D -->|Isolated Build| E[Hosted Build Service]
E -->|Signed Provenance| F[Artifact Registry]
F -->|Metadata Query| G[Policy Engine]
G -->|Approve/Reject| H[Release Promotion]
style E fill:#e0f7fa,stroke:#006064,stroke-width:2px
style F fill:#fff3e0,stroke:#bf360c,stroke-width:2px
The diagram illustrates that the provenance document travels alongside the artifact, is stored in a tamper‑evident registry, and is consulted by the policy engine before any promotion.
Security and governance
Security outcomes are expressed as evidence rather than a checklist of mitigations. The key governance controls are:
- Separation of duties – The identity that can merge code is not the same as the one that can sign a build. This follows the Prepare the Organization practice.
- Least‑privilege identities – Build service identities have only the permissions required to fetch source, resolve dependencies, and write to the artifact registry.
- Immutable logs – All provenance, commit signatures, and policy decisions are stored in append‑only logs that can be audited.
- Auditable attestation – Consumers can verify that an artifact was produced under the declared controls by checking the signed provenance against the public key of the build platform.
- Continuous monitoring – Vulnerability scanners feed findings into the policy engine, ensuring that any newly discovered issue blocks promotion until addressed.
Enterprise use cases
- Financial services – A bank must prove that a trading algorithm was built from audited source and that no unauthorized code was introduced. By enforcing SLSA Level 3 and signed commits, auditors can trace each artifact back to a specific, reviewed revision.
- Healthcare SaaS – HIPAA‑compliant applications require evidence that patient‑data handling code was built in an isolated environment. The hardened build platform satisfies the isolation requirement, while the provenance document demonstrates compliance.
- IoT firmware distribution – Devices receive signed firmware images. The firmware supply chain uses SLSA Level 2 provenance to guarantee that the image originated from a trusted build service, and the device validates the signature before installation.
Benefits and limitations
Benefits
- Verifiable trust – Consumers can programmatically verify provenance without manual inspection.
- Faster delivery – Automated compliance removes manual gates, allowing developers to self‑serve within the golden path.
- Reduced risk – Separation of duties and isolated builds limit the impact of a compromised credential.
- Auditable trail – Immutable logs support regulatory audits and post‑mortem analysis.
Limitations
- Platform dependency – Achieving SLSA Level 3 requires a hosted build service that can protect the signing secret, which may limit on‑premise implementations.
- Operational overhead – Defining and maintaining golden paths, policy rules, and attestation storage adds initial complexity.
- Scope of evidence – Provenance proves how an artifact was built, not whether the source code is free of logical vulnerabilities. Additional testing and code review remain essential.
Operational considerations
- Key management – The signing secret for provenance must be stored in a hardware security module (HSM) or managed cloud key service to meet Level 3 requirements.
- Performance impact – Isolated builds may increase queue times; scaling the build fleet and using caching strategies can mitigate latency.
- Change management – Updating the golden path should be treated as a controlled change, with a review process that ensures new steps still generate compliant provenance.
- Monitoring – Alert on failed compliance checks, unexpected provenance levels, or mismatched signatures to detect pipeline misuse early.
Best practices
- Treat provenance as first‑class citizen – Store it alongside the artifact and make it mandatory for promotion.
- Enforce code‑owner review for all changes – Align with the Protect the Software practice.
- Use short‑lived build identities – Reduce the blast radius of a compromised credential.
- Automate vulnerability response – Integrate scanners with the policy engine to block vulnerable artifacts automatically.
- Document the golden path – Provide clear, versioned documentation that explains required steps, evidence, and failure modes.
Analysis
The sources make clear that supply‑chain security is about evidence and separation rather than a static list of attacks. SLSA provides a concrete, tiered model for build‑track trust, while NIST SSDF supplies the broader organizational practices that enable those trust levels. Implementing both creates a pipeline where each artifact carries a verifiable chain of custody, and automated checks enforce compliance without manual gates. The shift from ticket‑queue delivery to a self‑service model is enabled by the golden path: a pre‑approved pipeline that automatically applies the required controls and emits the necessary evidence.
What the sources do not settle
- Exact migration path – The specifications do not prescribe how an organization moves from Level 1 to Level 3; that depends on platform capabilities and risk appetite.
- Tool selection – No particular CI system, artifact registry, or policy engine is mandated; the choice must fit the existing ecosystem.
- Metrics for effectiveness – While the documents describe outcomes, they do not define quantitative metrics (e.g., mean time to remediation) for measuring the impact of the controls.
- Future extensions – The source track is defined, but how it will evolve with emerging attestation standards is not addressed.
Conclusion
Securing CI/CD pipelines requires more than adding scanners; it demands a systematic approach to evidence generation, identity separation, and automated enforcement. By aligning internal platforms with SLSA Level 2‑3 provenance and the four SSDF practice groups, organizations can turn their delivery pipelines into trustworthy software supply chains. The result is a golden‑path model where developers self‑serve, compliance is baked into the flow, and auditors have concrete artifacts to verify. While implementation effort is non‑trivial, the payoff is a resilient pipeline that meets regulatory expectations and reduces supply‑chain risk.
References
These published CloudExchangers articles are further desk reading. They are not sources for the technical claims above.