{"id":19338,"date":"2026-09-23T04:55:51","date_gmt":"2026-09-23T04:55:51","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=19338"},"modified":"2026-09-23T04:55:51","modified_gmt":"2026-09-23T04:55:51","slug":"isc-csslp-practice-test-questions-and-exam-dumps-part18-q341-360","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/isc-csslp-practice-test-questions-and-exam-dumps-part18-q341-360\/","title":{"rendered":"ISC CSSLP Practice Test Questions and Exam Dumps Part18 Q341-360"},"content":{"rendered":"

View Full <\/b>ISC CSSLP Exam Dumps<\/b><\/a> and Practice Test Dumps<\/b><\/h2>\n

 <\/p>\n

Question 341.<\/b><\/p>\n

A development team wants to reduce the security risk of obsolete application features that are no longer used by customers. Which action is BEST?<\/b><\/p>\n

    \n
  1. <\/b> Remove or disable the unused features after impact assessment<\/span><\/li>\n
  2. <\/b> Leave them enabled indefinitely<\/span><\/li>\n
  3. <\/b> Hide them from the user interface only<\/span><\/li>\n
  4. <\/b> Give administrators permanent access to all obsolete functions<\/span><\/li>\n<\/ol>\n

    Correct Answer: 1. Remove or disable the unused features after impact assessment<\/b><\/p>\n

    Explanation:<\/b><\/p>\n

    Unused functionality increases attack surface and maintenance burden without providing business value. Removing or disabling obsolete features reduces the amount of code, configuration, and exposed interfaces that require security testing and monitoring. Before removal, teams should assess dependencies and customer impact. Simply hiding a feature in the interface does not prevent attackers from invoking backend functionality directly if it remains accessible.<\/span><\/p>\n

    Question 342.<\/b><\/p>\n

    A software team needs to protect sensitive API responses from being cached by shared intermediaries. Which control is MOST appropriate?<\/b><\/p>\n

      \n
    1. <\/b> Increase response size<\/span><\/li>\n
    2. <\/b> Use appropriate cache-control directives and avoid caching sensitive user-specific content<\/span><\/li>\n
    3. <\/b> Disable TLS<\/span><\/li>\n
    4. <\/b> Store credentials in response headers<\/span><\/li>\n<\/ol>\n

      Correct Answer: 2. Use appropriate cache-control directives and avoid caching sensitive user-specific content<\/b><\/p>\n

      Explanation:<\/b><\/p>\n

      Sensitive user-specific responses should not be stored in shared caches where another user might retrieve them. Appropriate cache-control headers and application-level caching rules help ensure private content is handled correctly. Developers should also understand how browsers, proxies, CDNs, and application caches process authenticated responses. Cache design should reflect the sensitivity and intended audience of the data.<\/span><\/p>\n

      Question 343.<\/b><\/p>\n

      A security review discovers that a privileged function can be called without rechecking the user’s current permissions. Which principle is MOST directly violated?<\/b><\/p>\n

        \n
      1. <\/b> Open design<\/span><\/li>\n
      2. <\/b> Economy of mechanism<\/span><\/li>\n
      3. <\/b> Complete mediation<\/span><\/li>\n
      4. <\/b> Least common mechanism<\/span><\/li>\n<\/ol>\n

        Correct Answer: 3. Complete mediation<\/b><\/p>\n

        Explanation:<\/b><\/p>\n

        Complete mediation requires each access to a protected resource or operation to be checked against current authorization rules. A previous authorization decision should not automatically remain valid if privileges, context, or policy may have changed. Server-side access checks should therefore be consistently enforced for protected functions. This reduces the risk of stale or bypassed permission decisions.<\/span><\/p>\n

        Question 344.<\/b><\/p>\n

        A deployment system detects that an application package was built outside the approved CI\/CD environment. What should it do?<\/b><\/p>\n

          \n
        1. <\/b> Deploy the package if the developer is trusted<\/span><\/li>\n
        2. <\/b> Ignore the source of the artifact<\/span><\/li>\n
        3. <\/b> Accept the package if its filename matches<\/span><\/li>\n
        4. <\/b> Reject or quarantine the package unless approved provenance can be established<\/span><\/li>\n<\/ol>\n

          Correct Answer: 4. Reject or quarantine the package unless approved provenance can be established<\/b><\/p>\n

          Explanation:<\/b><\/p>\n

          Software provenance provides evidence about where and how an artifact was produced. Packages built outside the approved process may bypass security checks, use untrusted dependencies, or contain unauthorized modifications. Deployment systems should enforce policy requiring trusted build provenance and appropriate integrity verification. Manual exceptions, if permitted, should follow formal risk and approval processes.<\/span><\/p>\n

          Question 345.<\/b><\/p>\n

          Which practice BEST supports secure management of feature flags that enable privileged functionality?<\/b><\/p>\n

            \n
          1. <\/b> Restrict changes through authorization, logging, and controlled configuration management<\/span><\/li>\n
          2. <\/b> Allow any developer to change flags directly in production<\/span><\/li>\n
          3. <\/b> Store flag values only in browser code<\/span><\/li>\n
          4. <\/b> Disable audit history for flag changes<\/span><\/li>\n<\/ol>\n

            Correct Answer: 1. Restrict changes through authorization, logging, and controlled configuration management<\/b><\/p>\n

            Explanation:<\/b><\/p>\n

            Feature flags can change application behavior without a code deployment and may expose security-sensitive functionality. Privileged flags should therefore be treated as security-relevant configuration. Changes should require appropriate authorization, be logged, and follow controlled processes. Flags that are no longer needed should be removed to reduce complexity and avoid unexpected future activation.<\/span><\/p>\n

            Question 346.<\/b><\/p>\n

            A software team is designing a high-value approval workflow. Which control BEST prevents one person from initiating and approving the same transaction?<\/b><\/p>\n

              \n
            1. <\/b> Shared administrator accounts<\/span><\/li>\n
            2. <\/b> Separation of duties enforced by independent identities and roles<\/span><\/li>\n
            3. <\/b> Longer passwords only<\/span><\/li>\n
            4. <\/b> Anonymous approval links<\/span><\/li>\n<\/ol>\n

              Correct Answer: 2. Separation of duties enforced by independent identities and roles<\/b><\/p>\n

              Explanation:<\/b><\/p>\n

              Separation of duties reduces the risk of fraud and misuse by requiring different individuals or roles to perform critical steps. The application should ensure the initiator cannot also act as the required independent approver and should maintain audit evidence for both actions. This control is especially important for financial transactions, security changes, and other high-impact workflows.<\/span><\/p>\n

              Question 347.<\/b><\/p>\n

              A web application allows users to submit URLs for image retrieval. Which validation is MOST important to reduce server-side request forgery risk?<\/b><\/p>\n

                \n
              1. <\/b> Check only that the URL contains \u201chttp\u201d<\/span><\/li>\n
              2. <\/b> Accept any destination from authenticated users<\/span><\/li>\n
              3. <\/b> Restrict schemes, destinations, redirects, and access to internal or metadata addresses<\/span><\/li>\n
              4. <\/b> Disable outbound request logging<\/span><\/li>\n<\/ol>\n

                Correct Answer: 3. Restrict schemes, destinations, redirects, and access to internal or metadata addresses<\/b><\/p>\n

                Explanation:<\/b><\/p>\n

                SSRF defenses should control where the server is allowed to connect. Applications should validate schemes and destinations, restrict redirects, block sensitive internal address ranges and metadata services, and apply outbound network controls where practical. Authentication does not make user-supplied URLs trustworthy. DNS resolution and redirect behavior should also be considered to prevent bypasses.<\/span><\/p>\n

                Question 348.<\/b><\/p>\n

                A critical cryptographic key is suspected of compromise. What is the BEST response?<\/b><\/p>\n

                  \n
                1. <\/b> Continue using it until the next scheduled rotation<\/span><\/li>\n
                2. <\/b> Copy it to additional systems for redundancy<\/span><\/li>\n
                3. <\/b> Disable audit logging around key use<\/span><\/li>\n
                4. <\/b> Revoke or rotate the key promptly and assess affected data or transactions<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 4. Revoke or rotate the key promptly and assess affected data or transactions<\/b><\/p>\n

                  Explanation:<\/b><\/p>\n

                  A suspected key compromise can undermine confidentiality, integrity, authenticity, or signing trust. The organization should rotate or revoke the affected key according to established procedures and determine what systems, data, or signatures may have been impacted. Dependent credentials, certificates, or encrypted content may also require action. Key compromise should be treated as a security incident rather than routine maintenance.<\/span><\/p>\n

                  Question 349.<\/b><\/p>\n

                  What is the PRIMARY benefit of performing root-cause analysis on recurring security defects?<\/b><\/p>\n

                    \n
                  1. <\/b> Identify systemic weaknesses that can be corrected to prevent recurrence<\/span><\/li>\n
                  2. <\/b> Eliminate the need to fix individual defects<\/span><\/li>\n
                  3. <\/b> Reduce the need for testing<\/span><\/li>\n
                  4. <\/b> Hide defect trends from management<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 1. Identify systemic weaknesses that can be corrected to prevent recurrence<\/b><\/p>\n

                    Explanation:<\/b><\/p>\n

                    Repeated vulnerabilities often indicate broader problems such as unsafe frameworks, inadequate coding standards, weak training, overly complex designs, or missing automated checks. Root-cause analysis helps organizations address these underlying factors rather than repeatedly fixing only symptoms. Lessons learned can then improve architecture, standards, tooling, training, and lifecycle controls across multiple teams and products.<\/span><\/p>\n

                    Question 350.<\/b><\/p>\n

                    A software team wants to ensure an API token cannot be used outside the service for which it was issued. Which validation is MOST important?<\/b><\/p>\n

                      \n
                    1. <\/b> Token length only<\/span><\/li>\n
                    2. <\/b> Validate the intended audience or equivalent service-binding claim<\/span><\/li>\n
                    3. <\/b> Ignore issuer information<\/span><\/li>\n
                    4. <\/b> Accept all tokens signed by any trusted key<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 2. Validate the intended audience or equivalent service-binding claim<\/b><\/p>\n

                      Explanation:<\/b><\/p>\n

                      Audience validation helps ensure a token intended for one service is not accepted by another. Signature validation alone proves integrity and issuer control but does not always establish that the receiving application is the intended consumer. Token validation should also consider issuer, expiration, scopes, and other required claims according to the authentication and authorization design.<\/span><\/p>\n

                      Question 351.<\/b><\/p>\n

                      A development team needs to prevent sensitive information from being exposed through application analytics events. Which practice is BEST?<\/b><\/p>\n

                        \n
                      1. <\/b> Capture all user-entered fields automatically<\/span><\/li>\n
                      2. <\/b> Send authentication tokens with every event<\/span><\/li>\n
                      3. <\/b> Define approved analytics fields and exclude or mask unnecessary sensitive data<\/span><\/li>\n
                      4. <\/b> Make analytics data publicly accessible<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 3. Define approved analytics fields and exclude or mask unnecessary sensitive data<\/b><\/p>\n

                        Explanation:<\/b><\/p>\n

                        Analytics systems can become secondary repositories for sensitive information if applications send excessive data. Teams should define which fields are necessary for legitimate analytical purposes and exclude credentials, secrets, payment data, and unnecessary personal information. Access, retention, and downstream sharing should also be controlled. Data minimization reduces both privacy and breach exposure.<\/span><\/p>\n

                        Question 352.<\/b><\/p>\n

                        A production application begins using a new external service without a security review. What should happen?<\/b><\/p>\n

                          \n
                        1. <\/b> Assume the service is trustworthy because it is popular<\/span><\/li>\n
                        2. <\/b> Continue integration and review it next year<\/span><\/li>\n
                        3. <\/b> Disable monitoring to simplify deployment<\/span><\/li>\n
                        4. <\/b> Assess the new dependency’s security, data handling, failure behavior, and trust boundaries<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 4. Assess the new dependency’s security, data handling, failure behavior, and trust boundaries<\/b><\/p>\n

                          Explanation:<\/b><\/p>\n

                          New external services can introduce security, privacy, availability, and supply-chain risks. The team should understand what data is shared, how authentication works, what privileges are granted, how failures are handled, and what contractual or compliance requirements apply. Significant architectural dependencies should be reviewed before production use and monitored throughout their lifecycle.<\/span><\/p>\n

                          Question 353.<\/b><\/p>\n

                          Which activity BEST helps verify that a security control remains effective after a major software upgrade?<\/b><\/p>\n

                            \n
                          1. <\/b> Security regression and verification testing<\/span><\/li>\n
                          2. <\/b> Marketing approval<\/span><\/li>\n
                          3. <\/b> Counting lines of code<\/span><\/li>\n
                          4. <\/b> Updating product screenshots<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 1. Security regression and verification testing<\/b><\/p>\n

                            Explanation:<\/b><\/p>\n

                            Major upgrades can alter code paths, dependencies, configuration, and security assumptions. Regression and verification testing help confirm that previously validated controls still operate as intended and that known vulnerabilities have not reappeared. Tests should be traceable to important security requirements and historical defects where practical. High-risk changes may also require focused architecture or penetration testing.<\/span><\/p>\n

                            Question 354.<\/b><\/p>\n

                            A software system generates audit events across multiple servers. Which capability MOST improves forensic reliability?<\/b><\/p>\n

                              \n
                            1. <\/b> Random local timestamps<\/span><\/li>\n
                            2. <\/b> Reliable time synchronization across systems<\/span><\/li>\n
                            3. <\/b> Deleting logs after each session<\/span><\/li>\n
                            4. <\/b> Allowing users to edit audit entries<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 2. Reliable time synchronization across systems<\/b><\/p>\n

                              Explanation:<\/b><\/p>\n

                              Consistent time is important when reconstructing events across distributed systems. If server clocks differ significantly, analysts may misinterpret the order of actions or fail to correlate related events. Reliable time synchronization, protected logs, unique identities, and correlation identifiers strengthen forensic usefulness. Time itself should not be trusted blindly if attackers can manipulate system clocks, so monitoring and secure configuration remain important.<\/span><\/p>\n

                              Question 355.<\/b><\/p>\n

                              A development team wants to reduce the risk of unauthorized changes to security-critical database procedures. Which control is MOST appropriate?<\/b><\/p>\n

                                \n
                              1. <\/b> Give all application developers database administrator privileges<\/span><\/li>\n
                              2. <\/b> Store procedures outside version control<\/span><\/li>\n
                              3. <\/b> Manage changes through controlled identities, review, versioning, and deployment<\/span><\/li>\n
                              4. <\/b> Disable database auditing<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 3. Manage changes through controlled identities, review, versioning, and deployment<\/b><\/p>\n

                                Explanation:<\/b><\/p>\n

                                Database procedures can contain authorization, validation, and business logic and should be governed like other security-sensitive code. Changes should be version-controlled, reviewed, tested, and deployed through authorized processes. Direct ad hoc modification in production makes it difficult to establish what changed and whether the code was validated. Database privileges should also follow least privilege.<\/span><\/p>\n

                                Question 356.<\/b><\/p>\n

                                A software application receives a correctly authenticated request containing a malformed file. What should the application assume?<\/b><\/p>\n

                                  \n
                                1. <\/b> Authenticated users always provide safe content<\/span><\/li>\n
                                2. <\/b> Authentication replaces input validation<\/span><\/li>\n
                                3. <\/b> The file can be executed because the user is known<\/span><\/li>\n
                                4. <\/b> The content remains untrusted and must be validated before processing<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 4. The content remains untrusted and must be validated before processing<\/b><\/p>\n

                                  Explanation:<\/b><\/p>\n

                                  Authentication establishes identity but does not guarantee that data supplied by the user is safe. Legitimate accounts can be compromised, malicious, or simply send malformed input accidentally. Applications should validate file format, size, structure, and content regardless of authentication status. Processing should also occur with minimal privilege and appropriate resource limits.<\/span><\/p>\n

                                  Question 357.<\/b><\/p>\n

                                  Which practice BEST reduces the security impact of a compromised CI\/CD pipeline credential?<\/b><\/p>\n

                                    \n
                                  1. <\/b> Use narrowly scoped, short-lived credentials for individual pipeline tasks<\/span><\/li>\n
                                  2. <\/b> Use one permanent administrator credential for every pipeline stage<\/span><\/li>\n
                                  3. <\/b> Store credentials directly in source code<\/span><\/li>\n
                                  4. <\/b> Disable pipeline audit logs<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 1. Use narrowly scoped, short-lived credentials for individual pipeline tasks<\/b><\/p>\n

                                    Explanation:<\/b><\/p>\n

                                    Short-lived and task-specific credentials reduce both the privileges and time window available to an attacker if a pipeline identity is compromised. Separate identities for source access, artifact publication, and deployment also improve accountability and containment. Long-lived administrator credentials create unnecessary risk and should be avoided when modern workload identity mechanisms are available.<\/span><\/p>\n

                                    Question 358.<\/b><\/p>\n

                                    A security requirement states that a customer must approve a transaction only once. Which control helps prevent repeated processing of the same approved request?<\/b><\/p>\n

                                      \n
                                    1. <\/b> Longer usernames<\/span><\/li>\n
                                    2. <\/b> Unique transaction identifiers or idempotency controls<\/span><\/li>\n
                                    3. <\/b> Disabling transaction logs<\/span><\/li>\n
                                    4. <\/b> Allowing unlimited replay<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 2. Unique transaction identifiers or idempotency controls<\/b><\/p>\n

                                      Explanation:<\/b><\/p>\n

                                      Idempotency mechanisms help applications recognize duplicate requests and avoid performing the same state-changing operation more than intended. Unique transaction identifiers, one-time tokens, or server-side transaction state can provide this protection depending on the workflow. This is particularly important for payments and other operations where network retries or malicious replay could cause duplicate processing.<\/span><\/p>\n

                                      Question 359.<\/b><\/p>\n

                                      A development team repeatedly discovers authorization flaws in newly added endpoints. What is the BEST long-term improvement?<\/b><\/p>\n

                                        \n
                                      1. <\/b> Continue fixing each endpoint independently<\/span><\/li>\n
                                      2. <\/b> Stop testing authorization<\/span><\/li>\n
                                      3. <\/b> Introduce reusable authorization mechanisms, secure patterns, training, and automated checks<\/span><\/li>\n
                                      4. <\/b> Hide endpoints from documentation<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 3. Introduce reusable authorization mechanisms, secure patterns, training, and automated checks<\/b><\/p>\n

                                        Explanation:<\/b><\/p>\n

                                        Recurring authorization defects usually indicate a systemic problem rather than isolated mistakes. Reusable server-side authorization libraries or framework patterns can make the secure path easier for developers. Targeted training, code-review checklists, security tests, and policy checks can further reduce recurrence. Root-cause improvement provides greater long-term value than repeatedly correcting individual endpoints after vulnerabilities are discovered.<\/span><\/p>\n

                                        Question 360.<\/b><\/p>\n

                                        Which practice BEST represents mature secure software operations after release?<\/b><\/p>\n

                                          \n
                                        1. <\/b> Stop reviewing security once deployment is complete<\/span><\/li>\n
                                        2. <\/b> Rely only on annual penetration testing<\/span><\/li>\n
                                        3. <\/b> Address vulnerabilities only after exploitation<\/span><\/li>\n
                                        4. <\/b> Continuously monitor controls, vulnerabilities, dependencies, incidents, and configuration throughout support<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 4. Continuously monitor controls, vulnerabilities, dependencies, incidents, and configuration throughout support<\/b><\/p>\n

                                          Explanation:<\/b><\/p>\n

                                          Software security continues throughout the support period. New vulnerabilities can appear in application code, dependencies, infrastructure, and external services, while configuration may drift and threat techniques may change. Mature operations therefore include continuous monitoring, vulnerability management, incident response, patching, dependency review, and reassessment of important security assumptions until the product is securely retired.<\/span><\/p>\n

                                           <\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full ISC CSSLP Exam Dumps and Practice Test Dumps   Question 341. A development team wants to reduce the security risk of obsolete application features that are no longer used by customers. Which action is BEST? Remove or disable the unused features after impact assessment Leave them enabled indefinitely Hide them from the user […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[1648,1647],"tags":[],"_links":{"self":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/19338"}],"collection":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/comments?post=19338"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/19338\/revisions"}],"predecessor-version":[{"id":19339,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/19338\/revisions\/19339"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=19338"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=19338"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=19338"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}