
KASLD dérandomise la disposition de la mémoire virtuelle et physique du noyau Linux depuis un processus local, en utilisant tout ce que son point de vue — privilège, configuration et confinement — lui permet.
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/48542/27960c6a9cf0003d33879e796f71de7930ff461d87e9c6333b9522d822615306.png" alt="KASLD logo generated with Copilot (cropped)"/>
</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 reconstitue la disposition de la mémoire virtuelle et physique du noyau Linux —
principalement la base du texte du noyau — depuis un processus local. Ce qu'il peut
reconstituer dépend du point de vue de ce processus : ses privilèges et capacités,
la configuration du système et tout confinement de conteneur. Il reconstitue la base
directement lorsqu'une fuite ou un canal auxiliaire le permet, et la réduit sinon au
plus petit ensemble de placements que les preuves disponibles étayent.
Le moteur d'inférence fusionne les preuves issues de dizaines de techniques
indépendantes avec les invariants connus de l'architecture, réduisant le placement
du noyau à une fenêtre résiduelle — rapportée comme le nombre d'*emplacements*
(slots) survivants (les placements que KASLR aurait pu choisir) et les bits
d'entropie qu'ils représentent : une borne supérieure de la protection que KASLR
conserve depuis ce point de vue, et non une garantie que la base est hors de portée
d'un attaquant (voir [docs/limitations.md](https://github.com/bcoles/kasld/blob/master/docs/limitations.md)).
La reconstitution complète est souvent impossible sur une cible durcie — une cible
où aucune fuite directe du texte du noyau ne subsiste et où les canaux auxiliaires
exposés par son architecture et son CPU sont fermés — mais l'ensemble de contraintes
est rarement vide. Sur les architectures sans KASLR, le moteur localise l'adresse de
chargement choisie par le bootloader.
Prend en charge :
* 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
## Démarrage rapide
```sh
sudo apt install libc-dev make gcc binutils git
git clone https://github.com/bcoles/kasld
cd kasld
make
./build/<arch>/kasld
```
Le répertoire `build/<arch>/` est autonome et peut être déployé sur un
système cible :
```
build/<arch>/
kasld <- exécuter ceci
components/ <- composants de fuite
```
Une configuration durcie (`kernel.dmesg_restrict=1`,
`kernel.kptr_restrict=1`, `kernel.perf_event_paranoid=2` ou plus,
`kernel.unprivileged_bpf_disabled=1`, et le hachage des pointeurs `%pK`) réduit
le chemin des oracles du système de fichiers, mais ne constitue qu'un seul axe du
point de vue : les techniques par canal auxiliaire, à faible entropie et accordées
par capacité sont indépendantes de ces sysctls. Pour les tests, le script
[extra/weaken-kernel-hardening](https://github.com/bcoles/kasld/blob/master/extra/weaken-kernel-hardening) peut
temporairement assouplir ces réglages (nécessite root).
## Exemple de sortie
Le mode texte par défaut affiche un aperçu commençant par la réponse :
```
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 colonne `Certainty` sépare deux affirmations différentes sur la même
quantité. Une ligne **guaranteed** est prouvée : la valeur réelle se situe à
l'intérieur de cette fenêtre. Une ligne **likely** est la meilleure estimation
unique que les preuves étayent — toujours un sous-ensemble de la fenêtre
garantie, et elle peut être fausse, car elle s'appuie sur des signaux sous le
seuil de solidité, comme les canaux auxiliaires temporels. Un résultat sur lequel
agir directement est une ligne `guaranteed` réduite à un seul candidat ; une
valeur `likely` est une piste à confirmer, pas un fait sur lequel s'appuyer.
`-v` ajoute la sortie détaillée complète (bannière, bloc de configuration
système, journaux par composant, analyse KASLR, cartes de disposition mémoire).
`-j` émet du JSON lisible par machine — la vue structurée complète, incluant
toujours les enregistrements par composant et l'évaluation du durcissement. `-1`
émet une seule ligne exploitable dans un pipe shell. `-m` formate pour les
gestionnaires de tickets. `-H` ajoute l'évaluation du durcissement aux rapports
texte/markdown.
Voir [docs/usage.md](https://github.com/bcoles/kasld/blob/master/docs/usage.md) pour l'interface CLI complète, les détails
des modes de sortie, le mode explain et l'évaluation du durcissement.
## Point de vue
Ce que KASLD peut reconstituer dépend du *point de vue* du processus en cours —
non pas d'un seul niveau de privilège, mais de la combinaison de trois éléments
indépendants :
* **Privilèges, groupes et capacités** — un uid non privilégié, l'appartenance
à un groupe tel que `adm` (qui accorde les journaux du noyau sous `/var/log/`),
une tâche de conteneur détenant une capacité supplémentaire, ou root. Ceux-ci
ne forment pas une échelle unique, car les permissions du système de fichiers
contrôlent chaque source indépendamment : un conteneur doté de `CAP_SYS_RAWIO`
est root dans le namespace init pour cette vérification et peut lire
`/proc/kcore` — une fuite qu'un utilisateur ordinaire ne peut atteindre —
tandis que les distributions diffèrent sur le fait qu'un fichier tel que
`/boot/System.map` soit lisible par tous ou non.
* **Configuration système** — `kptr_restrict`, `dmesg_restrict`,
`perf_event_paranoid`, BPF non privilégié, kernel lockdown. La configuration est
indépendante du privilège : root ne peut pas lire `/proc/kallsyms` sous
`kptr_restrict=2`, tandis qu'un sysctl assoupli ou BPF non privilégié peut
fournir à un simple utilisateur une fuite qu'un système durci refuserait.
* **Confinement** — un namespace ou un bac à sable seccomp qui masque les oracles
de `/proc` ou bloque des appels système, réduisant ce que tout niveau de
privilège observe.
Les trois axes contrôlent chaque source de fuite indépendamment — ainsi plus de
privilèges n'est pas un sur-ensemble de moins : la configuration peut refuser une
source à root, et les canaux auxiliaires contournent entièrement les sysctls.
[docs/usage.md](https://github.com/bcoles/kasld/blob/master/docs/usage.md#vantage) contient une matrice source-de-fuite par
barrière montrant quel axe contrôle chaque source.
KASLD suppose peu de privilèges par défaut et exploite de manière opportuniste ce
que le point de vue accorde. La fenêtre *guaranteed* rapportée ne dépend jamais du
privilège : un accès élevé ou une configuration faible peut élargir ce qui est
tenté, jamais la disposition solide que les preuves démontrent. Les sorties
détaillée (`-v`), JSON (`-j`) et Markdown (`-m`) rapportent le point de vue
détecté — conteneur, confinement, oracles lisibles et fuites conditionnées par
capacité accessibles depuis les capacités actuelles.
## Documentation
Nouveau sur KASLD ? À lire dans l'ordre : [docs/kaslr.md](https://github.com/bcoles/kasld/blob/master/docs/kaslr.md) (ce
qu'est KASLR et ce qu'il randomise) → [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) (comment KASLD transforme une
fuite en réponse) → [docs/limitations.md](https://github.com/bcoles/kasld/blob/master/docs/limitations.md) (ce qu'un résultat
prouve et ne prouve pas) → [CONTRIBUTING.md](https://github.com/bcoles/kasld/blob/master/CONTRIBUTING.md) (ajouter un
composant de fuite ou une règle d'inférence). Le tableau ci-dessous indexe la
documentation par sujet.
| Sujet | Document |
|---|---|
| Introduction à KASLR | [docs/kaslr.md](https://github.com/bcoles/kasld/blob/master/docs/kaslr.md) — historique de KASLR par architecture, base de texte par défaut, vmsplit, FG-KASLR |
| Utilisation & CLI | [docs/usage.md](https://github.com/bcoles/kasld/blob/master/docs/usage.md) — CLI, modes de sortie, mode explain, évaluation du durcissement |
| Interprétation des résultats | [docs/limitations.md](https://github.com/bcoles/kasld/blob/master/docs/limitations.md) — ce que signifie un résultat négatif ou partiel : solide mais incomplet, et pourquoi un échec n'est pas une garantie de sécurité |
| Techniques de contournement | [docs/bypass-techniques.md](https://github.com/bcoles/kasld/blob/master/docs/bypass-techniques.md) — fuites du système de fichiers, canaux auxiliaires, fuites par appel système / ioctl, faible entropie, CVE corrigées, lecture arbitraire |
| Exploitation | [docs/exploitation.md](https://github.com/bcoles/kasld/blob/master/docs/exploitation.md) — où la défaite de KASLR s'inscrit dans un exploit, contrôle de flux vs data-only, modèle pwntools, `ksymoff` |
| Empreinte & détection | [docs/footprint.md](https://github.com/bcoles/kasld/blob/master/docs/footprint.md) — à quoi ressemble une exécution sur un hôte surveillé : la signature comportementale pour la détecter, et le coût OPSEC de l'opérateur ; bruyant par conception |
| Utilitaires | [extra/README.md](https://github.com/bcoles/kasld/blob/master/extra/README.md) — les scripts auxiliaires de `extra/` (capture/replay, validation de solidité, posture-diff, `ksymoff`) et comment ils se combinent |
| Architecture & internes | [docs/architecture.md](https://github.com/bcoles/kasld/blob/master/docs/architecture.md) — le moteur d'inférence, les coutures de flux de données, le protocole de lignes balisées, la dérivation inter-régions |
| Solidité | [docs/soundness.md](https://github.com/bcoles/kasld/blob/master/docs/soundness.md) — ce que la fenêtre rapportée garantit, sous forme de propriétés formelles : le treillis que dénote chaque quantité, l'obligation sur une règle, la contenance de la vérité, le seuil de confiance, la borne de terminaison |
| Contribution | [CONTRIBUTING.md](https://github.com/bcoles/kasld/blob/master/CONTRIBUTING.md) — écrire un composant ou une règle, API d'émission, codes de sortie, métadonnées |
| Schéma JSON | [docs/kasld.schema.json](https://github.com/bcoles/kasld/blob/master/docs/kasld.schema.json) — le document `-j` sous forme de JSON Schema : valider un instantané ingéré par rapport à lui, ou générer des types à partir de lui. `schema_version` et sa règle de compatibilité sont dans [docs/usage.md](https://github.com/bcoles/kasld/blob/master/docs/usage.md#json--j) |
| Tests & CI | [docs/testing.md](https://github.com/bcoles/kasld/blob/master/docs/testing.md) — tests sur l'hôte, fixtures de replay, cross-arch sous qemu-user, couverture |
| Reproductibilité | [docs/reproducibility.md](https://github.com/bcoles/kasld/blob/master/docs/reproducibility.md) — vérification indépendante : sur le noyau local, en direct sur plusieurs architectures, ou sur le corpus capturé |
## Compilation
Un compilateur prenant en charge la macro `_GNU_SOURCE` est requis en raison de
l'utilisation de code non 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` restreint une compilation aux composants correspondant à un glob,
de sorte qu'une cible qui ne pourra jamais exécuter qu'une poignée de techniques
n'embarque que celles-ci. Les motifs nomment des composants et sont séparés par
des virgules ou des espaces, sous la même forme que prend le drapeau `--skip` ; un
motif ne correspondant à rien arrête la compilation plutôt que de la réduire
silencieusement. Non défini, tous les composants sont compilés.
```
make cross COMPONENTS='dmesg_*,sysfs_devicetree_*,devicetree_facts,proc_*'
```
Les composants constituent l'essentiel de la taille installée, donc une sélection
est le levier pour un petit rootfs — et elle réduit la compilation
proportionnellement, ce qui est l'économie la plus importante sur dix-sept cibles.
Comme `CC`, la sélection appartient à l'invocation plutôt qu'à l'arborescence : une
exécution `install` ou `install-strip` sans elle recompile et installe tout, donc
passez-la à celles-ci aussi.
```
make install-strip COMPONENTS='dmesg_*,proc_*' DESTDIR=/staging PREFIX=/usr
```
`make print-deps` rapporte la chaîne d'outils requise, les deux bibliothèques
optionnelles (`pthread`, `zlib`) avec leur résultat d'auto-détection pour le
compilateur actuel, et les exceptions de drapeaux de compilation/liaison par
composant — assez pour remplir le fichier de contrôle d'un paquet de distribution
sans lire la logique de sonde du Makefile.
`make installcheck` exécute le `bin/kasld` installé et confirme qu'il découvre ses
composants via le chemin FHS `../libexec/kasld` — un test de fumée post-installation
pour la disposition d'installation scindée, utilisant le même `PREFIX`/`DESTDIR`
que `make install` (donc il fonctionne aussi contre une racine de staging `DESTDIR`
dans la CI de paquet).
`make install` installe aussi les pages de manuel `man1` pour `kasld` et `ksymoff`
dans `<prefix>/share/man/man1/`, de sorte que `man kasld` et `man ksymoff`
fonctionnent après l'installation.
KASLD peut être compilé en croisé avec `make` en spécifiant le compilateur
approprié (`CC`). La liaison statique est appliquée automatiquement lors d'une
compilation croisée :
```
make CC=aarch64-linux-musl-gcc
```
Compiler toutes les cibles de compilation croisée prises en charge (les chaînes
d'outils doivent être dans le `PATH`) :
```
make cross
```
## Licence
KASLD est sous licence MIT (voir [LICENSE](https://github.com/bcoles/kasld/blob/master/LICENSE)). Certains composants de fuite
adaptent du code de preuve de concept tiers ou implémentent une technique publiée
pour la première fois par d'autres ; chacun de ces fichiers crédite son auteur et
sa source d'origine dans son en-tête, et
[THIRD-PARTY-NOTICES.md](https://github.com/bcoles/kasld/blob/master/THIRD-PARTY-NOTICES.md) les liste chacun avec sa licence
ou sa base de réutilisation (licence amont, autorisation de l'auteur, ou matériel
de technique/reproducteur réimplémenté ici).
## Citer KASLD
KASLD est sous licence MIT — l'attribution n'est pas requise pour l'utilisation,
mais une citation ou un lien est apprécié partout où il est référencé dans la
recherche, l'outillage, les exploits ou les écrits :
> **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 affiche également un bouton *« Cite this repository »* à partir de
[CITATION.cff](https://github.com/bcoles/kasld/blob/master/CITATION.cff). Pour une compilation non publiée depuis `master`,
citez le commit spécifique et la date d'accès — par ex. `bcoles/kasld@<commit>`
(consulté le AAAA-MM-JJ) — car les chaînes de version `-dev` ne sont pas uniques à
un seul commit.