Customize this training

Get a certificate — $16.67$5

DevSecOps Fundamentals: Pipeline Security, SAST/DAST, Secrets and SBOM

DevSecOps Fundamentals: Pipeline Security, SAST/DAST, Secrets and SBOM

Build security into every stage of a CI/CD pipeline: harden the pipeline, run SAST, SCA and DAST, keep secrets out of code and ship software with an SBOM and signed provenance.

What you will learn

  • Explain what DevSecOps changes and map pipeline activities to the NIST SSDF practice groups.
  • Harden a CI/CD pipeline against the main OWASP CI/CD security risks.
  • Place SAST, SCA and IaC scanning in the pipeline and act on their findings.
  • Run DAST and API tests safely and triage findings with security gates.
  • Keep secrets out of code, use short-lived credentials and respond to a leaked key.
  • Produce and use an SBOM, sign artefacts and describe SLSA build provenance.

Modules

  1. What DevSecOps changes
  2. Securing the pipeline itself
  3. Scanning code and dependencies: SAST, SCA and IaC
  4. Testing the running application: DAST, API tests and security gates
  5. Secrets management
  6. SBOM, signing and supply-chain integrity

Course facts

Level
Awareness
Estimated study time
about 45 minutes
Final assessment
24 questions · Pass mark 80%
Available in
English, Français
Price
Free. Optional verifiable certificate: $5
Last updated
Published by
AMAADOR ACADEMY

Who this course is for

Developers, DevOps and platform engineers, QA testers, security champions, IT and project managers who work with CI/CD pipelines or commission software.

Prerequisites

Basic familiarity with Git and with the idea of a build pipeline. No security background needed.

Course content

1. What DevSecOps changes

In a classic project, security arrives at the end: a penetration test a few days before go-live, a long list of findings, and a choice between delaying the release or shipping known flaws. DevOps made releases fast and frequent, so that model breaks. DevSecOps means building security checks into the same automated flow that builds, tests and deploys the software, and making the whole team responsible for them.

Two ideas sit behind it. Shift left: find problems as early as possible, when the developer still has the code in mind and the fix costs minutes. Automate what can be automated: tools run on every commit and every pull request, so people spend their time on design and on findings that need judgement.

Every stage gets its own security activity: threat modelling at Plan, secret scanning at Code, SAST and SCA at Build, DAST at Test, signing at Release, monitoring in production.

DevSecOps is not a tool you buy. A scanner that nobody reads, or that blocks every build with false positives, makes things worse: developers learn to bypass it. What works is a small set of well-tuned checks, clear rules on what blocks a release, and a named owner for each finding.

2. Securing the pipeline itself

A CI/CD pipeline holds the keys to production: cloud credentials, signing keys, registry tokens and the right to deploy. An attacker who controls the pipeline does not need to break your application; they can ship their own code inside it, signed and trusted.

Case: SolarWinds Orion, 2020. CISA advisory AA20-352A reports that a malicious version of an Orion DLL was inserted into the software build and signed with the legitimate SolarWinds code-signing certificate. The compromise began in at least March 2020 and the malicious version was delivered to customers as a normal Orion update. · Why: the build environment was compromised, so signing proved only that the file came from the vendor’s pipeline, not that the code was intended. · Prevention: hardened, isolated build systems, verifying that build output matches reviewed source, and monitoring of the build platform.

OWASP publishes the Top 10 CI/CD Security Risks (CICD-SEC-1 to 10). The ones you will meet most often:

RiskWhat it looks like
Insufficient flow control (SEC-1)One person can push straight to production with no review
Inadequate identity and access management (SEC-2)Old accounts, shared admin logins, no MFA
Dependency chain abuse (SEC-3)A malicious or look-alike package is pulled into the build
Poisoned pipeline execution (SEC-4)An attacker edits the pipeline file in a pull request to run their commands
Insufficient credential hygiene (SEC-6)Long-lived secrets printed in logs or shared across jobs
Improper artifact integrity validation (SEC-9)Nobody checks that what is deployed is what was built

3. Scanning code and dependencies: SAST, SCA and IaC

Static Application Security Testing (SAST) analyses source code, bytecode or binaries without running them. It follows data from inputs (a form field, an HTTP header) to dangerous places (a SQL query, a shell command, an HTML page) and flags paths where the data is not validated or encoded. It finds injection, hard-coded credentials, weak cryptography calls and unsafe functions.

