Podcast about DevSecOps

#108 - Assume You’re Vulnerable: Security Beyond Patching

Passing tests can still hide a bad update, and patching leaves other ways in.

17 min read

Are AI tools making software safer, or creating an endless patching treadmill? Mattias, Andrey, and Paulina discuss Dependabot, human review, and why teams should assume their software is already vulnerable.

Discuss the episode or ask us anything on LinkedIn


The patch queue stopped emptying

Open your repositories on a Monday and count the Dependabot pull requests waiting for someone. Then count how many of those were already waiting the Monday before. The number of patches arriving has gone up, and keeping that second count flat means draining the queue at the new rate.

That queue grew because finding vulnerabilities got cheap. Agents now read code for flaws at a scale no security team could ever staff. The results arrive as a steady stream of releases across nearly everything you depend on. The same tools point the other way too. Anything you serve publicly, the pages and the client-side JavaScript in them, can be fetched, chunked and read by a model in one pass. Your server-side code is not in that download, because the browser gets the response, not the program that produced it. The front end is the part that travels. That is how the API key baked into a bundle gets found, obfuscated or not, along with the endpoint it calls that nobody put behind auth. At the same time more people are shipping software than before, plenty of them without the background that would tell them what to ask about security in the first place.

So the question we keep coming back to is whether this is a backlog being cleared or the new baseline. We think it’s the baseline. That makes “how do I keep up” the wrong question, and “what do I want to be true on the days I don’t keep up” the right one.

The supply of vulnerabilities got cheap

Start with why the queue refills, because that decides how much of your week is worth spending on it.

Will the patching wave stop?

Not while finding bugs keeps getting cheaper and the pile of code keeps growing.

Google’s Project Zero published the first real-world vulnerability its Big Sleep agent found in November 2024: an exploitable stack buffer underflow in SQLite. It was caught before it reached a release and fixed the same day. By July 2025 Google said the agent had found multiple real-world vulnerabilities and was being pointed at widely used open source. One of those, the SQLite flaw CVE-2025-6965, was already known to threat actors, according to Google. Code nobody had the budget to audit is being audited now. A find like that first one costs you nothing, because it was fixed before any release carried it. The finds that land in versions you already run are the ones that become patch work, and that is the part of the workload we see growing.

The demand side grew at the same time. More code is being written by more people, and there’s no reason to think the new code is safer than the old code it sits on top of. A lot of the people prototyping now came to it from outside the industry, without the training that would tell them what to ask a model about security.

We’ve seen applications left on dependencies that were years out of date, in one case seven years, not because the team was overwhelmed but because the service had no owner. Automation does nothing for that. Somebody has to be on the hook for the thing before any of the tooling below matters.

For all the noise, we haven’t seen a matching wave of break-ins in the general news. What has arrived so far is patches. Keep that in mind as a reason to be deliberate rather than panicked.

Give a new release a few days to be wrong

If the queue never empties, the next argument is about how fast you should drain it.

Should you take a routine version bump the day it ships?

No. Give a routine upgrade a few days, because the hours right after publication are when a poisoned package is live and nobody has looked at it yet. Security fixes are the other queue, and they’re the rest of this section.

The npm incidents this year all have that shape. Unit 42’s tracking of the npm threat landscape records a coordinated campaign on 11 May 2026: 84 malicious artifacts across 42 @tanstack/* packages, all published within six minutes. A compromised maintainer account on 19 May pushed 639 malicious versions across 323 packages in about an hour. These get caught quickly, because plenty of people now scan new releases as they land. Caught quickly only helps if you aren’t first in line.

GitHub turned that window into a default on 14 July 2026. Dependabot now waits until a release has been on its registry for at least three days before it opens a version update pull request. You can set your own window with the cooldown option in .github/dependabot.yml. It takes default-days plus semver-major-days, semver-minor-days and semver-patch-days, with include and exclude lists when some dependencies need different rules.

Read the limit in GitHub’s own words before you rely on it: the cooldown option is only available for version updates, not security updates. The patch you most want merged within a day is exactly the one with no waiting room. That is the right trade, and it’s also a reason to keep the security queue separate in your head from the routine upgrade queue.

The same instinct applies further down. Don’t run latest, in your lockfiles or your image tags. Pin the version you tested.

Assume the software you run is already vulnerable

Draining the queue faster still leaves the question of what the queue is protecting you from.

What do you do when you can’t patch your way to safe?

Change the assumption underneath the rest of your design: treat the code you run as vulnerable, and build so that getting in is worth less.

This is where we don’t agree. Mattias and Paulina put the effort into keeping the queue moving: a tool on the dependencies, a window on new releases, a person on the merge. They would automate as much of that as the tests justify. Andrey thinks chasing every advisory is whack-a-mole, because your own developers introduce issues that no advisory will ever list, so there is always something in there.

None of that is an argument for skipping patches. Verizon’s 2026 DBIR executive summary puts exploitation of vulnerabilities at 31% of known initial access vectors, now ahead of credential abuse at 13%. Patching is load-bearing and stays load-bearing. The argument is about what gets the next hour. Once the queue is automated and the window is set, hardening deserves time alongside the patching rather than whatever is left over. How urgent a given patch is depends on the vulnerability and the workload it sits in. Something under active exploitation on a service facing the internet goes first. A flaw in a code path you never call can wait for the queue.

Give the scanner the context it’s missing

A lot of what sits in that pile never reaches your code, and the tool that raised it has no way of knowing either way.

How do you cut the alert pile without pretending it’s empty?

Hand the triage the context the scanner doesn’t have, and use it to order the queue rather than to make alerts quietly disappear.

Dependabot sees a version number. It can’t see that the vulnerable function is only called in tests, that the service sits behind a WAF, or that nothing routes to it from the internet. So write that down in the repository: a Markdown file describing the application, its runtime, its container, what’s in front of it, and the network around it. Then run a job that reads each open alert against that description and says whether your code path plausibly reaches the vulnerable call. Treat that as evidence for where to start rather than as a verdict. Require the reasoning in writing on the alert before anything is dismissed, so the next person can check the judgement instead of inheriting it. Developers get an ordered queue instead of the raw feed.

Part of that work is already deterministic, and Dependabot’s auto-triage rules do it without a model. They dismiss on metadata such as severity, package name or CWE. An alert reopens when that metadata changes, say when a dependency moves from development to production. Keep the model for the judgement calls. Either way the dismissals stay in the audit log, which matters the day someone asks why that alert was closed.

Fight fire with fire on the merge side too. A scheduled job can check the open Dependabot pull requests, merge them, run the suite and push when it’s green. Claude Code runs as a GitHub Action. Setting use_bedrock: "true" routes it through your own AWS account instead of an API key, so the spend lands on a bill you already watch. A cheap model is enough for this one.

That loop is worth exactly what your tests are worth. We’ve had an update where every test passed and the application ran, and the change was still wrong. That cost a rollback to the previous version until a follow-up release fixed it.

Make the inside boring

Automating the queue is housekeeping. The part that changes your odds is what an intruder finds when they arrive.

What does “architect around it” look like on a Tuesday?

Strip the tooling out of the place they land, and cut down what one compromised workload can reach from there.

Start with the container. Someone who lands in your runtime wants to live off the land, so they need a package manager, a shell, something to pipe into. Google’s distroless images “do not contain package managers, shells or any other programs you would expect to find in a standard Linux distribution”. A scratch image has even less. If your language ships a static binary, Go being the obvious one, the container can be the binary and nothing else. Hardening used to be a project in itself; now a model does most of the Dockerfile work, or you buy it. Chainguard sells minimal images rebuilt from source daily.

Your application is still running and still reachable, so this isn’t safety. Chainguard’s own walkthrough of attacker techniques in distroless containers is blunt about the limit. The missing utilities take away the convenient path and block some techniques. An attacker who already has code execution in your application can work from the process’s own memory instead.

The objection is always troubleshooting. You can’t get into a hardened image to look around, and sooner or later you need to. Build two images from the same source, then. One hardened for production, one with the tools in it, same deployment either way. When you have to debug, swap, do the work, swap back.

Then the network. Decide what genuinely has to face the internet, and that list is shorter than what currently does. Put whatever is left on its own segment, with the least connectivity you can give it. The devices we’d check first are the ones nobody wants to touch. Firewall and VPN appliances sit on the internet permanently, and they are hard enough to upgrade that upgrades slip. Their admin interfaces have a habit of facing the same side as the traffic. Keep that administrative access internal, and watch those boxes more closely than the workloads behind them. The implementing regulation that puts technical detail on NIS2, (EU) 2024/2690, carries network segmentation as its own requirement, and your risk assessment sets the zones. That one binds digital infrastructure and digital service providers rather than everyone in NIS2 scope, so check it applies before you quote it in a budget meeting.

Then watch for the one who gets in

Hardening sets the price of a break-in. Detection sets how long it lasts.

How would you know someone is inside?

Put something in their path that nothing legitimate touches, and log the outbound traffic nobody is looking at today.

A canary token is the cheapest version: a credential that no real code path uses, left where someone rummaging would find it. Be precise about what sets it off. Thinkst’s AWS API key token alerts when those keys are used against the AWS API. That is not the same as an alert when the file holding them is read. Place it where a credential would plausibly be picked up and tried. You can get one free at canarytokens.org, and dropping it into an image costs a line in a Dockerfile.

Outbound DNS is the other cheap one. Log and monitor external DNS from your workloads, and look at what is leaving rather than only at what arrives. Treat it as one signal rather than a net. MITRE’s Non-Application Layer Protocol entry catalogues command and control carried over ICMP, raw sockets and UDP. Those reach a hard-coded address without a lookup your resolver would ever log, and an intruder who reads what they came for and leaves may not call out at all. A container with no shell helps here twice. The attempt to get one is itself a signal, and tools that watch container behaviour can flag processes and calls a workload has never made before. Keep a WAF in front of anything serving traffic while you’re at it.

One more, from the other end of the summer. A Swedish agency’s holiday advice, as relayed on the radio, is to leave an unfinished coffee cup visible from the window. The other half is to skip the deep clean people do before they travel, so the house reads as occupied. That’s a decoy, the same shape as a canary token and about as cheap. It also went out on public radio, where burglars get to hear it too, which is the part we’d question. A decoy everybody has been told about is easier to recognise for what it is. Canaries have the same problem. Truffle Security showed in February 2024 that canarytokens.org AWS keys can be recognised from the account id encoded in the key itself, statically, without ever tripping the alert. What a canary buys you depends on the type you pick and where you put it.

Someone pays for your security either way

All of this competes for money with everything else, which is where the argument usually stalls.

Does any of this get funded?

It gets funded when somebody can price the alternative, and for most organizations ransomware is what put a price on it.

Security teams have been asking for this budget for years and getting a fraction of it. The blunt version, which we’ll let stand: ransomware crews may be the only force that has actually moved everyone’s security forward. The fines we read about for leaking data have looked small next to what preventing the leak would have cost. It’s a red team that invoices.

The money is moving in the victims’ favour, slowly. Verizon’s 2026 DBIR executive summary has ransomware in 48% of breaches, up from 44% the year before. The same summary reports that 69% of the ransomware victims in its dataset didn’t pay, with the median ransom paid down to $139,875 from $150,000.

How those crews get in runs both ways, which is why both halves of this post apply. Our own instinct was that ransomware is a credentials story: accounts compromised somewhere else, access sold on, sometimes sold by the person it belonged to. That half is real. It just isn’t the larger half. Sophos’ State of Ransomware 2025 surveyed 3,400 organizations that were hit. Exploited vulnerabilities came first among the technical root causes its respondents reported, at 32%, with compromised credentials at 23%. So keep the patch queue short on anything facing the internet, limit what one set of credentials can reach, and notice when they get used.

That arithmetic also settled an old argument about where to run. A small team used to be able to justify its own hardware on cost alone. With this much security work attached, the cloud providers patch the layers underneath you and give four people the same network and firewall primitives the large companies are using.

What this means for teams

Patching is table stakes and it isn’t a strategy. The version of this week’s work we’d defend: keep the queue moving with as little human attention as your tests can justify. Spend what you free up on the assumption that it won’t be enough.

Four things to do this week:

  • Check your cooldown setting in .github/dependabot.yml, or confirm you’re happy with the three-day default, and make sure security updates are still coming straight through.
  • Write the context file for your two most important repositories: what the service is, what it runs on, what’s in front of it, what it can reach. Point your alert triage at it, and make it record a reason on anything it wants dismissed.
  • Look at the container for your most exposed service. Shell, package manager, what a process in there could reach. If the answer is “most of the estate”, that’s your segmentation work, and the two-image split is how you keep debugging.
  • Turn on outbound DNS logging for one workload and put a canary token in it. Then trip the token yourself and follow the alert end to end. Check that it fired, what the logs covered, how much noise it adds, and who is on the hook for answering it.

Common questions, answered

How do I stop Dependabot opening pull requests the day a release ships?

Set the cooldown option in .github/dependabot.yml, which takes default-days and per-SemVer settings such as semver-major-days, plus include and exclude lists. Since 14 July 2026 Dependabot applies a three-day cooldown to version updates by default on github.com. You may already have the behaviour and only need to widen or narrow it. The option covers version updates only, so security updates still open immediately. Treat the two queues differently in your automation.

How do I troubleshoot a container that has no shell?

Build a second image from the same source with the tools in it, and swap the deployment to that one while you debug. The production image stays minimal, the debug image has your shell and your network utilities, and both come from the same build so you’re looking at the same application. Swap back when you’re done. Teams keep a fat base image in production for this one afternoon. A second image buys that afternoon without leaving a package manager in production the rest of the time.

Should I let an agent merge Dependabot pull requests on its own?

Only where a bad update would actually fail your tests, which is a smaller set of repositories than it sounds. We’ve had an update pass a full suite, run fine, and still be the wrong change, and the way out was a rollback until a later release corrected it. So let the job do the mechanical part: check the open pull requests, merge, run the suite, push when it’s green. Keep a person looking at what it did. Running it daily helps, because a daily pass keeps each review small. Arrivals can still outpace merges, so track how many updates are open and how old the oldest one is.

Resources

Since we recorded

Two weeks later, on 4 August 2026, a hijacked maintainer account pushed the Shai-Hulud worm into keyv, flat-cache and others, every poisoned release armed with a preinstall credential stealer. Aikido’s investigation of the attack counted at least 444 packages across 1,381 versions by the next day, with valid GitHub Actions provenance on the poisoned versions. So an attestation records where a package was built, not whether it is safe, and a cooldown covers only those first days. We came back to the exposure side of this in episode 114, Fridge Hacks and Security by Obscurity.