Vá direto para um resumo gerado por IA desta postagem do blog

A aplicação de patches em tempo real é um método de atualização do kernel do Linux sem reiniciá-lo – e, portanto, sem a necessidade de reiniciar a máquina. A aplicação de patches em tempo real é frequentemente utilizada para corrigir vulnerabilidades graves do kernel do Linux sem demora, pois a aplicação de patches em tempo real não causa interrupções e não requer um intervalo de manutenção.

Existem algumas ferramentas de aplicação de patches em tempo real disponíveis, e os usuários do sistema operacional Debian às vezes recorrem ao kpatch para aplicar patches em tempo real — ou para ajustar o kernel.

Este tutorial é uma demonstração prática do kpatch. Mostraremos como usar o kpatch para alterar o comportamento de um kernel do Debian 10 em execução sem precisar pará-lo, modificando o conteúdo de /proc/uptime (e do uptime ) de modo que o tempo de atividade relatado pelo sistema seja 10 anos maior.

O kpatch foi criado pela Red Hat e funciona no Red Hat Enterprise Linux (RHEL) e em seus derivados. A Red Hat oferece esse serviço comercial de aplicação de patches em tempo real para os clientes do RHEL. Na TuxCare, oferecemos o KernelCare Enterprise – que é capaz de aplicar patches em tempo real no RHEL, bem como em todas as outras distribuições Linux corporativas populares.

Escolhi o kpatch para este tutorial porque seu código-fonte está disponível gratuitamente e é atualizado regularmente.

Pré-requisitos

Aqui estão os pré-requisitos do sistema para acompanhar este tutorial:

Um sistema de teste (fora de produção) rodando o Debian Bullseye (a versão 11.6 foi utilizada nesta demonstração) em uma arquitetura x86_64/amd64
20 Gb de espaço livre em disco (o código-fonte do kernel do Linux ocupa cerca de 909 mb no disco, chegando a 17 gb quando compilado)
Seu kernel não foi personalizado; você está usando o kernel padrão fornecido pelo Debian
Seu kernel possui o recurso de correção dinâmica integrado. Use este comando e você verá dois valores definidos como y para CONFIG_HAVE_LIVEPATCH e CONFIG_LIVEPATCH:

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

A versão do gcc instalada corresponde à utilizada para compilar o kernel original (O kpatch-build O comando falhará se as versões não corresponderem. Isso pode ser contornado com a opção –skip-gcc-check, embora seu uso não seja recomendado.)
- Para verificar a versão do gcc instalada: gcc –version
- Para verificar a versão do gcc usada para compilar o kernel atual: cat /proc/version

Instalar pacotes de dependências

Instalar e configurar sudo

Como usuário 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. Instalar pacotes

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

Instale o kpatch

Como é comum nos pacotes do Debian, há um atraso entre as versões atuais e as versões oferecidas como atualizações pelo apt padrão. Vamos pegar o código mais recente do kpatch e compilá-lo a partir do código-fonte.

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

Obtenha uma cópia do código-fonte do kernel do Linux

(Opcional) Crie e acesse um diretório de trabalho

mkdir kernel && cd $_

Extrair o código-fonte do kernel do Linux

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

Observação: 5.10 é a versão do kernel do Linux para o Debian 11.6 no momento da redação deste artigo. Você deve verificar e substituir por a versão mais recente presente em /usr/src, como 5.10 para o Debian 11.7 ou 6.1 para o Debian 12, dependendo do seu sistema.

Criar o arquivo de configuração do kernel do Linux

O kernel do Linux é compilado usando as configurações de um arquivo de configuração fornecido com a sua distribuição. Faça uma cópia e altere algumas configurações para que o kpatch-build possa compilar um kernel do Linux com as mesmas configurações do kernel que está em execução.
cd linux-source-5.10

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

