CISSP domain - 10% of the exam

Software Development Security

Software Development Security is 10% of the CISSP exam. These are the objectives it covers, each with practice questions, with every answer explained.

The domain in numbers

30
Practice questions
5
Objectives
18
Medium
12
Hard

Where people go wrong

  • Offering a soft control where a technical gate is needed

    The wrong answers offer a soft, upstream or after-the-fact control where the question asks what stops the change. Peer review and signed commits govern what enters the codebase, not what is deployed, training raises awareness, runtime scanning and EDR detect after the event, alerting on a bypass fires after release, and attestation or local scans rely on developer honesty. The correct answers are technical gates: an immutable pipeline that rejects manually built artefacts, pipeline definitions in a protected repository with separate review, and an allow list of signed plug-ins.

    See it in a sample question
  • Leaving the contract gap or choosing a term that misses it

    The wrong answers leave the contractual gap in place or pick a term that does not cover it. Accepting the 30-day term and relying on internal monitoring, accepting the risk, terminating, or issuing an instruction with no contractual basis leave the terms unchanged. A perpetual licence, extended warranty or source access only after confirmed exploitation leave the firm exposed if the vendor fails. The correct answers amend the terms: a notification period that meets the insurer's 72-hour obligation, source code escrow with release conditions, and sub-processor disclosure with approval and notification.

    See it in a sample question
  • Strengthening the channel when authorisation is missing

    The wrong answers strengthen the channel when the flaw is missing authorisation. Unguessable identifiers, rate limits and an entitlement list in the token do not confirm that the authenticated partner owns the order requested. Mutual TLS, schema-aware filtering and static API keys do not limit which patients or fields a partner can read. The correct answers enforce server-side authorisation on every call, checking ownership against the system of record or the requested scope against the consent record.

    See it in a sample question
  • Handling dependency risk one library at a time

    The wrong answers deal with dependency risk one library at a time, outside the build. Patching the known component, attestation by squads, manual review of transitive dependencies, rewriting them, email CVE triage and external testing all leave the next vulnerable package free to enter. The correct answers put software composition analysis in the pipeline, feeding an approved-library registry or failing the build on policy-violating components, and produce a software bill of materials per release.

    See it in a sample question
  • Running the wrong test type at the wrong stage

    The wrong answers misplace a testing type or misstate what it does. SAST analyses source or binaries without executing the application, DAST exercises it while running, IAST instruments it at runtime, and SCA covers third-party dependencies. DAST is too slow to gate a pull request, so static analysis and secret scanning run there and DAST runs nightly. Switching to dynamic testing or suppressing severity bands does not fix a noisy static tool, whose ruleset should be tuned.

    See it in a sample question

Objectives in this domain

What to study

The official documents this domain's practice questions cite most.

Sample questions from this domain

Free sampleSoftware Development Securityhard

During a post-incident review, an auditor asks the development manager which DevSecOps practice MOST directly enforces that no unauthorised or unreviewed change reaches production, regardless of the developer who proposed it. Which practice should the manager identify?

  • ABranch protection rules that require peer code review and signed commits before a merge to the release branch is permitted.
  • BMandatory secure coding training for all engineers, refreshed annually and tracked through the learning management system.
  • CAn immutable, fully automated deployment pipeline whose promotion to production requires a recorded change approval and rejects manually built artefacts. Correct
  • DContinuous vulnerability scanning of production workloads with automated ticketing for findings above a defined CVSS threshold.
Identify the DevSecOps control that enforces change management and separation of duties at the production promotion step. Change management in a DevSecOps pipeline is implemented by treating the pipeline as the only path to production and gating promotion with recorded approval. Combined with artefact provenance, this gives an evidence trail showing every production change traces to an approved, reviewed source, satisfying both separation of duties and auditability without slowing routine delivery.

Why A is wrong: Peer review and signed commits are strong controls over what enters the codebase, but they sit before the deployment step. A reviewed commit can still bypass production controls if the deployment pipeline itself is not gated, so this is necessary but not the most direct answer to the auditor's question.

Why B is wrong: Training raises the floor of developer capability but is a preventative awareness control, not an enforcement mechanism against unauthorised production change. It would not stop a determined or careless developer from pushing an unapproved artefact.

Why C is correct: An automated pipeline that only accepts artefacts produced by the pipeline itself, coupled with a recorded approval gate for production, enforces separation of duties and change management for every promotion, irrespective of who proposed the change. This is the control closest to the auditor's concern.

Why D is wrong: Runtime scanning detects weaknesses after deployment. It does not prevent an unauthorised or unreviewed change from reaching production in the first place, which is precisely what the auditor is probing.

Free sampleSoftware Development Securitymedium

A health insurer is migrating its claims workflow to a SaaS provider. The provider's standard contract states the vendor will notify customers of a security incident within 30 days. The insurer's regulator requires notification of affected individuals within 72 hours of confirmation of a breach involving protected health information. What is the BEST course of action for the procurement and security teams?

  • ANegotiate a contractual amendment that requires the vendor to notify the insurer within a defined number of hours that allows the insurer to meet its 72-hour regulatory obligation. Correct
  • BAccept the 30-day vendor term and rely on the insurer's internal incident response team to detect any breach independently using monitoring tools.
  • CSign the agreement as written and use the difference between the vendor and regulator timelines as a documented residual risk that the business owner accepts.
  • DDefer the migration indefinitely until the vendor changes its standard terms for all of its customers in the same regulated sector.
Managed-service acquisitions must include contract terms that flow regulatory obligations down to the provider, especially incident notification timelines. When an acquirer outsources processing to a SaaS provider, the regulatory obligations on the data do not transfer. The acquiring organisation remains accountable, and its only reliable lever over the provider is the contract. A breach-notification clause shorter than the regulator's deadline gives the acquirer the time it needs to investigate, scope, and notify affected individuals within the statutory window.

Why A is correct: Correct because acquired-services assurance must align the vendor's contractual commitments with the acquirer's downstream regulatory obligations; only an enforceable, time-bound notification clause lets the insurer reliably meet its 72-hour obligation to affected individuals.

Why B is wrong: Tempting because internal monitoring sounds proactive, but the insurer typically lacks visibility into the SaaS provider's infrastructure, so unilateral detection cannot reliably substitute for a contractual notification commitment that aligns with regulatory timelines.

Why C is wrong: Tempting because risk acceptance is a legitimate treatment option, but no business owner has authority to accept a residual risk that translates directly into regulatory non-compliance and statutory penalties for affected individuals.

Why D is wrong: Tempting because it eliminates the conflict, but indefinite deferral ignores that bilateral contract amendments are routine for regulated buyers and abandons the business benefit of the migration without engaging the available negotiation lever.

Free sampleSoftware Development Securityhard

A retail company exposes a partner-facing REST API protected by OAuth 2.0 client credentials. A penetration tester reports that authenticated partners can retrieve any order by guessing sequential numeric identifiers in the URL path, including orders that belong to other partners. The development team proposes switching the identifiers to long random UUIDs. As the security lead, what is the BEST response to the proposal?

  • AApprove the move to UUIDs as the primary fix because unguessable identifiers will eliminate the enumeration vector and remove the need for further authorisation work on the endpoint.
  • BReject the proposal and instead enforce server-side authorisation that confirms the authenticated partner owns the requested order before any data is returned, keeping UUIDs only as a defence-in-depth measure. Correct
  • CRequire the API gateway to rate-limit GET requests against the orders endpoint so that a partner cannot enumerate identifiers quickly enough to make the attack worthwhile in practice.
  • DAdd a signed JSON Web Token claim listing every order identifier the partner is permitted to view and require the client to present it on each call to the orders endpoint.
Apply server-side object-level authorisation as the primary control for broken object-level authorisation, treating identifier opacity as defence in depth. Broken object-level authorisation occurs when the server returns a resource without confirming the authenticated caller is entitled to it. The defensive pattern is to enforce the ownership or entitlement check inside the API for every request against the system of record. Identifier opacity, rate limiting, and gateway controls reduce attacker convenience but do not supply the missing access decision.

Why A is wrong: Unguessable identifiers raise the cost of enumeration but rely on the URL staying secret, and any leak through logs, referrers, or a curious insider re-exposes the flaw; this is security through obscurity dressed as a control.

Why B is correct: The reported flaw is broken object-level authorisation, a top OWASP API risk. The correct primary control is a server-side check on every request that the caller is entitled to the requested object; UUIDs are a useful secondary measure but do not address the missing access decision.

Why C is wrong: Rate limiting slows enumeration but does not stop a single targeted lookup of a known competitor's order; it is a useful hardening control alongside authorisation, not a substitute for the missing access check.

