Tutoriel pour les développeurs : Corrections en direct du noyau Linux Focal Fossa d'Ubuntu 20.04 LTS avec Kpatch

Le live patching est un moyen de mettre à jour un noyau Linux sans interruption. Comme les mises à jour du noyau ne prennent effet qu'après le redémarrage du système, le live patching du noyau Linux est le plus souvent utilisé pour corriger les vulnérabilités graves du noyau Linux sans redémarrer les serveurs.

Outre l'amélioration de la continuité et de la disponibilité des services, les organisations disposant d'un grand parc de serveurs utilisent également les correctifs en direct pour éviter les frais administratifs liés à la coordination et à la planification nécessaires au redémarrage de plusieurs systèmes.

Ce tutoriel montrera comment utiliser Kpatch pour modifier le comportement d'un noyau Ubuntu 20.04 LTS Focal Fossa en cours d'exécution sans l'arrêter, en modifiant le contenu du fichier /proc/uptime (et le uptime ) afin que le temps de fonctionnement du système soit supérieur de 10 ans.

Kpatch a été créé par Red Hat et fonctionne sur RHEL et ses dérivés. Red Hat propose un service commercial de correctifs en direct pour les clients RHEL, tout comme les entreprises suivantes, qui se concentrent chacune sur des distributions différentes :

• Service Livepatch de Canonical pour Ubuntu ;
• KernelCare pour la plupart des principales distributions Linux ;
• Ksplice pour Oracle Linux ;
• SUSE Live Patching (précédemment connu sous le nom de Kgraft) pour SUSE Enterprise Linux.

Obtenez un essai GRATUIT de 7 jours avec assistance de KernelCare 

Nous avons choisi Kpatch pour ce tutoriel car c'est l'une des rares solutions dont le code source est librement disponible et régulièrement mis à jour. Nous avons un autre tutoriel sur Patchage en direct du noyau Linux de Debian 10 avec Kpatch - consultez-le également.

Conditions préalables

Voici les conditions préalables du système pour suivre ce tutoriel.

• Un système de test (non productif) exécutant Ubuntu 20.04 Focal Fossa sur une architecture x86_64/amd64.
• 20 Go d'espace disque libre. (Le code source du noyau Linux occupe environ 909 Mo sur le disque, et passe à 17 Go une fois compilé).
• Votre noyau n'a pas été personnalisé ; vous utilisez le noyau standard fourni par Debian.
• Votre noyau dispose d'un correctif en direct intégré. Utilisez cette commande et attendez-vous à voir deux valeurs définies comme suit y pour CONFIG_HAVE_LIVEPATCH et CONFIG_LIVEPATCH:

grep LIVEPATCH /boot/config-$(uname -r)

• La version de gcc installée correspond à celle utilisée pour construire le noyau d'origine. (Le kpatch-build échouera si les versions ne correspondent pas. Ceci peut être surchargé avec l'option --skip-gcc-checkbien que son utilisation soit découragée).
  • Pour voir la version de gcc installée : gcc --version (if gcc not installed run ”sudo apt install gcc”)
  • Pour voir la version de gcc utilisée pour compiler le noyau actuel : cat /proc/version

1. Installer les paquets de dépendance

1. Installer et configurer sudo.

   Comme root:

   apt-get install sudo
   adduser <user> sudo

   où <user> est le nom d'utilisateur d'un utilisateur normal. (Toutes les commandes suivantes doivent être effectuées en tant que cet utilisateur).

2. Installer les paquets.

   sudo apt-get -y update
   sudo apt-get -y upgrade
   sudo apt-get -y install build-essential devscripts 
   ccache 
   gawk libelf-dev libssl-dev linux-source flex bison

2. Installez Kpatch

Le paquet kpatch de Focal Fossa n'est plus à jour, vous devez donc l'installer à partir des sources.

git clone https://github.com/dynup/kpatch.git
cd kpatch && make && sudo make install

3. Obtenez une copie du code source du noyau Linux.

1. (Facultatif) Créez et déplacez-vous dans un répertoire de travail.

   mkdir kernel && cd $_

2. Extraire le code source du noyau Linux.

   tar xaf /usr/src/linux-source-5.4.0.tar.bz2

   Note : 5.4.0 est la version du noyau Linux pour Ubuntu 20.04 au moment de l'écriture. Vous devez vérifier et remplacer la version la plus récente présente dans /usr/src.

4. Créer le fichier de configuration du noyau Linux

1. Le noyau Linux est compilé en utilisant les paramètres d'un fichier de configuration fourni avec votre distribution. Prenez une copie et modifiez certains paramètres de sorte que kpatch-build peut compiler un noyau Linux avec les mêmes paramètres que votre noyau en cours d'exécution.

   cd linux-source-5.4.0/
   cp /boot/config-$(uname -r) .config

