Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
kasld — 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. | Kitploit
Outils/GitHubGitHub/bcoles/kasld
ReconnaissanceExploitationCollecte d'InformationsCTFTests d'IntrusionExploitation de Binaires
GitHubbcoles/kasld

kasld

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.

Voir le dépôt
5215171il y a 5 joursVérifié par Kitploit
Partager
<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.
Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    806
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    523
  • 3

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    441
  • 4

    redforge

    cybersecurity91/redforge

    Boîte à outils red team côté navigateur avec 102 outils hors ligne pour la reconnaissance, la génération de payloads, les attaques par identifiants, la cryptographie, l'encodage et le reporting d'engagement.

    346
  • 5

    looking-glass

    anonghosty/looking-glass

    Plateforme CSIRT qui ingère les rapports Shadowserver dans MongoDB et les rejoue sous forme de cartes interactives, d'analyses, de constats, d'avis et de tableaux de bord exécutifs.

    270
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Le système d'action pour la cybersécurité native IA—où l'intention devient une exécution gouvernée, les preuves deviennent une mémoire opérationnelle, et chaque opération améliore la suivante.

    264

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →