Table of contents

AI supply chain attacks: Old payloads, new entry points

Old payloads New entry points

There’s a strange thing happening in AI supply-chain security right now. We keep talking about AI as though every risk it introduces must also be new.

It isn’t.

Malicious packages aren’t new. Typosquatting isn’t new. Dependency confusion isn’t new. Credential theft certainly isn’t new.

But put AI into the development workflow and something important changes.

The way developers reach those threats.

A developer no longer has to search for a package, find it in a repository, or even know it exists. They can describe what they’re trying to build to an AI coding assistant and get code, dependencies, and recommendations back in seconds.

That is an incredible productivity shift.

It’s also a new entry point into the software supply chain.

The payload may be old. The entry point is new.

That’s the idea Gil Regev and I explored in our recent webinar, Hunting the AI Supply Chain. And once you start looking at AI-assisted development through that lens, a lot of the conversation around AI security starts to look different.

AI didn’t replace the software supply chain. It joined it.

Think about how developers traditionally choose what goes into an application.

They know a library. They search documentation. They find something on GitHub. They look through a package registry. Someone on their team recommends it.

Now there’s another voice in that process.

AI.

And increasingly, developers aren’t just asking AI to explain code. They’re asking it how to build something.

That means AI can influence the code that gets written, the packages that get selected, and the dependencies that ultimately enter an application.

The security implication isn’t that every AI recommendation is dangerous. It isn’t.

The implication is that we’ve introduced another path between a developer’s intent and the software that eventually executes.

Attackers pay attention when new paths appear.

Old attacks look different when AI is in the middle

This is where the conversation gets interesting.

During the webinar, Gil and I looked at five familiar software supply-chain threats and then introduced AI as the sixth variable.

The first five haven’t suddenly become obsolete because developers started using AI. If anything, AI gives us another reason to understand how those attacks actually work.

Take a malicious package.

The obvious security question is whether the package itself is malicious.

But that’s only the beginning.

Where does it execute?

What can that environment access?

Are there credentials there? Tokens? Source code? Cloud permissions? CI/CD secrets?

A malicious dependency sitting somewhere in a registry isn’t the same risk as that dependency executing inside an environment with valuable credentials.

So instead of stopping at:

“Is this package malicious?”

we need to start asking:

“What happens if it executes here?”

That shift — from identifying an object to understanding its execution path and potential blast radius — becomes increasingly important as AI accelerates how software is assembled.

And then AI gives us another problem entirely.

What happens when AI recommends something that doesn’t exist?

This was one of my favorite parts of our webinar because it demonstrates just how strange the AI supply chain can become.

LLMs can hallucinate package names.

Sometimes those names sound completely legitimate. A developer asks how to solve a problem, the model recommends a package, and the recommendation fits naturally into the answer.

Except the package doesn’t exist.

At least, not yet.

If an attacker finds that models repeatedly hallucinate the same package name, they can register it and put something behind the recommendation.

Now the next developer who receives that hallucination isn’t being directed toward nothing.

They’re being directed toward a real package controlled by someone else.

That’s slopsquatting.

And there’s an important distinction here: the hallucination isn’t necessarily the attack.

The attack happens when someone turns that hallucination into an opportunity.

AI creates the path.

The attacker occupies it.

The developer may complete it.

That’s a very different way of thinking about software supply-chain risk.

Follow the path

This is why I don’t think the most useful AI security conversation is simply, “How do we secure the model?”

Of course, model security matters.

But applications built with and around AI still have dependencies. They still have credentials. They still use APIs. They still execute code. They still run through build pipelines and production environments.

And now models, agents, coding assistants, and AI-generated recommendations are becoming part of those systems too.

So the attack surface isn’t disappearing.

It’s expanding.

For AppSec teams, that means the job isn’t to throw away everything we’ve learned about software supply chain security and start over.

It’s to understand where AI creates new paths through an attack surface we already know.

Because sometimes the most important thing about an AI security threat isn’t a brand-new payload.

It’s a brand-new way of getting there.

The payload is old. The entry point is new.

In Hunting the AI Supply Chain, Gil Regev and I go much deeper into what those paths actually look like. We cover malicious packages, typosquatting, dependency confusion, compromised packages, slopsquatting, and what changes when AI becomes part of the development workflow.

If you’re trying to understand where traditional software supply-chain security ends and AI security begins, that’s exactly the line we went hunting for.

Watch Hunting the AI Supply Chain on demand.

Increase visibility and control over the AI components in your applications

Mend AI

Recent resources

ISO 42001

ISO 42001 explained: Requirements, annexes & best practices

What ISO 42001 requires, its annexes, and five best practices for readiness.

Read more
Featured image Docker Mend Secures

Your AI agent is sandboxed. Its data still needs guardrails.

Docker Sandboxes contains your agent. Mend AI Guardrails checks what it sends.

Read more
Scalable Agent Security Posture Management

Best scalable agent security posture management solutions: Top 12 in 2026

12 tools that discover, secure, and govern AI agents at scale.

Read more