Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
kasld — KASLD derandomizza il layout della memoria virtuale e fisica del kernel Linux da un processo locale, utilizzando tutto ciò che il suo punto di osservazione — privilegi, configurazione e confinamento — consente. | Kitploit
Strumenti/GitHubGitHub/bcoles/kasld
RicognizioneExploitRaccolta InformazioniCTFPenetration TestingBinary Exploitation
GitHubbcoles/kasld

kasld

KASLD derandomizza il layout della memoria virtuale e fisica del kernel Linux da un processo locale, utilizzando tutto ciò che il suo punto di osservazione — privilegi, configurazione e confinamento — consente.

Vedi Repository
52151715 giorni faRevisionato da Kitploit
Condividi
<p align="center">
 <img src="https://assets.kitploit.com/production/public/readmes/48542/27960c6a9cf0003d33879e796f71de7930ff461d87e9c6333b9522d822615306.png" alt="KASLD logo generato con Copilot (ritagliato)"/>
</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 il layout della memoria virtuale e fisica del kernel Linux —
principalmente la base del testo del kernel — da un processo locale. Ciò che
può recuperare è funzione del punto di osservazione di quel processo: i suoi
privilegi e le sue capability, la configurazione del sistema e qualsiasi
confinamento in container. Recupera la base direttamente dove un leak o un
canale laterale lo consente, e altrimenti la restringe al più piccolo insieme
di posizionamenti supportati dalle prove disponibili.

