Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
kasld — 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. | Kitploit
Ferramentas/GitHubGitHub/bcoles/kasld
ReconhecimentoExploraçãoColeta de InformaçõesCTFTestes de PenetraçãoExploração de Binários
GitHubbcoles/kasld

kasld

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.

Ver Repositório
5215171há 5 diasRevisado pelo Kitploit
Compartilhar
<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.
Baixar ferramenta

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 O kit definitivo de OSINT: grafo de investigação, pontuação de confiança, famílias de alias, mapa, linha do tempo e relatórios. 49 módulos, mais de 400 sites, sem necessidade de chaves de API.

    717
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicativo de Execução em Um Toque GhostLock (CVE-2026-43499)

    504
  • 3

    ARTEX

    baarai/artex

    Plataforma autônoma de testes de penetração multiagente com LLM, com agentes planejador/executor, grafos de ativos e de exploração, registro de tráfego MITM e reteste de vulnerabilidades.

    402
  • 4

    redforge

    cybersecurity91/redforge

    Kit de ferramentas de red team do lado do navegador com 102 ferramentas offline para reconhecimento, geração de payloads, ataques a credenciais, criptografia, codificação e relatórios de engajamento.

    342
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    O sistema de ação para cibersegurança nativa em IA—onde a intenção se torna execução governada, a evidência se torna memória operacional, e cada operação melhora a próxima.

    260
  • 6

    antifox

    antifox-ai/antifox

    Plataforma de testes de penetração autónoma com multiagentes de IA que executa reconhecimento, descoberta de superfície de ataque, validação de exploração e entrega de relatórios com evidências.

    259

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →