> For the complete documentation index, see [llms.txt](https://stacked-rwx.gitbook.io/public/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://stacked-rwx.gitbook.io/public/malware-development/linux-kernel-module/procurando-a-syscall-table-em-linux-kernel-5.x.x.md).

# Procurando a Syscall Table em Linux Kernel 5.x.x

📁 Cabeçalho

* 📌Criando um software para capturas de sys\_call\_tables() em kernel 5.x.x
  * 📌Explicação geral sobre todo o corpo do software
  * 📌Conhecendo outros métodos de capturas sem utilizarmos o software
  * 📌Iniciando o módulo e descarregando o buffer do kernel

## 🔮 Criando um software para capturas de sys\_call\_tables() em kernel 5.x.x

* Vamos apresentar então o nosso código aqui:

<figure><img src="/files/KoygJ4OOXWQGBVdu2c3Z" alt=""><figcaption></figcaption></figure>

* Bom, podemos observar que no nosso cabeçalho de includes, temos um novo include chamado `kprobe`. Temos muito o que falar a respeito dele nesse tópico e por isso separei mais um capítulo para explicar de forma bem explicada como nós conseguimos pegar o endereço do sys\_call\_table() no kernel 5.x.x. Mas então... o que seria o kprobe?

\
`Kprobe é uma biblioteca muito importante para esse projeto, já que o Kernel sofreu diversas modificações em suas atualizações. Hoje posso dizer que existe uma maior dificuldade em conseguirmos hookar uma syscall para que possamos fazer um Rootkit (já que esse é o seu intuito de está lendo esse git). Bom, vamos deixar de enrolação e vamos falar o que é a library kprobe. O sistema kprobe permite inserir pontos de interrupção dinamicamente em um Kernel em execução. Básicamente iremos utiliza-lo para cumprir a função do kallsyms_lookup_name() para pesquisar a si mesmo.`\
\
Talvez essa explicação tenha ficado bem rasa, mas caso você queira compreender um pouco mais sobre o kprobe, recomendo você ler [aqui](https://www.kernel.org/doc/html/latest/trace/kprobes.html). Bom, mas agora é hora de darmos continuidade a nossa explicação.

<figure><img src="/files/m5FvOzkwlKknTlPUlNzg" alt=""><figcaption></figcaption></figure>

* Temos aqui então a primeira parte da estrutura do nosso software. O que está acontecendo nessa função é o seguinte. Simplesmente nós declaramos uma estrutura kprobe com o campo `.symbol_name` predefinido como `kallsyms_lookup_name()`. A primeira vez em que o kprobe é registrado, podemos então desreferenciar o `.addr` para obtermos o endereço de memória.

<figure><img src="/files/HS4tvYMFSM7r4CXiAdVF" alt=""><figcaption></figcaption></figure>

* Bom. Partindo agora para a próxima estrutura do nosso código, podemos observar a função de inicialização de carregamento do nosso módulo no Kernel. Primeiramente nós estamos registrando em nosso Kernel o kprobe para que possamos procurar pela função que declaramos no campo `.symbol_name` na primeira parte da estrutura do nosso software. Logo abaixo contamos com um `pr_alert()`, função essa que irá exibir um alerta nos logs de registros do kernel junto com a mensagem e logo afrente o endereço de memória que queríamos obter e caso o retorno for igual a 0, o nosso programa funcionará.

<figure><img src="/files/mO77znaEFTP1iG3LKB8D" alt=""><figcaption></figcaption></figure>

Possuímos aqui então a nossa última estrutura do nosso código. Essa estrutura é responsável por descarregar o buffer do Kernel e com isso a nossa mensagem que foi exibida após nós termos encontrado o endereço e memória, será apagado.

## Conhecendo outros métodos de captura sem utilizarmos o software

Podemos fazer capturas do endereço de memória sem precisarmos utilizar o software que descrevemos acima. Bom, são alguns pequenos comandos que podemos incorporar em nosso terminal para que possamos receber o resultado do que queríamos encontrar. Podemos utilizar o seguinte comando: `sudo cat /proc/kallsyms | grep kallsyms_lookup_name > address.txt` e após isso, digite `cat address.txt` e veja o retorno que você recebeu dentro do arquivo de texto. Bom, o retorno será o endereço de memória que você estava procurando. Simples, não?

## Iniciando o módulo e descarregando o buffer do kernel

* Para que a gente possa utilizar o nosso software e capturar o nosso endereço de memória, precisamos primeiramente montar o nosso módulo utilizando o comando `make`. Vá até o caminho onde está este projeto e digite `make` no terminal e após todo o módulo ter sido montado, é hora de você executa-lo. Digite `insmod FindSyscall.ko` e confira nos logs de registro do kernel utilizando o comando `dmesg`.

<figure><img src="/files/yrfNoKkE1gzSpUKsYOR4" alt=""><figcaption></figcaption></figure>

Esse foi o endereço retornado em minha máquina e na sua máquina o endereço será diferente do meu. E para descarregarmos o buffer do kernel, apenas digite `rmmod FindSyscall.ko` e o seu Kernel não terá mais nada se digitar `dmesg`.\
\
Bom, esse conteúdo aqui foi super necessário para que nós pudessemos dar continuidade aos nosso projeto, então criei esse tópico específico para continuarmos os nossos estudos sobre LKM e RK. Não esquecendo, esse código não foi eu quem criei mas com base no que estudei, me interessei em explica-lo para todos vocês sobre o meu código. O criador do código é o [f0lg0](https://github.com/f0lg0), então todos os créditos do código será para ele.\
\
Espero que vocês tenham gostado desse tópico e se você estiver interessado em criar seu rootkit, continue lendo meus tópicos, todos os dias estarei trazendo aqui mais tópicos com o mesmo intuito e com isso iremos criar o nosso Rootkit 5.x.x! Espero vocês no próximo Git! Até breve!