Technology · 7 min read · November 13, 2026

Software Supply Chain Attacks: 7 Checks for Your System

In recent weeks, software supply chain attacks have been back in the headlines: attackers planted malicious code in thousands of repositories to steal passwords and cloud access keys. If your system uses third-party libraries, has an automated deploy pipeline, or stores keys in any repository, the risk is yours too, even if nobody has attacked your company. The good news is that seven simple checks, which most teams can complete in a few days, take your system out of the most exposed group.

Developer reviewing code on a laptop
Photo by Nate Grant on Unsplash

What happened in recent weeks

Researchers at the security company Socket described an attack in which a malicious workflow, with a name suggesting a security check but which verifies nothing, spread across tens of thousands of GitHub repositories. It steals credentials from the affected repositories and sends them to an external server.

The same week, Aikido Security reported another episode: the attacker used credentials stolen from 4,837 accounts to plant a secrets collector in repositories where those accounts had write permission. According to the company, the code ran in at least 1,806 repositories and was built to take the secrets and cloud credentials that the automation pipeline can reach.

There were also reports that the update infrastructure of a website security product was compromised to distribute a backdoor, and that a popular keyboard software had its updates hijacked. The pattern is the same: the attacker doesn't break into you, they break into something you trust.

Why this matters even if you're not a tech company

The most common misreading is to assume this is a problem for Silicon Valley giants. It isn't. A management system, an ordering app, or a customer portal at a midsize company uses dozens or hundreds of third-party libraries, and nearly all of them come from public repositories.

On top of that, the deploy pipeline (the conveyor that takes the code and puts it into production) usually has access to everything: database, server, cloud, email service, payment gateway. Whoever steals what the pipeline can see walks away with the key to the whole vault.

The typical damage isn't a page going down. It's silent access to your cloud, charges for machines you never created, customer data being copied, or a system that starts behaving in a way nobody asked for.

Where your system is most exposed

In practice, exposure is concentrated in four places. It's worth knowing which one describes your situation before making any investment.

The first is a dependency installed without version control: the system downloads the latest version of a library on every build, and if that version has been tampered with, it goes straight into production. The second is a pipeline with overly broad permissions. The third is secrets stored in the wrong place, such as passwords inside the code, in versioned configuration files, or in variables that any workflow can read. The fourth is automatic updating of third-party tools installed on your servers, which becomes an entry point when the vendor is compromised.

  • Dependencies with no pinned version and no lockfile.
  • A deploy pipeline with full access and long-lived keys.
  • Passwords and keys inside the repository, even a private one.
  • Third-party tools that update themselves on your servers.

Seven checks to run this week

You don't need a project that takes months. Ask your in-house team or your software house to answer each item with evidence, not with an 'I think so.'

  • Look for secrets in the repository and its history, not just in the current code. If you find a key, treat it as leaked and replace it.
  • Confirm that dependencies have pinned versions and a versioned lockfile, so the build is reproducible.
  • Cut the pipeline's permissions to the minimum: it should read the code and publish, not administer the entire cloud. Prefer temporary credentials over permanent keys.
  • For third-party automation workflows, pin the exact version (ideally by commit identifier) instead of pointing to 'the latest.'
  • Require two-factor authentication on every account with write access to the code, and review who still has access and shouldn't.
  • Build a simple inventory: which libraries, which versions, which have known alerts. A spreadsheet is enough to start.
  • Have a rotation plan: if a key leaks today, who replaces it, how fast, and what breaks when it's replaced?

Updating too fast is a risk too

There's an instinctive reaction to this kind of news: turning on automatic updates for everything so you're always on the latest version. In part that makes sense, because known vulnerabilities need to be fixed. But accepting any published version the moment it appears is exactly the channel these attacks exploit.

The balance we recommend: security updates go in fast, but they go through review and automated tests, and the rest follow a schedule. A short waiting window before adopting newly published versions already filters out a good share of tampered packages, which are usually detected and removed within hours or days.

Legacy systems: the risk nobody sees

Here the problem flips. An old system with no maintenance is rarely the target of a new tampered package, but it often runs on libraries that have been outdated for years, with known vulnerabilities and nobody who knows what's inside. It's almost certain that there's no inventory, no lockfile, and no record of where the keys are.

At SKAD, when we take on a legacy system, the first step is precisely this survey: what the system uses, where the secrets are, who accesses what. Then modernization happens incrementally, module by module, without stopping operations, and critical dependencies are replaced or isolated along the way. Rewriting everything at once doesn't solve this any faster; it only concentrates the risk on a single date.

AI helps at this stage: it reads the code, lists libraries, and points out where keys are exposed much faster than a manual review. But the people are still the ones who decide what to replace, what to isolate, and what to keep.

What to demand from your software house and your contract

If the system was built by a third party, the question almost nobody asks at signing is: who takes care of the dependencies after delivery? Many contracts cover bug fixes but say nothing about updating libraries, rotating keys, or responding to an incident in a library in use.

Ask for it in writing: the inventory of components, where the secrets are stored, who has access to the repository and the pipeline, and the response time when an alert affecting your system comes up. If the answer is vague, the contract needs adjusting before the next incident, not after.

From our experience

What we find most often in audits of midsize companies' systems, in general terms, is the same combination: dependencies with no pinned version, long-lived keys in the pipeline, and nobody holding the list of who has access to the repository.

In our view, the cheapest, highest-return item is a rehearsed key rotation: whoever has practiced replacing a key without taking the system down responds to an incident in hours, not days.

Frequently asked questions

What is a software supply chain attack?

It's when an attacker compromises something you use to build or run your system, such as a library, an automation tool, or a vendor update, instead of attacking you directly. The malicious code arrives through a channel you trust.

My repository is private. Am I protected?

Only partly. A private repository doesn't protect you from a tampered library, a pipeline with too many permissions, or a developer account with a stolen password. Secrets inside the code are still a risk.

Do I need to change all passwords and keys right now?

Immediately replace the ones in the code, in the repository history, or accessible to third-party automation workflows. The rest can go on a rotation schedule, as long as you know where they are.

How much does this assessment cost?

It depends on the size of the system, the number of repositories, the existing documentation, and how much the team already controls versions and access. A small, well-organized system takes days; a legacy system with no inventory takes longer and should be treated as the first phase of modernization.

Do AI coding tools increase this risk?

They can, if they store keys in configuration files that end up versioned or if they have too much access to the environment. Treat them like any new team member: minimal access, review of what goes in, and no production keys in sight.

Conclusion

Start with a single question, today: if a production key leaked right now, could you say where it is, who uses it, and how fast it would be replaced? If the answer takes more than a day, that's the priority, before any new tool. Run the seven checks, record what you find, and if the system is old and has no clear owner, treat the survey as the first step of a gradual modernization, not as a separate cost.

Sources

Keep reading