Le live patching est une méthode de mise à jour d'un noyau Linux sans redémarrer le noyau - et donc sans avoir à redémarrer la machine. Le live patching est souvent utilisé pour corriger sans délai les vulnérabilités graves du noyau Linux, car le live patching ne provoque pas de perturbation 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 montrerons comment utiliser kpatch pour changer le comportement d'un noyau Debian 10 en cours d'exécution sans l'arrêter, en modifiant 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 offre ce service commercial de live patching pour les 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 conditions préalables du système pour suivre ce tutoriel :

• Un système de test (non productif) fonctionnant sous Debian Bullseye (la version 11.6 a été utilisée pour cette démonstration) sur une architecture x86_64/amd64.
• 20 Go d'espace disque disponible (le code source du noyau Linux occupe environ 909 Mo sur le disque, et 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 sur 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. 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
  • Pour voir 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

Comme 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 il est courant avec les paquets Debian, il y a un délai entre les versions actuelles et les versions proposées comme mises à jour par le biais d'apt régulier. Prenons le code le plus récent de kpatch 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 dans 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 l'écriture. Vous devez vérifier et substituer 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 afin 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 retourner 'y'.

2. scripts/config -s DYNAMIC_FTRACE_WITH_REGS

3. scripts/config -s FONCTION_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. Laissez le répertoire source

cd .

5. Créer un patch

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

L'exemple de correction présenté dans la section "Quick start" de la page github de 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 commande uptime pour 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-4.19/fs/proc/uptime.c .

1. Modifiez-le. A la ligne 33, changez :

(long non signé) uptime.tv_sec,

à

(unsigned long) uptime.tv_sec + 315576000,

Sauvegarder 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 nettement plus rapides, de l'ordre de quelques minutes. Il s'agit d'une de ces opérations où le fait d'injecter plus de CPU (virtuels) dans le problème aidera à accélérer le processus. Il s'agit d'une tâche liée au processeur).

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

1. Quand c'est fait, vous aurez un module Linux Module noyau chargeable (.ko) pour le patch

ls -l *.ko

6. Testez le correctif

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

cat /proc/uptime && uptime -p

1. Chargez le module de correction

sudo kpatch load livepatch-uptime.ko

1. Vérifiez à 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, seulement ce qui est imprimé).

1. Déchargez le module de correction

sudo kpatch unload livepatch-uptime.ko

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

cat /proc/uptime && uptime -p

Conclusion

Il n'est pas difficile de patcher en direct le noyau Linux avec kpatch. La difficulté réside dans l'écriture d'un correctif qui ne fera pas planter le système et qui fonctionnera avec les autres correctifs qui viendront plus tard. La plupart des correctifs sont créés à partir de plus qu'une simple diff et nécessitent des tests approfondis sur plusieurs versions du noyau fonctionnant sur diverses distributions.

Les rédacteurs de correctifs doivent être à la fois des programmeurs C accomplis et des développeurs expérimentés du noyau Linux. Compiler le noyau et tester les correctifs pour chaque version du noyau nécessite 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, qui sont souvent fournis dans le cadre de programmes de maintenance coûteux.

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

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.

Résumé

Nom de l'article

Tutoriel pour les développeurs : Patchage en direct du noyau Linux de Debian 10-Kpatch

Description

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

Auteur

Stephan Venter

Nom de l'éditeur

TuxCare

Logo de l'éditeur