Alpine Linux reconstruit son GitLab après une tentative d'attaque supply chain via CVE-2026-97229

Les 20 et 21 octobre 2026, des pirates ont exploité la CVE-2026-97229 (CVSS 10.0) contre l'instance GitLab d'Alpine Linux, provoquant huit crashs de processus dont quatre partiellement aboutis. L'équipe Alpine a fermé son GitLab le 27 octobre, reconstruit l'instance de zéro, réinitialisé tous les mots de passe et remplacé les clés secrètes avant de rouvrir le 29 octobre. Aucun package n'a été compromis, mais l'attaquant avait téléchargé l'image Docker GitLab d'Alpine, suggérant la préparation d'un empoisonnement de la chaîne d'approvisionnement (supply chain). Si vous utilisez des images Alpine dans vos containers Docker sur un VPS Linux ou un serveur dédié, cet incident justifie un audit de vos images et de vos builds.

Source : Alpine Linux - GitLab security incident CVE-2026-97229.

Alpine Linux : un système d'exploitation clé pour les containers

Alpine Linux est un système d'exploitation minimaliste conçu pour les environnements serveur et les containers. Avec une image de base d'environ 5 Mo, c'est la distribution la plus utilisée comme fondation des images Docker pour les serveurs web, les services MySQL, les applications Node.js, les scripts Python et les serveurs d'applications. Les développeurs et administrateurs de VPS Linux s'en servent pour exécuter des services en production avec une consommation de RAM minimale et une surface d'attaque réduite.

Contrairement à Ubuntu ou Debian, Alpine utilise musl libc et apk comme gestionnaire de packages au lieu de apt. Ce choix de conception réduit la taille des images, ce qui accélère les téléchargements et les déploiements sur les machines virtuelles et les serveurs physiques. Pour les développeurs qui construisent des Dockerfiles multi-stage, Alpine sert fréquemment d'image finale légère après une étape de compilation sur une image plus complète.

Compromettre le système de build d'Alpine, c'est potentiellement injecter du code malveillant dans des millions de containers déployés sur des serveurs web, des bases de données, des serveurs DNS et des services informatiques à travers le monde. C'est ce qui rend l'incident du 20 octobre aussi significatif.

Ce qui s'est passé les 20-21 octobre 2026

Alpine Linux héberge son propre GitLab pour gérer le code source de la distribution, les recettes de packages (APKBUILD) et les pipelines CI/CD qui compilent chaque paquet. L'instance exécutait GitLab 19.3.4, une version antérieure au correctif de sécurité publié par GitLab le 12 octobre 2026. Le 13 octobre, Alpine a par erreur mis à jour vers GitLab 19.3.4 au lieu de 19.3.5, laissant le bug non corrigé.

Le 20 octobre, un attaquant a créé un compte et commencé ses reconnaissances. Il a ensuite envoyé des configurations CI malveillantes (des scripts .gitlab-ci.yml spécialement construits) qui exploitaient la CVE-2026-97229, une faille critique dans le moteur d'expressions régulières Onigmo, embarqué dans Ruby. Ces scripts ont provoqué huit crashs de processus GitLab entre le 20 et le 21 octobre. Quatre de ces crashs ont été partiellement aboutis : les hackers ont pu déclencher un comportement anormal du serveur au-delà d'un simple déni de service.

L'attaquant a également téléchargé l'image conteneur GitLab d'Alpine depuis le registre de la distribution. Ce téléchargement suggère qu'il cherchait à reproduire l'environnement sur sa propre machine pour affiner son exploit, une technique classique de préparation d'attaque supply chain visant à injecter du code malveillant dans les packages distribués.

Le 22 octobre, Alpine a mis à jour vers GitLab 19.3.6, mais le système restait vulnérable : le correctif nécessitait un patch dans Ruby lui-même, pas seulement dans GitLab. Le 23 octobre, le compte de l'attaquant a été bloqué et Ruby a publié les correctifs (versions 3.3.13, 3.4.12 et 4.0.9). Les 25-26 octobre, l'attaquant est revenu avec de nouvelles tentatives de connexion, sans succès.

L'équipe Alpine n'a trouvé aucune preuve d'exécution de code sur le serveur, mais a précisé ne pas pouvoir exclure complètement cette possibilité en raison de lacunes dans l'infrastructure de journalisation et de la perte des logs des tâches d'arrière-plan.

CVE-2026-97229 : faille critique dans Onigmo

La CVE-2026-97229 est un bug de sécurité noté 10.0 sur 10 (score CVSS maximal) dans Onigmo, le moteur d'expressions régulières intégré à Ruby. L'évaluation de certaines expressions régulières spécialement construites permet à un attaquant distant d'exécuter du code arbitraire sur le serveur cible, ou au minimum de provoquer un crash du processus.

