{"id":19340,"date":"2026-09-23T04:56:06","date_gmt":"2026-09-23T04:56:06","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=19340"},"modified":"2026-09-23T04:56:06","modified_gmt":"2026-09-23T04:56:06","slug":"isc-csslp-practice-test-questions-and-exam-dumps-part19-q361-380","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/isc-csslp-practice-test-questions-and-exam-dumps-part19-q361-380\/","title":{"rendered":"ISC CSSLP Practice Test Questions and Exam Dumps Part19 Q361-380"},"content":{"rendered":"

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

 <\/p>\n

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

A development team is designing a service that stores sensitive configuration values. Which control is MOST appropriate?<\/b><\/p>\n

    \n
  1. <\/b> Store all configuration values in source code<\/span><\/li>\n
  2. <\/b> Place secrets in a public configuration repository<\/span><\/li>\n
  3. <\/b> Separate sensitive configuration from code and protect it with appropriate access controls<\/span><\/li>\n
  4. <\/b> Send configuration secrets through email<\/span><\/li>\n<\/ol>\n

    Correct Answer: 3. Separate sensitive configuration from code and protect it with appropriate access controls<\/b><\/p>\n

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

    Sensitive configuration such as credentials, keys, and tokens should not be embedded directly in source code or broadly accessible files. Separating configuration from code allows stronger access control, rotation, auditing, and environment-specific management. Secret-management services or protected configuration stores are generally more appropriate. This design also reduces the risk that sensitive values are exposed through repositories, build artifacts, or code-sharing workflows.<\/span><\/p>\n

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

    Which practice BEST reduces the risk of privilege escalation caused by excessive database permissions?<\/b><\/p>\n

      \n
    1. <\/b> Assign the application account only the database privileges it requires<\/span><\/li>\n
    2. <\/b> Give the application database-owner privileges<\/span><\/li>\n
    3. <\/b> Use one administrator account for every application<\/span><\/li>\n
    4. <\/b> Disable database auditing<\/span><\/li>\n<\/ol>\n

      Correct Answer: 1. Assign the application account only the database privileges it requires<\/b><\/p>\n

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

      Least privilege limits the damage that can occur if an application or credential is compromised. Database accounts should have access only to the tables, views, procedures, and operations required for legitimate business functions. Broad administrative permissions create unnecessary exposure. Permissions should also be reviewed periodically because application responsibilities can change over time.<\/span><\/p>\n

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

      A software team wants to determine whether a user-controlled value can cross multiple trust boundaries before reaching a sensitive component. Which activity is MOST useful?<\/b><\/p>\n

        \n
      1. <\/b> License review<\/span><\/li>\n
      2. <\/b> User-interface testing<\/span><\/li>\n
      3. <\/b> Data-flow and trust-boundary analysis<\/span><\/li>\n
      4. <\/b> Capacity planning<\/span><\/li>\n<\/ol>\n

        Correct Answer: 3. Data-flow and trust-boundary analysis<\/b><\/p>\n

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

        Data-flow analysis shows how information travels through processes, services, storage locations, and external systems. Mapping trust boundaries helps identify where validation, authentication, authorization, or encryption is required. This can reveal indirect attack paths that are not obvious when reviewing components individually. The technique is a core part of threat modeling and secure architecture review.<\/span><\/p>\n

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

        A secure application receives a signed message but the signature was created with an untrusted key. What should the application do?<\/b><\/p>\n

          \n
        1. <\/b> Accept the message because it has a signature<\/span><\/li>\n
        2. <\/b> Ignore key trust if the message format is correct<\/span><\/li>\n
        3. <\/b> Process the request with reduced privileges<\/span><\/li>\n
        4. <\/b> Reject the message because signer trust has not been established<\/span><\/li>\n<\/ol>\n

          Correct Answer: 4. Reject the message because signer trust has not been established<\/b><\/p>\n

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

          A digital signature is meaningful only when the verifying party trusts the signing key or can validate it through an approved trust chain. An untrusted key does not establish acceptable authenticity. The application should reject the message and log the failure appropriately. Signature verification should include both cryptographic validity and trust-policy validation.<\/span><\/p>\n

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

          Which secure design principle recommends checking every access request rather than relying on a previous decision?<\/b><\/p>\n

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

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

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

            Complete mediation requires every access to a protected object or operation to be checked against current authorization policy. Prior successful access should not automatically authorize future requests because user permissions, resource ownership, or context may have changed. Consistent server-side authorization helps prevent stale or bypassed security decisions.<\/span><\/p>\n

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

            A software team is designing a password recovery workflow. Which control is MOST important?<\/b><\/p>\n

              \n
            1. <\/b> Allow unlimited reset attempts<\/span><\/li>\n
            2. <\/b> Use short-lived, single-use, unpredictable reset tokens<\/span><\/li>\n
            3. <\/b> Display the existing password after identity verification<\/span><\/li>\n
            4. <\/b> Keep reset links valid indefinitely<\/span><\/li>\n<\/ol>\n

              Correct Answer: 2. Use short-lived, single-use, unpredictable reset tokens<\/b><\/p>\n

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

              Password recovery can become an alternate path around normal authentication and must therefore be strongly protected. Reset tokens should be cryptographically unpredictable, expire quickly, and become invalid after use. Attempt throttling, notification, and appropriate identity verification can provide additional protection. Long-lived or reusable reset tokens increase the chance of unauthorized account takeover.<\/span><\/p>\n

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

              A security review discovers that an API accepts an object identifier and returns data without checking whether the requester owns the object. What vulnerability is MOST likely?<\/b><\/p>\n

                \n
              1. <\/b> SQL injection<\/span><\/li>\n
              2. <\/b> Cross-site scripting<\/span><\/li>\n
              3. <\/b> Broken object-level authorization<\/span><\/li>\n
              4. <\/b> Buffer overflow<\/span><\/li>\n<\/ol>\n

                Correct Answer: 3. Broken object-level authorization<\/b><\/p>\n

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

                Object-level authorization flaws occur when a user can access another user’s resource simply by changing an identifier. The server should verify that the authenticated requester is authorized for each specific object. Unpredictable identifiers can reduce casual discovery but do not replace authorization. This class of flaw is especially common in APIs and multi-tenant applications.<\/span><\/p>\n

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

                A software pipeline allows unsigned artifacts to be promoted to production when a signing service is unavailable. What is the BEST improvement?<\/b><\/p>\n

                  \n
                1. <\/b> Accept unsigned artifacts if the build passed tests<\/span><\/li>\n
                2. <\/b> Disable provenance checks<\/span><\/li>\n
                3. <\/b> Allow developers to approve unsigned packages informally<\/span><\/li>\n
                4. <\/b> Fail securely and prevent promotion until required integrity controls are restored<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 4. Fail securely and prevent promotion until required integrity controls are restored<\/b><\/p>\n

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

                  If artifact signing is a required integrity control, bypassing it during outages creates a predictable weakness that attackers may exploit. The pipeline should fail securely and prevent production promotion until authenticity and integrity requirements can be satisfied. Emergency procedures, if necessary, should be formally authorized and preserve equivalent assurance wherever possible.<\/span><\/p>\n

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

                  What is the PRIMARY security value of secure coding standards?<\/b><\/p>\n

                    \n
                  1. <\/b> Provide consistent guidance that reduces recurring implementation weaknesses<\/span><\/li>\n
                  2. <\/b> Guarantee that no vulnerabilities can occur<\/span><\/li>\n
                  3. <\/b> Replace security testing<\/span><\/li>\n
                  4. <\/b> Eliminate the need for architecture review<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 1. Provide consistent guidance that reduces recurring implementation weaknesses<\/b><\/p>\n

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

                    Secure coding standards help developers apply consistent practices for input handling, authentication, authorization, cryptography, logging, error handling, and other security-sensitive areas. They reduce variation and make code review more effective. Standards should evolve based on new vulnerabilities, lessons learned, and platform changes. They work best when reinforced by training, reusable components, and automated checks.<\/span><\/p>\n

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

                    A software application uses cryptographic keys that never expire or rotate. What is the MAIN concern?<\/b><\/p>\n

                      \n
                    1. <\/b> Keys become longer over time<\/span><\/li>\n
                    2. <\/b> Compromise may remain useful for an excessive period<\/span><\/li>\n
                    3. <\/b> Encryption will stop working immediately<\/span><\/li>\n
                    4. <\/b> Key rotation always reduces availability<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 2. Compromise may remain useful for an excessive period<\/b><\/p>\n

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

                      Long-lived keys increase the window in which a stolen key can be abused. Key-management policy should define appropriate generation, storage, rotation, revocation, backup, and destruction based on risk. The correct lifetime depends on the key’s purpose and sensitivity. Rotation planning also supports cryptographic agility and incident response if compromise is suspected.<\/span><\/p>\n

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

                      A software team wants to identify defects that occur only under unexpected or malformed input. Which testing method is MOST appropriate?<\/b><\/p>\n

                        \n
                      1. <\/b> Usability testing<\/span><\/li>\n
                      2. <\/b> Performance benchmarking<\/span><\/li>\n
                      3. <\/b> Fuzz testing<\/span><\/li>\n
                      4. <\/b> Documentation review<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 3. Fuzz testing<\/b><\/p>\n

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

                        Fuzz testing supplies malformed, random, or boundary-case input to identify crashes, parsing defects, resource exhaustion, and other unexpected behavior. It is especially effective for file formats, network protocols, and parsers. Fuzzing complements static analysis, code review, and conventional test cases because it explores conditions developers may not have explicitly anticipated.<\/span><\/p>\n

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

                        A production application contains a hidden diagnostic account with a default password. What is the BEST action?<\/b><\/p>\n

                          \n
                        1. <\/b> Keep the account because users do not know it exists<\/span><\/li>\n
                        2. <\/b> Change only the username<\/span><\/li>\n
                        3. <\/b> Hide the login page<\/span><\/li>\n
                        4. <\/b> Remove or disable the diagnostic account and review deployment controls<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 4. Remove or disable the diagnostic account and review deployment controls<\/b><\/p>\n

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

                          Default or hidden accounts create unnecessary attack paths and should not remain active in production unless there is a justified, controlled requirement. Security should not depend on obscurity. The team should remove or disable the account, assess whether it was used, and strengthen deployment checks so development or diagnostic identities do not reach production unintentionally.<\/span><\/p>\n

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

                          Which practice BEST supports data minimization?<\/b><\/p>\n

                            \n
                          1. <\/b> Collect and retain only information required for defined business purposes<\/span><\/li>\n
                          2. <\/b> Store all available user data indefinitely<\/span><\/li>\n
                          3. <\/b> Collect additional information in case it becomes useful later<\/span><\/li>\n
                          4. <\/b> Share all collected data with every internal team<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 1. Collect and retain only information required for defined business purposes<\/b><\/p>\n

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

                            Data minimization reduces privacy exposure, breach impact, and regulatory complexity by limiting collection and retention to what is genuinely needed. Teams should define why each data element is required, who needs access, and how long it should be retained. Minimization should be considered during requirements and architecture rather than added only after implementation.<\/span><\/p>\n

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

                            A software team needs to verify that an API request has not been altered and was created by a party holding a shared secret. Which mechanism is MOST appropriate?<\/b><\/p>\n

                              \n
                            1. <\/b> Base64 encoding<\/span><\/li>\n
                            2. <\/b> A message authentication code<\/span><\/li>\n
                            3. <\/b> Data compression<\/span><\/li>\n
                            4. <\/b> Plaintext logging<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 2. A message authentication code<\/b><\/p>\n

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

                              A message authentication code provides integrity and origin authentication between parties that share a secret key. If the calculated MAC does not match, the recipient knows the message may have been altered or created by someone without the key. A MAC does not inherently provide confidentiality, so encryption may still be needed depending on requirements.<\/span><\/p>\n

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

                              A development team finds that automated tests use a production administrator credential. Which improvement is BEST?<\/b><\/p>\n

                                \n
                              1. <\/b> Share the credential with all testers<\/span><\/li>\n
                              2. <\/b> Keep the credential because automated tests are trusted<\/span><\/li>\n
                              3. <\/b> Use dedicated test identities with only the permissions required for the test<\/span><\/li>\n
                              4. <\/b> Disable authentication in the test environment<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 3. Use dedicated test identities with only the permissions required for the test<\/b><\/p>\n

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

                                Tests should not depend on powerful production credentials. Dedicated test identities support least privilege, reduce accidental production impact, and improve accountability. Test credentials should be scoped to the environment and functions required. Production secrets should remain separate from development and testing systems unless there is a very specific, controlled reason otherwise.<\/span><\/p>\n

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

                                A secure API accepts valid signed requests but permits the same transaction to be submitted repeatedly. Which control is MOST appropriate?<\/b><\/p>\n

                                  \n
                                1. <\/b> Longer passwords<\/span><\/li>\n
                                2. <\/b> Larger request bodies<\/span><\/li>\n
                                3. <\/b> Disable request signing<\/span><\/li>\n
                                4. <\/b> Add replay protection using unique transaction identifiers, nonces, or equivalent controls<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 4. Add replay protection using unique transaction identifiers, nonces, or equivalent controls<\/b><\/p>\n

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

                                  Signatures provide integrity and authenticity but do not always prove that a request is fresh. Attackers may replay a previously valid signed request. Nonces, sequence numbers, unique transaction identifiers, timestamps, or server-side state can detect duplicates. The freshness values should be protected by the same signature or integrity mechanism.<\/span><\/p>\n

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

                                  Which activity BEST helps confirm that production permissions still follow least privilege?<\/b><\/p>\n

                                    \n
                                  1. <\/b> Periodic entitlement and privilege reviews<\/span><\/li>\n
                                  2. <\/b> User-interface testing<\/span><\/li>\n
                                  3. <\/b> Marketing review<\/span><\/li>\n
                                  4. <\/b> Source-code compilation<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 1. Periodic entitlement and privilege reviews<\/b><\/p>\n

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

                                    Permissions often expand over time as systems and responsibilities change. Periodic reviews compare actual access with current business needs and identify unnecessary or outdated privileges. This is especially important for administrative, production, and service identities. Removing excessive access reduces the impact of compromise and supports stronger accountability.<\/span><\/p>\n

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

                                    A team wants to reduce risk from use of outdated open-source components. Which practice is BEST?<\/b><\/p>\n

                                      \n
                                    1. <\/b> Ignore component age if the application still works<\/span><\/li>\n
                                    2. <\/b> Continuously monitor component versions, support status, and vulnerabilities<\/span><\/li>\n
                                    3. <\/b> Disable dependency inventories<\/span><\/li>\n
                                    4. <\/b> Update components only after successful exploitation<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 2. Continuously monitor component versions, support status, and vulnerabilities<\/b><\/p>\n

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

                                      Open-source and third-party components can become vulnerable or unsupported after release. Continuous monitoring allows teams to identify newly disclosed vulnerabilities, end-of-support conditions, and available updates. Accurate dependency inventories and SBOM information can make impact analysis faster. Updating should occur through controlled testing and release processes rather than uncontrolled automatic changes.<\/span><\/p>\n

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

                                      A software organization repeatedly finds the same type of input-validation flaw. What is the BEST long-term response?<\/b><\/p>\n

                                        \n
                                      1. <\/b> Fix each defect individually and take no further action<\/span><\/li>\n
                                      2. <\/b> Stop reporting validation issues<\/span><\/li>\n
                                      3. <\/b> Perform root-cause analysis and improve standards, reusable controls, training, and automated checks<\/span><\/li>\n
                                      4. <\/b> Accept the flaws as unavoidable<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 3. Perform root-cause analysis and improve standards, reusable controls, training, and automated checks<\/b><\/p>\n

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

                                        Recurring defects indicate a systemic weakness in development practices. Root-cause analysis may show that developers lack clear standards, secure frameworks are missing, or automated validation checks are insufficient. Improving reusable controls, training, code review, and testing can reduce future recurrence more effectively than repeatedly fixing individual vulnerabilities after they are discovered.<\/span><\/p>\n

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

                                        Which practice BEST represents mature secure software lifecycle management?<\/b><\/p>\n

                                          \n
                                        1. <\/b> Address security only during final testing<\/span><\/li>\n
                                        2. <\/b> Stop monitoring after deployment<\/span><\/li>\n
                                        3. <\/b> Treat each vulnerability independently without learning from trends<\/span><\/li>\n
                                        4. <\/b> Integrate security across requirements, architecture, implementation, testing, release, operations, maintenance, and retirement<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 4. Integrate security across requirements, architecture, implementation, testing, release, operations, maintenance, and retirement<\/b><\/p>\n

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

                                          Mature software security is continuous rather than a single phase. Requirements establish objectives, architecture reduces structural risk, secure coding controls implementation flaws, testing provides evidence, and release processes protect production integrity. After deployment, vulnerability management, monitoring, incident response, dependency management, and secure retirement maintain assurance. Lessons learned should feed continuous improvement across the entire lifecycle.<\/span><\/p>\n

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

                                          View Full ISC CSSLP Exam Dumps and Practice Test Dumps   Question 361. A development team is designing a service that stores sensitive configuration values. Which control is MOST appropriate? Store all configuration values in source code Place secrets in a public configuration repository Separate sensitive configuration from code and protect it with appropriate access […]<\/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\/19340"}],"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=19340"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/19340\/revisions"}],"predecessor-version":[{"id":19341,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/19340\/revisions\/19341"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=19340"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=19340"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=19340"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}