Born Corrupted: Hack the Planet by Hijacking Linux Package Factories

splitline (Security Researcher · DEVCORE)

SEC-T 2026 · Day 2 · Main hall

Overview

In this compelling talk, security researcher splitline from DEVCORE unveils a series of critical vulnerabilities across the software supply chains of major Linux distributions: Ubuntu, Alpine Linux, and Fedora. The presentation, titled "Born Corrupted: Hack the Planet by Hijacking Linux Package Factories," challenges the conventional wisdom that distributing malware to millions of Linux machines is an inherently complex endeavor. Instead, splitline demonstrates a far more insidious and effective approach: compromising the very pipelines responsible for building, signing, and distributing official packages.

Watch on YouTube

Visual summary for Born Corrupted: Hack the Planet by Hijacking Linux Package Factories by splitline
Visual summary for Born Corrupted: Hack the Planet by Hijacking Linux Package Factories by splitline

Key moments

  1. 0:00 Introduction: Hijacking Linux package factories for malware distribution
  2. 4:36 Why OS package managers are ultimate supply chain targets
  3. 11:20 Ubuntu Launchpad vulnerability: Zip Slip in artifact processing
  4. 13:58 Escalating Ubuntu Zip Slip to RCE via /proc/self/mem
  5. 17:50 Alpine Linux compromise: Hijacking Renovate bot for admin access
  6. 22:20 Shocking unauthenticated pickle deserialization in Fedora Mirror Manager
  7. 25:30 Bypassing Fedora package signing with fork and dot-slash trick
  8. 27:50 Key takeaways for researchers, developers, and AI's role

Born Corrupted: Hack the Planet by Hijacking Linux Package Factories

Speakers: splitline, Security Researcher, DEVCORE

Conference: SEC-T

YouTube: https://www.youtube.com/watch?v=uD3hbSvZYls

Overview

In this compelling talk, security researcher splitline from DEVCORE unveils a series of critical vulnerabilities across the software supply chains of major Linux distributions: Ubuntu, Alpine Linux, and Fedora. The presentation, titled "Born Corrupted: Hack the Planet by Hijacking Linux Package Factories," challenges the conventional wisdom that distributing malware to millions of Linux machines is an inherently complex endeavor. Instead, splitline demonstrates a far more insidious and effective approach: compromising the very pipelines responsible for building, signing, and distributing official packages.

The core premise of the research is that by infiltrating the "distro release pipeline," an attacker can coerce the distribution's infrastructure to build their malware, sign it with legitimate release keys, and then leverage the official upgrade mechanisms to distribute it to unsuspecting users. This means that a simple apt update or dnf update command could unwittingly install malicious software, validated and delivered by the trusted operating system itself. The implications are profound, as such an attack bypasses most traditional security controls and user vigilance, fundamentally undermining the trust users place in their operating systems.

Splitline’s work highlights that despite the daily barrage of supply chain compromise news, there remain critical, unexplored layers of infrastructure that are implicitly trusted by the entire ecosystem. By shifting focus from individual packages or registries to the foundational operating system package managers, the research exposes a new frontier for high-impact attacks. The findings reveal that even widely-used, mature distributions harbor vulnerabilities that, when chained together, can lead to complete supply chain compromise, effectively allowing an attacker to "hack the planet" by poisoning the well at its source.

Background

▶ Watch: Introduction: Hijacking Linux package factories for malware distribution (0:00)

The speaker, splitline, began by reflecting on the perceived difficulty of distributing malware to millions of Linux machines. Traditional methods often involve complex remote code execution (RCE) exploits, elaborate social engineering campaigns, or the painstaking construction of vast distribution networks. These approaches are not only technically challenging but also carry significant risks for the attacker. However, splitline's research posited a more efficient and devastating alternative: directly compromising the Linux distribution release pipeline.

This approach leverages the inherent trust users place in their operating systems and their update mechanisms. If an attacker can inject malicious code into the official build process, the distribution itself will unwittingly compile the malware, sign it with its legitimate release keys, and then distribute it through its standard update infrastructure. Users, in turn, would install this "officially sanctioned" malware simply by running routine update commands like apt update or dnf update. This represents a fundamental subversion of the software supply chain, transforming the trusted distribution into an unwilling accomplice.

Splitline's motivation for this research stemmed from a broader disinterest in what he described as "yet another supply chain compromise" focusing on individual packages or registries, which he felt were often the most obvious targets. Having previously researched and published on vulnerabilities in package registries (like NuGet for C#) and programming language ecosystems (presented at Black Hat USA), he sought a "type three" target: the operating system package manager itself. This underlying layer, responsible for delivering virtually all software to a Linux machine, presented a far more critical and less explored attack surface.

The general architecture of a software distribution pipeline was conceptualized into two main parts: the CI/CD-ish stuff (source code acquisition, building, artifact processing) and the policy-ish stuff (releasing, signing, publishing, delivery). The research focused on demonstrating how vulnerabilities in either of these parts could lead to a complete compromise. The talk aimed to expose how seemingly minor flaws, when present in these foundational systems, could have catastrophic consequences, validating the belief that these "truth-worthy" layers are often the least scrutinized.

Key Findings

▶ Watch: Ubuntu Launchpad vulnerability: Zip Slip in artifact processing (11:20)

Splitline's research uncovered a series of critical vulnerabilities that, when chained, allowed for the complete compromise of the software supply chains for Ubuntu, Alpine Linux, and Fedora. These findings collectively demonstrated how an attacker could inject malicious code into official distribution packages, have them legitimately signed, and distribute them to millions of users.

The primary findings include:

  • Ubuntu Launchpad Artifact Processing Vulnerability: A zip slipping vulnerability combined with a sparse file format exploit in Ubuntu's build artifact processing system allowed for arbitrary code execution in the trusted publisher component. This enabled an attacker to hijack and replace any compiled binary (e.g., GCC, systemd) with their own malicious payload, compromising the entire Ubuntu release pipeline.
  • Alpine Linux GitLab Build Pipeline Compromise: By exploiting a misconfigured Renovate bot in Alpine's self-hosted GitLab instance, splitline gained initial access and bot permissions. This was then escalated via a Docker socket escape vulnerability in GitLab runners, allowing the attacker to push arbitrary Docker images and hijack any build pipeline, thereby poisoning Alpine's official package repository.
  • Fedora Mirror Manager and Signing Process Vulnerabilities: A severe, unauthenticated pickle deserialization vulnerability in Fedora's mirror manager provided direct shell access. Although initially hampered by package signing, splitline discovered a URL-encoded path traversal bypass in the build system's source control validation and a critical flaw in the signing process that allowed for the bypass of strict signing rules. This combination enabled the attacker to build and legitimately sign malicious RPM packages, compromising the entire Fedora supply chain.

These discoveries collectively highlight that even mature and widely-used Linux distributions possess fundamental security weaknesses in their core infrastructure. The ability to subvert the package signing and distribution mechanisms represents a "born corrupted" scenario, where the very software users trust is delivered in a compromised state, rendering traditional security measures largely ineffective.

Technical Deep Dive

▶ Watch: Alpine Linux compromise: Hijacking Renovate bot for admin access (17:50)

Splitline's research methodically targeted different stages of the Linux distribution pipeline across three major operating systems, revealing distinct but equally critical vulnerabilities.

Ubuntu: Launchpad and Arbitrary Code Execution via Artifact Processing

Ubuntu's package building and release infrastructure relies heavily on Launchpad, a comprehensive developer control panel akin to a specialized GitHub or GitLab. Launchpad hosts critical source code (e.g., GCC, bash) and manages their build pipelines. The build process involves an App Server cloning source code, delivering it via XML RPC to a Builder (which operates in an untrusted, sandboxed environment), and finally, the Builder uploads the compiled artifacts to a Publisher server. This Publisher is considered part of the trusted area.

The vulnerability was located in how the Publisher processed build results. The Builder would upload these results as a .tar archive. Splitline discovered that the Publisher used Python's extractall function to unpack this archive. This function is notoriously vulnerable to zip slipping (or path traversal within archives), allowing an attacker to write files to arbitrary locations on the file system.

While an arbitrary file write is powerful, gaining remote code execution (RCE) on a Linux system, especially one with properly configured permissions, is not straightforward. Splitline persisted, diving into the Python tarfile library's implementation. He uncovered support for sparse file format within tar archives. A sparse file format allows the archive to specify an offset within a file to start writing content, effectively allowing an attacker to "seek" to a specific memory address and write shellcode. The target for this was the /proc/self/mem file, which represents the memory layout of the current process. By writing directly to this memory region, RCE could be achieved.

To precisely target the memory, the attacker needed to know the process's memory layout. The release artifacts feature in Launchpad allowed for arbitrary file reads. This enabled reading the Publisher process's own binary, which, crucially, was non-PIE (Position-Independent Executable). This meant its base address was predictable, bypassing Address Space Layout Randomization (ASLR) for the executable code. By combining arbitrary file read (to learn memory layout) with arbitrary file write (via zip slipping and sparse file format to /proc/self/mem), splitline crafted a malicious .tar file. Upon processing by the Publisher, this .tar would execute attacker-controlled shellcode.

Gaining RCE on the Publisher was a critical win because the Publisher handles all artifacts destined for release. This allowed splitline to hijack any compiled binary, such as fundamental system components like GCC or systemd, and replace them with attacker-controlled malware. This effectively compromised the entire Ubuntu release pipeline, allowing the distribution of maliciously modified, but officially signed, software.

Alpine Linux: GitLab, Renovate Bot, and Docker Escape

Alpine Linux manages its package ecosystem using a self-hosted GitLab instance. Packages installed via APK add originate from repositories managed on this GitLab. Splitline's investigation began by browsing Alpine's GitLab infrastructure, specifically observing a bot named Renovate that automatically opened pull requests for dependency updates.

The critical misconfiguration lay in how Renovate was set up: it allowed custom comments in its configuration and would automatically discover projects with the renovate topic. This presented an immediate opportunity for an attacker. Splitline registered an account on Alpine's GitLab (which allowed free registration and project creation), created a new project, and added the renovate topic. Within this project, he defined a custom comment that would execute a reverse shell. Upon Renovate discovering and processing this project, the reverse shell was triggered, providing splitline with access to the bot's environment and, crucially, its POST token.

The Renovate bot possessed significant permissions, including the ability to write to repositories for dependency updates. It also mirrored some permissions to GitHub, but Alpine's core infrastructure was on GitLab. While the bot's permissions were high, direct RCE on the build runners was the next goal.

Further investigation into Alpine's GitLab runner configurations revealed that certain jobs, though restricted to users with "developer permission" or "insider permission," mounted a Docker socket inside the container. This is a well-known vulnerability, as access to the Docker socket allows for Docker escape and full control over the host's Docker daemon. Since the Renovate bot had sufficient permissions to trigger these restricted jobs, splitline used the bot's capabilities to initiate such a job. This provided a second reverse shell, but this time with access to the Docker socket. With this access, he could push arbitrary Docker images to the host, effectively hijacking any build pipeline and poisoning the build results. This meant attacker-controlled, malicious images could be injected into the Alpine Linux package build process, leading to the distribution of compromised software.

Fedora: Mirror Manager, Build System Bypass, and Signing Rule Flaw

Fedora's package distribution relies on a Mirror Manager application that automatically selects the best mirror for users downloading packages via DNF update. This process involves fetching a metalink file containing package metadata, checksums, and download URLs, followed by verification and installation. Compromising the Mirror Manager would allow an attacker to direct users to malicious package sources.

