rex-rs/rexRex ist ein sicheres und nutzbares Kernel-Erweiterungsframework, das das Laden und Ausführen von Rust-Kernel-Erweiterungsprogrammen anstelle von eBPF ermöglicht.
____ _______ __ _____ _ _
| _ \| ____\ \/ / | ____|_ _| |_ ___ _ __ ___(_) ___ _ __ ___
| |_) | _| \ / | _| \ \/ / __/ _ \ '_ \/ __| |/ _ \| '_ \/ __|
| _ <| |___ / \ | |___ > <| || __/ | | \__ \ | (_) | | | \__ \
|_| \_\_____/_/\_\ |_____/_/\_\\__\___|_| |_|___/_|\___/|_| |_|___/
Rex ist ein sicheres und benutzbares Framework für Kernel-Erweiterungen, das das Laden und Ausführen von Rust-Kernel-Erweiterungsprogrammen anstelle von eBPF ermöglicht. Im Gegensatz zu eBPF-basierten Frameworks wie Aya durchlaufen Rex-Programme nicht den In-Kernel-Verifier. Stattdessen werden die Programme in der sicheren Teilmenge von Rust implementiert, in der der Rust-Compiler die erforderlichen Sicherheitsprüfungen durchführt und direkt nativen Code erzeugt. Dieser Ansatz vermeidet die übermäßig restriktiven Verifizierungsanforderungen (z. B. Komplexitätsbeschränkungen für Programme) und die daraus resultierenden obskuren Verifizierungsfehler und bietet gleichzeitig potenziell eine bessere Optimierungsmöglichkeit im nativen Compiler-Backend (d. h. LLVM) als der eBPF-Backend + In-Kernel-JIT-Ansatz.
Rex unterstützt derzeit die folgenden Funktionen:
kprobe, perf_event, tracepoint, xdp und tc.Das folgende Beispiel implementiert ein kprobe-Programm, das einen ausgewählten Systemaufruf abfängt und einem Prozess (angegeben durch seine pid) einen Fehler (angegeben durch errno) in den Systemaufruf injiziert. Das vollständige Beispiel einschließlich des Ladeprogramms finden Sie unter samples/error_injector.
#![no_std]
#![no_main]
use rex::kprobe::kprobe;
use rex::map::RexHashMap;
use rex::pt_regs::PtRegs;
use rex::rex_kprobe;
use rex::rex_map;
use rex::Result;
#[allow(non_upper_case_globals)]
#[rex_map]
static pid_to_errno: RexHashMap<i32, u64> = RexHashMap::new(1, 0);
#[rex_kprobe]
pub fn err_injector(obj: &kprobe, ctx: &mut PtRegs) -> Result {
obj.bpf_get_current_task()
.map(|t| t.get_pid())
.and_then(|p| obj.bpf_map_lookup_elem(&pid_to_errno, &p).cloned())
.map(|e| obj.bpf_override_return(ctx, e))
.ok_or(0)
}
Weitere Beispielprogramme finden Sie unter samples.
Eine ausführliche Anleitung finden Sie hier.
Weitere Design-Dokumentationen finden Sie unter docs.
Die bestehende eBPF-Erweiterung stützt sich auf den In-Kernel-eBPF-Verifier, um Sicherheitsgarantien zu bieten. Dies führt leider zu Benutzbarkeitsproblemen, bei denen sichere Programme vom Verifier abgelehnt werden, einschließlich, aber nicht beschränkt auf:
Rex zielt darauf ab, diese Probleme zu lösen, indem es direkt auf die Sicherheitsgarantie von safe Rust zurückgreift. Entwickler können ihre Programme auf jede Art und Weise implementieren, die in safe Rust mit wenigen Einschränkungen geschrieben werden kann, und müssen sich nicht mehr um die Programmkomplexität, den Codegenerator oder die (oft kontraintuitive) Art und Weise kümmern, dieselbe Logik auszudrücken, um den Verifier zufriedenzustellen.
Wir demonstrieren dies mit der Implementierung des BPF Memcached Cache (BMC), einem hochmodernen Erweiterungsprogramm zur Beschleunigung von Memcached. Als komplexes eBPF-Programm ist BMC gezwungen, in mehrere Komponenten aufgeteilt zu werden, die über BPF-Tail-Calls verbunden sind, und umständliche Schleifen-/Verzweigungsimplementierungen zu verwenden, um den Verifier zufriedenzustellen – all das ist in seiner Rex-Implementierung völlig unnötig.
Zum Beispiel zeigen wir den Code in der Cache-Invalidierungslogik des BPF-BMC, der in der Paketnutzlast nach einem SET-Befehl sucht:
// Searches for SET command in payload
for (unsigned int off = 0;
off < BMC_MAX_PACKET_LENGTH && payload + off + 1 <= data_end;
off++) {
if (set_found == 0 && payload[off] == 's' &&
payload + off + 3 <= data_end && payload[off + 1] == 'e' &&
payload[off + 2] == 't') {
off += 3;
set_found = 1;
}
...
}
Der Code führt nicht nur eine zusätzliche Einschränkung in der Schleife ein (off < BMC_MAX_PACKET_LENGTH), die ausschließlich dazu dient, den Verifier zu passieren, sondern verwendet auch wiederholten Boilerplate-Code, um Paketenden zu prüfen (data_end), sowie umständliche Logik, um den "set"-String im Paket abzugleichen.
Keine dieser Lasten ist mit der Leistungsfähigkeit von safe Rust in Rex erforderlich, das keine Komplexitätsbeschränkungen hat und mehr Freiheit bei der Implementierung bietet:
let set_iter = payload.windows(4).enumerate().filter_map(|(i, v)| {
if v == b"set " {
Some(i)
} else {
None
}
});
Die vollständige Implementierung von BMC in Rex finden Sie unter samples/bmc.
Rex ist unter der GPLv2-Lizenz lizenziert. Die Untermodule (Linux, Rust, LLVM) in diesem Repository sind unter ihren eigenen Bedingungen lizenziert. Weitere Einzelheiten finden Sie in den entsprechenden Lizenzdateien. Darüber hinaus ist der Memcached-Benchmark unter der MIT-Lizenz lizenziert.