
KASLD desaleatoriza la disposición de la memoria virtual y física del kernel de Linux desde un proceso local, utilizando lo que su ventaja —privilegio, configuración y confinamiento— le permita.
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/48542/27960c6a9cf0003d33879e796f71de7930ff461d87e9c6333b9522d822615306.png" alt="Logotipo de KASLD generado con 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>
KASLD recupera el diseño de memoria virtual y física del kernel de Linux —
principalmente la base del texto del kernel — desde un proceso local. Lo que
puede recuperar es función del punto de observación de ese proceso: sus
privilegios y capacidades, la configuración del sistema y cualquier
confinamiento de contenedor. Recupera la base directamente cuando una fuga o
un canal lateral lo permite y, en caso contrario, la reduce al conjunto más
pequeño de ubicaciones que respalda la evidencia disponible.
El motor de inferencia fusiona evidencia de docenas de técnicas independientes
con las invariantes conocidas de la arquitectura, reduciendo la ubicación del
kernel a una ventana residual — reportada como el número de *slots*
supervivientes (las ubicaciones que KASLR podría haber elegido) y los bits de
entropía que representan: una cota superior de la protección que KASLR
conserva desde este punto de observación, no una garantía de que la base esté
fuera del alcance de un atacante (véase
[docs/limitations.md](https://github.com/bcoles/kasld/blob/master/docs/limitations.md)).
La recuperación completa suele ser imposible en un objetivo endurecido — uno
en el que no sobrevive ninguna fuga directa de texto del kernel y los canales
laterales que exponen su arquitectura y CPU están cerrados — pero el conjunto
de restricciones rara vez está vacío. En arquitecturas sin KASLR, el motor
localiza la dirección de carga elegida por el gestor de arranque.
Compatible con:
* 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
## Inicio 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
```
El directorio `build/<arch>/` es autocontenido y puede desplegarse en un
sistema objetivo:
```
build/<arch>/
kasld <- ejecutar esto
components/ <- componentes de fuga
```
Una configuración endurecida (`kernel.dmesg_restrict=1`,
`kernel.kptr_restrict=1`, `kernel.perf_event_paranoid=2` o superior,
`kernel.unprivileged_bpf_disabled=1` y el hashing de punteros `%pK`) reduce la
ruta del oráculo del sistema de archivos, pero es solo un eje del punto de
observación: las técnicas de canal lateral, de entropía débil y las que
otorgan capacidades son independientes de estos sysctls. Para pruebas, el
script [extra/weaken-kernel-hardening](https://github.com/bcoles/kasld/blob/master/extra/weaken-kernel-hardening) puede
relajar temporalmente estos ajustes (requiere root).
## Ejemplo de salida
El modo de texto predeterminado imprime una visión general que prioriza la
respuesta:
```
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]
```
La columna `Certainty` separa dos afirmaciones distintas sobre la misma
cantidad. Una fila **guaranteed** está demostrada: el valor verdadero se
encuentra dentro de esa ventana. Una fila **likely** es la mejor estimación
única que respalda la evidencia — siempre un subconjunto de la ventana
garantizada, y puede ser errónea, porque se basa en señales por debajo del
umbral de solidez, como los canales laterales de temporización. Un resultado
sobre el que merece la pena actuar directamente es una fila `guaranteed`
reducida a un único candidato; un valor `likely` es una pista que confirmar,
no un hecho en el que confiar.
`-v` añade la lectura detallada completa (banner, bloque de configuración del
sistema, registros por componente, análisis de KASLR, mapas de diseño de
memoria). `-j` emite JSON legible por máquina — la vista estructurada
completa, que incluye siempre los registros por componente y la evaluación de
endurecimiento. `-1` emite una única línea canalizable a un shell. `-m`
formatea para gestores de incidencias. `-H` añade la evaluación de
endurecimiento a los informes de texto/markdown.
Véase [docs/usage.md](https://github.com/bcoles/kasld/blob/master/docs/usage.md) para la CLI completa, los detalles de los
modos de salida, el modo explicativo y la evaluación de endurecimiento.
## Punto de observación
Lo que KASLD puede recuperar depende del *punto de observación* del proceso en
ejecución — no de un único nivel de privilegio, sino de la combinación de tres
cosas independientes:
* **Privilegios, grupos y capacidades** — un uid sin privilegios, la
pertenencia a un grupo como `adm` (que otorga los registros del kernel en
`/var/log/`), una tarea de contenedor que posee una capacidad adicional, o
root. Estos no forman una única escala, porque los permisos del sistema de
archivos controlan cada fuente de forma independiente: un contenedor al que
se le concede `CAP_SYS_RAWIO` es root del espacio de nombres de init para
esa comprobación y puede leer `/proc/kcore` — una fuga que un usuario normal
no puede alcanzar — mientras que las distribuciones difieren sobre si un
archivo como `/boot/System.map` es legible por todos.
* **Configuración del sistema** — `kptr_restrict`, `dmesg_restrict`,
`perf_event_paranoid`, BPF sin privilegios, lockdown del kernel. La
configuración es independiente del privilegio: root no puede leer
`/proc/kallsyms` con `kptr_restrict=2`, mientras que un sysctl relajado o
BPF sin privilegios puede proporcionar a un usuario normal una fuga que un
sistema endurecido denegaría.
* **Confinamiento** — un espacio de nombres o una sandbox seccomp que enmascara
los oráculos de `/proc` o bloquea llamadas al sistema, reduciendo lo que
observa cualquier nivel de privilegio.
Los tres ejes controlan cada fuente de fuga de forma independiente — por lo
que más privilegio no es un superconjunto de menos: la configuración puede
denegar una fuente a root, y los canales laterales eluden los sysctls por
completo. [docs/usage.md](https://github.com/bcoles/kasld/blob/master/docs/usage.md#vantage) contiene una matriz de
fuentes de fuga por control que muestra qué eje controla cada fuente.
KASLD asume pocos privilegios por defecto y aprovecha oportunistamente lo que
otorga el punto de observación. La ventana *guaranteed* reportada nunca depende
del privilegio: el acceso elevado o una configuración débil pueden ampliar lo
que se intenta, nunca el diseño sólido que la evidencia demuestra. Las salidas
detallada (`-v`), JSON (`-j`) y Markdown (`-m`) informan del punto de
observación detectado — contenedor, confinamiento, oráculos legibles y las
fugas controladas por capacidades alcanzables desde las capacidades actuales.
## Documentación
¿Nuevo en KASLD? Lee en orden: [docs/kaslr.md](https://github.com/bcoles/kasld/blob/master/docs/kaslr.md) (qué es KASLR y
qué aleatoriza) → [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) (cómo convierte KASLD una
fuga en una respuesta) → [docs/limitations.md](https://github.com/bcoles/kasld/blob/master/docs/limitations.md) (qué
demuestra y qué no demuestra un resultado) → [CONTRIBUTING.md](https://github.com/bcoles/kasld/blob/master/CONTRIBUTING.md)
(añadir un componente de fuga o una regla de inferencia). La tabla siguiente
indexa la documentación por tema.
| Tema | Documento |
|---|---|
| Introducción a KASLR | [docs/kaslr.md](https://github.com/bcoles/kasld/blob/master/docs/kaslr.md) — historial de KASLR por arquitectura, base de texto predeterminada, vmsplit, FG-KASLR |
| Uso y CLI | [docs/usage.md](https://github.com/bcoles/kasld/blob/master/docs/usage.md) — CLI, modos de salida, modo explicativo, evaluación de endurecimiento |
| Interpretación de resultados | [docs/limitations.md](https://github.com/bcoles/kasld/blob/master/docs/limitations.md) — qué significa un resultado negativo o parcial: sólido pero no completo, y por qué un fallo no es una garantía de seguridad |
| Técnicas de elusión | [docs/bypass-techniques.md](https://github.com/bcoles/kasld/blob/master/docs/bypass-techniques.md) — fugas del sistema de archivos, canales laterales, fugas por syscall / ioctl, entropía débil, CVE parcheados, lectura arbitraria |
| Explotación | [docs/exploitation.md](https://github.com/bcoles/kasld/blob/master/docs/exploitation.md) — dónde encaja la derrota de KASLR en un exploit, control de flujo frente a solo datos, plantilla de pwntools, `ksymoff` |
| Huella y detección | [docs/footprint.md](https://github.com/bcoles/kasld/blob/master/docs/footprint.md) — cómo se ve una ejecución en un host monitorizado: la firma de comportamiento para detectarla y el coste OPSEC del operador; ruidoso por diseño |
| Utilidades | [extra/README.md](https://github.com/bcoles/kasld/blob/master/extra/README.md) — los scripts auxiliares de `extra/` (captura/reproducción, validación de solidez, diff de postura, `ksymoff`) y cómo se combinan |
| Arquitectura e internals | [docs/architecture.md](https://github.com/bcoles/kasld/blob/master/docs/architecture.md) — el motor de inferencia, las costuras de flujo de datos, el protocolo de líneas etiquetadas, la derivación entre regiones |
| Solidez | [docs/soundness.md](https://github.com/bcoles/kasld/blob/master/docs/soundness.md) — qué garantiza la ventana reportada, como propiedades formales: el retículo que denota cada cantidad, la obligación sobre una regla, la contención de la verdad, el umbral de confianza, la cota de terminación |
| Contribuir | [CONTRIBUTING.md](https://github.com/bcoles/kasld/blob/master/CONTRIBUTING.md) — escribir un componente o una regla, API del emisor, códigos de salida, metadatos |
| Esquema JSON | [docs/kasld.schema.json](https://github.com/bcoles/kasld/blob/master/docs/kasld.schema.json) — el documento `-j` como JSON Schema: validar una instantánea ingerida contra él, o generar tipos a partir de él. `schema_version` y su regla de compatibilidad están en [docs/usage.md](https://github.com/bcoles/kasld/blob/master/docs/usage.md#json--j) |
| Pruebas y CI | [docs/testing.md](https://github.com/bcoles/kasld/blob/master/docs/testing.md) — pruebas en el host, fixtures de reproducción, multiplataforma bajo qemu-user, cobertura |
| Reproducibilidad | [docs/reproducibility.md](https://github.com/bcoles/kasld/blob/master/docs/reproducibility.md) — verificación independiente: en el kernel local, en vivo a través de arquitecturas, o sobre el corpus capturado |
## Compilación
Se requiere un compilador que soporte la macro `_GNU_SOURCE` debido al uso de
código no portable (`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 una compilación a los componentes que coinciden con un
patrón glob, de modo que un objetivo que solo puede ejecutar un puñado de
técnicas incluye únicamente esas. Los patrones nombran componentes y se separan
por comas o espacios, en la misma forma que acepta la opción `--skip`; un
patrón que no coincide con nada detiene la compilación en lugar de reducirla
silenciosamente. Si no se establece, se compilan todos los componentes.
```
make cross COMPONENTS='dmesg_*,sysfs_devicetree_*,devicetree_facts,proc_*'
```
Los componentes constituyen la mayor parte del tamaño instalado, por lo que una
selección es la palanca para un rootfs pequeño — y reduce la compilación en
proporción, que es el mayor ahorro entre diecisiete objetivos.
Al igual que `CC`, la selección pertenece a la invocación y no al árbol: una
ejecución de `install` o `install-strip` sin ella recompila e instala todo, así
que pásala también a esas.
```
make install-strip COMPONENTS='dmesg_*,proc_*' DESTDIR=/staging PREFIX=/usr
```
`make print-deps` informa de la cadena de herramientas requerida, las dos
bibliotecas opcionales (`pthread`, `zlib`) con su resultado de detección
automática para el compilador actual, y las excepciones de flags de
compilación/enlazado por componente — suficiente para rellenar el archivo de
control de un paquete de distribución sin leer la lógica de sondeo del
Makefile.
`make installcheck` ejecuta el `bin/kasld` instalado y confirma que descubre
sus componentes a través de la ruta FHS `../libexec/kasld` — una prueba de
humo posterior a la instalación para el diseño de instalación dividida, usando
el mismo `PREFIX`/`DESTDIR` que `make install` (por lo que también funciona
contra una raíz de staging `DESTDIR` en la CI de paquetes).
`make install` también instala las páginas de manual `man1` para `kasld` y
`ksymoff` en `<prefix>/share/man/man1/`, de modo que `man kasld` y
`man ksymoff` funcionan tras la instalación.
KASLD puede compilarse de forma cruzada con `make` especificando el compilador
adecuado (`CC`). El enlazado estático se aplica automáticamente al compilar de
forma cruzada:
```
make CC=aarch64-linux-musl-gcc
```
Compilar todos los objetivos de compilación cruzada compatibles (las cadenas de
herramientas deben estar en `PATH`):
```
make cross
```
## Licencia
KASLD tiene licencia MIT (véase [LICENSE](https://github.com/bcoles/kasld/blob/master/LICENSE)). Algunos componentes de
fuga adaptan código de prueba de concepto de terceros o implementan una técnica
publicada por primera vez por otros; cada uno de esos archivos acredita a su
autor y fuente originales en su cabecera, y
[THIRD-PARTY-NOTICES.md](https://github.com/bcoles/kasld/blob/master/THIRD-PARTY-NOTICES.md) enumera cada uno con su
licencia o base de reutilización (licencia upstream, permiso del autor o
material de técnica/reproductor reimplementado aquí).
## Citar KASLD
KASLD tiene licencia MIT — no se requiere atribución para su uso, pero se
agradece una cita o enlace siempre que se haga referencia a él en
investigación, herramientas, exploits o escritos:
> **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}
}
```
GitHub también muestra un botón *"Cite this repository"* a partir de
[CITATION.cff](https://github.com/bcoles/kasld/blob/master/CITATION.cff). Para una compilación no publicada de `master`,
cita el commit específico y la fecha de acceso — por ejemplo
`bcoles/kasld@<commit>` (accedido el AAAA-MM-DD) — ya que las cadenas de
versión `-dev` no son únicas para un solo commit.