Engineers with a laptop at automation test rigs in a bright production hall

SBOM

OWASP Top 10 CI/CD Security Risks, explained

Last updated:

The OWASP Top 10 CI/CD Security Risks project documents ten named risk categories, CICD-SEC-1 through CICD-SEC-10, covering the pipeline infrastructure that moves code from a developer's workstation to production — source control, CI orchestration, artifact repositories, secrets management and the third-party services wired into all of them. Per its own introduction, the list is "the result of extensive research into attack vectors associated with CI/CD, and the analysis of high profile breaches and security flaws," naming the SolarWinds build-system compromise, the Codecov secrets breach, a backdoored PHP release pushed straight to the project's own git repository, the Dependency Confusion flaw, and the ua-parser-js/coa/rc NPM package compromises as the incidents that motivated it. The project is led by Daniel Krivelevich and Omer Gil of Cider Security, with Ory Segal (then of Palo Alto Networks) as a third project leader on OWASP's own repository, and its content is dual-licensed Apache-2.0 / CC BY-SA 4.0.

Key takeaways

  • Because an attacker who controls the pipeline does not need a flaw in the product.
  • The project is listed as an OWASP Lab Project in the Documentation class, for builders, breakers and defenders.
  • All three run attacker code inside the build.
  • Each risk's References section ties the definition to a named incident rather than a hypothetical.

Why does the pipeline need its own Top 10?

Because an attacker who controls the pipeline does not need a flaw in the product. The main OWASP Top 10 (see our guide to the 2025 edition) covers risks in a deployed web application. CI/CD systems are a separate attack surface: an attacker who compromises the pipeline can inject a weakness during the build, or ship a malicious artifact that nobody reviewed. The project's own framing makes this explicit: CI/CD systems are "the beating heart of any modern software organization," and it notes that third parties now plug in "with the integration of a new service typically requiring no more than adding 1-2 lines of code," so the attack surface has grown faster than most organizations' controls around it. For a device maker, the same pipeline compiles the firmware, signs the image and writes the SBOM, so one compromise reaches all three.

What are the ten CICD-SEC risks?

Each of the ten follows the same Definition / Description / Impact / Recommendations / References structure in the source document:

# Risk What it is
CICD-SEC-1 Insufficient Flow Control Mechanisms An attacker with access to one pipeline system (SCM, CI, artifact repository) pushes malicious code or artifacts downstream — "without being required to undergo a strict set of reviews and approvals"
CICD-SEC-2 Inadequate Identity and Access Management Poorly managed human and programmatic identities spread across SCM, CI, artifact repository and deployment systems increase "the potential and the extent of damage" of any one account's compromise
CICD-SEC-3 Dependency Chain Abuse Flaws in how workstations and build environments fetch code dependencies let "a malicious package inadvertently [be] fetched and executed locally when pulled"
CICD-SEC-4 Poisoned Pipeline Execution (PPE) An attacker with source-control access, but no build-environment access, injects malicious commands into pipeline configuration to run code as part of the build
CICD-SEC-5 Insufficient PBAC (Pipeline-Based Access Controls) Once code runs inside a pipeline node, an attacker abuses that node's own permissions "for moving laterally within or outside the CI/CD system"
CICD-SEC-6 Insufficient Credential Hygiene Weak access controls, insecure secret storage or overly permissive credentials let an attacker obtain and reuse secrets and tokens scattered through the pipeline
CICD-SEC-7 Insecure System Configuration Hardening and configuration gaps across SCM, CI and artifact-repository systems become "low hanging fruits" for an attacker expanding their foothold
CICD-SEC-8 Ungoverned Usage of 3rd Party Services Third-party integrations "effectively expand[] the attack surface of the organization" because granting them access is trivially easy
CICD-SEC-9 Improper Artifact Integrity Validation Insufficient validation of code or artifacts lets an attacker with access to one pipeline system push malicious — but seemingly benign — content downstream
CICD-SEC-10 Insufficient Logging and Visibility Gaps in logging let an adversary operate inside the CI/CD environment undetected, and hamper reconstructing their techniques during a post-incident investigation

The project is listed as an OWASP Lab Project in the Documentation class, for builders, breakers and defenders. Its metadata also points to cicd-goat, described as "a deliberately vulnerable CI/CD environment," which is a safe place to practise the attacks below before testing your own systems.

How do direct, indirect and public PPE differ?

All three run attacker code inside the build. They differ in what the attacker has to change. The CICD-SEC-4 page defines them as follows:

