Courseiva

CCNA Kubernetes Threat Model Questions

51 questions · Kubernetes Threat Model · All types, answers revealed

1
MCQeasy

What is the security risk of configuring `privileged: true` in a container's SecurityContext?

A.It restricts the container from writing to any attached volume.
B.It disables container isolation, granting full access to host devices and kernel capabilities
C.It forces the API server to reject all incoming TLS client requests.
D.It prevents the application from reading its own environment variables.
AnswerB

Privileged containers share almost all host capabilities and device access, rendering container isolation effectively nonexistent.

Why this answer

A privileged container disables all kernel namespace isolation and security confinement, granting the container full access to all devices and kernel capabilities of the host.

2
MCQhard

A security auditor reviews a Kubernetes cluster threat model and identifies that the Kubelet API on port 10250 permits unauthenticated requests if not configured properly. What authentication and authorization mode should be enforced on the Kubelet to prevent unauthorized remote code execution?

A.Enforcing Basic HTTP Authentication headers in kubelet configuration files
B.Disabling the Kubelet API entirely by turning off port 10250
C.Enabling anonymous requests with strict NetworkPolicy egress rules
D.Kubelet Authentication Mode set to Webhook and Authorization Mode set to Webhook
AnswerD

Webhook authentication and authorization allow the Kubelet to use the API server to verify client tokens and check if the caller has permissions for actions like exec or logs.

Why this answer

Kubelet authentication should be set to Webhook mode, and authorization should also be set to Webhook mode so that Kubelet delegates access decisions back to the Kubernetes API server.

3
MCQhard

An organization wants to prevent supply chain attacks where malicious code is injected into third-party Helm charts before deployment. What mitigation technique provides cryptographic verification of Helm chart integrity and authenticity?

A.Restricting etcd database access using client certificate authentication
B.Verifying Helm chart provenance files using cryptographic signatures and public key rings
C.Disabling anonymous requests in the kube-apiserver configuration
D.Enabling Pod Security Standards in the target namespace
AnswerB

Provenance files (`.prov`) contain cryptographic signatures that verify the chart has not been tampered with and comes from a trusted publisher.

Why this answer

Helm supports cryptographically signing charts using Provenance files and verifying them with public key rings prior to installation.

4
MCQmedium

A security engineer is performing a threat analysis on a Kubernetes cluster and identifies a risk where a compromised container can exhaust the available CPU and memory on the underlying worker node, causing a denial of service for other tenants. Which native Kubernetes admission mechanism is specifically designed to mitigate this threat vector?

A.PodSecurityStandards
B.ValidatingWebhookConfiguration
C.LimitRanger
D.NetworkPolicy
AnswerC

Correct. LimitRanger sets compute resource constraints per pod or container in a namespace to prevent resource exhaustion.

Why this answer

LimitRanger enforces resource allocation limits (min/max) for pods and containers in a namespace, preventing runaway resource consumption that leads to node starvation.

5
MCQmedium

A security engineer identifies that an enterprise Kubernetes cluster has several cluster-admin bindings granted to user accounts that have left the company. Which Kubernetes security principle has been violated?

A.NetworkPolicy ingress traffic isolation
B.Principle of Least Privilege and proper identity/access lifecycle management
C.Pod Security Standards baseline enforcement
D.Container image vulnerability scanning policies
AnswerB

Users should only have the minimum permissions needed for their role, and credentials must be promptly revoked when personnel depart.

Why this answer

Granting excessive permissions or failing to revoke access upon role changes violates the principle of least privilege and robust identity lifecycle management.

6
MCQeasy

An administrator notices that a compromised Pod is attempting to access the cloud provider metadata service to retrieve IAM role credentials. Which native Kubernetes resource is best suited to block this specific attack vector at the network layer?

A.ResourceQuota
B.NetworkPolicy
C.ValidatingWebhookConfiguration
D.SecurityContext
AnswerB

A NetworkPolicy can restrict egress traffic to prevent pods from reaching the cloud metadata IP address 169.254.169.254.

Why this answer

NetworkPolicies can be configured to block egress traffic from specific pods to the link-local IP address of cloud provider metadata services (169.254.169.254).

7
Multi-Selecthard

Which THREE of the following mechanisms are essential for securing the Kubernetes control plane against unauthorized access and privilege escalation?

Select 3 answers
A.Enforcing robust Role-Based Access Control (RBAC) with least privilege principles
B.Requiring mutual TLS (mTLS) for all internal API server and component communications
C.Using mutable `:latest` image tags for all control plane system components
D.Enabling encryption at rest for sensitive data stored in etcd
E.Setting `allowPrivilegeEscalation: true` across all default container security contexts
AnswersA, B, D

RBAC restricts API callers to only the permissions they require.

Why this answer

Enabling mutual TLS for component communication, enforcing robust RBAC, and enabling etcd encryption at rest are fundamental control plane hardening steps.

8
MCQmedium

An attacker gains execution in a container and attempts to perform a denial of service attack on other workloads sharing the same Kubernetes node by consuming all available CPU and memory resources. What Kubernetes feature prevents this cross-workload resource exhaustion?

A.ValidatingWebhookConfiguration rejecting pod creations
B.NetworkPolicy egress blocking rules
C.Container Resource Requests and Limits (CPU and memory)
D.ClusterRoleBindings restricting RBAC permissions
AnswerC

Setting resource limits enforces cgroup constraints that cap CPU and memory usage per container, preventing resource starvation on the node.

Why this answer

ResourceQuotas and LimitRanges/Container Resource Limits (requests and limits) ensure that containers cannot exceed allocated compute resources, preventing noisy neighbor and starvation attacks.

9
MCQeasy

Which attack vector involves tricking a Kubernetes cluster user or service into executing unintended actions via authenticated sessions, frequently mitigated by robust CSRF defenses and proper API design?

A.Cross-Site Request Forgery (CSRF)
B.Denial of Service via memory leaks
C.Container escape via kernel flaw
D.Image tag mutation
AnswerA

CSRF exploits the trust that a web site has in a user's browser session.

Why this answer

Cross-Site Request Forgery (CSRF) tricks a victim into executing unwanted actions on a web application in which they are currently authenticated.

10
MCQhard

In a zero-trust Kubernetes architecture, an attacker attempts to exploit the Kubernetes API server via a Server-Side Request Forgery (SSRF) flaw in a poorly written custom controller. Which defense-in-depth mechanism specifically protects against unauthorized API requests originating from inside the cluster network?

A.Configuring Horizontal Pod Autoscalers to limit request rates
B.Enabling Pod Security Standards in baseline mode across all namespaces
C.Mandatory client certificate authentication and rigorous RBAC authorization on API endpoints
D.Disabling the Kubelet read-only port on all worker nodes
AnswerC

The API server requires valid credentials (like a service account token or client cert) and RBAC verification for all requests, preventing anonymous or under-privileged internal access.

Why this answer

Mutual TLS (mTLS) authentication combined with RBAC ensures that callers must present a valid, cryptographically signed client certificate and have explicit authorization rules to talk to the API server.

11
MCQeasy

An administrator needs to analyze the STRIDE threat model category that encompasses an attacker gaining unauthorized elevation of privilege inside a Kubernetes cluster by exploiting a misconfigured RBAC ClusterRoleBinding. Which threat category does this represent?

A.Tampering
B.Elevation of Privilege
C.Repudiation
D.Information Disclosure
AnswerB

Correct. Escalating privileges beyond intended authorization boundaries maps directly to Elevation of Privilege in STRIDE.

Why this answer

Elevation of privilege corresponds to users gaining capabilities they are not authorized to have, such as using an overly permissive ClusterRoleBinding to impersonate the system:masters group.

12
Multi-Selectmedium

When modeling threats related to Kubernetes secrets management, which TWO actions help protect secrets from unauthorized access?

Select 2 answers
A.Granting all namespace users cluster-admin read permissions on Secret objects
B.Integrating external secret management systems (e.g., HashiCorp Vault, AWS Secrets Manager)
C.Disabling RBAC authentication across all API server endpoints
D.Enabling etcd encryption at rest using a dedicated encryption provider configuration
E.Storing database credentials in plain text ConfigMaps in the default namespace
AnswersB, D

External secret stores decouple secrets from etcd storage and provide robust access auditing.

Why this answer

Using external secret stores (like Vault or cloud KMS) and enabling etcd encryption at rest protect secrets effectively.

13
MCQmedium

A security engineer is analyzing supply chain risks for container images. An unsigned image from an untrusted public registry is pulled into a secure cluster. Which Admission Controller plugin can be leveraged to prevent the deployment of unsigned container images?

A.NamespaceLifecycle admission plugin
B.ValidatingAdmissionWebhook executing a policy engine integrated with Cosign image signature verification
C.DefaultStorageClass admission controller
D.LimitRanger
AnswerB

Using a validating webhook with a policy engine allows checking cryptographic signatures against a trusted public key before allowing pod creation.

Why this answer

ValidatingAdmissionPolicy or admission webhook controllers like OPA Gatekeeper or Kyverno integrated with cryptographic signature verification (such as Cosign) are used to enforce image signing.

14
MCQhard

An adversary successfully compromises a workload and extracts the default service account token. By default, what permission level does this unconfigured service account token possess in modern Kubernetes clusters?

A.Read-only access to all Secrets and ConfigMaps cluster-wide
B.Full administrative rights restricted strictly to its own namespace
C.Zero explicit RBAC permissions (cannot query or modify cluster resources)
D.Cluster-admin permissions across all cluster namespaces
AnswerC

Modern Kubernetes versions ensure default service accounts in custom namespaces have no automatic RBAC privileges, preventing immediate lateral movement.

Why this answer

In Kubernetes 1.22+, automountServiceAccountToken defaults to true unless disabled, but default service accounts have virtually no RBAC permissions unless explicitly bound via ClusterRoleBinding or RoleBinding.

15
Multi-Selecthard

Which THREE of the following steps are recognized best practices for hardening worker nodes against attacks and container escapes?

Select 3 answers
A.Keeping node host operating system kernels and container runtimes regularly patched
B.Configuring all pods to execute with `securityContext.runAsUser: 0`
C.Disabling the Kubelet read-only port (10255)
D.Allowing anonymous authentication requests on the Kubelet API
E.Restricting direct SSH access to worker nodes and using secure bastion hosts
AnswersA, C, E

Kernel patching mitigates container escape vulnerabilities caused by OS flaws.

Why this answer

Disabling the Kubelet read-only port, keeping host OS kernels updated, and restricting SSH access are key node hardening practices.

16
MCQeasy

An organization wants to analyze potential threats to their Kubernetes cluster using the STRIDE model. Which STRIDE category maps to an attacker eavesdropping on unencrypted internal cluster traffic between pods?

A.Repudiation
B.Tampering
C.Information Disclosure
D.Denial of Service
AnswerC

Eavesdropping on network communication without authorization results in information disclosure.

Why this answer

Information Disclosure covers the reading or gaining access to data by an unauthorized entity, such as sniffing unencrypted pod-to-pod network traffic.

17
MCQhard

An attacker gains execution inside a container that has the `CAP_SYS_ADMIN` capability enabled and shares the host's IPC namespace. How does `CAP_SYS_ADMIN` facilitate container escape?

A.By encrypting all network traffic traversing the CNI plugin bridge
B.By permitting system administration operations like mounting host filesystems and manipulating cgroups
C.By enabling automated horizontal scaling of replica sets
D.By automatically granting cluster-admin Kubernetes RBAC permissions
AnswerB

CAP_SYS_ADMIN bypasses numerous kernel safety checks, allowing actions like mount() system calls that enable escaping the container namespace confinement.

Why this answer

CAP_SYS_ADMIN is a powerful capability that grants privileges similar to root across many subsystem operations, including mounting filesystems, manipulating cgroups, and interacting with core kernel features that often lead to escape.

18
MCQeasy

Which Kubernetes feature allows administrators to define mandatory security baselines, such as disallowing privileged containers, across an entire namespace or cluster?

A.Horizontal Pod Autoscaler
B.PersistentVolume security controller
C.kube-dns policy mapper
D.Pod Security Admission
AnswerD

Pod Security Admission is the built-in admission controller that enforces Pod Security Standards.

Why this answer

Pod Security Standards (enforced via Pod Security admission or admission controllers) define security levels like Privileged, Baseline, and Restricted.

19
Multi-Selecthard

Which THREE of the following configurations or features represent critical attack vectors or misconfigurations in a Kubernetes cluster threat model?

Select 3 answers
A.Mounting the host Docker socket (`/var/run/docker.sock`) into application pods
B.Exposing the unauthenticated Kubelet read-only port (10255)
C.Enabling Pod Security Admission in restricted mode across all namespaces
D.Running application pods with `securityContext.privileged: true`
E.Configuring etcd encryption at rest with a Secret encryption provider
AnswersA, B, D

Docker socket access allows creating sibling containers that can mount the host root filesystem for node escape.

Why this answer

Leaving the Kubelet unauthenticated/read-only, running containers in privileged mode, and mounting the Docker socket all introduce severe container escape and cluster takeover vectors.

20
MCQeasy

A developer configures a Kubernetes Pod with `hostNetwork: true`. Under the STRIDE threat model, which threat category is most directly introduced or elevated by this configuration?

A.Denial of Service via CPU exhaustion
B.Tampering of container image layers at rest
C.Elevation of Privilege and Information Disclosure
D.Repudiation of database audit logs
AnswerC

Sharing the host network allows bypassing namespace isolation, letting the pod capture host traffic and access local network services bound to localhost.

Why this answer

Setting hostNetwork to true exposes the host's network namespace to the container, elevating the threat of Elevation of Privilege or Information Disclosure through unauthorized packet sniffing on host interfaces.

21
MCQeasy

An auditor is evaluating the Kubernetes control plane attack surface. Which component exposes the primary interface for cluster management and must be protected with strong authentication and authorization?

A.CoreDNS
B.kube-proxy
C.kube-scheduler
D.kube-apiserver
AnswerD

All administrative commands, manifest submissions, and internal component communications flow through the kube-apiserver.

Why this answer

The kube-apiserver is the core front-end of the Kubernetes control plane that exposes the REST API.

22
MCQhard

An auditor is evaluating the security posture of an on-premises Kubernetes cluster. The team notices that the etcd data directory is stored without encryption at rest. What is the primary threat this exposes the cluster to?

A.Direct exposure of all Kubernetes Secrets in plain text to anyone with read access to etcd storage
B.Inability of worker nodes to perform TLS handshakes with the API server
C.Immediate failure of HorizontalPodAutoscaler metric polling loops
D.Automatic elevation of all ServiceAccounts to cluster-admin privileges
AnswerA

Without etcd encryption at rest enabled via EncryptionConfiguration, all sensitive data stored in secrets is readable in plain text from storage.

Why this answer

etcd stores all Kubernetes objects in plain text by default, including Secrets. Anyone with access to the etcd data files or snapshots can read all cluster secrets in plain text.

23
MCQeasy

What is the primary risk associated with running containers as the `root` user (`runAsUser: 0` or omitting the user directive)?

A.If a container escape vulnerability occurs, the attacker immediately obtains root privileges on the underlying host.
B.It prevents the kubelet from restarting the container upon failure.
C.It disables the container runtime engine's ability to pull images from private registries.
D.It forces the CNI plugin to drop network packets destined for external IPs.
AnswerA

Container root maps directly to host root or powerful UID 0 capabilities in misconfigured or un-namespaced environments, easing host compromise.

Why this answer

Running as root inside the container means the process has root privileges inside the container namespace, and if a container escape vulnerability exists, the attacker immediately gains root access on the host.

24
MCQmedium

An attacker who achieves remote code execution inside a misconfigured container discovers that the service account token mounted at /var/run/secrets/kubernetes.io/serviceaccount/token has cluster-wide administrative permissions. Which Kubernetes security feature should be enabled on the ServiceAccount to mitigate the risk of token theft and misuse?

A.Disabling automatic token mounting (automountServiceAccountToken: false) and utilizing projected volumes with bound audiences
B.Configuring a default Deny-All NetworkPolicy for the kube-system namespace
C.Enabling the NodeRestriction admission plugin
D.EnablingAnonymousAuth on the kube-apiserver
AnswerA

Correct. Disabling unnecessary token mounts and using audience-bound projected tokens limits token blast radius and lifespan.

Why this answer

AutomountServiceAccountToken can be set to false at the ServiceAccount or Pod level to prevent unnecessary token mounting, and projected service account tokens with audience restrictions improve token security.

25
MCQeasy

Which of the following represents a common cloud-native supply chain attack vector where malicious actors publish packages with names similar to popular libraries?

A.Kernel memory exploitation via unprivileged user namespaces
B.Denial of Service via packet flooding
C.Man-in-the-Middle etcd keystore sniffing
D.Typosquatting
AnswerD

Typosquatting relies on human error where developers misspell dependency names, inadvertently pulling malicious packages into the build.

Why this answer

Typosquatting involves registering package names in public repositories (like npm, PyPI, or container registries) that closely resemble popular libraries to trick developers.

26
MCQhard

An organization is building a secure software supply chain for Kubernetes. They want to ensure that containers running in the cluster were built from verified source code and passed automated security gates. Which tool combination supports this attestation and verification pipeline?

A.Cosign for cryptographic image signing, SBOM generation, and admission controllers for policy enforcement
B.HorizontalPodAutoscaler and Metrics Server integration
C.kube-proxy for CNI routing and CoreDNS for internal name resolution
D.etcd snapshots and kubeadm control plane bootstrapping scripts
AnswerA

Cosign signs container images and generates SBOMs, while admission policy engines verify these signatures and materials prior to deployment.

Why this answer

Tools like Tekton or GitHub Actions for CI/CD, Cosign for signing images and generating SBOMs (Software Bill of Materials), and Kyverno or OPA Gatekeeper for admission control verification form a complete software supply chain security framework.

27
MCQeasy

An auditor is reviewing the Kubernetes attack surface and notes that a container is running with privileged: true in its securityContext. Which threat model risk does this setting introduce?

A.It prevents the container from writing to ephemeral storage volumes.
B.It forces the kubelet to restart the container continuously due to failing readiness probes.
C.It completely disables the Kubernetes DNS resolution service for the pod.
D.It disables container isolation, granting the container root-equivalent access to the underlying host node.
AnswerD

Correct. Privileged mode removes namespace and cgroup restrictions, allowing container escape and direct host compromise.

Why this answer

Running a container in privileged mode disables almost all security isolation provided by the Linux kernel, granting the container full access to the host node's devices and kernel capabilities.

28
MCQeasy

A developer accidentally hardcodes a database password directly into a container's environment variables within a Deployment manifest. According to the Kubernetes threat model, what is the primary risk associated with storing plaintext secrets as environment variables?

A.Environment variables require etcd encryption at rest to function correctly.
B.Environment variables are automatically logged in plain text by the container runtime logs and can be viewed via kubectl describe pod.
C.Environment variables cannot be read by the application running inside the container.
D.Environment variables prevent the pod from passing liveness probes.
AnswerB

Correct. Pod specifications and environment variables are visible via kubectl describe and can be exposed through logs or process inspectors.

Why this answer

Environment variables are visible to anyone who can inspect the pod specification, view process listings inside the container, or access certain debugging endpoints, making them less secure than Kubernetes Secrets mounted as volumes.

29
MCQhard

A security team is evaluating the attack surface of the Kubernetes control plane. They notice that the kubelet API port 10250 is accessible from the internal pod network without proper authorization checks if authentication defaults are misconfigured. What is the primary threat vector associated with an unauthenticated, accessible kubelet API?

A.Execution of arbitrary commands inside running containers via the kubelet exec and run endpoints
B.Direct modification of etcd key-value pairs stored on the master node
C.Bypassing container image vulnerability scanners running in the CI/CD pipeline
D.Forcing the API server to issue new root certificates via TLS bootstrapping
AnswerA

Correct. An exposed kubelet API permits executing commands in pods running on that node, bypassing API server RBAC.

Why this answer

An unauthenticated kubelet API allows attackers to run commands inside containers (via the exec/run APIs), read logs, and extract sensitive information from the node.

30
MCQhard

An attacker with read access to Kubernetes Secrets inspects a secret containing TLS private keys. Under the STRIDE threat model, what specific threat category does this represent regarding confidentiality?

A.Denial of Service
B.Elevation of Privilege
C.Information Disclosure
D.Repudiation
AnswerC

Exposing cryptographic keys and confidential secrets violates data confidentiality, falling under Information Disclosure.

Why this answer

Unauthorized reading of sensitive data like TLS keys, API tokens, or passwords constitutes Information Disclosure.

31
MCQmedium

An attacker compromises a cluster node and attempts to inspect container communication. By default, how is pod-to-pod network traffic handled across different nodes in a standard Kubernetes cluster without a service mesh or CNI encryption enabled?

A.Encrypted automatically using mandatory 256-bit AES transport layer security
B.Blocked entirely by default unless a LoadBalancer service is declared
C.Routed exclusively through the etcd secure TLS database tunnel
D.Transmitted in plain text across the network fabric, making it vulnerable to sniffing
AnswerD

Default CNI configurations do not encrypt node-to-node or pod-to-pod transit traffic, allowing packet capture on intermediate networks.

Why this answer

Standard Kubernetes CNI plugins transmit pod-to-pod traffic in plain text across the underlying network fabric unless an encrypted overlay network (like IPsec or WireGuard) or a service mesh providing mTLS is configured.

32
MCQhard

During a supply chain security audit, a platform engineer discovers that container images deployed into the cluster are being pulled from public registries without cryptographic verification of their provenance or integrity. Which integrated Kubernetes security control should be implemented alongside an admission webhook to verify image signatures before admission?

A.Kubelet TLS bootstrapping
B.Secret encryption at rest using a KMS provider
C.Policy-based admission control with Sigstore Cosign verification
D.ImagePolicyWebhook
AnswerC

Correct. Validating admission policies or webhooks integrated with Cosign verify container image signatures and provenance at deploy time.

Why this answer

Admission controllers like Kyverno or OPA Gatekeeper can integrate with tools like Cosign to enforce image signature verification prior to allowing a pod to be scheduled.

33
MCQmedium

A security engineer discovers that an attacker has gained access to a container and is attempting to modify container files in a way that persists across pod restarts if the container image is faulty. However, the root filesystem is marked as readOnlyRootFilesystem: true. What is the impact of this setting on the attack?

A.It enforces TLS encryption for all outbound pod network connections.
B.It mitigates threats by preventing attackers from writing malicious binaries or modifying system files in the root filesystem.
C.It automatically encrypts all environment variables stored in the Pod spec.
D.It completely prevents any container from starting up if PersistentVolumeClaims are attached.
AnswerB

A read-only root filesystem blocks runtime tampering of system binaries inside the container image layer.

Why this answer

Setting readOnlyRootFilesystem to true prevents writes to the container's root filesystem, forcing attackers to use emptyDir or mounted volumes if they wish to write malicious binaries or tools.

34
Multi-Selecthard

Which THREE of the following capabilities or runtime configurations pose extreme risks of container escape when granted to an untrusted workload?

Select 3 answers
A.`hostPID: true` sharing the host process namespace
B.Setting `automountServiceAccountToken: false` on the service account
C.`securityContext.privileged: true`
D.Granting the `CAP_SYS_ADMIN` capability in the container security context
E.Setting `readOnlyRootFilesystem: true` in the container specification
AnswersA, C, D

Sharing host PID lets container processes see and potentially signal or ptrace host processes.

Why this answer

CAP_SYS_ADMIN, privileged mode, and hostPID/hostIPC namespace sharing all provide powerful vectors for breaking container boundaries.

35
Multi-Selectmedium

A cluster administrator is conducting a threat analysis regarding supply chain vulnerabilities in container registries and deployment pipelines. Which TWO of the following practices directly mitigate supply chain threats in Kubernetes? (Choose TWO)

Select 2 answers
A.Increasing the CPU limits on all worker nodes to handle larger container images
B.Enforcing cryptographic image signing and verification using tools like Sigstore Cosign
C.Configuring static IP addresses for all worker nodes in the private subnet
D.Integrating automated vulnerability scanning into the CI/CD pipeline before pushing images to the registry
E.Disabling the default token automount on all namespaces globally
AnswersB, D

Correct. Image signing ensures that only artifacts from trusted build pipelines are deployed.

Why this answer

Supply chain security involves verifying software provenance and minimizing vulnerabilities. Using trusted signed base images and scanning images before deployment directly addresses supply chain vectors.

36
Multi-Selecteasy

When modeling threats for a Kubernetes cluster using the STRIDE methodology, identifying scenarios where an attacker intercepts unencrypted traffic between worker nodes or between a client and the API server addresses which TWO STRIDE categories? (Choose TWO)

Select 2 answers
A.Repudiation
B.Denial of Service
C.Tampering
D.Elevation of Privilege
E.Information Disclosure
AnswersC, E

Correct. Unencrypted data in transit can be intercepted and modified maliciously.

Why this answer

Interception of unencrypted network traffic falls under Information Disclosure (reading sensitive data in transit) and Tampering (if the traffic can also be modified in flight without integrity checks).

37
MCQhard

An administrator wishes to defend against supply chain attacks involving malicious third-party Kubernetes operators installed from public catalogs. What security practice is most effective before installing such operators?

A.Reviewing requested RBAC permissions, operator manifests, and verifying image provenance
B.Enabling Horizontal Pod Autoscaling for CoreDNS replicas
C.Disabling the Kubernetes Dashboard service deployment
D.Configuring liveness probes on all worker nodes to check kubelet responsiveness
AnswerA

Malicious or overly permissive operators often request cluster-admin rights; reviewing manifests and RBAC scopes before installation prevents unauthorized privilege escalation.

Why this answer

Inspecting CustomResourceDefinitions (CRDs), controller manifests, RBAC permissions requested by the operator, and pulling container images from verified registries ensures the operator does not request excessive privileges (e.g., cluster-admin).

38
Multi-Selectmedium

An auditor evaluates network security controls in a Kubernetes cluster. Which TWO configurations help mitigate lateral movement and network-based attacks between pods?

Select 2 answers
A.Disabling CNI network plugins to run pods in bridge mode
B.Implementing a service mesh (such as Istio or Linkerd) with strict mTLS enforcement
C.Exposing all internal microservices via NodePort services on worker nodes
D.Mounting the host network namespace (`hostNetwork: true`) on all application pods
E.Enforcing Kubernetes NetworkPolicies to restrict pod-to-pod ingress and egress traffic
AnswersB, E

A service mesh encrypts traffic and authenticates service identities at layer 7.

Why this answer

Deploying CNI-level network policies and implementing a service mesh for mTLS traffic encryption and authentication mitigate lateral movement.

39
MCQmedium

An auditor notices that a cluster allows users to create Pods that mount host paths (`hostPath`). Which threat does this pose to the underlying node integrity?

A.Arbitrary read/write access to the host filesystem, enabling node compromise
B.Automatic failure of Kubernetes liveness and readiness health probes
C.Inability of the CNI plugin to assign IP addresses to pods
D.Immediate corruption of the etcd distributed consensus state
AnswerA

Mounting host directories lets a compromised container modify critical host files, leading directly to host takeover.

Why this answer

hostPath mounts allow containers to read and write directly to the host node's filesystem, enabling attackers to tamper with system files, cron jobs, or SSH authorized keys for node takeover.

40
Multi-Selectmedium

In the context of Kubernetes API server security, which TWO mechanisms are used to authenticate incoming API requests?

Select 2 answers
A.Kubernetes NetworkPolicy egress CIDR blocks
B.PersistentVolume claim capacity metadata
C.X509 Client Certificates presented during TLS handshakes
D.Container image pull secrets stored in private registries
E.Bearer Tokens (including ServiceAccount JWT tokens)
AnswersC, E

The API server validates client certificates signed by the cluster CA for authentication.

Why this answer

X509 client certificates and Service Account bearer tokens are standard Kubernetes authentication mechanisms.

41
MCQhard

An attacker with compromised Kubernetes credentials attempts to hide malicious activity by deleting Kubernetes audit logs on the worker node. Where should audit logs ideally be stored and managed in a securely hardened cluster to prevent tampering and ensure non-repudiation?

A.Written to the container image layer cache of the local container runtime
B.Stored inside unencrypted ConfigMaps within the default namespace
C.Saved locally in an ephemeral emptyDir volume inside the kube-system namespace
D.Forwarded to an external centralized SIEM or secure remote storage backend
AnswerD

Centralized logging ensures that even if an attacker gains root access to control plane or worker nodes, they cannot alter or delete historical audit records.

Why this answer

Audit logs should be sent synchronously or asynchronously out of the control plane nodes to an external, write-once-read-many (WORM) storage or centralized SIEM system where local node compromise does not affect log integrity.

42
MCQmedium

An engineer is reviewing the threat model of a Kubernetes cluster exposed to the public internet via a LoadBalancer service. Which configuration flaw most commonly leads to unintended external exposure of administrative dashboards?

A.Configuring liveness probes with HTTP GET requests instead of TCP socket checks
B.Exposing management dashboards via LoadBalancer or NodePort services without authentication or IP whitelisting
C.Setting imagePullPolicy to IfNotPresent on production deployments
D.Using ClusterIP service types for internal database connectivity
AnswerB

Unauthenticated or loosely secured dashboards exposed to the public internet allow arbitrary attackers to gain administrative cluster control.

Why this answer

Deploying management tools (like Kubernetes dashboards, monitoring UIs, or debugging tools) with external LoadBalancer services or NodePorts without authentication or network restriction is a major threat vector.

43
MCQeasy

Which of the following is a key component of the Kubernetes threat model concerning the compromise of node kubelets via insecure configuration?

A.Leaving the Kubelet read-only port (10255) enabled and accessible
B.Enforcing Pod Security Admission in restricted mode
C.Using secure HTTPS client certificates for API server communication
D.Enabling RBAC authorization mode across the control plane
AnswerA

Port 10255 provides unauthenticated read access to node data, exposing sensitive environment variables and pod metadata.

Why this answer

Exposing the Kubelet read-only port (10255) allows unauthenticated retrieval of pod specifications, container logs, and environment variables without any credentials.

44
Multi-Selecthard

An attacker manages to compromise a low-privilege pod inside a Kubernetes cluster and attempts to escalate privileges or pivot to other cluster components. Which THREE of the following misconfigurations or weaknesses would significantly aid the attacker's lateral movement or privilege escalation? (Choose THREE)

Select 3 answers
A.Etcd is encrypted at rest using a customer-managed KMS encryption provider.
B.The cluster uses a properly configured PodSecurityStandard of Restricted across all namespaces.
C.The pod's ServiceAccount has a ClusterRoleBinding granting cluster-admin permissions.
D.The pod is configured with hostNetwork: true, allowing it to sniff traffic on the node's network interface.
E.The cloud provider's instance metadata service is accessible without IMDSv2 token restrictions from the pod network.
AnswersC, D, E

Correct. Overly permissive RBAC allows the compromised token to control the entire cluster.

Why this answer

Attackers exploit weak RBAC rules, insecure access to the API server or cloud metadata, and overly permissive host namespaces to move laterally or escape.

45
MCQmedium

A security team discovers that an application container running as root has successfully mounted the host's Docker socket (`/var/run/docker.sock`). What is the primary attack vector enabled by this misconfiguration?

A.Bypassing Kubernetes NetworkPolicies across different worker nodes
B.Direct modification of the etcd database state via local unix socket tunneling
C.Container escape and full node takeover by orchestrating new sibling containers with host mounts
D.Automatic escalation of RBAC roles assigned to the API server
AnswerC

The Docker socket is the API endpoint for the container engine; sending commands to it lets the container spawn arbitrary containers on the underlying host node.

Why this answer

