Software Development Security

CISSP CISSP · Software Development Security

By Abu Anns · Last updated 20 November 2026Exam version: April 2024 outline (current until 15 April 2027)

Security is a lifecycle, not a phase

Domain 8 covers security throughout the software development lifecycle (SDLC). Its central principle is that security must be built in from the start, not bolted on at the end: a vulnerability found in production costs far more to fix — in money, time and reputation — than the same vulnerability found during design or coding. The exam tests the SDLC phases and the security activities that belong in each: requirements (defining security requirements alongside functional ones), design (threat modelling, secure architecture), development (secure coding practices, code review), testing (security testing, including static and dynamic analysis), deployment (secure configuration, hardening), and maintenance (patching, vulnerability management, and secure disposal at end of life). The "shift left" concept — moving security activities earlier in the lifecycle — is the modern expression of this principle, and DevSecOps is its operational form.

Secure SDLC models

The exam expects familiarity with the main development methodologies and their security implications. The waterfall model proceeds in sequential phases; security is typically a distinct phase, which makes it easy to plan but slow to adapt. Agile develops in short iterations (sprints), which means security must be integrated into every sprint — security requirements become user stories, and security testing happens continuously. DevOps automates the pipeline from code to deployment, and DevSecOps embeds security controls into that pipeline: automated static analysis on every commit, dependency scanning, container scanning, and policy-as-code. Spiral emphasises risk analysis at each iteration. The exam's key point is methodology-agnostic: whatever the model, security activities must be present in every phase, and the earlier a vulnerability is found, the cheaper it is to fix. The exam also covers maturity models such as BSIMM (Building Security In Maturity Model) and SAMM (OWASP Software Assurance Maturity Model), which measure how mature an organisation's software security practices are.

The OWASP Top 10

The OWASP Top 10 is the industry's standard list of the most critical web application security risks, and the exam tests its contents and countermeasures. The 2021 edition lists: Broken Access Control (users accessing resources or functions they should not — the most common serious risk), Cryptographic Failures (weak or missing encryption, exposing sensitive data), Injection (untrusted data sent to an interpreter — SQL injection, command injection, LDAP injection), Insecure Design (missing or ineffective security controls in the design itself), Security Misconfiguration (default credentials, unnecessary features, verbose error messages), Vulnerable and Outdated Components (known vulnerabilities in libraries and frameworks), Identification and Authentication Failures (weak session management, credential stuffing, broken authentication), Software and Data Integrity Failures (unverified updates, insecure CI/CD pipelines), Security Logging and Monitoring Failures (insufficient logging to detect breaches), and Server-Side Request Forgery (SSRF) (tricking a server into making requests to internal systems). The exam tests the countermeasures as much as the risks: input validation and parameterised queries for injection, access control enforcement on the server side for broken access control, and keeping components updated for vulnerable components.

OWASP Top 10 (2021)Key countermeasure
Broken Access ControlEnforce access control server-side on every request; deny by default
Cryptographic FailuresEncrypt sensitive data at rest and in transit; use current algorithms
InjectionParameterised queries; input validation; least-privilege database accounts
Insecure DesignThreat modelling; secure design patterns; reference architectures
Security MisconfigurationHardening; remove defaults; minimal attack surface
Vulnerable and Outdated ComponentsInventory; dependency scanning; timely patching
Identification and Authentication FailuresMFA; strong session management; protection against brute force
Software and Data Integrity FailuresSigned updates; secure CI/CD pipeline; integrity checks
Security Logging and Monitoring FailuresComprehensive logging; alerting; log protection
Server-Side Request Forgery (SSRF)Validate and allowlist outbound request destinations

Common vulnerabilities and secure coding

Beyond the OWASP Top 10, the exam covers the vulnerability classes that secure coding must prevent. Buffer overflows (see the security models guide) arise from unchecked input length. Cross-site scripting (XSS) injects malicious scripts into web pages viewed by other users — stored XSS persists in the application, reflected XSS arrives in a crafted link, and DOM-based XSS executes in the victim's browser; the countermeasures are output encoding and Content Security Policy. Cross-site request forgery (CSRF) tricks a user's browser into performing an unwanted action on a site where they are authenticated; the countermeasure is an anti-CSRF token. Race conditions (including TOCTOU) exploit the gap between a check and its use. Insecure direct object references (IDOR) let a user access another user's data by changing an identifier in a request (such as an account number in a URL); the countermeasure is server-side authorisation on every access. Secure coding practices that address these include: input validation (validate all input on the server side, using allowlists rather than denylists), output encoding, parameterised queries, least privilege for database and service accounts, error handling that does not leak system details, and secure session management (unpredictable session IDs, secure and HttpOnly cookies, session timeout, and regeneration of session IDs after login).

