Skip to content

DOMAIN 8 · Software Development Security

Secure Development with the NIST SSDF

Integrate security into development, protect the build and release process, and use vulnerability findings to prevent recurrence.

Put security into the development lifecycle

Section titled “Put security into the development lifecycle”

The Secure Software Development Framework, SSDF, describes practices that can be integrated into different software development lifecycle models. NIST SP 800-218 presents SSDF version 1.1 as a common vocabulary for reducing vulnerabilities, limiting their impact, and addressing causes of recurrence. It does not prescribe a single development method.1

For CISSP, connect secure development to governance and acquisition as well as programming. A team needs clear requirements, accountable decisions, protected environments, evidence of verification, and a way to respond after release.

Group Purpose in the development process
Prepare the Organization, PO Establish people, processes, tools, and security expectations
Protect the Software, PS Protect code and release artifacts against unauthorized changes and support release integrity
Produce Well-Secured Software, PW Design, build, review, and test software against requirements and risks
Respond to Vulnerabilities, RV Identify vulnerabilities, respond, and learn from their causes

These groups reinforce one another. Protecting a release artifact cannot repair an insecure authorization design; correcting that design cannot compensate for an attacker-controlled release pipeline.1

Translate a broad goal into behavior that can be evaluated. “Protect customer information” is a direction, while “a customer may download only invoices associated with their account” can guide design and testing. Record relevant assumptions and define who may approve an exception.

The SSDF includes defining requirements, modeling risks, tracking design decisions, and reviewing designs against those requirements. Security work should therefore begin before a final penetration test and continue as the design changes.1

The build environment, source repository, dependencies, credentials, and output artifacts are part of the software’s security. Restrict modification rights, protect release integrity, and retain the information needed to understand what was shipped. SSDF practices include release archives and component provenance, with a software bill of materials as one example.1

A component inventory helps answer where an affected dependency is used. It does not itself demonstrate that those components are trustworthy or that the application uses them securely. Evaluate the origin, maintenance, integration, and applicable security requirements of acquired components rather than treating an inventory as approval.

Worked example: releasing an invoice service

Section titled “Worked example: releasing an invoice service”

Imagine a fictional team introducing an invoice-download feature. It records the customer-ownership requirement, models cross-customer access as a threat, and reviews how every download endpoint enforces authorization. Automated checks cover both permitted and denied requests.

Before release, the team checks the relevant dependencies and records the built artifact and its provenance. A later report shows that an alternate export route bypasses the ownership check. The immediate repair closes that route; the process improvement adds a shared authorization mechanism, covers alternate routes in review, and verifies that the new tests detect the original failure. This example illustrates the connection between design, release evidence, and recurrence prevention.

Software buyers can use SSDF practices to communicate expectations to suppliers. Ask what evidence supports the relevant practices, which party is responsible for updates, and how vulnerability reports and remediations reach customers. A supplier statement should be evaluated in the context of the acquired service and the customer’s responsibilities.1

After discovery, prioritize response according to risk and investigate root causes. Counted fixes alone cannot show whether the same defect pattern continues to appear in other products. Feedback should influence requirements, training, design patterns, and tool configuration.

  • “Agile development leaves no room for security.” SSDF practices can be integrated into different lifecycle models.
  • “A passed scanner makes the release secure.” Tool output is only part of the evidence.
  • “An SBOM guarantees supply-chain security.” It provides component information, not a blanket assurance.
  • “Patching ends the development team’s responsibility.” Understanding recurrence and communicating treatment are also important.

Threat modeling develops design-time risk scenarios. Security testing supplies verification methods, and incident response connects software failures with coordinated operational action.

  1. NIST, SP 800-218, Secure Software Development Framework Version 1.1, February 2022; sections 1–2 and Table 1, especially PO.1, PO.4, PS.1–PS.3, PW.1–PW.8, and RV.1–RV.3. ↩ ↩2 ↩3 ↩4 ↩5

Independent, unofficial study notes. Not endorsed or reviewed by ISC2. CISSP is a registered trademark of ISC2.

Editorial policy & attribution