Secure DevOps Pipeline Pattern
Organisations are shipping software faster than ever. Continuous Integration and Continuous Delivery (CI/CD) pipelines have replaced manual build-test-deploy cycles with automated workflows that push code from commit to production in minutes. This velocity is a competitive advantage -- but without embedded security, it becomes a systemic risk multiplier. Every pipeline is an automated pathway to production, and every automated pathway to production is a potential attack vector.
DevSecOps -- the integration of security practices into DevOps workflows -- addresses this by shifting security left into the development process and embedding it throughout the delivery pipeline. Rather than treating security as a gate at the end of development, DevSecOps makes security a continuous, automated, and developer-friendly property of the pipeline itself. Static analysis runs on every commit. Dependencies are verified against known vulnerability databases on every build. Container images are scanned before they enter registries. Infrastructure changes are validated against security policies before they are applied. Deployment to production requires both automated checks and human approval for high-impact changes.
This pattern identifies a maturity spectrum with four levels of pipeline security: (1) Basic pipelines with manual or ad-hoc security checks, where the primary risk is that security is bypassed entirely under delivery pressure; (2) Integrated pipelines with automated SAST, SCA, and container scanning embedded as pipeline stages, providing consistent coverage but potentially creating false-positive fatigue; (3) Policy-enforced pipelines where security gates are mandatory and cannot be bypassed, artifact integrity is verified cryptographically, and infrastructure changes are governed by policy-as-code; (4) Zero-trust pipelines where every component -- source code, dependencies, build environments, artifacts, and deployment targets -- has verified provenance, cryptographic attestation, and continuous compliance monitoring.
The pattern addresses the security architecture required to build, operate, and govern CI/CD pipelines at any point on this maturity spectrum. The threats, controls, and implementation guidance documented here are derived from direct operational experience building and securing software delivery pipelines. This pattern was developed alongside a production CI/CD system with automated security gates, supply chain verification, and deployment controls -- the principles described here were applied in practice before being codified.
This pattern incorporates the developer-facing application security baseline previously published as SP-041. Where pipeline security addresses the delivery infrastructure, the application baseline addresses what the pipeline should verify about the applications it delivers: authentication and authorisation patterns, input validation, structured logging, and API security hardening. Together, these provide end-to-end coverage from secure pipeline infrastructure through to secure application deployment. The Detect/Gap/Implement methodology from SP-041 applies throughout: for each control area, detect what is already implemented, identify gaps against requirements, and implement what is missing.
Click any control badge to view its details. Download SVG
Key Control Areas
Pipeline Infrastructure Security
The pipeline itself is a high-value target -- an attacker who compromises the build environment can inject malicious code into every artifact it produces. Build environments must be hardened, ephemeral, and isolated. Use ephemeral build runners that are created fresh for each pipeline execution and destroyed afterwards, eliminating persistence of compromised state. Apply baseline configurations (CM-02) to build environments with minimal tooling installed -- only what the build requires. Network-isolate build environments (SC-07) so that compromised builds cannot reach internal systems or exfiltrate data. Self-hosted runners require particular attention: they must be patched, monitored, and treated as production infrastructure. Apply least functionality (CM-07) to pipeline orchestration platforms -- disable unused features, integrations, and plugins that expand the attack surface.
Source Code & Repository Governance
The source code repository is the root of trust for the entire pipeline. Enforce branch protection rules requiring code review by at least one reviewer who is not the commit author (AC-05, separation of duties). Require signed commits to establish author authenticity and detect tampering. Enforce access controls (AC-03) that prevent direct pushes to protected branches -- all changes must flow through pull/merge requests. Apply least privilege (AC-06) to repository permissions: most contributors need write access only to feature branches, not to main or release branches. Implement configuration change control (CM-03) for pipeline definition files (.github/workflows, .gitlab-ci.yml, Jenkinsfile) -- changes to pipeline configuration should require the same review rigour as application code, because a malicious pipeline change is functionally equivalent to a backdoor.
Secrets & Credential Management
Secrets -- API keys, database credentials, signing keys, deployment tokens -- are the most common source of pipeline security breaches. Never embed secrets in source code, pipeline configuration files, build scripts, or container images. Use dedicated secrets management services (HashiCorp Vault, AWS Secrets Manager, GitHub Encrypted Secrets, GitLab CI Variables) that inject secrets at runtime and prevent them from appearing in build logs. Rotate secrets automatically on a defined schedule and immediately upon suspected exposure. Scope secrets to the minimum required context: a deployment token for staging should not have access to production. Protect signing keys (SC-12) with hardware security modules or cloud KMS where possible. Encrypt secrets at rest (SC-28) in all pipeline-accessible stores. Audit secret access -- know which pipeline runs accessed which secrets, and detect anomalous access patterns.
Software Supply Chain Integrity
Modern software is composed more than it is written -- a typical application may include hundreds of transitive dependencies, each a potential vector for supply chain attack. Implement Software Composition Analysis (SCA) to identify known vulnerabilities in direct and transitive dependencies. Pin dependency versions to prevent silent updates and use lock files to ensure reproducible builds. Generate Software Bills of Materials (SBOMs) for every release to enable downstream consumers to assess their exposure when new vulnerabilities are disclosed. Verify dependency provenance (SR-04) -- confirm that packages originate from their claimed sources and have not been tampered with. Implement dependency update automation (Dependabot, Renovate) to keep dependencies current, but require review before merging updates. For critical dependencies, evaluate the project's security posture: maintenance activity, vulnerability response history, and contributor verification.
Automated Security Testing
Embed security testing as mandatory, automated pipeline stages that execute on every commit and cannot be bypassed. Static Application Security Testing (SAST) analyses source code for vulnerabilities without executing it -- run it early in the pipeline for fast feedback. Dynamic Application Security Testing (DAST) tests running applications for vulnerabilities including injection flaws, authentication issues, and configuration errors -- run it against deployed staging environments. Container image scanning checks base images and layers for known vulnerabilities and misconfigurations before images enter registries. Infrastructure as Code scanning validates Terraform, CloudFormation, Kubernetes manifests, and Helm charts against security policies before infrastructure changes are applied. Secret scanning detects accidentally committed credentials in code and build artifacts. Define clear policies for vulnerability severity thresholds: critical findings must block deployment, high findings should require explicit approval, and medium/low findings should be tracked and remediated within defined SLAs.
Artifact Integrity & Provenance
Every build artifact -- container image, package, binary, deployment bundle -- should be signed and its provenance attested. Artifact signing (CM-14) using tools like Sigstore/Cosign, GPG, or cloud KMS-backed signing enables consumers to verify that artifacts have not been tampered with between build and deployment. Provenance attestation following frameworks like SLSA (Supply Chain Levels for Software Artifacts) provides a verifiable record of how an artifact was built: what source code, what build environment, what build process, and what inputs were used. Store artifacts in registries with access controls and immutability -- once published, a version should not be overwritten. Implement transparency logs (Sigstore Rekor) to create tamper-evident records of all signing operations. Verify artifact signatures and provenance before deployment -- a pipeline that deploys unsigned artifacts undermines the entire integrity chain.
Deployment Security & Environment Promotion
Deployments to production must be controlled, auditable, and reversible. Implement environment promotion gates that require artifacts to pass security checks in lower environments before reaching production. Require human approval (AC-05) for production deployments -- automated security checks establish minimum assurance, but a human must own the deployment decision for high-impact changes. Conduct security impact analysis (CM-04) for changes that affect authentication, authorisation, data handling, or infrastructure configuration. Use immutable deployment patterns (blue-green, canary, rolling) that enable rapid rollback if issues are detected post-deployment. Separate the roles of code author, code reviewer, and deployment approver to prevent a single compromised or malicious actor from pushing code through to production. Maintain deployment audit trails that record exactly what version was deployed to which environment, by whom, and when.
Infrastructure as Code Governance
Infrastructure as Code (IaC) treats infrastructure definitions as software -- subject to version control, peer review, automated testing, and policy enforcement. Apply security engineering principles (SA-08) to IaC: default-deny network policies, encryption in transit and at rest, minimal permissions. Scan IaC templates (Terraform, CloudFormation, Kubernetes manifests) for security misconfigurations before applying them -- tools like Checkov, tfsec, and kube-bench catch common issues such as public S3 buckets, overly permissive security groups, and containers running as root. Implement policy-as-code (OPA/Rego, Sentinel, Kyverno) to codify organisational security policies and enforce them automatically. Detect and alert on infrastructure drift -- when running infrastructure diverges from its declared state, it may indicate manual changes that bypassed controls or active compromise. Treat IaC repositories with the same governance as application code (SA-10): version control, branch protection, mandatory review.
Audit, Evidence & Compliance Automation
The pipeline generates rich audit data that serves both security monitoring and compliance evidence collection. Log every pipeline execution with: who triggered it, what source commit was built, what tests ran and their results, what artifacts were produced, what approvals were obtained, and what was deployed where (AU-02, AU-03). Automate audit record generation (AU-12) so that compliance evidence is a byproduct of normal pipeline operation, not a separate manual effort. Implement continuous monitoring (CA-07) with alerting for: pipeline failures in security stages, bypassed or overridden security gates, unusual deployment patterns, access from unexpected locations, and changes to pipeline configuration. Retain pipeline audit logs independently of the CI/CD platform -- if the platform is compromised, audit logs stored only within it may be tampered with. Map pipeline controls to compliance framework requirements (SOC 2, ISO 27001, PCI DSS) so that audit evidence collection is continuous and automated.
Application Authentication and Authorisation Baseline
Pipelines should verify that deployed applications implement proper authentication and authorisation. Detect: map all authentication paths in the application (login, API keys, service-to-service, OAuth flows), check session configuration (timeout, rotation, secure flags), audit authorisation checks on every endpoint. Gap: any endpoint without authentication, any authorisation check done client-side only, any use of custom auth instead of standard protocols (OIDC/OAuth 2.0), any service-to-service communication without mutual authentication, any hardcoded roles or permissions. Implement: use OIDC for user authentication via an established IdP (Auth0, Okta, Keycloak, cloud-native). Implement RBAC or ABAC at the API gateway or middleware layer. Every API endpoint must declare its required permissions. Service-to-service uses mTLS or signed JWTs with short expiry. Session tokens: HttpOnly, Secure, SameSite=Strict, rotated on privilege change. MFA for all privileged operations. Pipeline enforcement: include auth configuration validation as a deployment gate, verify that no endpoint is deployed without declared authentication requirements.
Input Validation and Output Encoding
Application-level input validation is a pipeline-verifiable security property. Detect: audit all user input entry points (API request bodies, query parameters, headers, file uploads, WebSocket messages), check for parameterised queries vs string concatenation in database access, check output encoding in HTML rendering. Gap: any user input used without validation, any SQL/NoSQL query built with string concatenation, any HTML output without encoding, any file upload without type/size validation, any API accepting unbounded input. Implement: validate all input at the API boundary using schema validation (JSON Schema, Zod, Joi, Pydantic) -- reject by default, allowlist by exception. Use parameterised queries exclusively for all database operations. Apply context-appropriate output encoding (HTML entity encoding, URL encoding, JavaScript escaping). Limit file upload types and sizes and scan for malware. Set Content-Security-Policy headers. Rate limit all endpoints. Pipeline enforcement: SAST rules targeting input validation weaknesses (SI-10), output filtering verification (SI-15), and development process standards (SA-15) that mandate schema validation for all API endpoints.
Structured Application Logging
Beyond pipeline audit trails, the applications deployed through the pipeline must implement structured logging that supports security monitoring and incident investigation. Detect: check log output format (structured JSON vs unstructured text), verify what events are logged (authentication success/failure, authorisation decisions, data access, configuration changes, errors), check for PII in logs. Gap: any security-relevant event not logged, any log in unstructured format, any PII or secrets appearing in logs, any log not forwarded to centralised collection, any gap in log retention below regulatory requirement. Implement: structured JSON logging with consistent schema (timestamp, correlation ID, user ID, action, resource, outcome, source IP). Log all authentication events, authorisation failures, data access to sensitive resources, configuration changes, and error conditions. Never log passwords, tokens, PII, or request/response bodies containing sensitive data. Forward to centralised logging (ELK, Datadog, CloudWatch Logs) with retention meeting regulatory requirements. Alert on anomalous patterns. Pipeline enforcement: validate log format compliance in CI, reject deployments where security-critical events lack logging coverage.
API Security Hardening
APIs are the primary attack surface for modern applications deployed through CI/CD pipelines. Detect: inventory all API endpoints (OpenAPI spec, route listing), check TLS configuration (SSL Labs scan), verify rate limiting, authentication, and input validation on each endpoint, check for information disclosure in error responses. Gap: any API endpoint without TLS, any endpoint without rate limiting, any endpoint returning stack traces or internal details in errors, any endpoint without authentication that should have it, any missing CORS configuration. Implement: TLS 1.2+ on all endpoints with strong cipher suites. Rate limiting per client and per endpoint (token bucket or sliding window). Schema validation on all request bodies (reject malformed early). Generic error responses in production (no stack traces, no internal paths). CORS allowlist (never wildcard in production). API versioning strategy. Request size limits. Timeout configuration to prevent slow-loris attacks. mTLS for service-to-service APIs. Pipeline enforcement: automated TLS configuration checks, API schema validation in CI, DAST scanning of API endpoints in staging.
When to Use
Organisation develops and deploys software through CI/CD pipelines. Multiple teams contribute to shared codebases with automated build and test processes. Software is deployed to cloud infrastructure, containers, or managed platforms. Organisation has compliance obligations requiring evidence of secure development and deployment practices (SOC 2, ISO 27001, PCI DSS, FedRAMP). Software supply chain security is a board-level concern or regulatory requirement. Organisation consumes significant open source dependencies. Infrastructure is managed as code (Terraform, CloudFormation, Kubernetes). Organisation is adopting or expanding DevOps practices and wants to integrate security without compromising delivery velocity.
When NOT to Use
Organisation develops no software and operates no CI/CD pipelines. All software is procured as managed SaaS services with no custom development, build, or deployment activities. Note: this contra-indication is narrowing -- even organisations that primarily consume SaaS increasingly maintain custom integrations, scripts, and infrastructure-as-code that benefit from pipeline security practices.
Typical Challenges
Balancing pipeline speed with security thoroughness is the central tension in DevSecOps: comprehensive security scanning adds latency that frustrates developers under delivery pressure, leading to pressure to weaken or bypass security gates. False positive management in automated security tools erodes developer trust -- when tools consistently flag non-issues, teams learn to ignore findings, including genuine vulnerabilities. Secrets sprawl across multiple systems (CI platform, cloud providers, container orchestrators, application configuration) makes comprehensive secrets management difficult. Dependency management at scale is operationally challenging: a single critical vulnerability in a widely-used library may affect hundreds of services simultaneously. Legacy pipeline migration is complex -- retrofitting security into existing pipelines risks breaking delivery flows and requires careful phasing. Pipeline-as-code introduces its own security risks: misconfigured workflows, excessive permissions in pipeline tokens, and insufficient isolation between pipeline stages. Developer experience must be prioritised: if security tools are difficult to use, produce noisy output, or lack clear remediation guidance, adoption will be superficial. Multi-cloud and hybrid environments create pipeline complexity with inconsistent tooling and security models across providers.
Threat Resistance
Supply chain attacks via compromised dependencies, malicious packages, and typosquatting targeting package registries. Pipeline poisoning through malicious modification of build configuration, injection of unauthorised build steps, or compromise of build infrastructure. Secret exposure through hardcoded credentials in source code, build logs, container images, or error messages. Artifact tampering between build and deployment, including man-in-the-middle attacks on artifact registries and unsigned deployment packages. Privilege escalation through overly permissive CI/CD service accounts and pipeline tokens with excessive scope. Unauthorised code injection via merge request manipulation, insufficient branch protection, or compromise of developer accounts. Infrastructure drift attacks where manual changes introduce vulnerabilities that bypass IaC governance. Container supply chain compromise through base image manipulation, malicious layers, or registry poisoning. Insider threats leveraging pipeline access to inject backdoors or exfiltrate sensitive data. Compliance evidence manipulation through falsified pipeline results or tampered audit logs. Dependency confusion and typosquatting attacks targeting private package namespaces. Deployment to production without security gate verification due to pipeline misconfiguration or deliberate bypass.
Assumptions
Organisations use automated CI/CD pipelines to build, test, and deploy software. Pipelines run on cloud-hosted or self-hosted infrastructure with access to source code repositories, artifact registries, secrets stores, and deployment targets. Development teams practice continuous integration with multiple daily commits merged to shared branches. Deployment targets range from cloud infrastructure (containers, serverless, VMs) to on-premises environments. Some organisations use managed CI/CD services (GitHub Actions, GitLab CI, Azure DevOps) while others operate self-hosted platforms (Jenkins, TeamCity, custom). The threat landscape for software supply chains is intensifying rapidly, with nation-state actors and criminal groups specifically targeting build systems and distribution channels. Pipeline security controls should be proportionate to the value and exposure of the software being delivered -- internal tools may accept lower assurance levels than customer-facing services or safety-critical systems.
Developing Areas
- AI-generated code security review is an urgent and largely unsolved challenge as AI coding assistants become standard developer tools. Code generated by LLMs may contain subtle security vulnerabilities, use deprecated APIs, or introduce insecure patterns that look syntactically correct but violate security properties. Traditional SAST tools catch some of these issues, but AI-generated code can exhibit novel vulnerability patterns that are not in existing rule databases. The emerging discipline of AI code review -- where AI reviews AI-generated code -- creates recursive trust problems that the industry has not resolved.
- SLSA provenance adoption beyond Level 1 remains limited despite growing ecosystem support. SLSA Level 1 (documented build process) is achievable with standard CI/CD platforms, but Levels 2-4 (hermetic builds, verified provenance, reproducible builds) require significant infrastructure investment and workflow changes. Most open-source projects and enterprise pipelines operate at Level 1 at best, and the tooling for generating, storing, and verifying SLSA provenance attestations across heterogeneous build systems is still maturing. Sigstore adoption is helping, but integration with enterprise change management and compliance workflows remains incomplete.
- Ephemeral build environment security is improving but introduces its own attack surface. While ephemeral runners eliminate persistence of compromised state, they create supply chain risks around the build environment images themselves -- a poisoned base image used by ephemeral runners compromises every build that uses it. The attestation chain from build environment image, through runner provisioning, to artifact production is a nascent area where solutions like GitHub's verified build environments and Google Cloud Build's provenance attestation are establishing patterns, but standardisation across CI/CD platforms does not exist.
- Pipeline-as-target attacks are increasing in sophistication as adversaries recognise that compromising a CI/CD pipeline provides a scalable supply chain attack vector. The attacks on SolarWinds, Codecov, and GitHub Actions third-party actions demonstrated that build systems are high-value targets, yet most pipeline security assessments focus on the artifacts produced rather than the pipeline infrastructure itself. Emerging practices include treating pipeline configuration as security-critical code, applying the principle of least privilege to pipeline service accounts, and deploying runtime security monitoring within build environments -- but these practices are adopted by fewer than 10% of organisations with mature DevOps programmes.
- Software attestation ecosystem maturity is progressing through initiatives like Sigstore, in-toto, and the OpenSSF's GUAC project, but the end-to-end verification story remains fragmented. Generating attestations at build time is increasingly straightforward, yet verifying them at deployment time across heterogeneous environments -- Kubernetes clusters, serverless platforms, VM-based deployments -- requires tooling that is still in early stages. The vision of a continuous chain of trust from source code through build to runtime, where every component can prove its provenance, is technically feasible but operationally distant for most organisations.
- Software composition analysis (SCA) accuracy is improving but still generates significant noise. The core challenge is determining whether a vulnerable dependency is actually reachable in the application's execution path -- a library may contain a vulnerable function that the application never calls. Reachability analysis is an emerging SCA capability that reduces false positives by 40-60% in early implementations, but it requires deep language-specific analysis that not all SCA tools support across all ecosystems.
- Interactive Application Security Testing (IAST) adoption is growing as a middle ground between SAST (high false positives, no runtime context) and DAST (limited code coverage, slow feedback). IAST instruments the running application to observe data flow and detect vulnerabilities with runtime context, producing fewer false positives than SAST. However, IAST requires instrumentation agents that may not support all language runtimes, and coverage depends on test suite quality. The tool category is approximately 5 years behind SAST/DAST in ecosystem maturity.
Related Patterns
Patterns that operate within or alongside this one. Click any to view.
AC: 6AT: 2AU: 4CA: 2CM: 6IA: 4IR: 2RA: 2SA: 6SC: 5SI: 6SR: 4
AC-01 Access Control Policy And Procedures
AC-02 Account Management
AC-03 Access Enforcement
AC-04 Information Flow Enforcement
AC-05 Separation Of Duties
AC-06 Least Privilege
AT-02 Security Awareness
AT-03 Security Training
AU-02 Auditable Events
AU-03 Content Of Audit Records
AU-06 Audit Monitoring, Analysis, And Reporting
AU-12 Audit Record Generation
CA-02 Security Assessments
CA-07 Continuous Monitoring
CM-02 Baseline Configuration
CM-03 Configuration Change Control
CM-04 Security Impact Analysis
CM-06 Configuration Settings
CM-07 Least Functionality
CM-14 Signed Components
IA-02 User Identification And Authentication
IA-04 Identifier Management
IA-05 Authenticator Management
IA-08 Identification and Authentication (Non-Organizational Users)
IR-01 Incident Response Policy And Procedures
IR-06 Incident Reporting
RA-03 Risk Assessment
RA-05 Vulnerability Scanning
SA-04 Acquisitions
SA-08 Security Engineering Principles
SA-09 External Information System Services
SA-10 Developer Configuration Management
SA-11 Developer Security Testing
SA-15 Development Process, Standards, and Tools
SC-07 Boundary Protection
SC-08 Transmission Integrity
SC-12 Cryptographic Key Establishment And Management
SC-13 Use Of Cryptography
SC-28 Protection Of Information At Rest
SI-02 Flaw Remediation
SI-03 Malicious Code Protection
SI-04 Information System Monitoring Tools And Techniques
SI-07 Software, Firmware, And Information Integrity
SI-10 Information Input Validation
SI-15 Information Output Filtering
SR-01 Policy and Procedures
SR-02 Supply Chain Risk Management Plan
SR-03 Supply Chain Controls and Processes
SR-04 Provenance