skip to content

Software supply chain security

6 roadmaps328 questionsupdated

You will learn to secure what you ship, not just what you wrote: proving where an artifact came from, what is inside it, and that nobody tampered with the pipeline that built it. After SolarWinds and xz-utils this is the area senior DevSecOps interview loops probe hardest.

on this pageshow

guide

overview

~2 min

Software supply chain security asks a question most application security skips: not whether the code you wrote is safe, but whether what you ship is what you believe it is. Every artifact passes through other people's packages, a build system, a registry and a deploy step before it runs, and each hop is a place where someone else can add code. Interviewers probe the subject because the incidents everyone cites came through those hops rather than through a bug in first-party code, and because it is easy to name tools and hard to say what each one actually proves. Expect to be asked which threat a control addresses, who checks it, and what happens when the check fails. The subject splits into three groups. The threat model comes first: [supply chain attack vectors](/topics/sec-supply-chain-threat-landscape), meaning poisoned packages, compromised maintainers and tampered build or delivery machinery. Then the consumer's controls: [dependency risk and SCA](/topics/sec-supply-chain-dependency-risk) for what you pull in, [SBOM and VEX](/topics/sec-supply-chain-sbom) for recording it, [build pipeline hardening](/topics/sec-supply-chain-pipeline-hardening) for the machinery that turns source into artifacts, [artifact signing](/topics/sec-supply-chain-signing) and [SLSA build provenance](/topics/sec-supply-chain-slsa-provenance) for evidence about those artifacts, and [registry and image trust](/topics/sec-supply-chain-registry-trust) for the point where a deploy accepts or refuses one. Last come the obligations around them: [standards and regulation](/topics/sec-supply-chain-standards), which turned the practice into contract terms and law, and [publishing and disclosure](/topics/sec-supply-chain-publishing-disclosure), your duties when you are the upstream for somebody else. Learn the attack vectors first, because a control is worth only what it stops. Dependencies and SBOMs come next, since most day-to-day work happens there. Then take the pipeline, signing, provenance and registry sections together: they read best as one chain that ends at an enforcement point. Questions run from a junior explaining why an install step is already code execution to a principal asked to place a release process on a maturity ladder or to answer a customer's security schedule clause by clause.

primer

A few ideas carry the whole subject. Hold these and most questions below become applications of them rather than facts to memorise. - **The artifact is the unit of trust, not the repository.** What runs in production is built bytes, and everything between a clean commit and those bytes (build scripts, plugins, base images, resolved dependencies, the delivery path) can change them. Reviewing source is necessary but not sufficient on its own, which is why the subject keeps asking three things about an artifact: which exact bytes, produced by what, from which inputs. - **Evidence is not enforcement.** Signatures, provenance, SBOMs and scan reports are claims. They protect nothing until some consumer checks them against a policy written before the artifact arrived and refuses whatever fails. A common real-world gap is an estate that produces all of this evidence and has no gate that reads it. - **Each piece of evidence answers one question.** A signature says who vouched for these bytes. Provenance says how and where they were built, and from which source. An SBOM says what is inside. VEX says whether a known flaw matters in this product. A scanner says which published advisories match the versions it found. Interviewers listen for candidates who let one of these stand in for another. - **Identity is replacing the stored secret.** Keyless signing, trusted publishing and OIDC federation from CI to the cloud all swap long-lived keys and tokens for short-lived credentials minted for a workload identity. No long-lived credential is left to steal, but risk moves to whoever can get that identity issued, and to how precisely the verifier pins it. - **Pin by content, not by name.** Tags, version ranges, branch names and download URLs are mutable pointers; a digest fixes bytes. A pin covers only what it names, though, so anything fetched at run time sits outside it. - **Prioritise by exposure, not by count.** Scanners produce volume. The engineering work is deciding what matters: whether the component is in the deployed artifact at all, whether attacker input can reach the flawed code, whether the flaw is exploited in the wild. A severity score describes the flaw, not your system. - **Installing and building can execute code.** Install hooks, build plugins and some serialised file formats run code the moment they are processed. Once something malicious has run, the response is about what it could read and what it produced, not only about removing it.

