ISC CCSP Dumps
ISC CCSP Practice Test 60
Question 590
A payment service requires one writable scratch directory but the image runs as root with broad host mounts. Suppose the team makes this shortcut instead: Run every internet-facing container as privileged with the host filesystem mounted to simplify debugging. Which outcome is the most likely direct consequence?
Answer & Explanations
Correct answer: B
This failure concerns another scenario: A retail API terminates TLS correctly but accepts any account number from a logged-in user. In the stated case: A payment service requires one writable scratch directory but the image runs as root with broad host mounts. The relevant consequence is: One compromised container can access host credentials or neighboring workloads. The control that prevents it is: Run containers with least-privilege service identities, non-root users, read-only filesystems and explicit capability constraints where supported.
One compromised container can access host credentials or neighboring workloads. This is the risk in the stated situation: A payment service requires one writable scratch directory but the image runs as root with broad host mounts. The risky shortcut is: Run every internet-facing container as privileged with the host filesystem mounted to simplify debugging. Prevent it by: Run containers with least-privilege service identities, non-root users, read-only filesystems and explicit capability constraints where supported.
This failure concerns another scenario: A multinational enterprise adds SaaS login federation but accidentally maps all staff to a cloud admin group. In the stated case: A payment service requires one writable scratch directory but the image runs as root with broad host mounts. The relevant consequence is: One compromised container can access host credentials or neighboring workloads. The control that prevents it is: Run containers with least-privilege service identities, non-root users, read-only filesystems and explicit capability constraints where supported.
This failure concerns another scenario: A bank's serverless functions all reuse a broad database administrator password stored in their source code. In the stated case: A payment service requires one writable scratch directory but the image runs as root with broad host mounts. The relevant consequence is: One compromised container can access host credentials or neighboring workloads. The control that prevents it is: Run containers with least-privilege service identities, non-root users, read-only filesystems and explicit capability constraints where supported.
Question 591
A clinic's internal appointment API trusts any caller from the cluster pod network. Which cloud security control or governance decision most directly addresses the described issue while keeping the change scoped?
Answer & Explanations
Correct answer: C
This action is appropriate in a different case: A customer support assistant reads uploaded tickets and has permission to change billing access lists. There, the reason is: A model can follow malicious instructions embedded in lower-trust text unless tools, data and privileges are bounded outside the prompt. The current case is: A clinic's internal appointment API trusts any caller from the cluster pod network. The appropriate response is: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
This action is appropriate in a different case: A medical SaaS startup writes an application first and asks later how to prevent staff from viewing patient data. There, the reason is: Security requirements discovered only after deployment become expensive or incompatible with existing application architecture. The current case is: A clinic's internal appointment API trusts any caller from the cluster pod network. The appropriate response is: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices. The technical reason is: Private cluster networks can still carry attacker lateral movement if internal callers are not authenticated or scoped. The stated condition is: A clinic's internal appointment API trusts any caller from the cluster pod network. Confirm the result by: Spoof a test internal caller identity and verify the target service rejects access while legitimate service requests succeed.
This action is appropriate in a different case: A finance platform releases API changes daily but schedules its only security test annually. There, the reason is: Frequent deployment creates repeated change risk, so security review must track each material feature and dependency update. The current case is: A clinic's internal appointment API trusts any caller from the cluster pod network. The appropriate response is: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
Question 592
A clinic's internal appointment API trusts any caller from the cluster pod network. An engineer recommends: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices. Which technical explanation most directly justifies this recommendation?
Answer & Explanations
Correct answer: D
This principle explains a different technical intervention: Use risk-based secure design and code validation throughout agile iterations instead of relying on one end-stage checklist. It applies to: A finance platform releases API changes daily but schedules its only security test annually. The actual case is: A clinic's internal appointment API trusts any caller from the cluster pod network. The mechanism relevant here is: Private cluster networks can still carry attacker lateral movement if internal callers are not authenticated or scoped.
This principle explains a different technical intervention: Perform structured threat modeling of exposed trust boundaries and select controls for spoofing, tampering, disclosure, denial and privilege escalation. It applies to: A multi-tenant booking API accepts customer resource IDs without modeling horizontal access attacks. The actual case is: A clinic's internal appointment API trusts any caller from the cluster pod network. The mechanism relevant here is: Private cluster networks can still carry attacker lateral movement if internal callers are not authenticated or scoped.
This principle explains a different technical intervention: Enforce peer review, secret scanning and policy checks against cloud IaC changes before they are applied. It applies to: A university uses shared infrastructure templates containing hard-coded production API tokens. The actual case is: A clinic's internal appointment API trusts any caller from the cluster pod network. The mechanism relevant here is: Private cluster networks can still carry attacker lateral movement if internal callers are not authenticated or scoped.
Private cluster networks can still carry attacker lateral movement if internal callers are not authenticated or scoped. That mechanism explains the decision: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices. In the reported situation: A clinic's internal appointment API trusts any caller from the cluster pod network. Confirmation requires: Spoof a test internal caller identity and verify the target service rejects access while legitimate service requests succeed.
Question 593
A clinic's internal appointment API trusts any caller from the cluster pod network. After applying the relevant fix, which observable evidence would most convincingly establish that the underlying issue has been resolved?
Answer & Explanations
Correct answer: A
Spoof a test internal caller identity and verify the target service rejects access while legitimate service requests succeed. This check directly tests: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices. The underlying behavior is: Private cluster networks can still carry attacker lateral movement if internal callers are not authenticated or scoped. The case is: A clinic's internal appointment API trusts any caller from the cluster pod network.
This observation would verify a different remedy: Enforce peer review, secret scanning and policy checks against cloud IaC changes before they are applied. That remedy applies to: A university uses shared infrastructure templates containing hard-coded production API tokens. The present condition is: A clinic's internal appointment API trusts any caller from the cluster pod network. To assess it, check: Spoof a test internal caller identity and verify the target service rejects access while legitimate service requests succeed.
This observation would verify a different remedy: Run complementary source, dependency and runtime security tests with severity-based release gates. That remedy applies to: A cloud payment API passes source checks but deploys an outdated parser with a published security issue. The present condition is: A clinic's internal appointment API trusts any caller from the cluster pod network. To assess it, check: Spoof a test internal caller identity and verify the target service rejects access while legitimate service requests succeed.
This observation would verify a different remedy: Add automated negative-path tests for cross-tenant requests, malformed tokens and privilege escalation alongside normal functional tests. That remedy applies to: A property portal's normal customer checkout succeeds but users can alter another account's billing address. The present condition is: A clinic's internal appointment API trusts any caller from the cluster pod network. To assess it, check: Spoof a test internal caller identity and verify the target service rejects access while legitimate service requests succeed.
Question 594
A clinic's internal appointment API trusts any caller from the cluster pod network. Which apparently convenient shortcut would most directly undermine safe resolution of this specific situation?
Answer & Explanations
Correct answer: B
This proposed shortcut concerns a separate case: A property portal's normal customer checkout succeeds but users can alter another account's billing address. The risk in this question concerns: A clinic's internal appointment API trusts any caller from the cluster pod network. Here the unsafe shortcut is: Allow every workload in the Kubernetes cluster to call every financial API merely because traffic stays internal. Use this response instead: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
Allow every workload in the Kubernetes cluster to call every financial API merely because traffic stays internal. This shortcut is unsafe for: A clinic's internal appointment API trusts any caller from the cluster pod network. The resulting failure can be: A compromised low-value service pivots to sensitive internal APIs without user-facing controls. The safer response is: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
This proposed shortcut concerns a separate case: A healthcare startup uses an unpinned container image that an unknown publisher can replace. The risk in this question concerns: A clinic's internal appointment API trusts any caller from the cluster pod network. Here the unsafe shortcut is: Allow every workload in the Kubernetes cluster to call every financial API merely because traffic stays internal. Use this response instead: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
This proposed shortcut concerns a separate case: A retail API terminates TLS correctly but accepts any account number from a logged-in user. The risk in this question concerns: A clinic's internal appointment API trusts any caller from the cluster pod network. Here the unsafe shortcut is: Allow every workload in the Kubernetes cluster to call every financial API merely because traffic stays internal. Use this response instead: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
Question 595
A clinic's internal appointment API trusts any caller from the cluster pod network. Suppose the team makes this shortcut instead: Allow every workload in the Kubernetes cluster to call every financial API merely because traffic stays internal. Which outcome is the most likely direct consequence?
Answer & Explanations
Correct answer: C
This failure concerns another scenario: A retail API terminates TLS correctly but accepts any account number from a logged-in user. In the stated case: A clinic's internal appointment API trusts any caller from the cluster pod network. The relevant consequence is: A compromised low-value service pivots to sensitive internal APIs without user-facing controls. The control that prevents it is: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
This failure concerns another scenario: A multinational enterprise adds SaaS login federation but accidentally maps all staff to a cloud admin group. In the stated case: A clinic's internal appointment API trusts any caller from the cluster pod network. The relevant consequence is: A compromised low-value service pivots to sensitive internal APIs without user-facing controls. The control that prevents it is: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
A compromised low-value service pivots to sensitive internal APIs without user-facing controls. This is the risk in the stated situation: A clinic's internal appointment API trusts any caller from the cluster pod network. The risky shortcut is: Allow every workload in the Kubernetes cluster to call every financial API merely because traffic stays internal. Prevent it by: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
This failure concerns another scenario: A bank's serverless functions all reuse a broad database administrator password stored in their source code. In the stated case: A clinic's internal appointment API trusts any caller from the cluster pod network. The relevant consequence is: A compromised low-value service pivots to sensitive internal APIs without user-facing controls. The control that prevents it is: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
Question 596
A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. Which cloud security control or governance decision most directly addresses the described issue while keeping the change scoped?
Answer & Explanations
Correct answer: D
This action is appropriate in a different case: A finance platform releases API changes daily but schedules its only security test annually. There, the reason is: Frequent deployment creates repeated change risk, so security review must track each material feature and dependency update. The current case is: A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. The appropriate response is: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
This action is appropriate in a different case: A multi-tenant booking API accepts customer resource IDs without modeling horizontal access attacks. There, the reason is: Threat modeling connects system architecture to plausible abuse paths so authorization and rate-limit controls address actual threats. The current case is: A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. The appropriate response is: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
This action is appropriate in a different case: A university uses shared infrastructure templates containing hard-coded production API tokens. There, the reason is: Configuration is executable architecture, so insecure defaults and exposed credentials can propagate instantly through automation. The current case is: A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. The appropriate response is: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices. The technical reason is: Private cluster networks can still carry attacker lateral movement if internal callers are not authenticated or scoped. The stated condition is: A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. Confirm the result by: Spoof a test internal caller identity and verify the target service rejects access while legitimate service requests succeed.
Question 597
A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. An engineer recommends: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices. Which technical explanation most directly justifies this recommendation?
Answer & Explanations
Correct answer: A
Private cluster networks can still carry attacker lateral movement if internal callers are not authenticated or scoped. That mechanism explains the decision: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices. In the reported situation: A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. Confirmation requires: Spoof a test internal caller identity and verify the target service rejects access while legitimate service requests succeed.
This principle explains a different technical intervention: Enforce peer review, secret scanning and policy checks against cloud IaC changes before they are applied. It applies to: A university uses shared infrastructure templates containing hard-coded production API tokens. The actual case is: A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. The mechanism relevant here is: Private cluster networks can still carry attacker lateral movement if internal callers are not authenticated or scoped.
This principle explains a different technical intervention: Run complementary source, dependency and runtime security tests with severity-based release gates. It applies to: A cloud payment API passes source checks but deploys an outdated parser with a published security issue. The actual case is: A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. The mechanism relevant here is: Private cluster networks can still carry attacker lateral movement if internal callers are not authenticated or scoped.
This principle explains a different technical intervention: Add automated negative-path tests for cross-tenant requests, malformed tokens and privilege escalation alongside normal functional tests. It applies to: A property portal's normal customer checkout succeeds but users can alter another account's billing address. The actual case is: A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. The mechanism relevant here is: Private cluster networks can still carry attacker lateral movement if internal callers are not authenticated or scoped.
Question 598
A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. After applying the relevant fix, which observable evidence would most convincingly establish that the underlying issue has been resolved?
Answer & Explanations
Correct answer: B
This observation would verify a different remedy: Add automated negative-path tests for cross-tenant requests, malformed tokens and privilege escalation alongside normal functional tests. That remedy applies to: A property portal's normal customer checkout succeeds but users can alter another account's billing address. The present condition is: A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. To assess it, check: Spoof a test internal caller identity and verify the target service rejects access while legitimate service requests succeed.
Spoof a test internal caller identity and verify the target service rejects access while legitimate service requests succeed. This check directly tests: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices. The underlying behavior is: Private cluster networks can still carry attacker lateral movement if internal callers are not authenticated or scoped. The case is: A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication.
This observation would verify a different remedy: Require signed build artifacts, inventory of third-party dependencies and policy evaluation before deploying cloud application images. That remedy applies to: A healthcare startup uses an unpinned container image that an unknown publisher can replace. The present condition is: A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. To assess it, check: Spoof a test internal caller identity and verify the target service rejects access while legitimate service requests succeed.
This observation would verify a different remedy: Enforce token validation, per-operation authorization, schema checks and rate limits at appropriate cloud API boundaries. That remedy applies to: A retail API terminates TLS correctly but accepts any account number from a logged-in user. The present condition is: A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. To assess it, check: Spoof a test internal caller identity and verify the target service rejects access while legitimate service requests succeed.
Question 599
A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. Which apparently convenient shortcut would most directly undermine safe resolution of this specific situation?
Answer & Explanations
Correct answer: C
This proposed shortcut concerns a separate case: A retail API terminates TLS correctly but accepts any account number from a logged-in user. The risk in this question concerns: A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. Here the unsafe shortcut is: Allow every workload in the Kubernetes cluster to call every financial API merely because traffic stays internal. Use this response instead: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
This proposed shortcut concerns a separate case: A multinational enterprise adds SaaS login federation but accidentally maps all staff to a cloud admin group. The risk in this question concerns: A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. Here the unsafe shortcut is: Allow every workload in the Kubernetes cluster to call every financial API merely because traffic stays internal. Use this response instead: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
Allow every workload in the Kubernetes cluster to call every financial API merely because traffic stays internal. This shortcut is unsafe for: A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. The resulting failure can be: A compromised low-value service pivots to sensitive internal APIs without user-facing controls. The safer response is: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
This proposed shortcut concerns a separate case: A bank's serverless functions all reuse a broad database administrator password stored in their source code. The risk in this question concerns: A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. Here the unsafe shortcut is: Allow every workload in the Kubernetes cluster to call every financial API merely because traffic stays internal. Use this response instead: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
Question 600
A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. Suppose the team makes this shortcut instead: Allow every workload in the Kubernetes cluster to call every financial API merely because traffic stays internal. Which outcome is the most likely direct consequence?
Answer & Explanations
Correct answer: D
This failure concerns another scenario: A bank's serverless functions all reuse a broad database administrator password stored in their source code. In the stated case: A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. The relevant consequence is: A compromised low-value service pivots to sensitive internal APIs without user-facing controls. The control that prevents it is: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
This failure concerns another scenario: A SaaS team repeatedly introduces broken object-level authorization despite enforcing user login. In the stated case: A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. The relevant consequence is: A compromised low-value service pivots to sensitive internal APIs without user-facing controls. The control that prevents it is: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
This failure concerns another scenario: A customer support assistant reads uploaded tickets and has permission to change billing access lists. In the stated case: A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. The relevant consequence is: A compromised low-value service pivots to sensitive internal APIs without user-facing controls. The control that prevents it is: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
A compromised low-value service pivots to sensitive internal APIs without user-facing controls. This is the risk in the stated situation: A retailer separates application tiers but internal microservices exchange sensitive records without mutual authentication. The risky shortcut is: Allow every workload in the Kubernetes cluster to call every financial API merely because traffic stays internal. Prevent it by: Require authenticated service identities, appropriate mutual TLS and narrowly authorized service-to-service routes for cloud microservices.
Certified Cloud Security Professional (CCSP) (CCSP) Practice Tests
- ISC CCSP Practice Test 58 - 10 Questions (Last Reviewed 19-Nov-2026)
- ISC CCSP Practice Test 59 - 10 Questions (Last Reviewed 18-Nov-2026)
- ISC CCSP Practice Test 60 - 10 Questions (Last Reviewed 17-Nov-2026)
- ISC CCSP Practice Test 61 - 10 Questions (Last Reviewed 16-Nov-2026)
- ISC CCSP Practice Test 62 - 10 Questions (Last Reviewed 15-Nov-2026)