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.
- 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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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 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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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 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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
- 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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
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.
Further reading
A practical next step for the signing discussion: examine Chainguard's documentation on SLSA and artifact provenance.
Related talks
- Gateways are All You Need
Extends the agent-side security discussion into MCP architecture: centralized authentication, permissions, and visibility address how agents reach enterprise tools and data.
- How to Know When an AI Agent Can Work Unsupervised — Evan Kormos, Coinbase
Complements hardened agent inputs with controls over execution: bounded autonomy, deterministic workflow gates, traceability, and human fallback.
Full transcript
Loading transcript…