
O KASLD remove a aleatoriedade do layout de memória virtual e física do kernel Linux a partir de um processo local, usando o que sua posição — privilégio, configuração e confinamento — permite.
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/48542/27960c6a9cf0003d33879e796f71de7930ff461d87e9c6333b9522d822615306.png" alt="Logotipo do KASLD gerado com Copilot (recortado)"/>
</p>
<p align="center">
<img src="https://github.com/bcoles/kasld/actions/workflows/build.yml/badge.svg" alt="Build Status"/>
<img src="https://github.com/bcoles/kasld/actions/workflows/codeql.yml/badge.svg" alt="CodeQL"/>
<img src="https://img.shields.io/badge/platform-Linux-informational" alt="Platform: Linux"/>
<img src="https://img.shields.io/badge/arch-x86%20%C2%B7%20ARM%20%C2%B7%20MIPS%20%C2%B7%20PPC%20%C2%B7%20RISC--V%20%C2%B7%20LoongArch%20%C2%B7%20s390-blue" alt="Architectures"/>
<img src="https://img.shields.io/badge/C-C99-blue.svg" alt="C99"/>
<img src="https://img.shields.io/github/v/release/bcoles/kasld" alt="Release"/>
<img src="https://img.shields.io/badge/License-MIT-blue.svg" alt="License: MIT"/>
</p>
O KASLD recupera o layout de memória virtual e física do kernel Linux —
principalmente a base do texto do kernel — a partir de um processo local. O que
ele consegue recuperar é função do ponto de observação desse processo: seus
privilégios e capacidades, a configuração do sistema e qualquer confinamento de
container. Ele recupera a base de forma direta onde um vazamento ou canal
lateral o permite e, caso contrário, a restringe ao menor conjunto de
posicionamentos que as evidências disponíveis sustentam.
O motor de inferência funde evidências de dezenas de técnicas independentes
com as invariantes conhecidas da arquitetura, restringindo o posicionamento do
kernel a uma janela residual — reportada como o número de *slots* sobreviventes
(os posicionamentos que o KASLR poderia ter escolhido) e os bits de entropia
que eles representam: um limite superior da proteção que o KASLR mantém a
partir desse ponto de observação, não uma garantia de que a base está fora do
alcance de um atacante (veja
[docs/limitations.md](https://github.com/bcoles/kasld/blob/master/docs/limitations.md)).
A recuperação completa geralmente é impossível em um alvo endurecido — um onde
nenhum vazamento direto do texto do kernel sobrevive e os canais laterais que
sua arquitetura e CPU expõem estão fechados — mas o conjunto de restrições
raramente é vazio. Em arquiteturas sem KASLR, o motor localiza o endereço de
carregamento escolhido pelo bootloader.
Suporta:
* x86 (i386+, amd64)
* ARM (armv6, armv7, armv8, aarch64)
* MIPS (mipsbe, mipsel, mips64, mips64el)
* PowerPC (ppc, ppcle, ppc64, ppc64le)
* RISC-V (riscv32, riscv64)
* LoongArch (loongarch64)
* s390
## Início rápido
```sh
sudo apt install libc-dev make gcc binutils git
git clone https://github.com/bcoles/kasld
cd kasld
make
./build/<arch>/kasld
```
O diretório `build/<arch>/` é autocontido e pode ser implantado em um sistema
alvo:
```
build/<arch>/
kasld <- execute isto
components/ <- componentes de vazamento
```
Uma configuração endurecida (`kernel.dmesg_restrict=1`,
`kernel.kptr_restrict=1`, `kernel.perf_event_paranoid=2` ou superior,
`kernel.unprivileged_bpf_disabled=1` e hashing de ponteiros `%pK`) restringe o
caminho do oráculo do sistema de arquivos, mas é apenas um eixo do ponto de
observação: técnicas de canal lateral, de entropia fraca e concedidas por
capacidades são independentes desses sysctls. Para testes, o script
[extra/weaken-kernel-hardening](https://github.com/bcoles/kasld/blob/master/extra/weaken-kernel-hardening)
pode relaxar temporariamente essas configurações (requer root).
## Exemplo de saída
O modo de texto padrão imprime uma visão geral com a resposta em primeiro
lugar:
```
KASLD 0.4.2-dev -- Kernel Address Space Layout Derandomization
Target: x86_64 / 7.0.0
Running 117 of 120 components (3 experimental skipped; use -x to enable)...
[####################] 100% 117/117 40.9s
1 component timed out after 30s and was killed (prefetch_directmap)
Quantity Certainty Window Candidates Grain
------------------- ---------- --------------------------------------- ---------------- -----
Virtual Image Base guaranteed 0xffffffff81000000 - 0xffffffffbd400000 483 of 512 2 MiB
Virtual Image Base likely 0xffffffff93400000 slide +0x12400000 1 2 MiB
Physical Image Base guaranteed 0x1000000 - 0x3d400000 474 2 MiB
Physical Image Base likely 0x1000000 - 0x3c29d000 474 2 MiB
Direct Map Base guaranteed 0xffff800000000000 - 0xffffa4aa80000000 37,547 1 GiB
Vmalloc Base guaranteed 0xffff898000000000 - 0xffffd6d580000000 79,191 of 79,191 1 GiB
Vmemmap Base guaranteed 0xffffa98040000000 - 0xfffffd0000000000 85,504 1 GiB
Module Region Base guaranteed 0xffffffffa0000000 - 0xffffffffff000000 389,121 4 KiB
Module Region Base likely 0xffffffffc0000000 - 0xffffffffc0400000 1,025 4 KiB
Paging Level guaranteed 48 1 of 2 -
Note: physical and virtual text randomize independently
Note: 1 sub-range excluded from the windows above; the counts
already reflect them (-v lists the ranges).
Evidence (1 finding, 2 components)
Region Position Address Sources
----------------- -------- ------------------ -------
virt kernel image base 0xffffffff93400000 2
[-v: detailed results, memory map, system info] [-H: hardening assessment]
```
A coluna `Certainty` separa duas afirmações diferentes sobre a mesma
quantidade. Uma linha **guaranteed** é provada: o valor verdadeiro está dentro
dessa janela. Uma linha **likely** é a melhor estimativa única que as
evidências sustentam — sempre um subconjunto da janela garantida, e pode estar
errada, pois se baseia em sinais abaixo do piso de solidez, como canais
laterais de temporização. Um resultado que vale a pena usar diretamente é uma
linha `guaranteed` reduzida a um único candidato; um valor `likely` é uma pista
a confirmar, não um fato em que confiar.
`-v` adiciona a leitura verbosa completa (banner, bloco de configuração do
sistema, logs por componente, análise de KASLR, mapas de layout de memória).
`-j` emite JSON legível por máquina — a visão estruturada completa, sempre
incluindo os registros por componente e a avaliação de endurecimento. `-1`
emite uma única linha canalizável para shell. `-m` formata para rastreadores de
issues. `-H` anexa a avaliação de endurecimento aos relatórios de
texto/markdown.
Veja [docs/usage.md](https://github.com/bcoles/kasld/blob/master/docs/usage.md) para a CLI completa, detalhes dos modos de
saída, modo explain e avaliação de endurecimento.
## Ponto de observação
O que o KASLD consegue recuperar depende do *ponto de observação* do processo
em execução — não de um único nível de privilégio, mas da combinação de três
coisas independentes:
* **Privilégios, grupos e capacidades** — um uid sem privilégios, participação
em um grupo como `adm` (que concede os logs do kernel em `/var/log/`), uma
tarefa de container com uma capacidade extra, ou root. Estes não formam uma
única escada, porque as permissões do sistema de arquivos controlam cada
fonte de forma independente: um container com `CAP_SYS_RAWIO` é root do
namespace init para essa verificação e pode ler `/proc/kcore` — um vazamento
que um usuário comum não consegue alcançar — enquanto as distribuições
divergem sobre se um arquivo como `/boot/System.map` é legível por todos.
* **Configuração do sistema** — `kptr_restrict`, `dmesg_restrict`,
`perf_event_paranoid`, BPF sem privilégios, lockdown do kernel. A
configuração é independente do privilégio: root não consegue ler
`/proc/kallsyms` sob `kptr_restrict=2`, enquanto um sysctl relaxado ou BPF
sem privilégios pode entregar a um usuário comum um vazamento que um sistema
endurecido negaria.
* **Confinamento** — um namespace ou sandbox seccomp que mascara oráculos de
`/proc` ou bloqueia syscalls, restringindo o que qualquer nível de privilégio
observa.
Os três eixos controlam cada fonte de vazamento de forma independente — então
mais privilégio não é um superconjunto de menos: a configuração pode negar uma
fonte a root, e canais laterais contornam os sysctls inteiramente.
[docs/usage.md](https://github.com/bcoles/kasld/blob/master/docs/usage.md#vantage) tem uma matriz de fonte-de-vazamento por
portão mostrando qual eixo controla cada fonte.
O KASLD assume poucos privilégios por padrão e usa oportunisticamente o que o
ponto de observação concede. A janela *guaranteed* reportada nunca depende de
privilégio: acesso elevado ou uma configuração fraca podem ampliar o que é
tentado, nunca o layout sólido que as evidências provam. As saídas verbosa
(`-v`), JSON (`-j`) e Markdown (`-m`) reportam o ponto de observação detectado
— container, confinamento, oráculos legíveis e os vazamentos controlados por
capacidades alcançáveis a partir das capacidades atuais.
## Documentação
Novo no KASLD? Leia em ordem: [docs/kaslr.md](https://github.com/bcoles/kasld/blob/master/docs/kaslr.md) (o que é o KASLR e
o que ele randomiza) → [docs/architecture.md → A leak from end to
end](https://github.com/bcoles/kasld/blob/master/docs/architecture.md#a-leak-from-end-to-end) (como o KASLD transforma um
vazamento em uma resposta) → [docs/limitations.md](https://github.com/bcoles/kasld/blob/master/docs/limitations.md) (o que
um resultado prova e não prova) → [CONTRIBUTING.md](https://github.com/bcoles/kasld/blob/master/CONTRIBUTING.md) (adicionar
um componente de vazamento ou regra de inferência). A tabela abaixo indexa a
documentação por tópico.
| Tópico | Documento |
|---|---|
| Introdução ao KASLR | [docs/kaslr.md](https://github.com/bcoles/kasld/blob/master/docs/kaslr.md) — histórico de KASLR por arquitetura, base de texto padrão, vmsplit, FG-KASLR |
| Uso e CLI | [docs/usage.md](https://github.com/bcoles/kasld/blob/master/docs/usage.md) — CLI, modos de saída, modo explain, avaliação de endurecimento |
| Interpretação de resultados | [docs/limitations.md](https://github.com/bcoles/kasld/blob/master/docs/limitations.md) — o que um resultado negativo ou parcial significa: sólido mas não completo, e por que uma falha não é uma garantia de segurança |
| Técnicas de bypass | [docs/bypass-techniques.md](https://github.com/bcoles/kasld/blob/master/docs/bypass-techniques.md) — vazamentos de sistema de arquivos, canais laterais, vazamentos de syscall / ioctl, entropia fraca, CVEs corrigidas, leitura arbitrária |
| Exploração | [docs/exploitation.md](https://github.com/bcoles/kasld/blob/master/docs/exploitation.md) — onde a derrota do KASLR se encaixa em um exploit, control-flow vs data-only, template pwntools, `ksymoff` |
| Pegada e detecção | [docs/footprint.md](https://github.com/bcoles/kasld/blob/master/docs/footprint.md) — como uma execução se parece em um host monitorado: a assinatura comportamental para detectá-la e o custo de OPSEC do operador; ruidoso por design |
| Utilitários | [extra/README.md](https://github.com/bcoles/kasld/blob/master/extra/README.md) — os scripts auxiliares em `extra/` (captura/replay, validação de solidez, posture-diff, `ksymoff`) e como se combinam |
| Arquitetura e internos | [docs/architecture.md](https://github.com/bcoles/kasld/blob/master/docs/architecture.md) — o motor de inferência, costuras de fluxo de dados, protocolo de linha marcada, derivação entre regiões |
| Solidez | [docs/soundness.md](https://github.com/bcoles/kasld/blob/master/docs/soundness.md) — o que a janela reportada garante, como propriedades formais: o reticulado que cada quantidade denota, a obrigação sobre uma regra, contenção da verdade, o piso de confiança, o limite de terminação |
| Contribuição | [CONTRIBUTING.md](https://github.com/bcoles/kasld/blob/master/CONTRIBUTING.md) — escrever um componente ou regra, API do emitter, códigos de saída, metadados |
| Esquema JSON | [docs/kasld.schema.json](https://github.com/bcoles/kasld/blob/master/docs/kasld.schema.json) — o documento `-j` como um JSON Schema: valide um snapshot ingerido contra ele, ou gere tipos a partir dele. `schema_version` e sua regra de compatibilidade estão em [docs/usage.md](https://github.com/bcoles/kasld/blob/master/docs/usage.md#json--j) |
| Testes e CI | [docs/testing.md](https://github.com/bcoles/kasld/blob/master/docs/testing.md) — testes de host, fixtures de replay, cross-arch sob qemu-user, cobertura |
| Reprodutibilidade | [docs/reproducibility.md](https://github.com/bcoles/kasld/blob/master/docs/reproducibility.md) — verificação independente: no kernel local, ao vivo entre arquiteturas, ou sobre o corpus capturado |
## Compilação
Um compilador que suporta a macro `_GNU_SOURCE` é necessário devido ao uso de
código não portável (`MAP_ANONYMOUS`, `getline()`, `popen()`, …).
```
make # build kasld + components
make run # build and run
make test # build and run unit tests
make cross # cross-compile for all supported architectures
make install # install to /usr/local (PREFIX=/usr/local)
make install-strip # install, then strip the installed binaries
make installcheck # smoke-test the installed bin/kasld + libexec/kasld/
make uninstall # remove installed files
make clean # remove build directory
make print-deps # list build dependencies (libs + per-component flags)
make help # show all targets and options
```
`COMPONENTS` restringe uma compilação aos componentes que correspondem a um
glob, de modo que um alvo que só pode executar um punhado de técnicas inclui
apenas essas. Os padrões nomeiam componentes e são separados por vírgula ou
espaço, na mesma forma que a flag `--skip` aceita; um padrão que não corresponde
a nada interrompe a compilação em vez de restringi-la silenciosamente. Se não
definido, todos os componentes são compilados.
```
make cross COMPONENTS='dmesg_*,sysfs_devicetree_*,devicetree_facts,proc_*'
```
Os componentes constituem a maior parte do tamanho instalado, então uma seleção
é a alavanca para um rootfs pequeno — e reduz a compilação proporcionalmente,
que é a economia maior entre dezessete alvos.
Assim como `CC`, a seleção pertence à invocação e não à árvore: uma execução de
`install` ou `install-strip` sem ela recompila e instala tudo, então passe-a
para essas também.
```
make install-strip COMPONENTS='dmesg_*,proc_*' DESTDIR=/staging PREFIX=/usr
```
`make print-deps` reporta o toolchain necessário, as duas bibliotecas opcionais
(`pthread`, `zlib`) com seu resultado de autodetecção para o compilador atual,
e as exceções de flags de compilação/ligação por componente — o suficiente para
preencher o arquivo de controle de um pacote de distribuição sem ler a lógica
de sondagem do Makefile.
`make installcheck` executa o `bin/kasld` instalado e confirma que ele descobre
seus componentes via o caminho FHS `../libexec/kasld` — um smoke test
pós-instalação para o layout de instalação dividida, usando o mesmo
`PREFIX`/`DESTDIR` que `make install` (então também funciona contra uma raiz de
staging `DESTDIR` em CI de pacotes).
`make install` também instala páginas de manual `man1` para `kasld` e `ksymoff`
em `<prefix>/share/man/man1/`, então `man kasld` e `man ksymoff` funcionam após
a instalação.
O KASLD pode ser compilado de forma cruzada com `make` especificando o
compilador apropriado (`CC`). A ligação estática é aplicada automaticamente ao
compilar de forma cruzada:
```
make CC=aarch64-linux-musl-gcc
```
Compile todos os alvos de compilação cruzada suportados (os toolchains devem
estar no `PATH`):
```
make cross
```
## Licença
O KASLD é licenciado sob MIT (veja [LICENSE](https://github.com/bcoles/kasld/blob/master/LICENSE)). Alguns componentes de
vazamento adaptam código de prova de conceito de terceiros ou implementam uma
técnica publicada primeiro por outros; cada arquivo desse tipo credita seu autor
e fonte originais em seu cabeçalho, e
[THIRD-PARTY-NOTICES.md](https://github.com/bcoles/kasld/blob/master/THIRD-PARTY-NOTICES.md) lista cada um com sua licença
ou base de reutilização (licença upstream, permissão do autor, ou material de
técnica/reprodutor reimplementado aqui).
## Citando o KASLD
O KASLD é licenciado sob MIT — a atribuição não é exigida para uso, mas uma
citação ou link é apreciada onde quer que seja referenciado em pesquisa,
ferramentas, exploits ou textos:
> **KASLD: Kernel Address Space Layout Derandomization**, Brendan Coles,
> https://github.com/bcoles/kasld
BibTeX:
```bibtex
@software{kasld,
title = {KASLD: Kernel Address Space Layout Derandomization},
author = {Coles, Brendan},
url = {https://github.com/bcoles/kasld},
version = {0.4.1},
year = {2026}
}
```
O GitHub também mostra um botão *"Cite this repository"* a partir de
[CITATION.cff](https://github.com/bcoles/kasld/blob/master/CITATION.cff). Para uma compilação não lançada de `master`, cite
o commit específico e a data de acesso — por exemplo, `bcoles/kasld@<commit>`
(acessado em AAAA-MM-DD) — já que strings de versão `-dev` não são únicas para
um único commit.