Verifique se as configurações necessárias do kernel estão ativadas para o uso do kpatch. Todas devem retornar “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 MÓDULOS
```
```
scripts/config -s MODULE_SIG
```
```
scripts/config -s SYSFS
```

scripts/config -s SYSTEM_TRUSTED_KEYRING

Alterar o valor de um item de configuração do kernel

scripts/config --set-str SYSTEM_TRUSTED_KEYS ""

Saia do diretório de origem

cd .

Criar um patch

Um arquivo-fonte de patch é o resultado da execução do comando comando executado nos arquivos de código-fonte original e alterado.

O exemplo de aplicação de patch apresentado na seção “Introdução rápida” da página do kpatch no GitHub altera a saída de /proc/meminfo. Muitos outros artigos sobre o kpatch reproduzem esse exemplo, então eu queria algo diferente e um pouco mais interessante, mas que ainda fosse seguro.

Este exemplo altera a saída do comando uptime para dar a impressão de que o tempo de atividade do seu servidor aumentou em uma década.

Ainda no seu diretório de trabalho, copie um arquivo

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

Edite isso. Na linha 33, altere:

(unsigned long) uptime.tv_sec,

para

(unsigned long) uptime.tv_sec + 315576000,

Salve o arquivo

Crie o arquivo de patch

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

Crie o módulo de patch. (Na primeira vez que você fizer isso, levará algum tempo, pois o código-fonte do kernel precisa ser compilado. As compilações subsequentes são significativamente mais rápidas, da ordem de minutos. Essa é uma daquelas operações em que utilizar mais CPUs (virtuais) ajudará a acelerar o processo. Trata-se de uma tarefa limitada pela CPU).

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

Ao concluir, você terá um Linux Módulo de Kernel Carregável (.ko) para o patch

ls -l *.ko

Teste o patch

Antes de carregar o módulo de patch, verifique o tempo de atividade atual

cat /proc/uptime && uptime -p

Carregar o módulo de patch

sudo kpatch load livepatch-uptime.ko

Verifique o tempo de atividade novamente

cat /proc/uptime && uptime -p

Você deve perceber que o tempo de atividade está dez anos melhor (o valor interno não foi alterado, apenas o que é exibido)

Descarregar o módulo de patch

sudo kpatch unload livepatch-uptime.ko

Verifique se o tempo de atividade voltou ao valor anterior

cat /proc/uptime && uptime -p

Conclusão

Aplicar patches em tempo real no kernel do Linux com o kpatch não é difícil. A dificuldade está em escrever um patch que não trave o sistema e que seja compatível com outros patches que venham a ser aplicados posteriormente. A maioria dos patches é criada a partir de mais do que um simples diferença e exigem testes minuciosos em várias versões do kernel rodando em diversas distribuições.

Os autores de patches precisam ser, ao mesmo tempo, programadores experientes em C e desenvolvedores experientes do kernel do Linux. Compilar o kernel e testar patches para cada versão do kernel exige um grande investimento em hardware e ferramentas de automação.

A escassez de profissionais qualificados e o custo da infraestrutura fazem com que os fornecedores sejam obrigados a cobrar pelos serviços de aplicação de patches em tempo real, que geralmente são oferecidos por meio de programas de manutenção onerosos.

Essas cobranças somam valores elevados, mas esse não é o caso do serviço de correções em tempo real da TuxCare — que custa a partir de apenas US$ 49,50 por servidor por ano para Linux. Clique aqui para saber mais sobre a gama de serviços de aplicação de patches em tempo real da TuxCare para o kernel do Linux, bancos de dados, bibliotecas compartilhadas, dispositivos de IoT e sistemas de virtualização.

E não se esqueça de ler nosso guia detalhado sobre “Como aplicar patches de segurança no kernel do Linux: 3 maneiras diferentes”. O artigo explica como atualizar kernels do Linux sem reiniciar o sistema, abordando três métodos diferentes para alguns dos kernels mais populares do Linux.

Resumo