Supply Chain Attacks

Compromising trusted suppliers, software, and services

Introduction

Modern organisations rarely operate in isolation. Businesses rely on hundreds or even thousands of external organisations and technologies to operate its systems.

These might include suppliers such as:

  • Software vendors
  • Cloud providers
  • Managed Service Providers
  • Hardware manufacturers
  • IT contractors
  • Software libraries
  • Open-source projects
  • Security products
  • Update services
  • Logistics providers
  • Payment providers
  • Software development platforms

This interconnected ecosystem creates significant benefits, but it also creates a security problem.

An organisation may have strong security controls protecting its own systems while trusting software, services, or suppliers that it cannot directly control. An attacker can exploit this relationship by compromising a trusted supplier and then using that supplier’s legitimate access, software, infrastructure, or distribution mechanisms to reach its real targets.

Instead of attacking the target organisation directly, the attacker compromises something the target already trusts. The attack therefore takes advantage of a fundamental principle of cybersecurity:

Trust can become an attack surface.

This is known as a Supply Chain Attack.

Supply chain attacks are particularly dangerous because the victim may initially trust what is being delivered to them.

What is a Supply Chain Attack?

A Supply Chain Attack occurs when an attacker compromises a trusted third party, product, service, dependency, or process in order to attack organisations that depend upon it. The “supply chain” does not necessarily refer to physical goods, it can be anything a supplier provides to a customer.

In cybersecurity, it can include the entire ecosystem involved in developing, delivering, maintaining, and operating technology.

For example – If an attacker compromises a software developer or vendor, malicious code could be introduced before the software reaches the customer – The customer may then install the compromised software believing it to be legitimate.

Add to this, the software will most likely be digitally signed in a legitimate way, therefore embedding the trust mechanism into the now-malicious code

This makes supply chain attacks particularly difficult to detect.

The organisation may not have downloaded an obviously malicious program – It may have installed a legitimate product from a legitimate supplier.

Why are Supply Chain Attacks so dangerous?

As mentioned above, the primary advantage in a supply chain attack, for an attacker is trust.

A trusted supplier may already have:

  • Network access
  • Administrative privileges
  • Software distribution mechanisms
  • Update mechanisms
  • Remote management access
  • Access to sensitive information
  • Connections to multiple customers

Compromising one supplier can therefore provide an attacker with access to many potential victims.

This creates a multiplier effect, so instead of attacking victims individually, an attacker may target a trusted supplier and potentially reach hundreds of organisations through this vector.

How does a Supply Chain Attack work?

A typical attack can involve several stages.

  • 1. Identifying the supply chain – The attacker first identifies relationships surrounding the intended victim, such as software providers, managed service providers, cloud services, contractors, hardware vendors, and development platforms.

    The attacker is looking for a component that may be easier to compromise than the final target.
  • 2. Selecting a weak link – The attacker identifies a supplier or component with security weaknesses such as an exposed server, or a compromised developer account.

    The attacker does not necessarily need to compromise the ultimate target directly.
  • 3. Compromising the supplier – The attacker gains access to the supplier’s environment which could provide access to source code, build systems, software repositories, signing systems, etc.
  • 4. Introducing malicious functionality – The attacker attempts to introduce malicious functionality into something that will subsequently be trusted by customers. This could involve malicious source, code, a compromised software dependency, a modified software package, or a malicious update
  • 5. Distribution to customers – The compromised product or service is distributed through the normal supply chain. This is one of the most dangerous aspects of the attack as the customer may receive the malicious component through an apparently legitimate channel.
  • 6. Exploitation – Once the compromised component reaches the target environment, the attacker may attempt to use it to establish persistence, steal credentials, access internal systems, exfiltrate information, move laterally, or deploy additional malware.

    The attack can therefore progress from a trusted supplier into the victim’s internal environment.

Types of Supply Chain Attacks

Supply chain attacks can occur at different points in the technology lifecycle.

Software Supply Chain Attacks

Software is one of the most important supply chain attack surfaces. Modern applications are rarely built entirely from code written by one organisation.

Developers will often use open-source libraries, commercial libraries, frameworks, software packages, plugins, APIs, and development tools and environments.

If any one of these components is compromised, malicious code can potentially reach applications that depend upon it.

Software Dependency Attacks

Applications frequently depend on external packages.

The development team may directly control the application but have limited visibility into the security of every dependency. If one dependency becomes compromised, the application may inherit the risk.

The more dependencies an application has, the greater the potential attack surface becomes.

Dependency Confusion

Dependency Confusion is an attack technique involving software package management. Organisations may use internally developed packages with particular names. If an attacker publishes a malicious package using the same or a similar name in a public repository, package management systems may sometimes be tricked into retrieving the malicious package instead.

The attacker has effectively attempted to exploit the way software dependencies are resolved.

Organisations must employ strong controls around package repositories and dependency management.

Typosquatting

Typosquatting involves creating a malicious package with a name that resembles a legitimate package.

If the package contains malicious functionality, the attacker may gain access to the developer’s environment or any systems where the package is deployed.

This is particularly dangerous in environments where developers routinely install packages from public repositories.

Open-Source Software Supply Chain Attacks

Open-source software is an essential part of modern technology. Organisations can often use thousands of open-source components without directly knowing every developer involved in maintaining them.

An organisation may trust a widely used package even though it has limited visibility into:

  • Who maintains it
  • How changes are reviewed
  • How releases are produced
  • Where packages are built
  • Whether developer accounts are protected
  • Whether dependencies are themselves trustworthy

Open-source software is not inherently insecure, but the challenge is maintaining visibility and trust across a complex ecosystem.

Software Update Attacks

Software updates are normally considered a security control – They provide fixes for vulnerabilities and improve software security.

However, the update mechanism itself can become an attack vector. If attackers compromise the infrastructure used to produce or distribute updates, they may be able to deliver malicious code to customers.

One such devastating example of this was the SolarWinds Orion attack of 2020.

This was a major software supply chain cyberattack where hackers injected a hidden backdoor called SUNBURST into routine software updates for SolarWinds’ Orion IT management platform. This malicious update was unknowingly installed by roughly 18,000 public and private organizations globally, allowing the attackers stealthy, long-term access for espionage.

Build System Attacks

Modern software is frequently created using automated build pipelines. If an attacker compromises the build environment, they may be able to modify the resulting software without directly changing the original source code.

This creates a particularly difficult security problem in that the source code may appear legitimate while the final software package has been compromised during the build process.

Code-Signing Attacks

Software publishers often digitally sign applications and updates – A valid digital signature provides evidence that software originated from a trusted publisher and has not been modified after signing.

If attackers compromise the systems or credentials used for code signing, they may potentially obtain the ability to sign their malicious software. This altered software will then appear significantly more trustworthy.

Hardware Supply Chain Attacks

Supply chain attacks are not limited to software – Hardware can also be compromised during manufacturing, shipping, or distribution.

Potential risks include:

  • Counterfeit components
  • Modified firmware
  • Hardware implants
  • Tampered devices
  • Compromised manufacturing systems
  • Manipulated firmware updates

Hardware supply chain attacks can be particularly difficult to detect because the organisation may have limited visibility into how a device was manufactured.

These types of attacks are not new – In 2008, the FBI conducted an investigation into counterfeit CISCO routers – and discovered a huge supply-chain attack had managed to see hundreds of thousands of dollars worth of equipment sold into the networks of the US military, energy supplier, and defence contractors – A copy of the presentation by the FBI can be read here

Managed Service Provider Attacks

Organisations increasingly outsource IT operations to Managed Service Providers (MSPs). These MSP’s may have privileged access to network infrastructure, cloud platforms, backup systems, and security systems.

If an attacker compromises an MSP, they may potentially gain access to multiple customer environments.

The MSP therefore becomes an attractive target because one successful compromise could provide access to many organisations.

Cloud Supply Chain Attacks

Cloud environments create additional dependencies such as SaaS applications, identity providers, APIs, third-party integrations, cloud security products, and other managed services.

Compromising one of these services can potentially affect many customers.

Cloud security therefore requires organisations to understand not only their own infrastructure, but also the security of the services connected to it.

Identity and Credential Supply Chain Attacks

Supply chain attacks can also target accounts belonging to suppliers. For example, a contractor may have legitimate access to an organisation’s systems to run analysis, management tools, or to provide other dedicated services.

If the contractor’s credentials are compromised, the attacker may be able to authenticate using a legitimate account. From the organisation’s perspective, the login may initially appear legitimate.

Detecting Supply Chain Attacks

Supply chain attacks can be particularly difficult to detect because the compromised software may behave normally. Security teams should therefore monitor for changes and anomalies in their systems.

Potential indicators include:

  • Unexpected software changes
  • Unusual application behaviour
  • New outbound connections
  • Unexpected child processes
  • New persistence mechanisms
  • Unusual authentication activity
  • Unexpected administrative actions
  • Changes to software packages
  • Unexpected binaries
  • Unknown dependencies
  • Unusual communication with external infrastructure

Endpoint Detection and Response (EDR), network monitoring, application logging, and centralised security monitoring can all help identify suspicious behaviour.

Software Bill of Materials

One increasingly important defensive measure is the Software Bill of Materials (SBOM). This provides an inventory of the components contained within a software product and can identify elements such as:

  • Libraries
  • Packages
  • Versions
  • Dependencies
  • Components

This helps organisations understand what they are actually deploying, so if a vulnerability is later discovered in a particular software component, an organisation with an accurate SBOM can more quickly determine which applications are affected.

How can organisations prevent Supply Chain Attacks?

Supply chain security requires organisations to consider the security of the technology they depend upon.

  • Supplier risk assessments – Organisations should assess important suppliers before granting them access to sensitive systems. Conducting due diligence when embarking on third-party supplier contracts is paramount to modern security controls.
    Obtaining SOC2 reports, Cyber Security audit results, and proof of Cyber Security compliance is important
  • Third-party access controls – Suppliers should receive only the access they require.
  • Secure software development – Software vendors should implement secure development practices throughout the development lifecycle.
  • Protect the build pipeline – Build environments should be treated as critical infrastructure. Organisations should protect source repositories, build servers, CI/CD systems, signing infrastructure, package repositories, and developer credentials.
    Compromising the build pipeline can allow attackers to affect every customer receiving the resulting software.
  • Verify software integrity – Organisations should verify software packages and updates where appropriate with controls such as digital signatures, cryptographic hashes, trusted repositories, certificate validation processes, and secure update mechanisms
  • Monitor third-party software – Installing trusted software does not mean that it should be excluded from security monitoring. Security teams should monitor third-party applications just as they monitor internally developed software.
  • Network segmentation – Third-party applications should not automatically have unrestricted access to the internal network. Segmentation can limit what a compromised application can reach.

The importance of Zero Trust

Supply chain attacks demonstrate why organisations should not automatically trust systems simply because they come from an approved supplier. A Zero Trust approach assumes that access should be continuously evaluated rather than automatically granted based on location or previous trust.

For third-party access, this means considering:

  • Who is accessing the system?
  • What device are they using?
  • What are they attempting to access?
  • Does the access match their normal behaviour?
  • Does the supplier actually require this permission?

Trust should therefore be verified, limited & monitored rather than simply assumed.

Why supply chain attacks are difficult to defend against

Traditional security models often focus on protecting the organisation’s own infrastructure.

Supply chain attacks challenge this approach.

An organisation can have strong firewalls, endpoint protection, multi-factor authentication, network monitoring, and robust security policies – and still be compromised through a trusted supplier.

The problem is that the initial malicious activity may enter through something that has already been approved.

This creates a fundamental security challenge – How do you secure something you do not completely control?

The answer is not to eliminate third-party technology, but instead, organisations must manage third-party risk as part of their overall security strategy.

The future of Supply Chain Security

The modern software ecosystem is becoming increasingly complex. Applications today may contain thousands of third-party dependencies. Organisations may use hundreds of SaaS platforms and cloud services, and development environments increasingly rely upon automated CI/CD pipelines. Additionally, Artificial intelligence is increasing the number and complexity of software components being developed and integrated into the software solutions we use.

This means supply chain security will become increasingly important as a main way of preventing attacks

Supply Chain Attack Prevention Checklist

Organisations should consider:

  • Assessing the security of critical suppliers.
  • Maintaining an inventory of third-party services.
  • Maintaining an accurate Software Bill of Materials where appropriate.
  • Monitoring software dependencies.
  • Protecting developer accounts with MFA.
  • Protecting source-code repositories.
  • Securing CI/CD pipelines.
  • Protecting code-signing infrastructure.
  • Verifying software integrity.
  • Applying least privilege to third-party accounts.
  • Segmentation of third-party systems.
  • Monitoring third-party applications.
  • Reviewing supplier access regularly.
  • Having an incident response plan covering supplier compromise.
  • Understanding how suppliers notify the organisation of security incidents.
  • Removing unnecessary third-party access.
  • Keeping software and dependencies updated.

Conclusion

Supply Chain Attacks exploit one of the most fundamental concepts in modern technology: trust.

Organisations depend upon suppliers, software vendors, cloud platforms, contractors, open-source projects, libraries, development tools, and countless other third parties.

These relationships create efficiency and enable modern digital services, but they also create additional attack surfaces.

Effective protection requires supplier risk management, least privilege, strong authentication, secure software development, protected build systems, dependency management, software integrity verification, network segmentation, monitoring, and continuous assessment of third-party risk.

Understanding and managing these pathways is now an essential part of modern cybersecurity.