GitLab, écrit en Ruby on Rails, utilise intensivement les expressions régulières pour analyser les fichiers de configuration CI (.gitlab-ci.yml), les commentaires, les pipelines et les branches. Un script CI malveillant contenant une expression régulière piégée peut atteindre directement le moteur vulnérable. L'attaquant n'a besoin que d'un compte GitLab de base pour soumettre ces configurations.

Ce type de bugs affecte toute application Ruby qui traite des expressions régulières à partir d'entrées utilisateur : serveurs web Rails, outils d'intégration continue, scripts d'automatisation et applications déployées dans des containers sur des machines virtuelles ou des serveurs dédiés.

Alpine exécutait GitLab 19.3.4 au moment de l'attaque. Même après la mise à jour vers 19.3.6 le 22 octobre, le système restait vulnérable : les correctifs officiels de Ruby n'ont été publiés que le 23 octobre. Ce délai de 11 jours entre le patch GitLab et le patch Ruby illustre un problème récurrent en sécurité informatique : une faille dans une dépendance profonde (ici le moteur regex du langage) n'est pas corrigée par une simple mise à jour de l'application qui l'utilise.

La réponse d'Alpine : reconstruction complète

Face à l'impossibilité d'exclure une compromission, l'équipe Alpine a appliqué la seule réponse fiable en sécurité informatique : une reconstruction complète de l'infrastructure GitLab, l'équivalent d'un reformatage complet d'un serveur suspect.

• Fermeture le 27 octobre : l'instance GitLab a été mise hors ligne pour analyse forensique.
• Reconstruction from scratch le 28 octobre : nouveau serveur, nouvelle installation GitLab 19.3.7, restauration des dépôts depuis des sauvegardes vérifiées.
• Réouverture le 29 octobre : GitLab remis en ligne après validation.
• Réinitialisation de tous les mots de passe : chaque compte utilisateur du GitLab a dû redéfinir son mot de passe.
• Remplacement des clés secrètes GitLab : tokens d'API, clés de chiffrement internes, secrets de session, tokens de runners CI.
• Vérification de l'intégrité des packages : les packages publiés entre le 20 et le 24 octobre ont été comparés à des enregistrements conservés sur 45 serveurs de build indépendants. Aucun n'avait été modifié.
• Journalisation renforcée : ajout de logs pour les connexions sortantes et les accès aux bases de données.
• Tags de release signés : permet aux développeurs de vérifier indépendamment l'authenticité de chaque version publiée.

Les clés de signature des packages Alpine n'ont jamais été stockées sur le serveur GitLab, ce qui a empêché les pirates de signer de faux packages même en cas d'exécution de code root sur le serveur.

Alpine a également annoncé un objectif de déploiement des correctifs de sécurité critiques sous 24 heures après publication. C'est un rappel concret pour tout administrateur de VPS qui automatise ses mises à jour de sécurité : le délai entre la publication d'un correctif et son application est la fenêtre d'attaque que les hackers exploitent.

Aucun package compromis, mais un risque réel

L'enquête forensique d'Alpine, menée du 24 au 27 octobre, a confirmé qu'aucun package distribué n'a été altéré. Tous les commits du dépôt aports (les recettes de build) effectués entre le 20 et le 22 octobre correspondent aux enregistrements provenant de clones indépendants des développeurs et de 45 serveurs de compilation. Les releases Alpine 3.21.9, 3.22.7, 3.23.7 et 3.24.3 publiées le 21 octobre ont été vérifiées intègres.

Cependant, le scénario visé par l'attaquant est bien documenté en sécurité informatique : compromettre le système de build d'une distribution Linux pour injecter du code malveillant dans des packages légitimes. Ce type d'attaque supply chain a un impact massif car les images Docker basées sur Alpine sont parmi les plus utilisées au monde. Les images officielles alpine, python:alpine, node:alpine et nginx:alpine cumulent des milliards de téléchargements sur Docker Hub.

Si l'attaque avait réussi, les données potentiellement exposées comprenaient : adresses e-mail, hachages de mots de passe, secrets 2FA, variables CI/CD, tokens de runners, identifiants de webhooks, tokens d'accès personnels et dépôts privés. Pour un administrateur qui exécute des containers Docker sur un VPS, la confiance dans les images de base repose sur l'intégrité de la chaîne de compilation en amont.

Ce que cela signifie pour les administrateurs de serveurs

Les containers basés sur Alpine exécutent une part significative des services informatiques hébergés sur des VPS et des serveurs dédiés : serveurs web Nginx et Apache, bases de données MySQL et PostgreSQL, serveurs DNS, services FTP, applications PHP, scripts d'automatisation et services de virtualisation légers. Un empoisonnement de la chaîne d'approvisionnement Alpine aurait touché tous ces services simultanément.

Pour un hébergeur ou un administrateur système qui gère des VPS avec Docker, cet incident met en lumière trois risques concrets :

• Dépendance à une image de base unique : si Alpine est compromis, tous vos containers le sont, que ce soit votre serveur web, votre base de données ou vos scripts de maintenance.
• Délai de propagation des correctifs : 11 jours se sont écoulés entre le patch GitLab et le patch Ruby. Pendant ce délai, exécuter apk upgrade sur un container Alpine n'aurait rien corrigé.
• Confiance implicite dans les tags Docker : un tag comme alpine:latest peut pointer vers une image différente d'un jour à l'autre. Sans vérification de digest, une machine virtuelle peut télécharger une image modifiée sans que l'administrateur ne le remarque.

Vérifier et mettre à jour vos images Alpine Docker

Si vous utilisez des images Docker basées sur Alpine sur votre VPS Linux, commencez par vérifier quelles versions tournent actuellement. Ouvrez un terminal et exécutez cette commande en ligne de commande :

docker images --filter "reference=*alpine*" --format "{{.Repository}}:{{.Tag}}  {{.CreatedAt}}"

Cette commande liste toutes les images dont le nom contient alpine, avec leur tag et leur date de création. Pour vérifier la version exacte du système d'exploitation Alpine à l'intérieur d'un container en cours d'exécution :

docker exec mon-conteneur cat /etc/alpine-release

Identifiez les images datant d'avant le 29 octobre 2026 et mettez-les à jour. Si vous utilisez des images Alpine pour un serveur web, une base de données ou des scripts de traitement, mettez à jour chaque image concernée :

docker pull alpine:latest
docker pull python:3.12-alpine
docker pull node:22-alpine
docker pull nginx:alpine
docker pull php:8.3-fpm-alpine

Après avoir récupéré les nouvelles images, recréez vos containers pour qu'ils utilisent les versions à jour. Si vous utilisez Docker Compose, la migration vers les images corrigées se fait en deux commandes :

docker compose pull
docker compose up -d

Supprimez les anciennes images inutilisées pour libérer de l'espace disque et du processeur de votre VPS lors des scans. Notre guide nettoyer Docker sur VPS Linux détaille la procédure complète avec docker system prune.

Auditer vos builds multi-stage sur VPS

Les Dockerfiles multi-stage utilisent souvent une image Alpine comme base de compilation ou comme image finale légère. Les développeurs s'en servent pour réduire la taille des images déployées sur leurs machines virtuelles et serveurs dédiés. Vérifiez les instructions FROM de vos Dockerfiles en ligne de commande pour identifier les images de base et leurs tags :

grep -rn "^FROM.*alpine" ~/docker/*/Dockerfile

Remplacez les tags flottants (alpine:latest) par des tags versionnés (alpine:3.21) pour maîtriser exactement quelle version du système d'exploitation s'exécute sur votre serveur. Épinglez vos images de base avec un digest SHA256 dans vos Dockerfiles pour garantir la reproductibilité et détecter toute modification inattendue :

FROM alpine:3.21@sha256:abc123...digest...

Cette pratique empêche un tag modifié en amont de se propager silencieusement dans vos builds. Combinez-la avec un scan régulier des vulnérabilités connues dans vos images. Exécutez un de ces outils en ligne de commande sur votre VPS :

docker scout cves alpine:3.21
# ou avec Trivy
trivy image alpine:3.21

Pour les containers PHP sur Alpine, notre guide auditer et patcher les conteneurs Docker PHP couvre les vérifications spécifiques aux images php:*-alpine.

Checklist de sécurité pour les administrateurs de VPS

Suite à cet incident, voici les actions concrètes à exécuter sur votre infrastructure :

Si vous hébergez un GitLab auto-hébergé ou un autre service d'intégration continue sur votre VPS, appliquez les mêmes principes qu'Alpine : mises à jour immédiates des correctifs critiques, journalisation renforcée des accès, et séparation des clés de signature des packages du serveur de build. Pour sécuriser l'accès en ligne de commande à votre serveur, consultez notre guide sécuriser SSH sur VPS Linux.

Ce qu'il faut retenir

L'incident du GitLab d'Alpine Linux illustre la fragilité de la chaîne d'approvisionnement logicielle : un seul bug non corrigé dans un moteur d'expressions régulières a failli ouvrir la porte à l'empoisonnement de millions de containers Docker déployés sur des machines virtuelles et des serveurs dédiés à travers le monde. Les pirates visaient le coeur de la distribution : le système de build qui produit les packages installés par des développeurs et des administrateurs sur leurs serveurs web, leurs bases de données MySQL, leurs services DNS et tous leurs services informatiques.

Alpine a réagi avec rigueur en reconstruisant son infrastructure de zéro, en réinitialisant tous les accès et en vérifiant l'intégrité de chaque package publié. Pour les administrateurs de VPS et de serveurs dédiés, les actions concrètes sont : mettre à jour vos images Alpine Docker, épingler vos images de base avec des digests SHA256, exécuter des scans de vulnérabilités en ligne de commande, automatiser les mises à jour de sécurité de vos serveurs et auditer régulièrement vos Dockerfiles et vos scripts CI/CD. La sécurité d'un container commence par la confiance dans son image de base, et cette confiance se vérifie, elle ne se présume pas.