Security testing in development

Testing for security uses several complementary techniques. Static Application Security Testing (SAST) analyses source code without executing it — it finds vulnerabilities early and cheaply, but produces false positives and cannot find runtime issues. Dynamic Application Security Testing (DAST) tests a running application from the outside, like an attacker — it finds runtime vulnerabilities but cannot see the code and runs later in the lifecycle. Interactive Application Security Testing (IAST) combines both, instrumenting the running application. Software Composition Analysis (SCA) scans third-party libraries and dependencies for known vulnerabilities. Fuzzing feeds random or malformed input to find crashes and unexpected behaviour. Manual code review by a skilled reviewer catches logic flaws that automated tools miss. The exam's key insight is that no single technique is sufficient: SAST and DAST complement each other, SCA covers the supply chain, and manual review catches what automation cannot. Testing must also include unit testing, integration testing, and acceptance testing with security criteria, and the results must feed back into the development process rather than sitting in a report.

Acquired software and the supply chain

Most software is not written in-house — it is bought, licensed, or assembled from open-source components, and Domain 8 covers the security of acquired software. Commercial off-the-shelf (COTS) software must be evaluated for security before purchase (vendor security practices, vulnerability history, patch cadence, and contractual obligations such as SLAs for security fixes). Open-source software requires the same diligence: the organisation must inventory its dependencies, monitor them for vulnerabilities, and have a process for updating them — the Log4Shell vulnerability demonstrated how a single widely used library can expose thousands of organisations simultaneously. Software escrow is an arrangement where the source code of a critical commercial product is held by a third party and released to the customer if the vendor goes out of business or fails to support the product. The exam also covers service-level agreements (SLAs) for security (patch timelines, vulnerability disclosure, incident notification) and the principle that acquiring software does not transfer accountability for its security — the organisation remains responsible for the risk.

DevSecOps and the secure pipeline

DevSecOps embeds security into the continuous integration / continuous delivery (CI/CD) pipeline: every code commit triggers automated security checks (SAST, dependency scanning, secret scanning), every build is scanned, and deployment gates block releases that fail security policy. Secrets management is critical: credentials, API keys and tokens must never be hard-coded in source code or committed to version control — they belong in a secrets manager or vault, injected at runtime. Infrastructure as Code (IaC) templates should be scanned for misconfigurations before deployment. Container security includes scanning images for vulnerabilities, running containers with minimal privileges, and not running containers as root. The exam's framing is that automation is what makes security scalable in modern development: manual security review cannot keep pace with dozens of deployments per day, so the pipeline itself must enforce the policy.

Exam mindset for software development security

Software security questions reward thinking about the lifecycle: the earlier a control is applied, the better. When a scenario describes a vulnerability, identify its class (injection, XSS, broken access control, insecure component) and match the countermeasure. And remember that acquiring software does not transfer accountability — the organisation owns the risk of every component it deploys.

Advertisement

Exam traps to watch for

Practice questions

Test yourself on this guide. Answers are checked instantly, with a full explanation for each question.

Q1.A web application builds SQL queries by concatenating user input directly into the query string. An attacker enters SQL commands in a login field and gains access to the entire database. Which vulnerability is this, and what is the BEST fix?

Report an error

Q2.A development team discovers a security vulnerability during the design phase of a new application. The project manager suggests deferring the fix until after release to avoid delaying the launch. What is the BEST argument against deferring?

Report an error

Q3.A user notices that changing the account number in a URL from /account/12345 to /account/12346 displays another customer’s account details. Which vulnerability is this, and what is the BEST fix?

Report an error

Q4.A CI/CD pipeline automatically scans source code for vulnerabilities on every commit, scans third-party dependencies, and blocks deployment if critical findings are present. Which concept does this BEST illustrate?

Report an error

Q5.A developer commits code containing a hard-coded database password to a shared source code repository. What is the MOST appropriate response?

Report an error

Q6.A security team wants to find vulnerabilities in a web application by analysing its source code before it is deployed. Which testing method should they use?

Report an error

Q7.A critical vulnerability is disclosed in a widely used open-source library that the organisation’s applications depend on. What is the FIRST step the organisation should take?

Report an error

Q8.A company is purchasing a critical commercial software product from a small vendor. The company is concerned about what happens if the vendor goes out of business. Which arrangement BEST protects the company?

Report an error