Software Development Security · Topic 2 of 4

Development Ecosystem Controls

Security controls for languages, libraries, IDEs, runtimes, CI/CD pipelines, code repositories and configuration management, plus SAST, DAST, IAST and SCA.

  • 3 min
  • Includes a diagram
In a nutshell
  • Every ecosystem element (languages, libraries, tools, IDEs, runtimes, pipelines, repositories) needs controls.
  • SAST reads code; DAST tests the running app; IAST observes from inside; SCA checks dependencies.
  • Protect pipelines: least privilege, independent approval of pipeline changes, ephemeral runners, signed artifacts.

What it is

The development ecosystem is everything used to build software: languages, libraries, tools, IDEs, runtimes, pipelines and repositories. Attackers increasingly target this ecosystem, because compromising a build can compromise every customer. Each element needs its own controls.

Developer workstationCode repositoryCI/CD pipelinebuild and testArtifact repositoryDeploy

How it works

Ecosystem elements and controls

ElementRiskControls
Programming languagesMemory-unsafe languages allow overflowsPrefer memory-safe languages where possible; secure coding standards
Libraries and dependenciesVulnerable or malicious packages, dependency confusionSoftware composition analysis, approved sources, private registries, lock files with hashes
Tool sets and IDEsMalicious plugins, secrets in local filesApproved plugins, secret scanning, managed workstations
RuntimesVulnerable runtime versionsPatch and pin runtimes, container image scanning
CI/CD pipelinesTampered builds, stolen credentialsLeast-privilege pipeline accounts, protected pipeline definitions, ephemeral isolated runners, signed artifacts
Code repositoriesUnauthorized changes, leaked secretsMFA, branch protection, required reviews, pull-request-only access for contractors
Configuration managementUntracked or drifting configurationVersion-controlled configuration, approved baselines
Test environmentsReal data exposureMasked or synthetic data
Exam tip

If engineers can edit the pipeline definition that builds and checks their own code, they can disable the checks. Require independent approval for pipeline configuration changes.

Application security testing

ToolHow it worksFinds
SAST (static)Analyzes source code without running itUnsafe data flows, insecure functions, early in development
DAST (dynamic)Tests the running application from outsideRuntime and configuration issues, injection
IAST (interactive)Agent inside the running app observes behaviour during testsFlaws with precise code locations
SCA (software composition analysis)Compares dependencies with known-vulnerability data and licencesVulnerable or non-compliant libraries
Secret scanningLooks for credentials in code and commitsKeys and passwords before they reach the repository
FuzzingSends malformed inputCrashes and input-handling flaws

Build integrity

A secure software pipeline: secret scanning at pre-commit, a protected repository with MFA and required review, a pipeline with SAST, SCA, lock files and ephemeral runners, signed artifacts with an SBOM, and signature checks at deployment.

  • Build in clean, ephemeral environments so residue from one build cannot affect another.
  • Sign artifacts and verify signatures at deployment.
  • Record provenance (what was built from which source, by which pipeline).
  • Keep a software bill of materials for each release.

Secrets in development

Do not store credentials in code or configuration files. Use secrets managers and short-lived credentials issued at run time, so a compromised laptop does not expose production credentials.

How the exam asks about this

  • "Enforce a ban on deprecated cryptographic functions on every commit." A static analysis rule that fails the build.
  • "Public package with a name like an internal one is pulled into builds." Private registry with namespace pinning.
  • "Dependencies resolve to the latest release at each build." Lock files with hash verification.

What to remember for the exam

  • Every ecosystem element (languages, libraries, tools, IDEs, runtimes, pipelines, repositories) needs controls.
  • SAST reads code; DAST tests the running app; IAST observes from inside; SCA checks dependencies.
  • Protect pipelines: least privilege, independent approval of pipeline changes, ephemeral runners, signed artifacts.
  • No secrets in code; use vaults and short-lived credentials.
  • Pin and verify dependencies.
Watch out

A compromised build system can insert malicious code into signed, trusted releases. Protect the pipeline as carefully as production.

Common mistakes

Relying on annual attestations to enforce coding rules.

Letting builds pull the newest dependency versions automatically.

Using production data in test environments.

Check yourself

  • Which testing approach analyzes source code without executing it?

    Static application security testing (SAST).

  • What does software composition analysis find?

    Known-vulnerable or non-compliant third-party components.

  • Why use ephemeral build runners?

    Each build starts clean, so residue or compromise from one build cannot carry into another.

Topic 2 of 4 in Software Development Security

Test yourself on Software Development Security

The full ISC2 CISSP question bank has 1,113 questions, with timed practice exams and an explanation for every answer.

This study guide is independent and is not affiliated with, endorsed by, or sponsored by ISC2. Vendor names, certification names and exam codes are trademarks of their respective owners and are used for identification only.