Le live patching est une méthode de mise à jour d'un noyau Linux sans redémarrer le noyau - et donc sans qu'il soit nécessaire de redémarrer la machine. Le live patching est souvent utilisé pour corriger sans délai les vulnérabilités graves du noyau Linux, pour les raisons suivantes le live patching ne provoque pas d'interruption et ne nécessite pas de fenêtre de maintenance.

Il existe quelques outils de correction en direct et les utilisateurs du système d'exploitation Debian se tournent parfois vers kpatch pour mettre en œuvre la correction en direct - ou pour modifier le noyau.

Ce tutoriel est une démonstration pratique de kpatch. Nous allons montrer comment utiliser kpatch pour modifier le comportement d'un noyau Debian 10 en cours d'exécution sans l'arrêter, en changeant le contenu de /proc/uptime (et le fichier 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 Red Hat Enterprise Linux (RHEL) et ses dérivés. Red Hat propose ce service commercial de live patching aux clients RHEL. Chez TuxCare, nous proposons KernelCare Enterprise - qui est capable de patcher en direct RHEL ainsi que toute autre distribution Linux d'entreprise populaire.

J'ai choisi kpatch pour ce tutoriel car son code source est librement disponible et régulièrement mis à jour.

Conditions préalables

Voici les prérequis du système pour suivre ce tutoriel :

• Un système de test (hors production) fonctionnant sous Debian Bullseye (la 11.6 a été utilisée pour cette démo) 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 (live patching). Utilisez cette commande et attendez-vous à voir deux valeurs fixées à 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 original. kpatch-build échouera si les versions ne correspondent pas. Ceci peut être surchargé avec l'option -skip-gcc-check(bien que son utilisation soit découragée).
  • Pour connaître la version de gcc installée : gcc -version
  • Pour connaître la version de gcc utilisée pour compiler le noyau actuel : cat /proc/version

1. Installer les paquets de dépendances

1. Installer et configurer sudo

En tant que racine:

  apt-get install sudo 

  (sudo should already be installed, but this makes sure of it)

  adduser <user> sudo

  where <user> is the username for a normal user (all subsequent commands should be done as this user)

     2. installer les paquets

  3.sudo apt-get -y update

  4. sudo apt-get -y upgrade

  5.sudo apt-get -y install build-essential devscripts ccache gawk libelf-dev libssl-dev linux-source linux-image-$(uname -r)-dbg 

2. Installer kpatch

Comme c'est souvent le cas avec les paquets Debian, il y a un décalage entre les versions actuelles et les versions proposées comme mises à jour par apt. Prenons le code de kpatch le plus récent et construisons-le à partir des sources.

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

3. Obtenir une copie du code source du noyau Linux

1. (Facultatif) Créer et déplacer un répertoire de travail

mkdir kernel && cd $_

1. Extraire le code source du noyau Linux

tar xaf /usr/src/linux-source-5.10.tar.xz

Note : 5.10 est la version du noyau Linux pour Debian 11.6 au moment de la rédaction de ce document. Vous devez vérifier et remplacer la version la plus récente présente dans /usr/src, telle que 5.10 pour Debian 11.7 ou 6.1 pour Debian 12, selon votre système.

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

1. Le noyau Linux est compilé à l'aide des paramètres d'un fichier de configuration fourni avec votre distribution. Faites-en une copie et modifiez certains paramètres de façon à ce que kpatch-build puisse compiler un noyau Linux avec les mêmes paramètres que votre noyau en cours d'exécution.
2. cd linux-source-5.10

cp /boot/config-$(uname -r) .config

1. Vérifiez que les paramètres requis du noyau sont activés pour l'utilisation de kpatch. Tous devraient renvoyer 'y'.

2. scripts/config -s DYNAMIC_FTRACE_WITH_REGS

3. scripts/config -s FUNCTION_TRACER

4. scripts/config -s HAVE_DYNAMIC_FTRACE_WITH_REGS

5. scripts/config -s HAVE_FENTRY

6. scripts/config -s HAVE_LIVEPATCH

7. scripts/config -s KALLSYMS_ALL

8. scripts/config -s KALLSYMS_ALL

9. scripts/config -s LIVEPATCH

10. scripts/config -s MODULES

11. scripts/config -s MODULE_SIG

12. scripts/config -s SYSFS

scripts/config -s SYSTEM_TRUSTED_KEYRING

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

scripts/config --set-str SYSTEM_TRUSTED_KEYS ""

1. Quitter le répertoire source

cd .

5. Créer un patch

Un fichier source de correctifs est le résultat de la fonction diff exécutée sur les fichiers de code source originaux et modifiés.

L'exemple de patching présenté dans la section 'Quick start' de la page github de kpatch sur github modifie la sortie de /proc/meminfo. Beaucoup d'autres articles de kpatch reproduisent cet exemple, donc je voulais 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 donner l'illusion que le temps de fonctionnement de votre serveur a augmenté de dix ans.

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

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

1. Modifiez-le. À la ligne 33, modifiez :

(long non signé) uptime.tv_sec,

à

(unsigned long) uptime.tv_sec + 315576000,

Enregistrer le fichier

1. Créer le fichier patch

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

1. Créez le module de correction. (La première fois que vous faites cela, cela prendra un certain temps, car le code source du noyau doit être compilé. Les compilations suivantes sont beaucoup plus rapides, de l'ordre de quelques minutes. Il s'agit d'une de ces opérations où le fait d'utiliser plus de CPU (virtuels) pour résoudre le problème permettra d'accélérer le processus. Il s'agit d'une tâche liée à l'unité centrale).

kpatch-build -s linux-source-5.10 -v /usr/lib/debug/lib/modules/$(uname -r)/vmlinux uptime.patch

1. Vous obtiendrez alors un module noyau chargeable Linux module noyau chargeable (.ko) pour le correctif

ls -l *.ko

6. Tester le patch

1. Avant de charger le module de correctifs, vérifiez l'heure de disponibilité actuelle.

cat /proc/uptime && uptime -p

1. Charger le module de patch

sudo kpatch load livepatch-uptime.ko

1. Vérifier à nouveau le temps de fonctionnement

cat /proc/uptime && uptime -p

Vous devriez constater que votre temps de fonctionnement est amélioré de dix ans (la valeur interne n'a pas été modifiée, seule l'impression l'a été).

1. Décharger le module de patch

sudo kpatch unload livepatch-uptime.ko

1. Vérifier que le temps de fonctionnement est revenu à son ancienne valeur

cat /proc/uptime && uptime -p

Conclusion

Lelive patching du noyau Linux avec kpatch n'est pas difficile. La difficulté réside dans l'écriture d'un correctif qui ne fera pas planter le système et qui fonctionnera avec d'autres correctifs ultérieurs. La plupart des correctifs sont créés à partir de plus qu'un simple diff et nécessitent des tests approfondis sur plusieurs versions du noyau fonctionnant sur différentes distributions.

Les auteurs de correctifs doivent être à la fois des programmeurs C accomplis et des développeurs expérimentés du noyau Linux. La compilation du noyau et le test des correctifs pour chaque version du noyau nécessitent un investissement important en matériel et en outils d'automatisation. 

La rareté des compétences et le coût de l'infrastructure obligent les fournisseurs à facturer les services de correction en direct, qui sont souvent fournis dans le cadre de programmes de maintenance coûteux.

Ces frais représentent des sommes considérables, mais ce n'est pas le cas avec le service de correctifs en direct de TuxCare, qui commence à partir de 49,50 $/serveur/an pour Linux. Cliquez ici pour en savoir plus sur la gamme de services de live patching de TuxCare pour le noyau Linux, les bases de données, les bibliothèques partagées, les appareils IoT et les systèmes de virtualisation.

Et n'oubliez pas de consulter notre guide détaillé intitulé « Comment appliquer les correctifs de sécurité du noyau Linux : 3 méthodes différentes ». Cet article explique comment mettre à jour les noyaux Linux sans redémarrer, en présentant trois méthodes différentes pour certains des noyaux Linux les plus courants.

Résumé

Nom de l'article

Tutoriel du développeur : Dépannage en direct du noyau Linux de Debian 10 - Kpatch

Description

Ce tutoriel est une démonstration pratique de kpatch. Nous montrerons comment l'utiliser pour modifier le comportement d'un noyau Debian 10 en cours d'exécution.

Auteur

Stephan Venter

Nom de l'éditeur

de TuxCare

Logo de l'éditeur