Exploits Now Beat Patches: Open Source Security in the AI Era - Patrick Smyth, Chainguard

Loading slides…

Read the talk

When Exploits Beat Patches: Open Source Security in the AI Era

Patrick Smyth explains why faster attacks require more than shorter patch deadlines: separate malware from vulnerabilities, protect the development pipeline, verify artifact handoffs, and reconsider how third-party code reaches your systems.

From a talk by Patrick Smyth

At a glance

Ideas worth remembering

  • A remediation schedule is not a period of safety. Smyth's presented timing comparison puts average exploitation before patch availability, while a 30-day internal deadline can extend exposure further.

  • Separate malware, known vulnerabilities, zero-days, and side doors. Package cooldowns, rapid fixes, and pipeline protections address different failure modes.

  • Apply controls where dependencies are consumed. A production package cooldown does not protect a developer laptop that downloads the same new package without one.

  • Wolfi's rolling updates and one-to-four daily image rebuilds support a different remediation model: Chainguard states one day for known exploited vulnerabilities, seven for criticals, and fourteen for everything else.

  • Sign artifacts and verify them at receiving stages. Rebuilding packages from clean source separately addresses compromise in the upstream build-and-distribution path; it does not inherently make the source safe.

  • Treat third-party and internal agent skills as supply-chain inputs. Deliberately malicious skills and unintentionally insecure skills are distinct problems, and both matter before wide reuse.

AI gives attackers more than faster code

A single attacker can use an AI assistant to choose targets, organize an operation, write attack code, and draft ransom letters. Patrick Smyth, speaking as a Chainguard employee, opens with reported incidents that put this expanded capacity ahead of any product discussion. The concern is not simply that malicious scripts become easier to write. Work that once required several kinds of expertise can fit into one person's workflow.

Three reported incidents illustrate how AI assistance expands attackers’ capabilities.Open full source frame
Three reported incidents illustrate how AI assistance expands attackers’ capabilities.
  • A teenager with scripts: Smyth describes a 17-year-old in Osaka using ChatGPT to write scripts and exfiltrate roughly 4.25 million records from a Japanese internet café business, then using a stolen credit card to buy Pokémon cards. The juxtaposition is part of the point: operational capacity need not come with mature judgment.
  • A campaign with many targets: He cites FunkSec as an example of a reportedly semi-technical operator reaching 85 targets over a few months.
  • An assistant across the whole operation: Another unidentified individual reportedly used Claude Code against 17 organizations spanning healthcare, government, and major corporations. The assistant's role extended from attacks to target selection, file organization, and ransom correspondence.

Smyth's shorthand is that everyone goes “a level up”: an engineer can operate more like a team, and a team can approach the capacity associated with an advanced persistent threat. This is a threat-model analogy, not a measured conversion between attacker categories. Its practical meaning is that defenders cannot assume yesterday's limits on an individual attacker's time, specialization, or coordination still apply.

0:121:12
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:12 · section reference included

The patch window has crossed zero

How much time separates a patch from exploitation? Smyth’s slide compares exploited vulnerabilities Mandiant tracked, using the vendor’s patch release as day zero. For 2018–19, it reports that exploitation came an average of 63 days after release. For 2025, it shows an estimated average of seven days before release. Smyth calls the average noisy. The slide gives no sample sizes or calculation details that would turn seven days into a deadline for an individual vulnerability.

The slide contrasts a 63-day patch window in 2018–19 with exploitation seven days before a patch in 2025; these are speaker-presented averages.Open full source frame
The slide contrasts a 63-day patch window in 2018–19 with exploitation seven days before a patch in 2025; these are speaker-presented averages.

The important relationship is the reversal in ordering. A positive interval offers some opportunity to deploy a fix before an attack. A negative interval means that even immediate adoption of an available patch cannot prevent all earlier exposure. Smyth connects the earlier narrowing to software spreading into more institutions—his example is hospitals using Python—and the sharper recent change to frontier AI. The timing comparison motivates that concern, but does not by itself isolate AI's contribution.

The familiar remediation process still looks sensible on paper. Run a scanner such as Grype or Trivy against the software stack, collect known vulnerabilities identified as CVEs, sort them by severity, and send the findings to a team with an allotted time to fix them. The failure is temporal: a 30-day allowance can leave a vulnerable system exposed long after attackers have started using the weakness.