Software composition analysis
Tooling that inventories the open-source packages a project resolves and matches each identity and version against vulnerability advisories and license data.
Transitive dependency
A package you never declared that arrives because something you did declare needs it; usually the bulk of a dependency graph and of its findings.
Lockfile
A file recording the exact versions, and often hashes, a package manager resolved, so later installs reproduce that graph instead of re-resolving ranges.
Dependency confusion
An attack where a public package reuses the name of a private internal one, so a build that consults both sources resolves the attacker's copy.
Typosquatting
Publishing a malicious package under a name one keystroke or a plausible variation away from a popular one, waiting for mistyped installs.
Software bill of materials
A machine-readable inventory of the components in an artifact, with identifiers, versions and relationships; SPDX and CycloneDX are the two common formats.
VEX
Vulnerability Exploitability eXchange: a statement, usually from a supplier, that a given product is or is not affected by a specific vulnerability, with a justification.
Package URL (purl)
A component identifier built from ecosystem, namespace, name and version, derived from where the package came from rather than assigned from a dictionary.
Content digest
A cryptographic hash of an artifact's bytes, used as an immutable address; unlike a tag or version label it cannot be repointed at other content.
Provenance attestation
A signed statement describing how an artifact was built: which builder, from which source and revision, with which parameters, bound to the artifact's digest.
in-toto statement
The envelope format attestations use: a subject naming artifacts by digest, a predicate type, and a predicate carrying the claim such as provenance.
SLSA build level
A rung on SLSA's build track describing how hard provenance is to forge, from merely existing to being generated by an isolated builder the build cannot influence.
Keyless signing
Signing with a single-use key whose public half is certified for a short time against an OIDC identity, so no long-lived private key must be kept.
Transparency log
An append-only, publicly auditable log of signing events whose entries and inclusion proofs let anyone confirm when and by whom something was signed.
Trusted publishing
A registry accepting releases from a named CI workflow by verifying its short-lived OIDC token, replacing stored long-lived publish tokens.
Admission control
A gate in the deploy platform that evaluates each workload before it starts and refuses those whose images fail policy, such as a missing valid signature.
Hermetic build
A build that runs only on inputs declared and pinned in advance, with access to anything undeclared cut off for its duration.
EPSS and KEV
Two exploitation signals: EPSS estimates the probability a vulnerability is exploited soon; the KEV catalogue lists vulnerabilities already seen exploited in the wild.

Read the sections as one chain from a developer's laptop to a running workload, with each section owning a hop and the evidence that crosses it. **Attack vectors frame everything else.** Every later section is a defence against one of the entry points catalogued there: a malicious or hijacked package, a person whose account or trust is abused, or machinery that builds or delivers the artifact. When an interviewer names a control, the strong answer starts by saying which entry point it closes and which it leaves open. **Inputs: dependencies and their inventory.** [Dependency risk](/topics/sec-supply-chain-dependency-risk) covers choosing, scanning, triaging and updating what you pull in. [SBOM and VEX](/topics/sec-supply-chain-sbom) turn that knowledge into a record that outlives the build and can be shared with customers, so the question "are we affected?" is answered by a query rather than a scramble. The two lean on the same identifiers, which is why naming components correctly sits underneath both. **Transformation: the pipeline.** [Pipeline hardening](/topics/sec-supply-chain-pipeline-hardening) treats CI as production infrastructure with its own attack surface: untrusted event data, job credentials, third-party steps and reused runners. It is also where evidence is produced, so a weak pipeline weakens every attestation it emits. **Evidence and its consumer.** [Signing](/topics/sec-supply-chain-signing) binds an identity to bytes; [provenance](/topics/sec-supply-chain-slsa-provenance) binds those bytes to a builder and a source, and the SLSA levels grade how much the claim can be trusted. [Registry and image trust](/topics/sec-supply-chain-registry-trust) is where both are finally checked: how an artifact is addressed, where its trust material is discovered, and which gate refuses it. Without that last hop the first two are paperwork. **The frame around the chain.** [Standards and regulation](/topics/sec-supply-chain-standards) name the practices above and attach procurement or legal consequences to them, which is how they reach a team's backlog. [Publishing and disclosure](/topics/sec-supply-chain-publishing-disclosure) is the same chain seen from the other end: once you publish, you are somebody else's dependency, and their controls depend on how you release, retract and report.

  1. Supply Chain Attack Vectors →

    Start with how real attacks got in; every control in the later sections is judged by which of these entry points it closes.

  2. Dependency Risk & SCA →

    Most daily work is here: knowing what you depend on, deciding which findings matter, and keeping upgrades from piling up.

  3. SBOM & VEX →

    Turns dependency knowledge into a durable, shareable inventory, and introduces the component identifiers every later section relies on.

  4. Build Pipeline Hardening →

    The build is both an attack surface and the producer of all evidence, so secure it before trusting what it signs.

  5. Artifact Signing & Sigstore →

    Learn exactly what a signature binds and what it cannot say, before layering build provenance on top of it.

  6. Registry & Image Trust →

    Closes the chain: where signatures and provenance are actually checked, and what refuses an artifact that fails.

  • Treating a valid signature as proof an artifact is safe; it names who vouched for the bytes, not whether that party was honest or still in control.

  • Verifying a signature or attestation without pinning the expected signer identity and issuer, so any identity the trust root accepts passes the check.

  • Ranking remediation by severity score alone instead of by exposure: whether the component ships, whether attacker input reaches it, whether it is exploited.

  • Calling a dependency or CI step pinned when it is pinned to a tag, branch or version range; only a digest fixes the bytes.

  • Removing a malicious package and moving on, without rotating the credentials it could read or rebuilding the artifacts produced while it was installed.

  • Generating SBOMs, provenance and signatures in the pipeline with no gate anywhere that reads them and refuses a failing artifact.

  • Giving workflows triggered by outside contributions access to secrets or write tokens, or pasting branch names and PR titles straight into shell steps.

  • Assuming an image scan covers application dependencies, or that a lockfile scan covers operating-system packages; each sees a different inventory.

  • Reading a high SLSA level as a statement about vulnerable dependencies; the build track grades how an artifact was produced, not what it contains.

  • Describing a regulation's duties without knowing whom it binds and how it reaches a vendor, for example through procurement rather than directly.

The same few decisions come up in nearly every section, and naming the one you are making usually earns more credit than naming a tool. - **Coverage versus accuracy.** A broad inventory with wrong versions misleads every lookup that relies on it; a narrow, exact one with a stated boundary can be extended. Interviewers want to hear which you would rather defend. - **Update velocity versus review.** Automated dependency updates close known flaws quickly and keep upgrade distance short, but merging them unread also imports whatever a compromised maintainer just shipped. Cooldown periods, grouping and risk-based auto-merge are the usual middle ground. - **Stored keys versus keyless identity.** A long-lived key is simple to reason about and painful to guard, rotate and revoke. Keyless flows remove the key and add dependence on an identity provider, a certificate authority and a transparency log someone must monitor. - **Audit versus enforce.** Blocking enforcement is the only mode that stops anything, and switching it on blind takes down whatever nobody inventoried. Running in audit first, with a time-limited exception path, trades a delay for a known blast radius. - **Consume directly versus mirror.** Pulling from public registries is cheap; keeping your own copy behind a proxy costs storage and upkeep but survives yanked releases and gives policy a single chokepoint. - **Minimal images versus debuggability.** Stripping shells and package managers shrinks what an attacker can use after a breach, and also what an on-call engineer can use during one. - **Embargo length versus user exposure.** A longer coordinated window gives maintainers time to fix; a shorter one limits how long users stay exposed without knowing.

A handful of shapes recur under different names across the sections; spotting one is the fastest way to place an unfamiliar question. - **Produce, attach, verify, refuse.** Signatures, provenance, SBOMs and VEX all follow the same lifecycle, and questions about any of them usually turn on the last two steps: who verifies, and what happens on failure. - **Separate the actor from the authority.** The build should not write and sign its own provenance, an author should not approve their own change to a privileged path, and a job running untrusted code should not hold release credentials. Many hardening questions reduce to finding where one party holds both roles. - **Swap a stored secret for a short-lived identity.** Trusted publishing, keyless signing and CI-to-cloud federation are one move made three times. The follow-up is usually about which claims the receiving side checks. - **Pin, then watch the pin.** Digests for images, commit hashes for CI steps and lockfile hashes for packages fix what you run. The next question is what drifts outside the pin and how pins get refreshed without becoming stale. - **Data that is really code.** Install hooks, pickled model files, piped install scripts and build plugins all execute on load. Treat any input that runs on processing as a dependency with full privileges. - **Measure blast radius before acting.** Audit-mode admission, a queryable component inventory and exposure-ordered triage all answer "what does this touch?" before anything is changed, which is the habit senior answers show.

explore

report an issue with this guide →

questions

328 · 9 sections

How can a build produce a backdoored artifact when every source file is clean?

level: juniorimportance: must knowfreq 64%
basics
~20 s

Because the artifact is made by the build, not by the repository. Anything that runs during the build - a build script, a plugin, a build-time dependency, the compiler image, a packaging step - can add code that appears in no source file.

open as a page

A team installs its internal CLI by piping a hosted install script into a shell - what supply chain risk does that create?

level: juniorimportance: must knowfreq 66%
basics
~20 s

It runs whatever that URL returns at that moment, with the caller's full privileges and no version, review or integrity check. Anyone who can write to the hosting location therefore runs code on every laptop and every CI job.

open as a page

In SUNBURST, xz-utils, event-stream, Codecov and ua-parser-js, what was each entry point?

level: juniorimportance: must knowfreq 70%
basics
~20 s

Five different doors. SUNBURST came through a compromised build system, xz-utils through a contributor who earned maintainer trust, event-stream through inherited maintainership, Codecov through a tampered delivery script, and ua-parser-js through a stolen publisher account.

open as a page

Why does installing an npm dependency execute that package's code before your build starts?

level: juniorimportance: must knowfreq 72%
basics
~20 s

Many package managers let a package declare install hooks, scripts the manager runs automatically as part of installing it. Installing is therefore code execution, not a file copy, and it happens before your tests or scanners ever run.

open as a page

Why is installing a PyPI package your AI assistant suggested but nobody recognises risky?

level: juniorimportance: must knowfreq 62%
basics
~20 s

AI assistants invent plausible package names that were never published. Attackers collect those hallucinated names, register them on the public index, and wait for someone to install one. The name looks right precisely because a model generated it.

open as a page

What do the OSV, NVD and GHSA advisory databases each assert about a vulnerable package?

level: juniorimportance: must knowfreq 62%
basics
~20 s

NVD enriches a CVE record with a severity score and product applicability. GHSA describes the flaw per package ecosystem with a package name and affected version range. OSV is a schema and aggregator normalising many feeds into ecosystem-native ranges.

open as a page

Why does changing one line inside a committed lockfile count as a code change?

level: juniorimportance: must knowfreq 60%
basics
~20 s

A lockfile line names the exact package version, the source it is fetched from and the bytes accepted as that release. Editing it swaps different executable code into the build, with no source-file diff to review.

open as a page

What does a dependency's scope (test, build, runtime) change about whether a vulnerability finding is exploitable?

level: juniorimportance: must knowfreq 74%
basics
~10 s

Scope says where a package is needed, so it decides whether the package is in the artifact you deploy. A test-only library is absent from production and a production attacker cannot reach it.

open as a page

What do you check about an open-source library before adopting it in a production service?

level: juniorimportance: must knowfreq 72%
basics
~20 s

Check how many people really maintain it, whether releases and patch fixes still ship, whether it publishes a way to report a flaw privately, what the license is, how large the transitive tree is, and how much of it you actually need.

open as a page

What does an EPSS score of 0.08 on a CVE actually tell you about that vulnerability?

level: juniorimportance: must knowfreq 62%
basics
~10 s

EPSS estimates the probability a vulnerability will be exploited in the wild within 30 days. A score of 0.08 means roughly an 8 percent chance. It forecasts likelihood, not how damaging the flaw is.

open as a page

Why keep a queryable SBOM estate instead of regenerating SBOMs when an advisory lands?

level: juniorimportance: must knowfreq 58%
basics
~20 s

A stored, queryable estate answers 'where do we run this component, and at what version' in seconds. Regenerating means rebuilding every service at its deployed commit, which is slow and describes today's source rather than what is actually running.

open as a page

A vendor gave you an SBOM once at contract signature — what is it still worth a year on?

level: juniorimportance: must knowfreq 55%
basics
~20 s

Little, as a live inventory. An SBOM describes one build at one moment, so after a year of vendor releases it need not match the version you run. It survives as a baseline and as proof the vendor can produce one.

open as a page

In VEX, what are the four product statuses a statement can assign, and what does each claim?

level: juniorimportance: must knowfreq 58%
basics
~10 s

VEX defines four statuses for a product-and-vulnerability pair: not_affected, affected, fixed, and under_investigation. They state whether a known vulnerability is actually exploitable in that product, not whether the flawed component is present.

open as a page

In an SBOM, how does a purl differ from a CPE as a component identifier?

level: juniorimportance: must knowfreq 70%
basics
~20 s

A purl is a coordinate computed from where a package actually came from: ecosystem, namespace, name, version. A CPE is a string from a curated dictionary that a human assigns, so it is often missing, duplicated or ambiguous.

open as a page

What does Syft do when you point it at a container image, and what does it not report?

level: juniorimportance: must knowfreq 68%
basics
~10 s

Syft unpacks the image's layers, runs per-ecosystem catalogers over the resulting filesystem to list installed packages, then serialises that list as SPDX or CycloneDX. It reports what is present, not whether anything is vulnerable.

open as a page

What does an npm provenance attestation assert about a package, and what does it not?

level: juniorimportance: must knowfreq 55%
basics
~20 s

It binds a published tarball's digest to the source repository, commit and CI workflow that built it, signed by that build's identity. It says nothing about whether the code is reviewed, safe, or free of vulnerabilities.

open as a page

In Sigstore's keyless flow, what does a Fulcio certificate bind, and how long is it valid?

level: juniorimportance: must knowfreq 55%
basics
~20 s

A Fulcio certificate binds a one-time public key, generated locally at signing time, to the OIDC identity and issuer in the token you presented. It stays valid for roughly ten minutes, so no signing key is ever stored.

open as a page

What does verifying a detached GPG .asc signature on a release tarball actually prove?

level: juniorimportance: must knowfreq 62%
basics
~20 s

It proves the file is byte-for-byte what the holder of that private key signed. It does not prove the key belongs to the project, that the build was clean, or that the code is safe.

open as a page

In keyless artifact signing, what happens to the private key that produced the signature?

level: juniorimportance: must knowfreq 62%
basics
~10 s

Keyless signing still uses a private key, but it is generated for that one signing operation and destroyed immediately afterwards. Nothing long-lived is left behind to store, guard, rotate, or lose.

open as a page

A vendor's Helm chart carries a valid signature from the vendor's release identity. What does that prove about the chart's behaviour?

level: juniorimportance: must knowfreq 80%
basics
~10 s

Nothing about behaviour. A signature binds a signer identity to one exact set of bytes: it says who vouched for them, not that the chart's contents, defaults or dependencies are safe to install.

open as a page

A firmware binary carries a valid vendor signature: what does that prove, and what can it not tell you?

level: juniorimportance: must knowfreq 66%
basics
~20 s

A valid signature proves only that the bytes are unchanged since signing and that a named identity vouched for them. It says nothing about which components are inside the binary or which source revision and build produced it.

open as a page

Why is build provenance from a long-lived, reused build machine worth less than from a single-use builder?

level: juniorimportance: must knowfreq 62%
basics
~20 s

A reused machine keeps state from earlier builds - caches, installed tools, leftover credentials, running processes - so an earlier job could have altered this build or what was recorded about it. A single-use environment removes that whole class of doubt.

open as a page

Does SLSA Build L3 provenance mean an artifact has no known vulnerable dependencies?

level: juniorimportance: must knowfreq 62%
basics
~10 s

No. The SLSA build track attests to how an artifact was produced and by which builder, not to what is inside it or whether those components are flawed. Vulnerable dependencies are a separate question.

open as a page

Your pipeline generates a provenance attestation for every build — what still has to happen for that to protect anything?

level: juniorimportance: must knowfreq 74%
basics
~20 s

A provenance statement proves nothing until something checks it. The control is a consumer verifying the statement against expectations fixed in advance and refusing the artifact when the check fails. Unverified attestations are metadata, not protection.

open as a page

When verifying build provenance, what does a consumer compare it against?

level: juniorimportance: must knowfreq 74%
basics
~20 s

Verification compares the statement against expectations written down in advance: the builder identity that produced the artifact, the source repository and revision it was built from, the build entry point, and the subject digest matching the artifact you actually hold.

open as a page

What does a default-deny outbound network policy on a build job actually prevent?

level: juniorimportance: must knowfreq 60%
basics
~20 s

Default-deny outbound stops build-time code reaching unapproved hosts: no exfiltrating secrets or source, no pulling a second-stage payload. It does not make a malicious dependency safe - the code still runs and can still corrupt the artifact.

open as a page

In a CI pipeline, which parts of the triggering event are attacker-controlled, and which are not?

level: juniorimportance: must knowfreq 68%
basics
~20 s

Anything a person typed is attacker-controlled: branch and tag names, commit messages, git author names, issue and comment bodies, pull request descriptions. Commit hashes, the repository name and the event type are produced by the platform, not by the submitter.

open as a page

When a fork's pull request triggers CI, what decides whether that run can read the base repository's secrets?

level: juniorimportance: must knowfreq 70%
basics
~20 s

The trigger event, and whose context it runs in. Runs in the fork's context get no repository secrets and a read-only token; a second family of events runs in the base repository's context with full secrets and a write token.

open as a page

What makes a build hermetic, and why is a hermetic build not automatically deterministic?

level: juniorimportance: must knowfreq 68%
basics
~20 s

A hermetic build declares and pins every input before it starts and fetches nothing while it runs. It can still emit different bytes on each run, because embedded timestamps, absolute paths and file ordering vary independently of the inputs.

open as a page

Why should a CI build's automatic job token be scoped per job rather than per repository?

level: juniorimportance: must knowfreq 63%
basics
~20 s

A repository-wide grant is the ceiling for every job in it, so a docs-preview job inherits whatever the deploy job needs. Per-job scoping means code running in a low-value job cannot touch the release path.

open as a page

What does a shell and a package manager inside a container image give an attacker after a code-execution bug?

level: juniorimportance: must knowfreq 70%
basics
~20 s

They turn one code-execution bug into a working foothold: the attacker can explore the filesystem, read mounted credentials, fetch more tooling and pivot. An image holding only a static binary forces them to bring everything themselves.

open as a page

A change board approved an image by sha256 digest but the deployment names a mutable tag - what is the risk?

level: juniorimportance: must knowfreq 70%
basics
~20 s

The approval is not attached to what runs. Anyone able to push to that repository can re-aim the tag at different bytes, so the next pull fetches an image nobody reviewed, with no change to the deployment.

open as a page

Your pipeline signs every container image but nothing verifies the signature — what does that buy you?

level: juniorimportance: must knowfreq 62%
basics
~20 s

Almost nothing on its own. A signature is only a claim until something refuses an artifact whose signature is missing or wrong. The value appears at the enforcement point: a pipeline gate, admission, or pull-time policy.

open as a page

Why does loading a model checkpoint saved as a Python pickle execute code, while safetensors does not?

level: juniorimportance: must knowfreq 58%
basics
~20 s

Pickle files carry executable instructions: unpickling can call arbitrary Python code while it rebuilds objects. A safetensors file holds only raw tensor bytes plus a JSON header, so loading it parses data and never runs code from the file.

open as a page

Why turn on image signature enforcement in audit mode before it starts blocking deploys?

level: juniorimportance: must knowfreq 66%
basics
~20 s

Audit mode records which images would have been rejected without rejecting anything. That record is the blast radius: it exposes unsigned images, registries nobody documented and workloads with no owner, before a blocking rule takes production down.

open as a page

What does US Executive Order 14028 require from a company selling software to a federal agency?

level: juniorimportance: must knowfreq 65%
basics
~20 s

EO 14028 binds federal agencies, not vendors directly. It reaches sellers as a procurement condition: an agency may buy software only from a producer who attests to following NIST secure-development practices, and the agency may also require an SBOM.

open as a page

Under the EU Cyber Resilience Act, which products and companies are in scope?

level: juniorimportance: must knowfreq 68%
basics
~20 s

The CRA covers products with digital elements: hardware or software placed on the EU market, including firmware and components. The manufacturer, whoever sells it under their own name, carries the duties; importers and distributors carry lighter ones.

open as a page

What are the four practice groups in the NIST SSDF (SP 800-218), and what does each cover?

level: juniorimportance: must knowfreq 62%
basics
~20 s

SSDF has four groups: Prepare the Organization (PO), Protect the Software (PS), Produce Well-Secured Software (PW), and Respond to Vulnerabilities (RV). They cover org readiness, protecting code and releases, building software securely, and handling flaws found after release.

open as a page

How do you turn a customer's 200-line security schedule into a clause-by-clause answer?

level: middleimportance: must knowfreq 60%
basics
~20 s

Sort every clause into four buckets: already satisfied, partly satisfied, a real gap, or refused. For each satisfied clause name the evidence artifact, cost each gap in engineer-months, and get vague scope agreed in writing before signature.

open as a page

What triggers the EU Cyber Resilience Act's 24-hour early-warning report?

level: middleimportance: must knowfreq 62%
basics
~20 s

Becoming aware that a vulnerability in your product is being actively exploited, or that a severe incident affects its security. Within 24 hours you send an early warning to the coordinating national CSIRT and ENISA - not a public advisory.

open as a page

For a package registry account, why is a passkey phishing-resistant but a TOTP code not?

level: juniorimportance: must knowfreq 70%
basics
~20 s

A passkey signs a challenge bound to the registry's real domain, so a lookalike login page cannot relay it. A TOTP code is just six digits, which an attacker proxying your login replays within seconds.

open as a page

What is trusted publishing on a package registry, and how does it differ from a long-lived API token?

level: juniorimportance: must knowfreq 63%
basics
~20 s

Trusted publishing lets a registry accept a release from one specific CI workflow by verifying a short-lived OIDC identity token, instead of a long-lived API token stored as a CI secret. No reusable credential exists to steal.

open as a page

What does deprecating a published npm version do, and how does that differ from unpublishing it?

level: juniorimportance: must knowfreq 62%
basics
~20 s

Deprecating leaves the version fully installable and only attaches a message the registry shows at install time. Unpublishing removes the version so it can no longer be downloaded. One is a signal, the other is a withdrawal.

open as a page

When you publish a security advisory for your own library, what must it state about affected and fixed versions?

level: juniorimportance: must knowfreq 40%
basics
~20 s

Name the package identity in its ecosystem, the version where the vulnerable code was introduced, and the first fixed version on every release line you maintain. Ranges must be structured data, not prose like 'all earlier versions'.

open as a page

What is coordinated vulnerability disclosure, and how does it differ from full disclosure?

level: juniorimportance: must knowfreq 66%
basics
~20 s

Coordinated disclosure means the finder reports privately and gives the maintainer an agreed window to ship a fix before details go public. That window is the embargo. Full disclosure publishes the details straight away, with no window.

open as a page