
KASLD randomisiert das virtuelle und physische Speicherlayout des Linux-Kernels von einem lokalen Prozess aus, wobei es nutzt, was seine Perspektive – Privilegien, Konfiguration und Einschränkungen – zulässt.
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/48542/27960c6a9cf0003d33879e796f71de7930ff461d87e9c6333b9522d822615306.png" alt="KASLD-Logo, generiert mit Copilot (zugeschnitten)"/>
</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 rekonstruiert das virtuelle und physische Speicherlayout des Linux-Kernels —
hauptsächlich die Kernel-Textbasis — aus einem lokalen Prozess. Was es
rekonstruieren kann, hängt von der Perspektive dieses Prozesses ab: seinen
Privilegien und Fähigkeiten, der Systemkonfiguration und einer etwaigen
Container-Eingrenzung. Wo ein Leck oder ein Seitenkanal es erlaubt, rekonstruiert
es die Basis direkt; andernfalls grenzt es sie auf die kleinste Menge von
Platzierungen ein, die die verfügbaren Hinweise stützen.
Die Inferenz-Engine fusioniert Hinweise aus Dutzenden unabhängiger Techniken
mit den bekannten Invarianten der Architektur und grenzt die Platzierung des
Kernels auf ein Restfenster ein — angegeben als Anzahl der verbleibenden
*Slots* (der Platzierungen, die KASLR hätte wählen können) und die Bits an
Entropie, die sie repräsentieren: eine obere Schranke für den Schutz, den
KASLR aus dieser Perspektive behält, keine Garantie, dass die Basis außerhalb
der Reichweite eines Angreifers liegt (siehe
[docs/limitations.md](https://github.com/bcoles/kasld/blob/master/docs/limitations.md)).
Eine vollständige Rekonstruktion ist auf einem gehärteten Ziel oft unmöglich —
einem, bei dem kein direktes Kernel-Text-Leck überlebt und die Seitenkanäle,
die seine Architektur und CPU offenlegen, geschlossen sind —, doch die
Constraint-Menge ist selten leer. Auf Architekturen ohne KASLR ermittelt die
Engine die vom Bootloader gewählte Ladeadresse.
Unterstützt:
* 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
## Schnellstart
```sh
sudo apt install libc-dev make gcc binutils git
git clone https://github.com/bcoles/kasld
cd kasld
make
./build/<arch>/kasld
```
Das Verzeichnis `build/<arch>/` ist eigenständig und kann auf ein Zielsystem
deployt werden:
```
build/<arch>/
kasld <- dies ausführen
components/ <- Leck-Komponenten
```
Eine gehärtete Konfiguration (`kernel.dmesg_restrict=1`,
`kernel.kptr_restrict=1`, `kernel.perf_event_paranoid=2` oder höher,
`kernel.unprivileged_bpf_disabled=1` und `%pK`-Pointer-Hashing) verengt den
Dateisystem-Oracle-Pfad, ist aber nur eine Achse der Perspektive:
Seitenkanal-, Schwache-Entropie- und durch Fähigkeiten gewährte Techniken sind
von diesen Sysctls unabhängig. Zum Testen kann das Skript
[extra/weaken-kernel-hardening](https://github.com/bcoles/kasld/blob/master/extra/weaken-kernel-hardening) diese
Einstellungen vorübergehend lockern (erfordert Root).
## Beispielausgabe
Der Standard-Textmodus gibt eine antwortorientierte Übersicht aus:
```
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]
```
Die Spalte `Certainty` trennt zwei verschiedene Aussagen über dieselbe
Größe. Eine **guaranteed**-Zeile ist bewiesen: Der wahre Wert liegt innerhalb
dieses Fensters. Eine **likely**-Zeile ist die beste einzelne Schätzung, die
die Hinweise stützen — immer eine Teilmenge des garantierten Fensters, und sie
kann falsch sein, weil sie auf Signale unterhalb der Soliditätsschwelle wie
Timing-Seitenkanäle zurückgreift. Ein direkt verwertbares Ergebnis ist eine
`guaranteed`-Zeile, die auf einen einzigen Kandidaten verengt ist; ein
`likely`-Wert ist eine zu bestätigende Spur, kein Fakt, auf den man sich
verlassen sollte.
`-v` fügt die vollständige ausführliche Ausgabe hinzu (Banner, Systemkonfigurationsblock,
Komponenten-Protokolle, KASLR-Analyse, Speicherlayout-Karten). `-j` gibt
maschinenlesbares JSON aus — die vollständige strukturierte Ansicht, stets
einschließlich der Komponenten-Datensätze und der Härtungsbewertung. `-1` gibt
eine einzelne shell-pipebare Zeile aus. `-m` formatiert für Issue-Tracker. `-H`
hängt die Härtungsbewertung an die Text-/Markdown-Berichte an.
Siehe [docs/usage.md](https://github.com/bcoles/kasld/blob/master/docs/usage.md) für die vollständige CLI, Details zu den
Ausgabemodi, den Erklärungsmodus und die Härtungsbewertung.
## Perspektive
Was KASLD rekonstruieren kann, hängt von der *Perspektive* des laufenden
Prozesses ab — nicht von einer einzelnen Privilegienstufe, sondern von der
Kombination dreier unabhängiger Dinge:
* **Privilegien, Gruppen und Fähigkeiten** — eine unprivilegierte UID,
Mitgliedschaft in einer Gruppe wie `adm` (die die Kernel-Logs unter
`/var/log/` gewährt), ein Container-Task mit einer zusätzlichen Fähigkeit
oder Root. Diese bilden keine einzelne Leiter, weil Dateisystemberechtigungen
jede Quelle unabhängig absichern: Ein Container, dem `CAP_SYS_RAWIO`
gewährt wurde, ist für diese Prüfung Root im Init-Namespace und kann
`/proc/kcore` lesen — ein Leck, das ein gewöhnlicher Benutzer nicht erreichen
kann —, während Distributionen sich darin unterscheiden, ob eine Datei wie
`/boot/System.map` überhaupt weltweit lesbar ist.
* **Systemkonfiguration** — `kptr_restrict`, `dmesg_restrict`,
`perf_event_paranoid`, unprivilegiertes BPF, Kernel-Lockdown. Die
Konfiguration ist unabhängig von Privilegien: Root kann `/proc/kallsyms`
unter `kptr_restrict=2` nicht lesen, während ein gelockertes Sysctl oder
unprivilegiertes BPF einem einfachen Benutzer ein Leck liefern kann, das ein
gehärtetes System verweigern würde.
* **Eingrenzung** — ein Namespace- oder Seccomp-Sandbox, der `/proc`-Oracles
maskiert oder Syscalls blockiert und verengt, was jede Privilegienstufe
beobachtet.
Die drei Achsen sichern jede Leck-Quelle unabhängig ab — mehr Privilegien sind
also keine Obermenge von weniger: Die Konfiguration kann eine Quelle für Root
verweigern, und Seitenkanäle umgehen die Sysctls vollständig.
[docs/usage.md](https://github.com/bcoles/kasld/blob/master/docs/usage.md#vantage) enthält eine Matrix der Leck-Quellen
nach Gate, die zeigt, welche Achse jede Quelle kontrolliert.
KASLD geht standardmäßig von wenigen Privilegien aus und nutzt opportunistisch,
was die Perspektive gewährt. Das gemeldete *guaranteed*-Fenster hängt niemals
von Privilegien ab: Erhöhter Zugriff oder eine schwache Konfiguration können
erweitern, was versucht wird, niemals das solide Layout, das die Hinweise
beweisen. Die ausführlichen (`-v`), JSON- (`-j`) und Markdown-Ausgaben (`-m`)
melden die erkannte Perspektive — Container, Eingrenzung, lesbare Oracles und
die durch Fähigkeiten abgesicherten Lecks, die von den aktuellen Fähigkeiten
aus erreichbar sind.
## Dokumentation
Neu bei KASLD? In dieser Reihenfolge lesen: [docs/kaslr.md](https://github.com/bcoles/kasld/blob/master/docs/kaslr.md) (was
KASLR ist und was es randomisiert) → [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) (wie KASLD aus einem Leck eine
Antwort macht) → [docs/limitations.md](https://github.com/bcoles/kasld/blob/master/docs/limitations.md) (was ein Ergebnis
beweist und was nicht) → [CONTRIBUTING.md](https://github.com/bcoles/kasld/blob/master/CONTRIBUTING.md) (eine
Leck-Komponente oder Inferenzregel hinzufügen). Die folgende Tabelle
indexiert die Dokumentation nach Thema.
| Thema | Dokument |
|---|---|
| KASLR-Einführung | [docs/kaslr.md](https://github.com/bcoles/kasld/blob/master/docs/kaslr.md) — KASLR-Historie pro Architektur, Standard-Textbasis, vmsplit, FG-KASLR |
| Nutzung & CLI | [docs/usage.md](https://github.com/bcoles/kasld/blob/master/docs/usage.md) — CLI, Ausgabemodi, Erklärungsmodus, Härtungsbewertung |
| Ergebnisse interpretieren | [docs/limitations.md](https://github.com/bcoles/kasld/blob/master/docs/limitations.md) — was ein negatives oder partielles Ergebnis bedeutet: solide, aber nicht vollständig, und warum ein Fehlschlag keine Sicherheitsgarantie ist |
| Bypass-Techniken | [docs/bypass-techniques.md](https://github.com/bcoles/kasld/blob/master/docs/bypass-techniques.md) — Dateisystem-Lecks, Seitenkanäle, Syscall-/ioctl-Lecks, schwache Entropie, gepatchte CVEs, beliebiges Lesen |
| Ausnutzung | [docs/exploitation.md](https://github.com/bcoles/kasld/blob/master/docs/exploitation.md) — wo die KASLR-Umgehung in einen Exploit passt, Control-Flow vs. Data-Only, pwntools-Template, `ksymoff` |
| Footprint & Erkennung | [docs/footprint.md](https://github.com/bcoles/kasld/blob/master/docs/footprint.md) — wie ein Lauf auf einem überwachten Host aussieht: die verhaltensbasierte Signatur zu seiner Erkennung und die OPSEC-Kosten für den Operator; absichtlich auffällig |
| Hilfsprogramme | [extra/README.md](https://github.com/bcoles/kasld/blob/master/extra/README.md) — die Hilfsskripte in `extra/` (Capture/Replay, Soliditätsvalidierung, Posture-Diff, `ksymoff`) und wie sie kombiniert werden |
| Architektur & Interna | [docs/architecture.md](https://github.com/bcoles/kasld/blob/master/docs/architecture.md) — die Inferenz-Engine, Datenfluss-Nähte, Tagged-Line-Protokoll, regionsübergreifende Ableitung |
| Solidität | [docs/soundness.md](https://github.com/bcoles/kasld/blob/master/docs/soundness.md) — was das gemeldete Fenster garantiert, als formale Eigenschaften: das Gitter, das jede Größe bezeichnet, die Verpflichtung einer Regel, Wahrheitsenthaltung, die Konfidenzschwelle, die Terminierungsschranke |
| Mitwirken | [CONTRIBUTING.md](https://github.com/bcoles/kasld/blob/master/CONTRIBUTING.md) — eine Komponente oder Regel schreiben, Emitter-API, Exit-Codes, Metadaten |
| JSON-Schema | [docs/kasld.schema.json](https://github.com/bcoles/kasld/blob/master/docs/kasld.schema.json) — das `-j`-Dokument als JSON-Schema: einen eingelesenen Snapshot dagegen validieren oder Typen daraus generieren. `schema_version` und seine Kompatibilitätsregel stehen in [docs/usage.md](https://github.com/bcoles/kasld/blob/master/docs/usage.md#json--j) |
| Testen & CI | [docs/testing.md](https://github.com/bcoles/kasld/blob/master/docs/testing.md) — Host-Tests, Replay-Fixtures, Cross-Arch unter qemu-user, Coverage |
| Reproduzierbarkeit | [docs/reproducibility.md](https://github.com/bcoles/kasld/blob/master/docs/reproducibility.md) — unabhängige Verifikation: auf dem lokalen Kernel, live über Architekturen hinweg oder über den erfassten Korpus |
## Bauen
Ein Compiler, der das Makro `_GNU_SOURCE` unterstützt, ist erforderlich, da
nicht-portabler Code verwendet wird (`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` beschränkt einen Build auf die Komponenten, die einem Glob
entsprechen, sodass ein Ziel, das nur eine Handvoll Techniken ausführen kann,
nur diese ausliefert. Muster benennen Komponenten und sind durch Kommas oder
Leerzeichen getrennt, in derselben Form, die das Flag `--skip` annimmt; ein
Muster, das nichts trifft, stoppt den Build, statt ihn stillschweigend zu
verengen. Ohne Angabe wird jede Komponente gebaut.
```
make cross COMPONENTS='dmesg_*,sysfs_devicetree_*,devicetree_facts,proc_*'
```
Komponenten machen den Großteil der installierten Größe aus, daher ist eine
Auswahl der Hebel für ein kleines Rootfs — und sie reduziert den Build
proportional, was über siebzehn Ziele hinweg die größere Einsparung ist.
Wie `CC` gehört die Auswahl zum Aufruf und nicht zum Baum: Ein `install`- oder
`install-strip`-Lauf ohne sie baut und installiert alles neu, also geben Sie
sie auch dort an.
```
make install-strip COMPONENTS='dmesg_*,proc_*' DESTDIR=/staging PREFIX=/usr
```
`make print-deps` meldet die erforderliche Toolchain, die beiden optionalen
Bibliotheken (`pthread`, `zlib`) mit ihrem Auto-Erkennungsergebnis für den
aktuellen Compiler und die Compile-/Link-Flag-Ausnahmen pro Komponente — genug,
um die Control-Datei eines Distributionspakets zu befüllen, ohne die
Probe-Logik des Makefiles zu lesen.
`make installcheck` führt das installierte `bin/kasld` aus und bestätigt, dass
es seine Komponenten über den FHS-Pfad `../libexec/kasld` findet — ein
Post-Install-Smoke-Test für das Split-Install-Layout, der dasselbe
`PREFIX`/`DESTDIR` wie `make install` verwendet (funktioniert also auch gegen
ein `DESTDIR`-Staging-Root in der Paket-CI).
`make install` installiert außerdem `man1`-Handbuchseiten für `kasld` und
`ksymoff` nach `<prefix>/share/man/man1/`, sodass `man kasld` und `man ksymoff`
nach der Installation funktionieren.
KASLD kann mit `make` cross-kompiliert werden, indem der passende Compiler
(`CC`) angegeben wird. Statisches Linken wird beim Cross-Kompilieren
automatisch angewendet:
```
make CC=aarch64-linux-musl-gcc
```
Alle unterstützten Cross-Kompilierungsziele bauen (Toolchains müssen im `PATH`
sein):
```
make cross
```
## Lizenz
KASLD ist MIT-lizenziert (siehe [LICENSE](https://github.com/bcoles/kasld/blob/master/LICENSE)). Einige Leck-Komponenten
adaptieren Proof-of-Concept-Code Dritter oder implementieren eine Technik, die
zuerst von anderen veröffentlicht wurde; jede solche Datei nennt ihren
ursprünglichen Autor und ihre Quelle im Header, und
[THIRD-PARTY-NOTICES.md](https://github.com/bcoles/kasld/blob/master/THIRD-PARTY-NOTICES.md) listet jede mit ihrer Lizenz
oder Wiederverwendungsgrundlage auf (Upstream-Lizenz, Genehmigung des Autors
oder hier neu implementiertes Technik-/Reproducer-Material).
## KASLD zitieren
KASLD ist MIT-lizenziert — eine Namensnennung ist für die Nutzung nicht
erforderlich, aber eine Zitierung oder ein Link ist willkommen, wo immer es in
Forschung, Tooling, Exploits oder Texten referenziert wird:
> **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 zeigt außerdem eine Schaltfläche *"Cite this repository"* aus
[CITATION.cff](https://github.com/bcoles/kasld/blob/master/CITATION.cff) an. Für einen unveröffentlichten Build aus
`master` zitieren Sie den spezifischen Commit und das Datum des Zugriffs —
z. B. `bcoles/kasld@<commit>` (abgerufen am YYYY-MM-DD) —, da `-dev`-Versionsstrings
nicht eindeutig für einen einzelnen Commit sind.