Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Einreichen
ToolsExploitsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

FeedsKontaktDatenschutz© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
Tools/GitHubGitHub/bcoles/kasld
AufklärungExploitationInformationsbeschaffungCTFPenetrationstestsBinary-Exploitation
GitHubbcoles/kasld

kasld

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.

Repository anzeigen
5215171vor 5 TagenVon Kitploit geprüft
Teilen
<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.
Tool herunterladen

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Das ultimative OSINT-Toolkit: Untersuchungsgraph, Konfidenzbewertung, Alias-Familien, Karte, Zeitleiste und Berichte. 49 Module, 400+ Websites, keine API-Schlüssel erforderlich.

    795
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock One-Tap Execution App (CVE-2026-43499)

    520
  • 3

    ARTEX

    baarai/artex

    LLM-basierte Multi-Agenten-Plattform für autonome Penetrationstests mit Planer-/Worker-Agenten, Asset- und Explorationsgraphen, MITM-Verkehrsaufzeichnung und Schwachstellen-Retesting.

    439
  • 4

    redforge

    cybersecurity91/redforge

    Browser-seitiges Red-Team-Toolkit mit 102 Offline-Tools für Recon, Payload-Generierung, Credential-Angriffe, Krypto, Encoding und Engagement-Reporting.

    346
  • 5

    looking-glass

    anonghosty/looking-glass

    CSIRT-Plattform, die Shadowserver-Berichte in MongoDB einliest und sie als interaktive Karten, Analysen, Findings, Advisories und Executive-Dashboards wiedergibt.

    267
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Das System der Handlung für KI-native Cybersicherheit – wo Absicht zu gesteuerter Ausführung wird, Beweise zu operativem Gedächtnis werden und jeder Einsatz den nächsten verbessert.

    264

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →