Ursprünglich ist es Teil des Quellcodes des Linux-Kernels, daher wird es als GPLv2 behandelt (Anerkennung, dass es sein sollte).
https://www.kernel.org/doc/html/latest/index.html
Licensing documentation
The following describes the license of the Linux kernel source code (GPLv2), how to properly mark the license of individual files in the source tree, as well as links to the full license text.
https://www.kernel.org/doc/html/latest/process/license-rules.html#kernel-licensing
https://www.kernel.org/doc/html/latest/dev-tools/kasan.html
Docs » Development tools for the kernel » The Kernel Address Sanitizer (KASAN)
The Kernel Address Sanitizer (KASAN)
Overview
KernelAddressSANitizer (KASAN) is a dynamic memory error detector designed to find out-of-bound and use-after-free bugs. KASAN has two modes: generic KASAN (similar to userspace ASan) and software tag-based KASAN (similar to userspace HWASan).
KernelAddressSANitizer (KASAN) ist eine dynamische Speicherfehlererkennungsmethode. Es wurde entwickelt, um nicht gebundene und nachträglich verwendete Fehler zu erkennen. KASAN hat zwei Modi. Generisches KASAN (ähnlich wie User Space Asan) und Software Tag-Baed KASAN (ähnlich wie User Space HWAsan).
KASAN uses compile-time instrumentation to insert validity checks before every memory access, and therefore requires a compiler version that supports that.
KASAN verwendet Messungen zur Kompilierungszeit zur Validierung vor dem vollständigen Speicherzugriff. Und es erfordert eine unterstützte Compiler-Version.
Generic KASAN is supported in both GCC and Clang. With GCC it requires version 4.9.2 or later for basic support and version 5.0 or later for detection of out-of-bounds accesses for stack and global variables and for inline instrumentation mode (see the Usage section). With Clang it requires version 7.0.0 or later and it doesn’t support detection of out-of-bounds accesses for global variables yet.
Generisches KASAN wird sowohl von GCC als auch von Clang unterstützt. Für GCC ist Version 4.9.2 oder höher für die Basisunterstützung erforderlich, Version 5.0 oder höher ist erforderlich, um außerhalb der Grenzen liegende Stapel- und globale Variablen zu erkennen, und der Inline-Instrumentierungsmodus ist erforderlich (siehe Abschnitt Verwendung). Bitte). Für Clang sind Versionen 7.0.0 und höher erforderlich, die Erkennung außerhalb der Grenzen für globale Variablen wird jedoch noch nicht unterstützt.
Tag-based KASAN is only supported in Clang and requires version 7.0.0 or later.
Tag-basiertes KASAN wird nur in Clang unterstützt und erfordert Version 7.0.0 oder höher.
Currently generic KASAN is supported for the x86_64, arm64, xtensa, s390 and riscv architectures, and tag-based KASAN is supported only for arm64.
Derzeit wird generisches KASAN von x86_64-, arm64-, xtensa s390- und riscv-Architekturen unterstützt. Und tagbasiertes KASAN wird nur auf arm64 unterstützt.
Usage
To enable KASAN configure kernel with:
Die Kerneleinstellungen für das effektive Reiben von KASAN sind wie folgt.
CONFIG_KASAN = y
and choose between CONFIG_KASAN_GENERIC (to enable generic KASAN) and CONFIG_KASAN_SW_TAGS (to enable software tag-based KASAN).
Wählen Sie dann entweder CONFIG_KASAN_GENERIC (um generisches KASAN zu aktivieren) oder CONFIG_KASAN_SW_TAGS (um Software-Tag-basiertes KASAN zu aktivieren).
You also need to choose between CONFIG_KASAN_OUTLINE and CONFIG_KASAN_INLINE. Outline and inline are compiler instrumentation types. The former produces smaller binary while the latter is 1.1 - 2 times faster.
Außerdem müssen Sie zwischen CONFIG_KASAN_OUTLINE und CONFIG_LASAN_INLINE wählen. Gliederung und Inline sind Instrumentierungstypen von Not. Ersteres erzeugt eine kleine Binärdatei. Letzteres ist 1,1-2 mal schneller.
Both KASAN modes work with both SLUB and SLAB memory allocators. For better bug detection and nicer reporting, enable CONFIG_STACKTRACE.
Beide KASAN-Modi können mit SLUB- und SLAB-Speicherzuordnungen verwendet werden. Aktivieren Sie CONFIG_STACKTRACE für eine bessere Fehlererkennung und Berichterstellung.
To augment reports with last allocation and freeing stack of the physical page, it is recommended to enable also CONFIG_PAGE_OWNER and boot with page_owner=on.
Um den Bericht über den endgültig zugewiesenen / freigegebenen Stapel auf der physischen Seite zu erweitern, aktivieren Sie auch CONFIF_PAGE_OWNER und setzen Sie page_owner = beim Start auf.
To disable instrumentation for specific files or directories, add a line similar to the following to the respective kernel Makefile:
Um die Instrumentierung für eine bestimmte Datei oder ein bestimmtes Verzeichnis zu deaktivieren, fügen Sie jedem Kernel-Makefile eine Zeile hinzu, die der folgenden ähnelt:
KASAN_SANITIZE_main.o := n
KASAN_SANITIZE := n
Error reports
A typical out-of-bounds access generic KASAN report looks like this:
Zum Zeitpunkt des typischen Zugriffs außerhalb der Grenzen meldet generisches KASAN Folgendes.
==================================================================
BUG: KASAN: slab-out-of-bounds in kmalloc_oob_right+0xa8/0xbc [test_kasan]
Write of size 1 at addr ffff8801f44ec37b by task insmod/2760
CPU: 1 PID: 2760 Comm: insmod Not tainted 4.19.0-rc3+ #698
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.10.2-1 04/01/2014
Call Trace:
dump_stack+0x94/0xd8
print_address_description+0x73/0x280
kasan_report+0x144/0x187
__asan_report_store1_noabort+0x17/0x20
kmalloc_oob_right+0xa8/0xbc [test_kasan]
kmalloc_tests_init+0x16/0x700 [test_kasan]
do_one_initcall+0xa5/0x3ae
do_init_module+0x1b6/0x547
load_module+0x75df/0x8070
__do_sys_init_module+0x1c6/0x200
__x64_sys_init_module+0x6e/0xb0
do_syscall_64+0x9f/0x2c0
entry_SYSCALL_64_after_hwframe+0x44/0xa9
RIP: 0033:0x7f96443109da
RSP: 002b:00007ffcf0b51b08 EFLAGS: 00000202 ORIG_RAX: 00000000000000af
RAX: ffffffffffffffda RBX: 000055dc3ee521a0 RCX: 00007f96443109da
RDX: 00007f96445cff88 RSI: 0000000000057a50 RDI: 00007f9644992000
RBP: 000055dc3ee510b0 R08: 0000000000000003 R09: 0000000000000000
R10: 00007f964430cd0a R11: 0000000000000202 R12: 00007f96445cff88
R13: 000055dc3ee51090 R14: 0000000000000000 R15: 0000000000000000
Allocated by task 2760:
save_stack+0x43/0xd0
kasan_kmalloc+0xa7/0xd0
kmem_cache_alloc_trace+0xe1/0x1b0
kmalloc_oob_right+0x56/0xbc [test_kasan]
kmalloc_tests_init+0x16/0x700 [test_kasan]
do_one_initcall+0xa5/0x3ae
do_init_module+0x1b6/0x547
load_module+0x75df/0x8070
__do_sys_init_module+0x1c6/0x200
__x64_sys_init_module+0x6e/0xb0
do_syscall_64+0x9f/0x2c0
entry_SYSCALL_64_after_hwframe+0x44/0xa9
Freed by task 815:
save_stack+0x43/0xd0
__kasan_slab_free+0x135/0x190
kasan_slab_free+0xe/0x10
kfree+0x93/0x1a0
umh_complete+0x6a/0xa0
call_usermodehelper_exec_async+0x4c3/0x640
ret_from_fork+0x35/0x40
The buggy address belongs to the object at ffff8801f44ec300
which belongs to the cache kmalloc-128 of size 128
The buggy address is located 123 bytes inside of
128-byte region [ffff8801f44ec300, ffff8801f44ec380)
The buggy address belongs to the page:
page:ffffea0007d13b00 count:1 mapcount:0 mapping:ffff8801f7001640 index:0x0
flags: 0x200000000000100(slab)
raw: 0200000000000100 ffffea0007d11dc0 0000001a0000001a ffff8801f7001640
raw: 0000000000000000 0000000080150015 00000001ffffffff 0000000000000000
page dumped because: kasan: bad access detected
Memory state around the buggy address:
ffff8801f44ec200: fc fc fc fc fc fc fc fc fb fb fb fb fb fb fb fb
ffff8801f44ec280: fb fb fb fb fb fb fb fb fc fc fc fc fc fc fc fc
>ffff8801f44ec300: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 03
^
ffff8801f44ec380: fc fc fc fc fc fc fc fc fb fb fb fb fb fb fb fb
ffff8801f44ec400: fb fb fb fb fb fb fb fb fc fc fc fc fc fc fc fc
==================================================================
The header of the report provides a short summary of what kind of bug happened and what kind of access caused it. It’s followed by a stack trace of the bad access, a stack trace of where the accessed memory was allocated (in case bad access happens on a slab object), and a stack trace of where the object was freed (in case of a use-after-free bug report). Next comes a description of the accessed slab object and information about the accessed memory page.
Der Header-Abschnitt des Berichts enthält eine kurze Zusammenfassung dessen, was schief gelaufen ist und um welche Art von Zugriff es sich handelt. Danach eine Stapelverfolgung des nicht autorisierten Zugriffs, eine Stapelverfolgung, wenn der Speicher, auf den zugegriffen wird, gesichert ist (wenn im Plattenobjekt ein nicht autorisierter Zugriff vorhanden ist), und eine Stapelverfolgung (Fehler "Use-After-Free"), wenn das Objekt freigegeben wird. Im Falle eines Berichts) folgt. Darauf folgt eine Beschreibung des aufgerufenen Plattenobjekts und Informationen über die Speicherseite, auf die zugegriffen wird.
In the last section the report shows memory state around the accessed address. Reading this part requires some understanding of how KASAN works.
Der letzte Abschnitt zeigt den Speicherstatus der wöchentlichen Verkäufe der Adresse, auf die zugegriffen wird. Um diesen Teil lesen zu können, müssen Sie die KASAN-Funktionen verstehen.
The state of each 8 aligned bytes of memory is encoded in one shadow byte. Those 8 bytes can be accessible, partially accessible, freed or be a redzone. We use the following encoding for each shadow byte:
We use different negative values to distinguish between different kinds of inaccessible memory like redzones or freed memory (see mm/kasan/kasan.h).
Der Zustand jedes 8 ausgerichteten Bytes im Speicher wird in ein Schattenbyte codiert. Auf diese 8 Bytes kann teilweise zugegriffen, freigegeben oder neu eingeteilt werden. Verwenden Sie für jedes Schattenbyte die folgende Codierung.
--0 bedeutet, dass Sie auf alle 8 Bytes des entsprechenden Speicherbereichs zugreifen können. --Nummer N (1 <= N <= 7) bedeutet, dass auf die ersten N Bytes zugegriffen werden kann und auf die anderen (8-N) Bytes nicht.
In the report above the arrows point to the shadow byte 03, which means that the accessed address is partially accessible.
Im obigen Bericht zeigt der Pfeil auf das Schattenbyte 03. Dies bedeutet, dass auf die Adresse, auf die zugegriffen wird, teilweise zugegriffen werden kann.
For tag-based KASAN this last report section shows the memory tags around the accessed address (see Implementation details section).
Im tagbasierten KASAN werden im Abschlussbericht die Speicher-Tags um die Adresse angezeigt, auf die zugegriffen wird (siehe Abschnitt Implementierungsdetails).