2. Vérifiez que les paramètres requis du noyau sont activés pour utiliser Kpatch. Tous devraient retourner 'y'.

   scripts/config -s DYNAMIC_FTRACE_WITH_REGS
   scripts/config -s FUNCTION_TRACER
   scripts/config -s HAVE_DYNAMIC_FTRACE_WITH_REGS
   scripts/config -s HAVE_FENTRY
   scripts/config -s HAVE_LIVEPATCH
   scripts/config -s KALLSYMS_ALL
   scripts/config -s KALLSYMS
   scripts/config -s LIVEPATCH
   scripts/config -s MODULES
   scripts/config -s MODULE_SIG
   scripts/config -s SYSFS
   scripts/config -s SYSTÈME_TRUSTED_KEYRING

3. Modifier la valeur d'un élément de configuration du noyau.

   scripts/config --set-str SYSTEM_TRUSTED_KEYS ""

4. Laissez le répertoire source.

   cd ..

5. Créer un patch

Un fichier source de patch est la sortie de la commande diff exécutée sur les fichiers de code source originaux et modifiés.

L'exemple d'application d'un correctif présenté dans la section "Démarrage rapide" de l'outil d'évaluation de la sécurité de l'UE. Page github de kpatch modifie la sortie de /proc/meminfo. De nombreux autres articles de Kpatch reproduisent cet exemple, je voulais donc quelque chose de différent et d'un peu plus intéressant, tout en restant sûr.

Cet exemple modifie la sortie de la fonction uptime pour leur donner l'illusion que le temps de fonctionnement de votre serveur a augmenté d'une décennie.

1. Toujours dans votre répertoire de travail, copiez un fichier.

   cp linux-source-5.4.0/fs/proc/uptime.c .

2. Modifiez-le. A la ligne 26, changez :

   (unsigned long) uptime.tv_sec,

   à

   (unsigned long) uptime.tv_sec + 315576000,

   Enregistrez le fichier.

3. Créez le fichier patch.

   diff -u linux-source-5.4.0/fs/proc/uptime.c ./uptime.c > uptime.patch

4. Installer paquets de symboles de débogage noyau :

   sudo apt install linux-image-$(uname -r)-dbgsym

5. Créez le module de correction. (La première fois que vous faites cela, cela prendra quelques heures, car le code source du noyau doit être compilé. Les constructions ultérieures sont nettement plus rapides, de l'ordre de quelques minutes).

   kpatch-build -t vmlinux -v /usr/lib/debug/boot/vmlinux-5.4.0-37-generic uptime.patch

6. Quand ce sera fait, vous aurez un Linux Module noyau chargeable fichier (.ko) pour le patch.

   ls -l *.ko

6. Testez le patch

1. Avant de charger le module de correction, vérifiez le temps de fonctionnement actuel.

   cat /proc/uptime && uptime -p

2. Chargez le module de correction.

   sudo kpatch load livepatch-uptime.ko

3. Vérifiez à nouveau le temps de fonctionnement.

   cat /proc/uptime && uptime -p

   Vous devriez voir que votre temps de fonctionnement est amélioré de dix ans. (La valeur interne n'a pas été modifiée, seulement ce qui est imprimé).

4. Déchargez le module de correction.

   sudo kpatch unload livepatch-uptime.ko

5. Vérifiez que le temps de fonctionnement est revenu à sa valeur précédente.

   cat /proc/uptime && uptime -p

Conclusion

Patcher en direct le noyau Linux avec Kpatch n'est pas difficile. La difficulté réside dans l'écriture d'un patch qui ne fera pas planter le système et qui fonctionnera avec les autres patchs qui viendront plus tard. La plupart des correctifs sont créés à partir de plus qu'un simple diff et doivent faire l'objet de tests approfondis sur plusieurs versions de noyaux fonctionnant sur diverses distributions.

Les rédacteurs de patchs doivent être à la fois des programmeurs C accomplis et des développeurs expérimentés du noyau Linux, et la compilation du noyau et le test des patchs pour chaque version du noyau nécessitent un investissement important en matériel et en outils d'automatisation. En raison de la rareté des compétences et du coût de l'infrastructure, les fournisseurs doivent facturer les services de correctifs en direct.

Et n'oubliez pas de lire notre guide explicite sur Comment appliquer les correctifs de sécurité du noyau Linux : 3 Different Ways. L'article explique comment mettre à jour les noyaux Linux sans redémarrer, en couvrant trois méthodes différentes pour certains des noyaux Linux les plus populaires.