Developer Tutorial: Live patching Debian 10 Linux kernel with Kpatch

January 27, 2023 - TuxCare PR Team

Live patching is a method of updating a Linux kernel without restarting the kernel – and therefore without the need to reboot the machine. Live patching is often used to patch severe Linux kernel vulnerabilities without delay, because live patching doesn’t cause disruption and doesn’t require a maintenance window.

There are a few live patching tools out there and users of the Debian operating system sometimes turn to kpatch to implement live patching – or to tweak the kernel.

This tutorial is a practical demonstration of kpatch. We will demonstrate how to use kpatch to change the behavior of a running Debian 10 kernel without stopping it, changing the contents of /proc/uptime (and the uptime command) so that the system’s reported uptime is 10 years greater.

kpatch was created by Red Hat and works on Red Hat Enterprise Linux (RHEL) and its derivatives. Red Hat offers this commercial live patching service for RHEL customers. At TuxCare, we offer KernelCare Enterprise – which is able to live patch RHEL as well as every other popular enterprise Linux distribution.

I have chosen kpatch for this tutorial because its source code is freely available and regularly updated.

Prerequisites

Here are the system prerequisites for following this tutorial:

A test (non-production) system running Debian Bullseye (11.6 was used for this demo) on an x86_64/amd64 architecture
20 Gb of free disk space (the Linux kernel source code takes up around 909 mb on disk, growing to 17 gb when compiled)
Your kernel has not been customized; you are using the standard kernel supplied by Debian
Your kernel has live patching built in. Use this command and expect to see two values set to y for CONFIG_HAVE_LIVEPATCH and CONFIG_LIVEPATCH:

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

Version of gcc installed matches that used to build the original kernel (The kpatch-build command will fail if the versions don’t match. This can be overridden with the option –skip-gcc-check, although use of it is discouraged.)
- To see the version of gcc installed: gcc –version
- To see the version of gcc used to compile the current kernel: cat /proc/version

Install Dependency Packages

Install and configure sudo

As root:

  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.Install packages

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

Install kpatch

As is common with Debian’s packages, there is a delay between the current versions and the versions offered as updates through regular apt. Let’s take the most current kpatch code and build it from source.

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

Get a Copy of the Linux Kernel Source Code

(Optional) Make and move into a working directory

mkdir kernel && cd $_

Extract the Linux kernel source code

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

Note: 5.10 is the Linux kernel version for Debian 11.6 at the time of writing. You should check and substitute the most recent version present in /usr/src

Create The Linux Kernel Configuration File

The Linux kernel is compiled using settings in a configuration file supplied with your distribution. Take a copy and change some settings so kpatch-build can compile a Linux kernel with the same settings as your running kernel.
cd linux-source-5.10

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

Check that the required kernel settings are enabled for using kpatch. All should return ‘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_ALL
```
```
scripts/config -s LIVEPATCH
```
```
scripts/config -s MODULES
```
```
scripts/config -s MODULE_SIG
```
```
scripts/config -s SYSFS
```

scripts/config -s SYSTEM_TRUSTED_KEYRING

Change the value of one kernel configuration item

scripts/config --set-str SYSTEM_TRUSTED_KEYS ""

Leave the source directory

cd .

Create a Patch

A patch source file is the output from the diff command run on the original and the changed source code files.

The patching example shown in the ‘Quick start’ section of the kpatch github page changes the output of /proc/meminfo. Many other kpatch articles reproduce this example, so I wanted something different and a little more interesting, yet still safe.

This example changes the output of the uptime command to give the illusion that your server’s uptime has increased by a decade.

Still in your working directory, copy a file

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

Edit it. On line 33, change:

(unsigned long) uptime.tv_sec,

(unsigned long) uptime.tv_sec + 315576000,

Save the file

Create the patch file

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

Create the patch module. (The first time you do this, it will take some time, as the kernel source code must be compiled. Subsequent builds are significantly faster, in the order of minutes. This is one of those operations where throwing more (virtual) CPUs at the problem will help speed the process along. It is a CPU-bound task).

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

When done, you will have a Linux Loadable Kernel Module file (.ko) for the patch

ls -l *.ko

Test the Patch

Before loading the patch module, check the current uptime

cat /proc/uptime && uptime -p

Load the patch module

sudo kpatch load livepatch-uptime.ko

Check the uptime again

cat /proc/uptime && uptime -p

You should see your uptime is ten years better (the internal value hasn’t been changed, only what is printed)

Unload the patch module

sudo kpatch unload livepatch-uptime.ko

Check that the uptime has returned to its former value

cat /proc/uptime && uptime -p

Conclusion

Live patching the Linux kernel with kpatch isn’t hard. The difficulty lies in writing a patch that won’t crash the system and that will work with other patches that come later. Most patches are created from more than a simple diff and need thorough testing across multiple kernel versions running on various distributions.

Patch writers need to be both accomplished C programmers and experienced Linux kernel developers. Compiling the kernel and testing patches for every kernel version requires a large investment in hardware and automation tools.

The rarity of skills and the cost of infrastructure means that vendors must charge for live patching services, which are often provided through expensive maintenance programs.

These charges add up to large sums, but that’s not the case with TuxCare’s live patching service – which starts from just $59.50/server/year for Linux. Click here to read more about TuxCare’s range of live patching services for the Linux kernel, databases, shared libraries, IoT devices, and virtualization systems.

And don’t forget to read our explicit guide on How to Apply Linux Kernel Security Patches: 3 Different Ways. The article explains how to update Linux kernels without rebooting, covering three different methods for some of the most popular Linux kernels.

Summary