Lightwell is an open-source security platform that discovers vulnerabilities in software and buried dependencies, uses AI to analyze them and develop fixes such as backported patches, and subjects those fixes to engineering review. It distributes validated fixes through trusted software repositories before contributing them upstream to the affected open-source projects.
Log4j is a Java logging library used in enterprise software to record application events. It was cited as an example of dependency risk because a security flaw enabled remote code execution, while remediation was difficult when the library was embedded across thousands of deployments.
Project Akrites is a Linux Foundation initiative that addresses open-source software vulnerabilities by providing fixed software packages that teams can use without upgrading dependencies in ways that could break their applications.
SolarWinds is a software distributor that was cited as an example of a software build pipeline becoming a supply-chain attack vector. Attackers breached its build environment and covertly inserted a backdoor into software updates distributed to approximately 18,000 customers.
Searchable transcript of Software Supply Chain Security: What AI Coding Changes — IBM Technology (09:55). Search for a phrase, then click its timestamp to jump straight to that moment in the video.
Captions sourced from the original video on YouTube, published by IBM Technology. The video, its captions and all related intellectual property remain the property of their respective owners; AINotes claims no ownership. Provided for research, accessibility and search — see the Transcript Notice and Copyright Policy.
00:00 Let's say that you're building an awesome new app. You've built out the features, the tests are passing and you're ready to ship. Woohoo! But how much of what's about to run in production did you actually write? Well, for most apps, it's actually not a lot. Most software today isn't written from scratch, but put together from a whole bunch of pieces that came from somewhere else.
00:22 So, let's fill in the rest of the picture, because you're likely to have open-source software packages, and each of those packages are pulling in their own dependencies. You've also got a container base image. This allows you to run that software in a variety of environments. My computer. Your computer. Somewhere in the cloud. You've also got a build pipeline.
00:41 This is your continuous integration and deployment that allows you to constantly make updates and changes in real time. You've also got, for example, secrets that might be used to connect your application to data sources, and much more. And more and more, you also have the idea and concept of AI-generated code that a model is creating and writing. So every one of these is something that your software is depending on.
01:14 And most of them you didn't write and some of them you probably never even looked at. I'm guilty of that one too. But this whole picture is what's known as the software supply chain. And this is about securing everything and everyone that touches your code, from the actual code itself to writing, building it and getting it deployed. It includes not just the application, but also everything else around it.
01:33 That whole picture is your software supply chain. It's all about securing everything and everyone that touches your code, from writing the code to building it and getting it deployed so that people can access it. It includes the application itself, but on the other hand, everything else around it, as well. In fact, you've probably heard of popular examples of supply chain security attacks, for example, with software bugs like the incident of log4j.
02:13 Now, Log4j is a popular logging library that was in almost every piece of software in order to collect metrics and logs, and almost 93% of enterprise environments had it installed as a dependency in the software they use, or maybe we're using as a service. And a security flaw left teams vulnerable to remote code execution. That means if I have my server here and a malicious attacker was to use a specific command, they could get access to our environment to exfiltrate data, to sabotage things, and remediating this issue
02:46 was quite difficult because it was in not just servers, but applications that you and I use every day. And it was in the hybrid cloud, uh, deployed on thousands of different machines. So that's an example of software bugs where remediation of a dependency can be quite difficult. There's also issues of ecosystem poisoning. So you might have heard of attacks on different package registries like NPM for JavaScript developers or PyPI for Python developers, where attackers intentionally upload malicious packages either in
03:15 typo squatting, where let's say I'm looking for a specific package called request in order to make requests from my app to another, and someone has taken a name of request, but with a small typo, maybe two S's. And if I type this in, it's in my application. I could get hacked. There's also the idea of hacking a legitimate account of a contributor to a popular project, and using their account to upload a new version of software that might be downloaded automatically on your or I's application, hich could be vulnerable.
03:56 Andfinally, there's attacks through the build pipeline, ah, of software. So there's a popular example of SolarWinds, which is a distributor of software where they had attackers that breached their environment to covertly, um, hack about 18,000 of their customers with a backdoor. And even though it was a trusted software provider for these different customers, well, that backdoor got in because of a code build process and was updated automatically on all those different environments.
04:31 So, these are different entry points for your software supply chain. Some are through a dependency or an ecosystem. Some are through the build process. But this is really why we have to care about the whole picture. So none of this is necessarily brand new. But what has changed? Well, AI has changed things from both sides actually, where on one side, the models and agents are now producing much more code that we're actually using in applications and senior engineers now get dozens of different review requests per day.
05:01 And trust me, people were already struggling to keep up before AI. On the other side, though, AI is finding vulnerabilities and helping us test and validate our applications as we deploy them. And these frontier models can scan open-source code and dependency chains at machine speed. And that means the time between a bug being disclosed and someone using it in attack, or you having to prevent that, is getting a lot shorter.
05:28 So I like to think of AI and agents as a new supplier in our supply chain. It's a really fast one, and just like any other supplier, you need a way to check what it ships. A lot of teams are still finding vulnerabilities way over here near the end, and by then fixing it can be quite disruptive because you have to reload all the context, rework something that's maybe already been merged, and hold up a new release.
05:50 It's like when you're deep in a problem and you get pulled into a meeting and you come back an hour later with no idea where you were. Except now the code is weeks or months old. And so that's why you hear this term of shift left. And what does this really mean? Well, this means checks as you're building out new features before and after you push code, signing off on those artifacts in the continuous integration pipeline before you get to production And really as many checks as possible that can be automated and done
06:18 up front so that the real attention from a person or an AI reviewer goes to the activities that really need judgment. So what can you start doing today Well, there are four simple things. And first is to know what's in your application. This is exactly what an SBOM is for. It's a software bill of materials, and you can think of it as the ingredient list for your application or software.
06:47 That means when the next Log4j or big critical vulnerability shows up, all you have to do is check the list to see what's in your application and which version instead of going hunting in those applications that you might manage. And second is to check early and check automatically. This means to scan the dependencies that you're using for critical vulnerabilities, to scan for secrets that might be exposed, and to validate authenticity of those dependencies and code that comes in.
07:15 So, speaking of code, keep those changes small. A giant change that mixes a dependency bump, a refactor of code and new behavior for your application is hard for anybody to review, whether it be human or AI. And speaking of AI, verify independently. So if you're using an AI agent for code generation or code review, this means that if you're using the agent to both write the code that is going into the application and review the code to make sure that it's functional, well, it's likely to miss the same thing twice.
07:51 So, a good review should use a separate model or a separate session so that you have this kind of separation of concern and zero trust. And this is a proven idea that we already use in a lot of other fashions. But, finally is to prove where your application came from. So this means to sign your artifacts and code so that you can show provenance. And there's actually already a framework for this called SLSA from the Linux Foundation, which is really good to follow here because it gives you a way to record what was
08:26 checked in your application and document why it was approved. As your application grows larger and larger, this gets more and more important. So even if you do all four of these, something will get through eventually, and maybe you'll fix it by patching or upgrading the software in your application from, say for example, version one to version two. But in a lot of situations, maybe it'll break your application and you just can't do it So that's where initiatives to combat open-source vulnerabilities come in.
08:58 So there's two of them I want to mention Project Akrites from the Linux Foundation and Lightwell from Red Hat and IBM, which have fixed packages of software ready to go so that you don't have to automatically upgrade, which might break your application. So the thing is, software supply chain security, it's not about slowing things down, but catching these issues before they get to production so that you're able to go ship faster and feel confident about it.
09:27 You want to be able to think that, hey, if something were wrong, how would we know? And I believe that after watching this video, you can answer that question. So, thanks so much for watching. If you learned something today, be sure to like the video and subscribe to the channel. We'll see you in the next one.