Where to run itWhat it is good for
In the IDEInstant feedback while typing, cheapest fix
On each pull requestReport only new findings in changed code, as review comments
Nightly full scanDeeper rules across the whole codebase, trend tracking

SAST has known limits. It produces false positives (it cannot always see that input was validated elsewhere) and false negatives (it does not understand business logic, so it will not see that a user can read another customer’s invoice). It also needs to support your language and framework.

  1. Start small — enable a high-confidence rule set first, not every rule.
  2. Gate on new findings — block a merge for new high or critical issues; handle the old backlog as planned work.
  3. Triage honestly — mark a finding as false positive only with a short reason that a reviewer can check.
  4. Fix the pattern — if the same flaw appears ten times, fix the shared library or add a safe helper.

4. Testing the running application: DAST, API tests and security gates

Dynamic Application Security Testing (DAST) attacks the running application from the outside, like a user or an attacker would: it crawls pages and endpoints, sends crafted inputs and watches the responses. It does not need the source code and it sees what is really deployed, including server configuration, missing security headers, cookies without the Secure flag and error pages that leak stack traces.

TechniqueNeedsStrengthWeakness
SASTSource codeEarly, exact line of codeFalse positives, no runtime view
DASTRunning appReal behaviour and configurationLater, does not point to the line
IASTApp with an agent, during testsRuntime view with code locationLanguage support, setup effort

Modern applications are mostly APIs, and a crawler finds few of them alone. Feed the scanner your OpenAPI specification or recorded test traffic, and give it test accounts for at least two different users so it can check that user A cannot read user B’s data. Broken access control is A01 in the OWASP Top 10:2025.

Do

  • Scan a dedicated test or staging environment
  • Use test data and test accounts
  • Run a quick baseline scan on each deploy to staging, a full scan on a schedule

5. Secrets management

A secret is anything that grants access: passwords, API keys, cloud access keys, database connection strings, private keys, signing keys and tokens. Once a secret is committed to a repository it is copied to every clone, every fork and every backup, and it stays in the Git history even after you delete the line.

Case: Uber, 2016 breach. The US Federal Trade Commission reported that intruders used an access key an Uber engineer had posted on a code-sharing site to download unencrypted files from Uber’s cloud storage, including more than 25 million names and email addresses and about 600,000 driver’s licence numbers. · Why: a long-lived cloud key stored with code. · Prevention: no keys in repositories, secret scanning, least-privilege and short-lived credentials, encrypted data at rest.

All of these are secrets and none of them belong in source code, images or logs.

Where secrets should live instead: a secrets manager or vault (for example HashiCorp Vault, AWS Secrets Manager, Azure Key Vault, Google Secret Manager) or the protected secret store of your CI platform. The application or job fetches the secret at run time, with an identity that is allowed to read only what it needs.

6. SBOM, signing and supply-chain integrity

CISA describes a Software Bill of Materials (SBOM) as a nested inventory of the components that make up software. Like an ingredients list on food, it lets the buyer, the operator and the vendor’s own security team see what is inside.

Two open formats dominate:

FormatMaintained byNotes
SPDXLinux Foundation (also ISO/IEC 5962)Strong on licences and file-level detail
CycloneDXOWASP / Ecma International (ECMA-424)Strong on security use cases, supports VEX

A useful SBOM records, for each component, at least: supplier, name, version, a unique identifier (such as a package URL or CPE), the dependency relationships, plus who produced the SBOM and when. These come from the US NTIA minimum elements (2021); CISA has since published updated guidance on minimum elements that adds fields and practices.

  1. Generate it in the build — from the exact artefact you release, not by hand.
  2. Store it with the release — one SBOM per version, kept as long as that version is supported.
  3. Monitor it — feed SBOMs into a tool that alerts you when a new CVE affects a listed component.
  4. Share it — with customers who ask, together with VEX statements.

The full lesson continues in the interactive course on this page.

Sources and references

Educational course on general good practice. It is not a certification and does not replace your organisation’s security policy, tool vendor documentation or a professional security assessment. Test only systems you are authorised to test.

All courses · Cybersecurity and IT — Free courses, certificate $5 | AMAADOR ACADEMY