Il motore di inferenza fonde le prove provenienti da decine di tecniche
indipendenti con le invarianti note dell'architettura, restringendo il
posizionamento del kernel a una finestra residua — riportata come il numero di
*slot* sopravvissuti (i posizionamenti che KASLR avrebbe potuto scegliere) e i
bit di entropia che essi rappresentano: un limite superiore alla protezione che
KASLR conserva da questo punto di osservazione, non una garanzia che la base sia
fuori dalla portata di un attaccante (vedi
[docs/limitations.md](https://github.com/bcoles/kasld/blob/master/docs/limitations.md)).

Il recupero completo è spesso impossibile su un target irrobustito — uno in cui
non sopravvive alcun leak diretto del testo del kernel e i canali laterali
esposti dalla sua architettura e dalla sua CPU sono chiusi — ma l'insieme dei
vincoli è raramente vuoto. Su architetture senza KASLR, il motore individua
l'indirizzo di caricamento scelto dal bootloader.

Supporta:

* 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

## Avvio rapido

```sh
sudo apt install libc-dev make gcc binutils git
git clone https://github.com/bcoles/kasld
cd kasld
make
./build/<arch>/kasld
```

La directory `build/<arch>/` è autosufficiente e può essere distribuita su un
sistema target:

```
build/<arch>/
  kasld              <- eseguire questo
  components/        <- componenti di leak
```

Una configurazione irrobustita (`kernel.dmesg_restrict=1`,
`kernel.kptr_restrict=1`, `kernel.perf_event_paranoid=2` o superiore,
`kernel.unprivileged_bpf_disabled=1` e hashing dei puntatori `%pK`) restringe il
percorso dell'oracolo del filesystem, ma è solo un asse del punto di
osservazione: le tecniche basate su canali laterali, entropia debole e
capability concesse sono indipendenti da questi sysctl. Per i test, lo script
[extra/weaken-kernel-hardening](https://github.com/bcoles/kasld/blob/master/extra/weaken-kernel-hardening)
può allentare temporaneamente queste impostazioni (richiede root).

## Esempio di output

La modalità testo predefinita stampa una panoramica che mette la risposta al
primo posto:

```
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 colonna `Certainty` separa due diverse affermazioni sulla stessa quantità.
Una riga **guaranteed** è dimostrata: il valore vero giace all'interno di quella
finestra. Una riga **likely** è la singola migliore stima supportata dalle prove
— sempre un sottoinsieme della finestra garantita, e può essere errata, perché
si basa su segnali al di sotto della soglia di solidità, come i canali laterali
temporali. Un risultato su cui vale la pena agire direttamente è una riga
`guaranteed` ristretta a un solo candidato; un valore `likely` è un indizio da
confermare, non un fatto su cui fare affidamento.

`-v` aggiunge la lettura dettagliata completa (banner, blocco di configurazione
del sistema, log per componente, analisi KASLR, mappe del layout di memoria).
`-j` emette JSON leggibile dalla macchina — la vista strutturata completa,
includendo sempre i record per componente e la valutazione dell'hardening. `-1`
emette una singola riga incanalabile in shell. `-m` formatta per i sistemi di
issue tracking. `-H` aggiunge la valutazione dell'hardening ai report
testo/markdown.

Vedi [docs/usage.md](https://github.com/bcoles/kasld/blob/master/docs/usage.md) per la CLI completa, i dettagli delle
modalità di output, la modalità explain e la valutazione dell'hardening.

## Punto di osservazione

Ciò che KASLD può recuperare dipende dal *punto di osservazione* del processo
in esecuzione — non un singolo livello di privilegio, ma la combinazione di tre
cose indipendenti:

* **Privilegi, gruppi e capability** — un uid non privilegiato, l'appartenenza
  a un gruppo come `adm` (che concede i log del kernel sotto `/var/log/`), un
  task in container che detiene una capability extra, o root. Questi non
  formano una singola scala, perché i permessi del filesystem controllano ogni
  sorgente in modo indipendente: un container a cui è concessa `CAP_SYS_RAWIO`
  è root nell'init namespace per quel controllo e può leggere `/proc/kcore` — un
  leak che un utente ordinario non può raggiungere — mentre le distribuzioni
  differiscono sul fatto che un file come `/boot/System.map` sia leggibile da
  tutti o meno.
* **Configurazione del sistema** — `kptr_restrict`, `dmesg_restrict`,
  `perf_event_paranoid`, BPF non privilegiato, kernel lockdown. La
  configurazione è indipendente dal privilegio: root non può leggere
  `/proc/kallsyms` con `kptr_restrict=2`, mentre un sysctl allentato o BPF non
  privilegiato può fornire a un utente semplice un leak che un sistema
  irrobustito negherebbe.
* **Confinamento** — un namespace o una sandbox seccomp che maschera gli
  oracoli di `/proc` o blocca le syscall, restringendo ciò che qualsiasi
  livello di privilegio osserva.

I tre assi controllano ogni sorgente di leak in modo indipendente — quindi più
privilegio non è un sovrainsieme di meno: la configurazione può negare una
sorgente a root, e i canali laterali aggirano del tutto i sysctl.
[docs/usage.md](https://github.com/bcoles/kasld/blob/master/docs/usage.md#vantage) contiene una matrice
sorgente-di-leak-per-cancello che mostra quale asse controlla ciascuna sorgente.

KASLD assume pochi privilegi per impostazione predefinita e sfrutta
opportunisticamente ciò che il punto di osservazione concede. La finestra
*guaranteed* riportata non dipende mai dal privilegio: un accesso elevato o una
configurazione debole possono ampliare ciò che viene tentato, mai il layout
solido che le prove dimostrano. Gli output verbose (`-v`), JSON (`-j`) e
Markdown (`-m`) riportano il punto di osservazione rilevato — container,
confinamento, oracoli leggibili e i leak controllati da capability raggiungibili
dalle capability correnti.

## Documentazione

Nuovo a KASLD? Leggi in ordine: [docs/kaslr.md](https://github.com/bcoles/kasld/blob/master/docs/kaslr.md) (cos'è KASLR e
cosa randomizza) → [docs/architecture.md → Un leak dall'inizio alla
fine](https://github.com/bcoles/kasld/blob/master/docs/architecture.md#a-leak-from-end-to-end) (come KASLD trasforma un leak
in una risposta) → [docs/limitations.md](https://github.com/bcoles/kasld/blob/master/docs/limitations.md) (cosa dimostra e
cosa non dimostra un risultato) → [CONTRIBUTING.md](https://github.com/bcoles/kasld/blob/master/CONTRIBUTING.md) (aggiungere
un componente di leak o una regola di inferenza). La tabella sottostante
indicizza la documentazione per argomento.

| Argomento | Documento |
|---|---|
| Introduzione a KASLR | [docs/kaslr.md](https://github.com/bcoles/kasld/blob/master/docs/kaslr.md) — storia di KASLR per architettura, base del testo predefinita, vmsplit, FG-KASLR |
| Utilizzo e CLI | [docs/usage.md](https://github.com/bcoles/kasld/blob/master/docs/usage.md) — CLI, modalità di output, modalità explain, valutazione dell'hardening |
| Interpretare i risultati | [docs/limitations.md](https://github.com/bcoles/kasld/blob/master/docs/limitations.md) — cosa significa un risultato negativo o parziale: solido-ma-non-completo, e perché un fallimento non è una garanzia di sicurezza |
| Tecniche di bypass | [docs/bypass-techniques.md](https://github.com/bcoles/kasld/blob/master/docs/bypass-techniques.md) — leak dal filesystem, canali laterali, leak da syscall / ioctl, entropia debole, CVE patchate, lettura arbitraria |
| Sfruttamento | [docs/exploitation.md](https://github.com/bcoles/kasld/blob/master/docs/exploitation.md) — dove si colloca il superamento di KASLR in un exploit, control-flow vs data-only, template pwntools, `ksymoff` |
| Impronta e rilevamento | [docs/footprint.md](https://github.com/bcoles/kasld/blob/master/docs/footprint.md) — come appare un'esecuzione su un host monitorato: la firma comportamentale per rilevarla, e il costo OPSEC per l'operatore; rumoroso per progettazione |
| Utilità | [extra/README.md](https://github.com/bcoles/kasld/blob/master/extra/README.md) — gli script di supporto in `extra/` (capture/replay, validazione della solidità, posture-diff, `ksymoff`) e come si combinano |
| Architettura e interni | [docs/architecture.md](https://github.com/bcoles/kasld/blob/master/docs/architecture.md) — il motore di inferenza, le giunture del flusso di dati, il protocollo a righe etichettate, la derivazione tra regioni |
| Solidità | [docs/soundness.md](https://github.com/bcoles/kasld/blob/master/docs/soundness.md) — cosa garantisce la finestra riportata, come proprietà formali: il reticolo che ogni quantità denota, l'obbligo su una regola, il contenimento della verità, la soglia di confidenza, il limite di terminazione |
| Contribuire | [CONTRIBUTING.md](https://github.com/bcoles/kasld/blob/master/CONTRIBUTING.md) — scrivere un componente o una regola, API dell'emitter, codici di uscita, metadati |
| Schema JSON | [docs/kasld.schema.json](https://github.com/bcoles/kasld/blob/master/docs/kasld.schema.json) — il documento `-j` come JSON Schema: validare uno snapshot acquisito rispetto ad esso, o generare tipi da esso. `schema_version` e la sua regola di compatibilità sono in [docs/usage.md](https://github.com/bcoles/kasld/blob/master/docs/usage.md#json--j) |
| Test e CI | [docs/testing.md](https://github.com/bcoles/kasld/blob/master/docs/testing.md) — test sull'host, fixture di replay, cross-arch sotto qemu-user, copertura |
| Riproducibilità | [docs/reproducibility.md](https://github.com/bcoles/kasld/blob/master/docs/reproducibility.md) — verifica indipendente: sul kernel locale, dal vivo su più architetture, o sul corpus acquisito |

## Compilazione

È richiesto un compilatore che supporti la macro `_GNU_SOURCE` a causa
dell'uso di codice non portabile (`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` limita una build ai componenti che corrispondono a un glob, così
un target che può eseguire solo una manciata di tecniche distribuisce solo
quelle. I pattern nominano i componenti e sono separati da virgole o spazi,
nella stessa forma accettata dal flag `--skip`; un pattern che non corrisponde a
nulla interrompe la build anziché restringerla silenziosamente. Se non
impostato, viene compilato ogni componente.

```
make cross COMPONENTS='dmesg_*,sysfs_devicetree_*,devicetree_facts,proc_*'
```

I componenti costituiscono la maggior parte della dimensione installata, quindi
una selezione è la leva per un rootfs piccolo — e riduce la build in
proporzione, che è il risparmio maggiore su diciassette target.

Come `CC`, la selezione appartiene all'invocazione anziché all'albero: un
`install` o `install-strip` eseguito senza di essa ricompila e installa tutto,
quindi passala anche a quelli.

```
make install-strip COMPONENTS='dmesg_*,proc_*' DESTDIR=/staging PREFIX=/usr
```

`make print-deps` riporta il toolchain richiesto, le due librerie opzionali
(`pthread`, `zlib`) con il loro risultato di auto-rilevamento per il compilatore
corrente, e le eccezioni ai flag di compilazione/link per componente — quanto
basta per popolare il file di controllo di un pacchetto di distribuzione senza
leggere la logica di probing del Makefile.

`make installcheck` esegue il `bin/kasld` installato e conferma che scopra i
suoi componenti tramite il percorso FHS `../libexec/kasld` — uno smoke test
post-installazione per il layout a installazione separata, usando gli stessi
`PREFIX`/`DESTDIR` di `make install` (quindi funziona anche contro una root di
staging `DESTDIR` nella CI dei pacchetti).

`make install` installa anche le pagine di manuale `man1` per `kasld` e
`ksymoff` in `<prefix>/share/man/man1/`, così `man kasld` e `man ksymoff`
funzionano dopo l'installazione.

KASLD può essere compilato in cross-compilazione con `make` specificando il
compilatore appropriato (`CC`). Il linking statico viene applicato
automaticamente durante la cross-compilazione:

```
make CC=aarch64-linux-musl-gcc
```

Compila tutti i target di cross-compilazione supportati (i toolchain devono
essere nel `PATH`):

```
make cross
```

## Licenza

KASLD è distribuito con licenza MIT (vedi [LICENSE](https://github.com/bcoles/kasld/blob/master/LICENSE)). Alcuni
componenti di leak adattano codice proof-of-concept di terze parti o
implementano una tecnica pubblicata per la prima volta da altri; ciascuno di
tali file accredita il suo autore e la sua fonte originale nell'intestazione, e
[THIRD-PARTY-NOTICES.md](https://github.com/bcoles/kasld/blob/master/THIRD-PARTY-NOTICES.md) elenca ciascuno con la sua
licenza o base di riutilizzo (licenza upstream, permesso dell'autore, o
materiale di tecnica/riproduttore reimplementato qui).

## Citare KASLD

KASLD è distribuito con licenza MIT — l'attribuzione non è richiesta per l'uso,
ma una citazione o un link è apprezzata ovunque venga referenziato in ricerca,
strumenti, exploit o scritti:

> **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 mostra anche un pulsante *"Cite this repository"* da
[CITATION.cff](https://github.com/bcoles/kasld/blob/master/CITATION.cff). Per una build non rilasciata da `master`, cita il
commit specifico e la data di accesso — ad es. `bcoles/kasld@<commit>`
(accessed YYYY-MM-DD) — poiché le stringhe di versione `-dev` non sono uniche
per un singolo commit.
Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Nessun dato di popolarità ancora.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →