SaveMyCert
Log in
5 of 5 free questions left today·for 10 a day
KCSA · Domain 5

Platform Security practice questions

Platform Security is worth 16% of the KCSA exam — the 3rd-heaviest of the 6 domains. Security of the platform around the cluster: the software supply chain, image repositories, observability, service mesh, PKI, connectivity and admission control. Official weighting 16%. 6 fully worked examples are further down this page, answers included.

Exam weight
16%
the 3rd-heaviest of the 6 domains
Questions
62
across 2 topics
Free, no account
5/day
a free account allows 10 a day
Explanations
Every option
right and wrong

Build a practice session

5 free questions left today.

Domains

How many?

5 free questions left today.

Mode

Ready when you are

10 fresh questions drawn across 1 of 6 domains, in Learn mode.

Review what you missed

Every question you answer incorrectly, and every question you flag while practising, is saved here automatically. Finish a session and you can come back to re-drill just those.

6 sample Platform Security questions, fully explained

Questions from the KCSA bank mapped to domain 5, with the answer key and the reasoning behind every option. None of them repeat the examples on the main KCSA practice page.

Question 1Platform Security

A new critical CVE is published for a widely used compression library. The security team must quickly list which of the 400 images in its registry include that library, without pulling and unpacking every image. Which practice makes this possible?

Choose one.

  • a
    Signing each image at build time with cosign and storing the signature in the registry

    A signature proves who built the image and that it is unchanged; it carries no list of the libraries inside.

  • b
    Generating an SBOM for each image at build time and storing it with the image Correct

    Stored SBOMs can be searched for the library name and version, so affected images are found in minutes without touching the images themselves.

  • c
    Recording a SLSA provenance attestation for each image and storing it with the image

    Provenance records the builder, source and build steps, not the full set of packages in the image.

  • d
    Scanning each image at build time and keeping the scan result from that day

    An old scan predates the new CVE, so it cannot report it; the team would still have to rescan every image.

The concept

SBOMs turn 'are we affected?' into a search.

Why that’s the answer

Because an SBOM records every component and version, a team that generated one per image can respond to a new disclosure by querying the SBOMs. A signature and a provenance attestation answer different questions (who and how), and a scan result from build day was produced before the CVE existed, so it cannot list it.

How to reason it out
  1. Identify the need: find which images contain a named component.
  2. Pick the record that lists components: the SBOM.
  3. Reject records about identity or build origin.
  4. Reject point-in-time scan results that predate the CVE.

Exam tip: Keep an SBOM per image so a new CVE becomes a query, not a rescan.

KCSA Supply Chain Security, Image Registries and Admission Control — the lesson that teaches this.

Question 2Platform Security

Which TWO of these are standard formats for a software bill of materials? (Select TWO.)

Choose TWO.

  • a
    SPDX Correct

    SPDX, from the Linux Foundation, is an SBOM standard (also published as ISO/IEC 5962); the Kubernetes project publishes its release SBOMs in it.

  • b
    CycloneDX Correct

    CycloneDX, an OWASP standard, is the other widely used SBOM format.

  • c
    SLSA

    SLSA is a framework of supply chain security levels and a provenance format, not an SBOM format.

  • d
    in-toto

    in-toto is a framework for signed attestations about supply chain steps; an SBOM can be carried inside one, but in-toto is not an SBOM format.

  • e
    OCI

    The Open Container Initiative defines image and registry formats, not a bill of materials format.

The concept

SPDX and CycloneDX are the two common SBOM standards.

Why that’s the answer

SPDX (Linux Foundation, ISO/IEC 5962) and CycloneDX (OWASP) are the standard SBOM formats that tools such as Syft and Trivy emit. SLSA defines supply chain levels and provenance, in-toto defines how attestations are structured and signed, and OCI defines how images and artifacts are packaged and stored.

How to reason it out
  1. Recall which formats describe component inventories.
  2. Place SLSA and in-toto under provenance and attestations.
  3. Place OCI under image packaging.

Exam tip: SBOM formats: SPDX and CycloneDX.

KCSA Supply Chain Security, Image Registries and Admission Control — the lesson that teaches this.

Question 3Platform Security

A build pipeline produces a SLSA provenance attestation for every image it builds. What does this attestation describe?

Choose one.

  • a
    Which packages, libraries and versions were installed into the image's layers

    That is the content of an SBOM, not of build provenance.

  • b
    Which nodes in the cluster are allowed to pull and run the image at deploy time

    Where an image may run is decided by scheduling and admission policy, not recorded in provenance.

  • c
    Which known vulnerabilities in the image were accepted by the security team

    Accepted-risk records are vulnerability exceptions (sometimes VEX documents), not build provenance.

  • d
    How the image was built: the builder, the source repository and the build inputs Correct

    SLSA provenance is verifiable information about where, when and how an artifact was produced, including the builder identity and source.

The concept

Provenance answers 'how and from what was this built?'.

Why that’s the answer

SLSA (Supply-chain Levels for Software Artifacts) defines provenance as verifiable metadata about how an artifact was produced: the build platform, the source repository and revision, and the build parameters. Consumers check it to confirm an image came from the expected pipeline and source. The inventory of contents is an SBOM, and run-time placement is a cluster concern.

How to reason it out
  1. Read 'provenance' as origin.
  2. Match it to builder, source and build inputs.
  3. Leave component lists to SBOMs.

Exam tip: Provenance = builder + source + build steps.

KCSA Supply Chain Security, Image Registries and Admission Control — the lesson that teaches this.

Question 4Platform Security

Production may run only images built by the company's CI system from its main repository. Developers also hold the team's cosign signing key, and they sometimes sign images built on laptops. Which admission-time check meets the requirement?

Choose one.

  • a
    Verify that each image carries a valid signature made with the team's cosign signing key

    Laptop builds signed with the same team key pass this check, so it cannot tell CI builds from local ones.

  • b
    Verify a signed SBOM attestation that lists the packages approved for the main repository

    An SBOM lists contents; a laptop build of the same code can produce a matching SBOM without coming from CI.

  • c
    Verify a signed provenance attestation whose builder and source repository match the CI system Correct

    Provenance generated and signed by the CI builder records the builder identity and source repository, so the check fails for laptop builds even when they carry the team's signature.

  • d
    Verify that each Pod references its image by digest rather than by a mutable tag

    A digest pins exact content, but it says nothing about where that content was built.

The concept

Who signed is not the same as how it was built.

Why that’s the answer

Two facts combine here. A signature proves which key signed an image, and the team key is shared with developers, so signature checks accept laptop builds. Provenance, produced by the build platform and signed by it, records the builder and source repository; an admission policy (Kyverno verifyImages attestations, Sigstore policy-controller and similar) can require those fields to match the CI system and main repository. SBOMs and digests answer different questions.

How to reason it out
  1. Note the constraint: developers can sign with the same key.
  2. Conclude that signature checks alone cannot separate CI from laptop builds.
  3. Look for evidence that records the builder and source: provenance.
  4. Require it to be checked at admission.

Exam tip: To prove an image came from your pipeline, verify its provenance, not just its signature.

KCSA Supply Chain Security, Image Registries and Admission Control — the lesson that teaches this.

Question 5Platform Security

In Sigstore keyless signing with cosign, what is the role of Fulcio?

Choose one.

  • a
    It records each signing event in a tamper-evident, publicly auditable transparency log

    That is Rekor, Sigstore's transparency log.

  • b
    It checks image signatures in the cluster and rejects Pods whose images are unsigned

    That is an admission policy, such as the Sigstore policy-controller or a Kyverno rule.

  • c
    It issues a short-lived signing certificate bound to the signer's OIDC identity Correct

    Fulcio is Sigstore's certificate authority: it checks an OIDC token and issues a short-lived certificate for that identity, so no long-lived key has to be stored.

  • d
    It stores the signature next to the image in the OCI registry under a related tag

    cosign itself pushes the signature to the registry; Fulcio does not store artifacts.

The concept

Fulcio = certificate authority; Rekor = transparency log.

Why that’s the answer

Keyless signing replaces a stored private key with an identity: cosign obtains an OIDC token (from a CI system or a user login), Fulcio issues a short-lived certificate for that identity, the artifact is signed with an ephemeral key, and the event is recorded in Rekor. Verifiers then check the identity and issuer in the certificate.

How to reason it out
  1. Recall the three Sigstore parts: cosign, Fulcio, Rekor.
  2. Match Fulcio to certificate issuance from an OIDC identity.
  3. Assign logging to Rekor and enforcement to admission policies.

Exam tip: Keyless: OIDC identity in, short-lived certificate out from Fulcio.

KCSA Supply Chain Security, Image Registries and Admission Control — the lesson that teaches this.

Question 6Platform Security

An image was signed with cosign keyless signing. The signing certificate expired minutes after the signature was made, yet the cluster verifies the signature successfully a month later. What makes this verification valid?

Choose one.

  • a
    Fulcio reissues the signing certificate whenever the image is pulled again

    Fulcio issues certificates only when a signer requests one; it does not renew them on pull.

  • b
    A Rekor log entry shows the signing time fell inside the certificate's lifetime Correct

    Rekor records the signing event with a trusted timestamp, so a verifier can confirm the signature was created inside the certificate's short validity window.

  • c
    The verifier treats the registry's recorded push time as the signing time

    A registry push time is neither signed nor trusted evidence; anyone with push rights could re-push later, so verifiers do not rely on it.

  • d
    The verifier checks the chain to Fulcio's root but ignores certificate lifetimes

    Lifetimes are checked; what satisfies the check is the trusted Rekor (or TSA) timestamp showing signing happened while the certificate was valid.

The concept

Short-lived certificates rely on the transparency log for time.

Why that’s the answer

Keyless certificates are valid only briefly, by design, so a stolen key is useless almost at once. Verification later works because the signing event is in Rekor with a trusted timestamp: the verifier checks that the signature, certificate and log entry agree and that the signing happened during the certificate's validity. Nothing is renewed or re-signed.

How to reason it out
  1. Note the certificate expired long before verification.
  2. Ask what proves when the signature was made.
  3. Recall that Rekor timestamps and logs each signing event.

Exam tip: Keyless signatures stay verifiable because Rekor proves when they were made.

KCSA Supply Chain Security, Image Registries and Admission Control — the lesson that teaches this.

What KCSA domain 5 tests, topic by topic

The official exam guide breaks Platform Security into 2 topics. The question bank follows the same split, so a weak topic shows up as a cluster of misses you can go back and read.

Published KCSA practice questions per topic in Platform Security
TopicWhat it coversQuestions
Supply chain security, image repositories and admission controlOfficial KCSA competencies (Platform Security): Supply Chain Security; Image Repository; Admission Control. Scope: SBOMs, provenance and image signing, vulnerability scanning, private registries and image pull credentials, and validating and mutating admission webhooks and policy engines that enforce rules at deploy time.31
Observability, service mesh, PKI and connectivityOfficial KCSA competencies (Platform Security): Observability; Service Mesh; PKI; Connectivity. Scope: logs, metrics and runtime threat detection, mutual TLS and identity in a service mesh, the cluster certificate authority and certificate rotation, and secure connectivity into and out of the cluster.31
Total62

Revise Platform Security before you drill it

Other KCSA domains

Platform Security: your questions

Platform Security is domain 5 of the KCSA exam guide and carries 16% of the scored content — the 3rd-heaviest of the 6 domains. On a 60-question paper that works out to roughly 10 questions, though CNCF does not publish an exact per-domain count and individual exam forms vary.

Source

The domain weight and topic list on this page come from the official KCSA exam guide.