Why D is wrong: Embedding an enumerated entitlement list in the token shifts authorisation to the client, scales poorly as orders accumulate, and still depends on the server trusting the claim; the cleaner control is to check ownership against the system of record on each call.

Free sampleSoftware Development Securitymedium

A development team at a healthcare insurer is migrating its monolith to microservices. Each squad maintains its own CI/CD pipeline and chooses its own open-source libraries. A recent audit found three squads using a vulnerable logging component that was disclosed six months ago. As the application security lead, what should you do FIRST to address the systemic problem?

  • AMandate that every squad immediately upgrade the vulnerable logging component to a patched version and report completion within the week.
  • BRequire each squad lead to sign an attestation that they have reviewed the dependencies of their service against public vulnerability databases each sprint.
  • CStand up a centralised software composition analysis service feeding an approved-library registry that all squad pipelines must consult before a build can succeed. Correct
  • DEngage an external penetration testing firm to assess each microservice and prioritise findings related to outdated third-party components.
Recognise that governed component repositories and software composition analysis embedded in CI/CD are the systemic control for third-party library risk. Vulnerable third-party libraries are a supply-chain risk that cannot be managed by reactive patching alone. Integrating software composition analysis into every pipeline and curating an approved-library registry shifts control left, enforces vetted versions at build time, and produces an inventory that supports ongoing vulnerability monitoring across all squads.

Why A is wrong: Patching the known issue is necessary but tactical; it remediates the current finding without preventing the next vulnerable library from entering the codebase, so it does not address the systemic gap the audit exposed.

Why B is wrong: Attestation creates accountability but relies on manual review by busy developers, scales poorly across squads, and does not technically prevent a vulnerable library from being introduced between attestations.

Why C is correct: A governed component repository combined with SCA in the pipeline gives consistent visibility, blocks vulnerable or unvetted libraries at build time, and creates the systemic control the audit identified as missing.

Why D is wrong: External testing validates exploitability after release but is periodic and expensive; it detects rather than prevents vulnerable libraries entering the build, leaving the underlying supply-chain weakness in place.

Free sampleSoftware Development Securityhard

A fintech's security engineering team has been triaging static analysis output for a critical lending application and is struggling with a high false-positive rate that is eroding developer trust in the tool. The CISO has asked for a recommendation on how to restore confidence without weakening assurance over real source-code vulnerabilities. What is the BEST recommendation?

  • ALower the tool's severity thresholds so that only critical findings are surfaced to developers, on the basis that fewer alerts will reduce noise and rebuild trust over time.
  • BTune the ruleset to the application's frameworks and language idioms, calibrate it against a labelled sample of confirmed true and false positives, and publish the tuning evidence to developers. Correct
  • CReplace the static analysis tool with dynamic application security testing in pre-production, since dynamic testing exercises the running application and produces fewer false positives than source-code scanners.
  • DRequire developers to triage every static analysis finding before merge and reject pull requests that have any open findings of any severity in the affected files.
Recognise that calibrated ruleset tuning, evidenced by labelled positives, is the appropriate response to high false-positive rates in static analysis. Static analysis tools surface candidate weaknesses against generic rule sets that rarely match a specific stack out of the box. Calibrating the ruleset against the application's frameworks and a labelled sample of confirmed true and false positives improves precision while preserving recall over real source-code vulnerabilities. Publishing the tuning evidence restores developer trust by showing the security team has done its own homework before raising tickets.

Why A is wrong: Suppressing whole severity bands hides genuine medium and high findings as well as the noise, weakens assurance over the codebase, and trades a false-positive problem for an undetected-vulnerability problem that is far harder to recover from.

Why B is correct: Static analysis becomes trustworthy when its ruleset is calibrated against the actual technology stack and an evidence base of confirmed positives and negatives. Tuning to the frameworks in use and sharing the evidence base with developers restores credibility without weakening coverage of real source-code vulnerabilities.

Why C is wrong: Dynamic testing has its own blind spots and is not a like-for-like replacement for source-code analysis; switching tools to avoid tuning work loses coverage of weaknesses that only appear in code and resets developer learning rather than fixing the trust problem.

Why D is wrong: A zero-tolerance merge gate against an untuned tool magnifies the false-positive pain, punishes developers for noise that the security team owns, and accelerates the loss of trust rather than restoring it.

Other domains in this exam

See also the CISSP cert hub, the study guide, and the cheat sheet.

Examworthy is not affiliated with or endorsed by ISC2. Original, blueprint-aligned practice material only.