Access to the Docker socket allows a container to create sibling containers on the host, often mounting the host root filesystem (`/`) and achieving full node compromise.

46
MCQeasy

What is the primary security benefit of using immutable container base distroless images?

A.They prevent the API server from restarting during control plane upgrades.
B.They automatically encrypt persistent storage volumes attached to the pod.
C.They eliminate unnecessary shells and package managers, drastically reducing the attack surface.
D.They configure automatic mTLS between all pods in the cluster via CNI.
AnswerC

Removing package managers and shell utilities stops attackers from downloading or executing arbitrary scripts even if remote code execution is achieved.

Why this answer

Distroless images contain only the application and its runtime dependencies, stripping out shells, package managers, and utilities, which drastically reduces the attack surface and prevents attackers from executing shell commands if compromised.

47
Multi-Selectmedium

An organization is performing a STRIDE-based threat model on their Kubernetes deployment. Which TWO of the following threats map directly to the 'Tampering' category in a Kubernetes environment?

Select 2 answers
A.An attacker altering container image layers stored in an insecure registry
B.An attacker modifying Kubernetes API objects stored directly or in transit via compromised credentials
C.An attacker flooding the API server with requests to exhaust control plane memory
D.An attacker sniffing unencrypted pod-to-pod network traffic across the CNI bridge
E.An administrator denying that they executed a cluster deletion command due to missing logs
AnswersA, B

Modifying image contents in a registry constitutes tampering with the software supply chain.

Why this answer

Tampering involves unauthorized modification of data or code. Modifying container images in a registry and tampering with Kubernetes manifests in etcd/Git repository are prime examples.

48
MCQmedium

A cluster administrator wants to mitigate supply chain risks stemming from vulnerable base images used by developers. Where in the software lifecycle should vulnerability scanning ideally be integrated first to shift-left security?

A.Manual inspection of etcd database backups
B.Configuring kube-dns forwarding rules to external resolvers
C.Setting up PersistentVolume backup retention policies
D.CI/CD pipeline build and image registry push stages
AnswerD

Scanning container images inside the CI/CD pipeline prevents vulnerable artifacts from ever being published to registries or deployed to production clusters.

Why this answer

Integrating vulnerability scanning into the CI/CD pipeline registry push phase or source code repository ensures vulnerable base images are flagged before they reach cluster deployment stages.

49
MCQmedium

A Kubernetes cluster experiences an attack where an untrusted pod attempts to access the Kubernetes API server and discover cluster secrets. The cluster uses RBAC. What is the mechanism that prevents this pod from reading secrets in other namespaces?

A.Enabling the AlwaysAdmit authorization webhook mode
B.Default ClusterRole bindings assigned automatically to all service accounts
C.NetworkPolicies blocking traffic directed at the Kubernetes API server port
D.Namespaced RoleBindings limiting permissions strictly to the pod's own namespace
AnswerD

Namespaced RoleBindings enforce isolation boundaries so that identities authorized in one namespace cannot access resources in another.

Why this answer

Kubernetes RBAC RoleBindings are namespaced, meaning a Role or RoleBinding grants permissions only within the specific namespace where it is created, preventing cross-namespace access unless a ClusterRoleBinding is used.

50
Multi-Selecthard

Which THREE of the following supply chain vulnerabilities or risks can impact Kubernetes application deployments during the build or deployment phase?

Select 3 answers
A.Enforcing Pod Security Standards in baseline mode in production namespaces
B.Using outdated container base images containing known remote code execution CVEs
C.Typosquatting malicious packages in public package registries (npm, PyPI)
D.Deploying third-party Helm charts that contain backdoored deployment templates
E.Enabling Kubernetes audit logging with webhook sinks
AnswersB, C, D

Outdated base images inherit known vulnerabilities that attackers can exploit at runtime.

Why this answer

Compromised base images, typosquatting dependencies, and untrusted Helm charts are all common supply chain vectors.

51
MCQmedium

A DevOps team uses mutable image tags like `:latest` in their deployment manifests. Under supply chain threat modeling, what vulnerability does this practice introduce?

A.Automatic revocation of TLS certificates issued by cert-manager
B.Exposition of etcd database credentials on public DNS servers
C.Escalation of RBAC permissions from Role to ClusterRole
D.Image Tag Hijacking / Malicious substitution without manifest updates
AnswerD

Because `:latest` can point to different digests over time, a compromised registry allows attackers to replace legitimate images with malicious ones silently.

Why this answer

Mutable image tags allow an attacker who compromises the image registry to overwrite the tag with a malicious binary, causing pods restarting or pulling new instances to execute compromised code without changing the deployment manifest.

Ready to test yourself?

Try a timed practice session using only Kubernetes Threat Model questions.