“Thirty days may as well be a million years” captures the mismatch. Organizations still need a remediation cadence, but the cadence cannot be mistaken for protection during the waiting period. Smyth identifies pressure from both sides: attackers act quickly on publicly known vulnerabilities, while newly discovered, previously unknown vulnerabilities create exposure before the normal scanner-to-ticket process can help.

2:423:12
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

2:42 · section reference included

Malware spreads through shared dependencies

A separate problem sits alongside exploitable bugs: deliberately malicious software entering the dependency supply chain. Smyth used to illustrate the frequency of supply-chain attacks with a meme calendar containing one major incident per month. He now jokes that he could almost fill one daily. Shai-Hulud, a worm originating in the JavaScript ecosystem, is his example of a successful pattern spawning copycats, including SANDWORM_MODE. The Dune reference earns a brief aside: a worm named after a worm.

Which kinds of dependencies became attack vehicles? Smyth groups incidents affecting Trivy, the vulnerability scanner; LiteLLM, an agent-related routing layer; and Axios. He places those three incidents in March 2026 and reports that the Axios supply-chain attack was live for only two hours yet accumulated 600,000 downloads. That count describes downloads during the exposure he cites, not 600,000 independently established compromises.

Shai-Hulud, Trivy, LiteLLM and Axios illustrate successive supply-chain malware incidents.Open full source frame
Shai-Hulud, Trivy, LiteLLM and Axios illustrate successive supply-chain malware incidents.

The causal mechanism is dependency reuse. Compromise one participant, and the software other participants consume can become a route into their systems. Those newly compromised systems can expose still more dependencies and organizations. A brief publication window can therefore have a large reach: downstream automation keeps fetching software while the malicious release is available. This is why malware deserves its own treatment rather than being folded into a queue of ordinary bug fixes.

5:135:43
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

5:13 · section reference included

Upstream trust meets downstream responsibility

Agents accelerate work on both sides of this supply chain. The same assistance that helps a developer make software also helps an attacker produce and organize attacks. Smyth reaches for “Eternal September,” the old computing-community story in which recurring waves of newcomers disrupt established norms. His use of the analogy is about trust: an environment built around cooperative assumptions can become more adversarial without every participant changing how they work.

A supply-chain analogy connects upstream code, distribution, vendors and end users.Open full source frame
A supply-chain analogy connects upstream code, distribution, vendors and end users.

A software provider occupies an uncomfortable middle position. Users rely on its application and infrastructure, so it owes them care. Yet that provider also relies on upstream software it did not write and cannot fully vet. An upstream component can compromise both the provider and its users. Responsibility points downstream while much of the code arrives from upstream; that is the basic supply-chain problem Smyth wants the rest of the talk to address.

Several responses address different parts of that problem:

  • Package cooldowns: Delay adoption of newly published packages rather than consuming every release immediately. Smyth presents this as a defense against malware; he does not prescribe a duration.
  • Faster vulnerability fixes: Shorten the time known vulnerable components remain in use.
  • Signed artifacts: Sign software artifacts and verify them when they change hands, using mechanisms he later discusses through SLSA and Sigstore.
  • Developer operational security: Protect developer laptops as part of the supply chain, including the use of physical security keys.

These changes cost money and effort. They also depend on less glamorous infrastructure work. Containerization, CI/CD adoption, a golden-image program, and centralized container management make it more practical to apply changes consistently; unfinished foundations make later modernization harder. Smyth's recommendation is to finish those projects rather than leave them indefinitely in migration. AI may help teams catch up, but it does not remove the work.

6:447:14
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

6:44 · section reference included

Four attack surfaces need different defenses

The next distinction prevents a common category error: a defense that helps with one supply-chain threat may leave another untouched. Smyth separates four interacting surfaces. They are useful to reason about independently even though an actual attack can cross several of them.

The slide separates known CVEs, malware and zero-days from CI/CD compromise and the agent layer.Open full source frame
The slide separates known CVEs, malware and zero-days from CI/CD compromise and the agent layer.
  • Malware: An attacker deliberately introduces harmful code, as in the package incidents discussed earlier. A cooldown reduces immediate exposure to newly published releases; it does not repair a vulnerable component already in use.
  • Known vulnerabilities: Publicly catalogued weaknesses let an attacker match a software inventory against a vulnerability database. Many CVEs create noise, but dismissing the whole category also discards findings that matter. Noise makes prioritization harder; it does not make known weaknesses safe.
  • Zero-days: Previously unknown vulnerabilities fall outside the known-CVE workflow. Smyth emphasizes frontier models' ability to combine smaller weaknesses into an exploit, making it important to consider chains rather than only isolated severe findings.
  • Side doors: CI/CD systems, developer workstations, and the emerging agent layer offer routes around a well-protected production application. Misconfiguration, dependencies, and insufficient scrutiny can make these easier targets.

The developer-laptop example makes the last category concrete. An organization may enforce a package cooldown in its main delivery process while a developer fetches a fresh package locally to prepare work. The same package-age rule no longer protects that download. An attacker can target the workstation instead of confronting the production control. A policy's effectiveness therefore depends on where software is actually consumed, not merely where the policy was first installed.

CI/CD creates a similar gap when teams focus security attention on the application and overlook the machinery that builds it. The agent layer adds another changing entry point, where third-party material can influence agent or model behavior. These routes explain why a clean production vulnerability scan is an incomplete answer to supply-chain risk.

11:1311:43
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

11:13 · section reference included

Wolfi changes how fixes reach container images

Chainguard's product discussion maps onto those separate threats. Containers address known-vulnerability remediation; Libraries supplies packages rebuilt from source in place of direct consumption from PyPI, npm, or Maven Central; Athena provides a consortium-based clearinghouse for information about zero-days; and Actions and Agent Skills supply hardened versions of components used outside the production application. These are different interventions, not interchangeable ways of lowering a single score.

For containers, Smyth describes an offering with no known vulnerabilities. The word “known” matters: that claim concerns identified vulnerabilities, not proof that no undiscovered weakness exists. Athena addresses a different information problem. Chainguard works with banks and technology companies to collect information about zero-days and share it within the consortium; the mechanism described here is shared threat knowledge, rather than a public scanner discovering every unknown bug.

The obstacle to fixing container CVEs is the infrastructure iceberg. Application engineers control the code they write, but the operating system, language runtime, and other underlying components belong to much larger upstream projects. Smyth illustrates the imbalance with a deliberately made-up estimate of one or two percent application code. His memorable name for the resulting assignment is the “my boss told me to fix Ubuntu problem”: the team receives responsibility for weaknesses in systems it does not maintain.

Wolfi, Chainguard's Linux distribution, changes the update path. Its rolling model pulls upstream maintainer code quickly instead of sitting on stable versions, and Smyth reports image rebuilds one to four times a day. This prioritizes rapid incorporation of upstream changes over the stable-version approach he contrasts it with. Minimal images also reduce the amount of software present, which he presents as helpful against zero-days as well as known vulnerabilities.

How does that operating model translate into remediation commitments? Smyth gives a one/seven/fourteen-day SLA:

  • One day: Known exploited vulnerabilities.
  • Seven days: Critical vulnerabilities.
  • Fourteen days: Everything else.

The comparison with 30/60/90-day schedules is not only about the most severe findings. The final category includes medium- and low-severity issues that, in his experience, many teams would never triage. The frequent rebuilds describe the update machinery; the SLA states the promised remediation timing for different classes of finding.

Chainguard’s presented remediation SLA: one day for known-exploited vulnerabilities, seven days for critical issues and fourteen days for everything else.Open full source frame
Chainguard’s presented remediation SLA: one day for known-exploited vulnerabilities, seven days for critical issues and fourteen days for everything else.
13:4314:13
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

13:43 · section reference included

Sign the handoffs—and reconsider the build path

An artifact can be altered somewhere between source code and the software a user receives. Tags, download pages, dependencies, and pipeline stages all appear in Smyth's list of places attackers can interfere. His recommendation is to sign at creation and verify at receipt: whenever an artifact is produced, sign it before passing it on, then check the signature at the other end.

Sigstore supplies useful signing machinery; SLSA brings provenance into the discussion. Smyth describes attaching information about an artifact's origin, signing it cryptographically, and checking it in consuming pipelines. The useful distinction is between merely receiving a file and checking evidence about the file being received. Verification must happen at the receiving stage; producing signatures without checking them leaves that handoff unprotected by this mechanism.

Chainguard Libraries changes another relationship: which build-and-distribution system stands between upstream source and the consumer? Smyth's “airlift” analogy starts with clean source, lifts it out of the maintainer's CI/CD and distribution environment, and rebuilds it inside Chainguard's system. Consumers then obtain the resulting packages from Chainguard rather than the public package repositories.

The security benefit is specific to that route. Rebuilding from clean source can bypass tampering introduced in the maintainer's later build or distribution process. It does not, by that mechanism alone, remove malicious behavior already present in the source; “clean source” is a consequential premise. Chainguard also performs scanning and remediation triage, but Smyth identifies the separate build path as the distinctive structural intervention.

One source, two routes to the consumer

Upstream sourceThe rebuild mechanism starts with source assumed to be clean.
Maintainer CI/CDupstream-route — The upstream build environment sits between source and the distributed artifact.
Upstream distributionupstream-route — Published packages are consumed through repositories such as PyPI, npm, and Maven Central.
Chainguard build systemreplacement-route — Builds packages from the source, with additional scanning and remediation triage.
Chainguard Librariesreplacement-route — Supplies the rebuilt packages through replacement repositories.
Consuming organizationChanges where it obtains packages; the source project remains upstream.
Which upstream stages does rebuilding replace? The ordinary route uses the maintainer's build and distribution environment. The Libraries route takes source into Chainguard's build system and delivers its resulting packages instead. Arrows show software flow, not a claim that either route makes source code inherently safe.
Read the diagram as text
  • Upstream source. The rebuild mechanism starts with source assumed to be clean.
  • Maintainer CI/CD. upstream-route — The upstream build environment sits between source and the distributed artifact.
  • Upstream distribution. upstream-route — Published packages are consumed through repositories such as PyPI, npm, and Maven Central.
  • Chainguard build system. replacement-route — Builds packages from the source, with additional scanning and remediation triage.
  • Chainguard Libraries. replacement-route — Supplies the rebuilt packages through replacement repositories.
  • Consuming organization. Changes where it obtains packages; the source project remains upstream.
  • Upstream source → Maintainer CI/CD: Upstream build route.
  • Maintainer CI/CD → Upstream distribution: Builds for distribution.
  • Upstream distribution → Consuming organization: Direct repository consumption.
  • Upstream source → Chainguard build system: Source taken into a separate build system.
  • Chainguard build system → Chainguard Libraries: Produces rebuilt packages.
  • Chainguard Libraries → Consuming organization: Replacement repository consumption.
16:4317:13
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

16:43 · section reference included

The supply chain now includes agent skills

The final technical examples return to the side doors. Chainguard Actions offers hardened components that Smyth describes as drop-in replacements for GitHub Actions, with a free trial available at the time of the talk. The target is the delivery machinery itself: hardening the application does not address a compromised action used to build or release it.

Chainguard Agent Skills applies a similar upstream-to-hardened-distribution pattern to third-party skills. Skills enter a pipeline, pass through deterministic and agentic hardening steps, and are then supplied to users. Smyth does not enumerate those checks in this talk, so the described mechanism establishes where hardening happens without establishing what every check catches.

The distinction between malicious intent and insecure behavior matters here. Smyth reports that his recent analysis found roughly five percent of skills in upstream repositories actively malicious, compared with an earlier estimate around 20 percent, and another 30–40 percent with serious security issues despite not being intentionally malicious. The sample and method are not specified, so these are estimates from his analysis rather than established prevalence across all skills. They nevertheless explain why checking only for deliberate malware would leave a second class of problems untreated.

Organizations can also upload their own skills for hardening and make the results discoverable internally. That extends the same concern to institutional knowledge: an internally useful skill still needs security work before broad reuse. The distribution benefit and the risk travel together—once many people or agents can discover a skill, its behavior can spread well beyond its original author.

The closing mascot is Wolfi, a tiny octopus, which Smyth uses to return to minimalism: “Being minimal helps with zero days.” The useful security idea is smaller software scope, not a promise that a small image cannot be exploited. Alongside faster updates, checked handoffs, and hardened development inputs, minimalism is one more way to reduce the opportunities an attacker can combine.

13:1318:42
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

18:42 · section reference included

Resources

From the talk

  • Explore the replacement-package approach discussed in the talk: consume dependencies rebuilt from source rather than artifacts from the original distribution path.

  • AthenaReference14:13

    Follow up on the consortium approach to sharing zero-day information among participating financial and technology organizations.

  • Investigate the hardened CI/CD components Smyth presents as replacements for GitHub Actions.

  • Explore the skill-hardening offering discussed at the end, including the distinction between third-party skills and skills supplied by an organization.

Transcript download
Full transcript

Loading transcript…