Type What the attacker changes Precondition named by OWASP
Direct PPE (D-PPE) The CI configuration file itself, pushed to an unprotected branch or sent as a pull request from a branch or fork The pipeline is triggered by push or PR events and reads its configuration from the changed branch
Indirect PPE (I-PPE) Files the configuration calls: a Makefile, scripts in the repository, test code, or linter and scanner configuration The configuration file itself is protected, for example pulled from a protected branch, kept in a separate repository or defined in the CI system
Public PPE (3PE) Either of the above, by an anonymous contributor to a public repository The public project's CI runs unreviewed code from outside contributors, sometimes on the same CI instance as private projects

OWASP's two worked examples steal AWS credentials: one by editing a GitHub Actions workflow on a new branch, one by appending a curl command to a Makefile that a protected Jenkinsfile calls. The second matters most for embedded teams. A Yocto, Buildroot or vendor SDK build is mostly recipes, Makefiles and scripts stored next to the source, so protecting only the top-level pipeline file leaves the I-PPE path open. The impact section lists what the attacker gains: any secret available to the job, files and cloud credentials reachable from the node, the ability to ship artifacts "in the guise of legitimate code," and network access from the node.

Which incidents does each risk cite?

Each risk's References section ties the definition to a named incident rather than a hypothetical. That is what separates this project from a generic hardening checklist: each Recommendations section is written to close the technique its incidents used. A selection, as listed in the per-risk pages:

Risk Cited incidents (selection)
CICD-SEC-1 PHP git backdoor pushed to the main branch; Homebrew auto-merge bypass; bypassing required reviews with GitHub Actions
CICD-SEC-2 Stack Overflow TeamCity (new accounts got admin rights); Mercedes-Benz and New York State GitLab servers open to self-registration; Gentoo GitHub account takeover
CICD-SEC-3 Dependency Confusion; the ua-parser-js, coa and rc npm hijacks
CICD-SEC-4 Indirect PPE in an AWS CodeBuild pipeline; a Teleport Drone CI pull request (3PE); terraform plan command execution
CICD-SEC-6 Codecov environment-variable theft; Travis CI secrets in PR builds; Homebrew Jenkins token exposure
CICD-SEC-7 SolarWinds build system; Webmin build server backdoor; Nissan Bitbucket with default credentials
CICD-SEC-8 Codecov; DeepSource GitHub app; Waydev OAuth token theft
CICD-SEC-9 SolarWinds (code changed during the build, "leaving no trace in the codebase"); Codecov, spotted by a customer comparing script hashes; Webmin

Two of these are build-server compromises that changed shipped software without touching source control. A firmware team that reviews only commits would miss both.

What does OWASP recommend for each risk?

The Recommendations sections are short and concrete. In summary, quoting where wording matters:

  • CICD-SEC-1: branch protection on production branches with no excluded accounts; limited, reviewed auto-merge rules; extra approval before production pipelines; artifacts accepted only from "a pre-approved CI service account"; drift detection between production and its CI/CD origin.
  • CICD-SEC-2: map every human and programmatic identity with the permissions granted and used; remove stale accounts; central identity provider; no self-registration, shared accounts or personal email addresses.
  • CICD-SEC-3: pull packages through an internal proxy; checksum and signature verification; pinned versions rather than "the latest version of a package"; scoped private package names; install scripts in a context without secrets.
  • CICD-SEC-4: run unreviewed code on isolated nodes without secrets; avoid fork-triggered pipelines or require manual approval; a branch protection rule for every branch that triggers a sensitive pipeline; review CI configuration before it runs.
  • CICD-SEC-5: no shared nodes across sensitivity levels; secrets scoped per pipeline and step; nodes reverted to a pristine state after each run; limited network access from build nodes.
  • CICD-SEC-6: prefer temporary credentials; rotate static ones; scan commits and history for secrets; keep secrets out of console output and out of "container images, binaries, or Helm charts."
  • CICD-SEC-7: inventory systems and versions with an owner, patch them, review configuration on a schedule, and restrict debug access to execution nodes.
  • CICD-SEC-8: govern third parties through approval, integration, ongoing visibility and deprovisioning.
  • CICD-SEC-9: sign resources when they are created and verify them before use, naming in-toto, SLSA and Sigstore; check the hash of any third-party script against the publisher's.
  • CICD-SEC-10: inventory every system, enable audit and application logs, centralise them, and alert on anomalies in the code-shipping process.

How do the risks map onto SLSA, in-toto and the SBOM?

Most directly through CICD-SEC-3 and CICD-SEC-9. Those two describe the gaps that SLSA's provenance levels and in-toto attestation are designed to close: a build pipeline that cannot prove where an artifact came from, or verify it before shipping, is exposed to both. CICD-SEC-2 and CICD-SEC-5 overlap with the CI-runner and token-permission checks in OpenSSF Scorecard. Because the same pipeline that compiles and signs a firmware image usually also generates its SBOM (see Firmware SBOM and our Yocto and Buildroot SBOM guide), a CICD-SEC-4 attack or a CICD-SEC-9 gap can corrupt the image and the SBOM in the same incident. Treat pipeline hardening and SBOM/provenance work as one workstream. For the maturity view of the same controls, DSOMM's Build sub-dimension scores pinning, SBOM creation and artifact signing as separate activities (see our DSOMM guide).

Worked example: how would a firmware release pipeline score?

Synthetic example, not a real product. A gateway maker builds Yocto images on a self-hosted CI server. Release builds run on tags, sign the image with a key stored as a CI variable, and upload it to an update server. A one-day review against the ten risks finds:

  1. CICD-SEC-4 (I-PPE)The pipeline file is protected, but pull requests from any branch trigger a full build on the same runner that holds the signing key. A changed recipe could read it. Fix: PR builds move to a separate runner with no secrets.
  2. CICD-SEC-6The signing key is a long-lived file variable available to every job. Fix: move it to a hardware security module or signing service called only from the release job.
  3. CICD-SEC-3Layers are fetched from public Git mirrors by branch name. Fix: pin layer revisions and mirror sources internally.
  4. CICD-SEC-9The update server accepts any upload with valid credentials. Fix: verify the image signature and provenance before publishing.
  5. CICD-SEC-10CI audit logs are kept for 7 days. Fix: ship them to the central log store with the release records.

Items 1 and 2 together are the shortest path from one stolen developer account to a signed malicious update, so they go first.

How should a device maker start, and what are the pitfalls?

  1. Start with CICD-SEC-1 and CICD-SEC-4 togetherFlow control (who can push unreviewed code to production) and Poisoned Pipeline Execution (who can inject commands into the pipeline) are the most direct path from a single compromised account to a shipped malicious artifact.
  2. Inventory third-party CI/CD integrations before adding new onesCICD-SEC-8's own framing — that granting a new service access takes "no more than adding 1-2 lines of code" — means the attack surface grows by default unless someone reviews what has access to what.
  3. Treat pipeline service-account permissions as a lateral-movement riskCICD-SEC-5 exists because pipeline nodes often hold credentials far broader than the step needs. Scope them to the job, not the project.
  4. Pair artifact integrity checks (CICD-SEC-9) with existing SBOM and provenance workIf a build already produces an SBOM and a SLSA provenance attestation, verify the artifact's origin at the same point before it ships.
  5. Check logging coverage (CICD-SEC-10) against the incidents in the other nine risksIf the pipeline could not reconstruct a PHP-style direct push or a Codecov-style secret theft after the fact, close that gap first.

Common pitfalls:

  • Protecting the pipeline file but not what it calls. I-PPE works through Makefiles, scripts and test code.
  • Keeping the signing key where every job can read it. One poisoned PR build then signs malware.
  • Reviewing only source control. SolarWinds and Webmin were changed on the build server.
  • Leaving secrets in build output. CICD-SEC-6 names binaries explicitly; see our guide to hard-coded credentials in firmware.

SoftWSP covers the artifact side of this work. It extracts a CycloneDX 1.6 SBOM from the finished firmware image, matches the components against NVD, CISA KEV, FIRST EPSS and CISA CSAF ICS advisories, and drafts a cited report that an engineer reviews; watchlist alerts flag new CVEs on a CVE ID, vendor or product. It does not audit branch protection, runner permissions or signing keys; that review stays with your build team. Comparing the SBOM of each release with the previous one, for example with the SBOM diff tool, can surface a dependency nobody expected. See Device & Firmware Security.

This guide summarizes and quotes the OWASP Top 10 CI/CD Security Risks project (dual-licensed Apache-2.0 / CC BY-SA 4.0 by OWASP and its named authors); it is not a substitute for the full per-risk Definition/Description/Impact/Recommendations/References text published in the project repository.

Put this guide to work

Frequently asked questions

What is the OWASP Top 10 CI/CD Security Risks project, and who maintains it?

OWASP Top 10 CI/CD Security Risks is an OWASP Lab Project documenting the ten most significant risk categories in continuous integration/continuous delivery environments — the systems (source control, build, artifact repository, deployment) that move code from a developer's workstation to production. Per the project's own introduction, it is "the result of extensive research into attack vectors associated with CI/CD, and the analysis of high profile breaches and security flaws," citing the SolarWinds build-system compromise, the Codecov secrets-exfiltration breach, a backdoored PHP release pushed directly to the project's git repository, the Dependency Confusion flaw, and compromises of the ua-parser-js, coa and rc NPM packages as its motivating incidents. The project's listed leaders are Daniel Krivelevich (co-founder/CTO, Cider Security) and Omer Gil (Director of Research, Cider Security), with Ory Segal (then Senior Director of Product Management, Palo Alto Networks) added as a project leader on the OWASP repository; the project's own metadata lists its content under a dual Apache-2.0 / CC BY-SA 4.0 license, and the GitHub project repository under the OWASP organization was created in July 2022.

What do the ten CICD-SEC risks cover?

Each risk follows a consistent Definition / Description / Impact / Recommendations / References structure. In the project's own numbering: CICD-SEC-1, Insufficient Flow Control Mechanisms — an attacker with access to one pipeline system pushing malicious code or artifacts downstream with no required review; CICD-SEC-2, Inadequate Identity and Access Management — poorly managed human and programmatic identities scattered across SCM, CI, artifact repository and deployment systems; CICD-SEC-3, Dependency Chain Abuse — flaws in how workstations and build environments fetch code dependencies, letting a malicious package get fetched and executed; CICD-SEC-4, Poisoned Pipeline Execution (PPE) — an attacker with source-control access but no build-environment access injecting malicious commands into pipeline configuration to run code during the build; CICD-SEC-5, Insufficient PBAC (Pipeline-Based Access Controls) — abusing a pipeline execution node's own permissions to move laterally once malicious code runs inside it; CICD-SEC-6, Insufficient Credential Hygiene — obtaining and reusing secrets/tokens due to weak access controls, insecure secret storage or overly broad credential scope; CICD-SEC-7, Insecure System Configuration — hardening and configuration flaws across SCM, CI and artifact-repository systems; CICD-SEC-8, Ungoverned Usage of 3rd Party Services — third-party integrations expanding the attack surface because they're trivially easy to grant access to CI/CD resources; CICD-SEC-9, Improper Artifact Integrity Validation — insufficient mechanisms to verify code or artifacts before they move further down the pipeline; and CICD-SEC-10, Insufficient Logging and Visibility — gaps that let an attacker operate inside the CI/CD environment, and complicate post-incident reconstruction of their techniques, undetected.

How is this different from the general OWASP Top 10 or a CI/CD security checklist?

The general OWASP Top 10 (see our guide to the 2025 edition) categorizes risks in deployed web applications; this project is scoped specifically to the pipeline infrastructure that builds and ships that application — source control, CI orchestration, artifact repositories, secrets and third-party integrations — a distinct attack surface the main Top 10 doesn't cover. OWASP's own companion CI/CD Security Cheat Sheet is a shorter, control-oriented checklist for hardening specific tools; this Top 10 project is the longer-form risk taxonomy each CICD-SEC entry's Recommendations section draws from, with worked incident References (the PHP git backdoor, a Homebrew auto-merge bypass, a documented GitHub Actions required-reviews bypass) attached to specific risks rather than generic tool settings.

How does this map onto firmware/device supply-chain practices like SLSA, SBOM and in-toto?

CICD-SEC-3 (Dependency Chain Abuse) and CICD-SEC-9 (Improper Artifact Integrity Validation) describe the same failure modes that SLSA's provenance levels and in-toto's attestation framework are built to close — see our guides to [SLSA](/guides/slsa-supply-chain-levels/) and [in-toto attestation](/guides/in-toto-attestation-framework/). CICD-SEC-2 (identity/access) and CICD-SEC-5 (PBAC) map onto the same CI-runner and service-account scoping concerns covered by [OpenSSF Scorecard](/guides/openssf-scorecard/)'s automated checks. For a firmware or embedded device maker, these risks apply to the build pipeline that compiles and signs firmware images and generates the accompanying SBOM — a poisoned build (CICD-SEC-4) or an unvalidated artifact (CICD-SEC-9) can corrupt the firmware and the SBOM's accuracy at the same time, which is why pipeline hardening and SBOM/provenance controls are typically addressed together rather than as separate workstreams.

Sources

  1. OWASP: Top 10 CI/CD Security Risks — official project page (introduction, authors/leaders, license, list of CICD-SEC-1 through CICD-SEC-10)
  2. OWASP (GitHub): www-project-top-10-ci-cd-security-risks — full per-risk Definition/Description/Impact/Recommendations/References pages, LICENSE (CC BY-SA 4.0), the project's OWASP metadata file (license, leaders)
  3. Cider Security Research: top-10-cicd-security-risks — original research repository referenced by the OWASP project
  4. OWASP Cheat Sheet Series: CI/CD Security Cheat Sheet (companion control checklist)
Was this guide helpful?

In this cluster

OWASP Top 10 CI/CD Security Risks, explained