Splitline discovered an "amazingly and incredibly simple" vulnerability in the Mirror Manager: an unauthenticated pickle deserialization flaw. The application directly used pickle.loads(data) on unauthenticated user input. This allowed an attacker to submit a malicious pickled object, immediately gaining a shell on the Mirror Manager. This granted control over package URLs and sources, but a critical hurdle remained: Fedora packages are in RPM format and are cryptographically signed. An unsigned or improperly signed package would fail verification and not be installed.

To overcome the signing challenge, splitline needed to get a malicious package signed by Fedora's legitimate infrastructure. The build system typically only accepts Git repositories from their own service, and only for approved packagers. As an unapproved attacker, direct submission was impossible. However, the system offered a fork function, allowing users to fork existing packages. Splitline forked a package, creating a personal, attacker-controlled repository. The challenge then became how to get the build system to process this forked repository, as its URL did not match the allowed formats. The solution was a classic URL-encoded path traversal (../ or /%2e%2e%2f) in the Git URL. By manipulating the URL, the attacker could make the forked repository appear as if it originated from an approved path within Fedora's own service, tricking the build system into building the attacker's modified package.

Even with a package successfully built by Fedora's trusted system, it still needed to be signed. Fedora has strict signing rules designed to prevent unauthorized packages from receiving legitimate signatures. However, splitline found a critical flaw in the signing rule parser: it only evaluated the first rule, effectively ignoring all subsequent, stricter rules. This bypass allowed the attacker to submit their malicious, built package (demonstrated with a modified bash binary) and have it legitimately signed by Fedora's infrastructure.

By chaining these three vulnerabilities – the pickle deserialization in Mirror Manager, the URL-encoded path traversal in the build system, and the signing rule bypass – splitline achieved a full compromise of the Fedora supply chain. An attacker could direct users to malicious mirrors, have them download attacker-controlled, legitimately signed RPM packages, and thus compromise Fedora users.

Demo / Proof of Concept

▶ Watch: Shocking unauthenticated pickle deserialization in Fedora Mirror Manager (22:20)

While the talk did not feature a live, real-time demonstration of the exploits, splitline meticulously detailed the step-by-step process for each compromise, presenting the outcomes as confirmed vulnerabilities and successful proof-of-concept chains. He described achieving remote shells, gaining control over critical infrastructure components (like the Ubuntu Publisher, Alpine's GitLab runners, and Fedora's Mirror Manager), and ultimately producing legitimately signed malicious packages. The technical depth provided for each attack vector, including specific function names (extractall, pickle.loads), file paths (/proc/self/mem), and attack techniques (zip slipping, sparse file format, Docker socket escape, URL-encoded path traversal, signing rule bypass), strongly implies the existence and successful execution of these proofs of concept during the research phase. The presentation focused on the methodology and impact rather than a visual execution of the exploits.

Defensive Implications

▶ Watch: Key takeaways for researchers, developers, and AI's role (27:50)

The findings presented by splitline carry significant and urgent defensive implications for both Linux distribution maintainers and end-users.

For Linux distribution maintainers and developers, the research underscores the critical need for:

  • Rigorous Input Validation: The vulnerabilities highlight fundamental flaws in how systems process external input, whether it's tar archives (Ubuntu's zip slipping), serialized data (Fedora's pickle deserialization), or URLs (Fedora's path traversal). Every input from an untrusted source, or even seemingly trusted internal sources, must be strictly validated against expected formats and boundaries.
  • Secure Deserialization Practices: The unauthenticated pickle deserialization in Fedora's Mirror Manager is a glaring example of a well-known, high-impact vulnerability. Maintainers must avoid insecure deserialization of untrusted data and, where deserialization is necessary, employ safe, authenticated, and limited alternatives.
  • Least Privilege for Automated Systems: The Renovate bot compromise in Alpine Linux demonstrates the danger of granting overly broad permissions to automated systems. Bots should operate with the absolute minimum privileges required for their function, and their configuration and execution environments must be tightly controlled and regularly audited.
  • Secure CI/CD and Containerization: The Docker socket escape in Alpine's GitLab runners highlights a critical misconfiguration. Docker sockets should never be mounted inside containers that process untrusted or semi-trusted code. CI/CD environments must be designed with strong isolation, and container escape vulnerabilities must be a top priority for remediation.
  • Robust Signing Process Implementation: Fedora's signing rule bypass illustrates that even with seemingly strict policies, implementation flaws can completely undermine security. Signing processes should be independently reviewed, and rules must be enforced comprehensively rather than selectively. Multi-factor signing and independent audit trails should be considered.
  • Comprehensive Code Audits: The "easy" bugs found suggest that critical infrastructure layers often remain unexamined. Regular, in-depth security audits, both automated and manual, by internal teams and external experts, are essential for identifying these foundational weaknesses.

For end-users, the defensive implications are stark and, as splitline noted, "sadly, there's nothing much you can do." When the core supply chain is compromised and packages are legitimately signed by the distribution, typical user-level defenses (like verifying package origins or checksums) become ineffective. The speaker's controversial advice, "just don't update things too fast," implies a reactive approach where users might wait for news of compromises and subsequent patches before updating. However, this advice is problematic as it also delays critical security fixes. Ultimately, users are left in a precarious position, relying entirely on the diligence and security posture of their chosen Linux distribution. The only true defense for users against such deep supply chain compromises is the continuous improvement and hardening of the distribution's infrastructure itself.

Key Takeaways

  • Linux distribution package pipelines are a critical, often overlooked, and highly impactful attack surface. Compromising these foundational layers allows attackers to subvert the entire software delivery process.
  • Common, well-known vulnerabilities can have catastrophic supply chain implications when present in core infrastructure. Examples include zip slipping, pickle deserialization, and path traversal, which were successfully leveraged across Ubuntu, Fedora, and Alpine.
  • Automated bots and misconfigured CI/CD runners are high-value targets for privilege escalation. Granting excessive permissions to bots or exposing sensitive resources like Docker sockets creates pathways for attackers to hijack build processes.
  • Package signing processes, even with seemingly strict rules, can be vulnerable to bypasses if the implementation is flawed. Fedora's signing rule parser flaw demonstrated how a policy intended to prevent malicious packages could be entirely circumvented.
  • The entire software ecosystem relies on unexamined, "truth-worthy" layers. The research highlights that fundamental components of our digital infrastructure are often assumed secure without adequate scrutiny, leaving them ripe for exploitation.
  • Defending against a compromised Linux distribution pipeline is extremely challenging for end-users. When official, signed packages are malicious, users have few reliable mechanisms to detect or prevent infection, underscoring the paramount importance of distributor security.

About the Speaker(s)

splitline is a Security Researcher at DEVCORE, a security company based in Taiwan. He is also a member of the undefined conclave. With a significant presence in the cybersecurity conference circuit, splitline has been a speaker at prestigious events including Black Hat USA, Black Hat Europe, Black Hat Asia, and HITCON (a conference in Taiwan). Despite his extensive research and speaking experience on advanced topics like supply chain security, he humorously describes himself as "just an average web hacking enjoyer."

Reviews

Dr. Zero (Offensive Security Researcher) — STRONG ACCEPT

This is what actual supply chain research looks like. Instead of whining about npm typosquatting, splitline from DEVCORE went straight for the distro jugular—Ubuntu, Alpine, Fedora—and chained classic bugs into full infrastructure compromise.

Heather Calloway (CISO) — SOLID

This is a deeply technical breakdown of how to compromise the release pipelines of Ubuntu, Alpine, and Fedora to push officially signed malware. While the exploit mechanics belong to your security engineering teams, the strategic takeaway is stark: our foundational root of trust is brittle. It changes how we have to model third-party risk.

→ Top-rated talks at SEC-T 2026

All talks from SEC-T 2026