Modul 20 — Unsafe Code: Verträge, Rohe Zeiger & Undefined Behavior

Das Versprechen von Rust

Rusts Typ- und Borrow-Checker verhindern ganze Fehlerklassen zur Compile-Zeit. Aber manches lässt sich nicht automatisch prüfen. Ein unsafe-Feature ist eines, das einen Vertrag auferlegt: Regeln, die Rust nicht selbst erzwingen kann, die du aber befolgen musst, um undefiniertes Verhalten (UB) zu vermeiden.

Undefined Behavior ist Verhalten, von dem Rust annimmt, dass es nie eintritt. Trifft es doch ein, macht Rust keine Vorhersagen über die Folgen — von verwirrenden Abstürzen bis zur Übergabe deines Computers an einen Angreifer.

Beispiel: Ein roher Zeiger, der über das Ende seines Ursprungsobjekts hinaus läuft, verstößt gegen den Zeiger-Vertrag. Rust kompiliert das trotzdem — die Sicherheitsprüfung erkennt es nicht. Du trägst die Verantwortung.

Unsafe-Features

Diese Optionen stehen dir in unsafe zur Verfügung:

1. unsafe-Funktionen aufrufen
2. Rohe Zeiger dereferenzieren
3. Felder von unions lesen
4. Mutable static-Variablen zugreifen
5. FFI-Funktionen/-Variablen (aus anderen Sprachen) benutzen

unsafe-Block

Ein unsafe-Block sieht aus wie ein normaler Block, nur mit unsafe davor. Innerhalb darfst du Unsafe-Features nutzen — z. B. String::from_utf8_unchecked:

fn main() {
    let ascii = b"hello".to_vec();
    // from_utf8_unchecked ist eine unsafe-Funktion:
    let s = unsafe { String::from_utf8_unchecked(ascii) };
    println!("{s}");
}

Ohne unsafe davor lehnt Rust den Aufruf ab. Der Block separiert Code, der besondere Prüfung verdient, vom Rest des Programms.

unsafe-Funktion

Eine unsafe fn ist eine Funktion mit einem Vertrag:

/// Liefert einen String ohne Laufzeit-UTF-8-Prüfung.
///
/// # Safety
/// `bytes` muss gültiges UTF-8 enthalten.
unsafe fn from_utf8_unchecked(bytes: Vec<u8>) -> String {
    String::from_utf8_unchecked(bytes)
}

Der Aufruf erfordert einen unsafe-Block. Die # Safety-Doku erklärt den Vertrag.

Zwei Arten roher Zeiger

Ein roher Zeiger ist ein unbeschränkter Zeiger — wie ein C-Zeiger. Du kannst damit Strukturen bauen, die geprüfte Zeiger nicht zulassen (z. B. doppelt verkettete Listen). Dafür kann Rust nicht prüfen, ob du sie sicher verwendest — dereferenzieren darfst du sie nur im unsafe-Block.

• *mut T — roher Zeiger, der das Referent ändern darf
• *const T — roher Zeiger, der das Referent nur lesen darf

Es gibt kein *T — du musst const oder mut angeben.

Zeiger erzeugen und dereferenzieren

fn main() {
    let mut x = 10;
    let ptr_x: *mut i32 = &raw mut x;   // &raw-mut-Operator

    let y = Box::new(20);
    let ptr_y: *const i32 = &*y;        // implizite Koerzion

    unsafe {
        *ptr_x += *ptr_y;               // dereferenzieren nur hier
    }
    assert_eq!(x, 30);
}

Rohe Zeiger können null sein (wie C NULL) und werden nicht automatisch gelöscht/geleert.

Übung: Zeiger erstellen und lesen

Warum vertraut der Compiler?

Ein Optimierer transformiert dein Programm schrittweise — schneller, kleiner. Dabei verlässt er sich darauf, dass manche Dinge nie passieren (UB). Diese Annahme erlaubt aggressive Optimierung.

Beispiel — der Compiler darf Folgendes annehmen:

let i = 10;
some_function(&i);
println!("{}", i * 100);

Wenn some_function Unsafe-Code enthält, der i über den Zeiger entgegen seiner Referenz-Semantik verändert, ist das UB. Der Compiler kann das Ergebnis von i * 100 dann vorab berechnen, als wäre i unverändert — und das Programm überrascht dich.

Unsafe-Traits

Genau wie Funktionen können Traits unsafe sein. Das Kennzeichnen einer Trait als unsafe signalisiert: Wer sie implementiert, muss bestimmte Garantien einhalten. Send und Sync sind klassische Unsafe-Traits.

unsafe trait MeineVertrag {
    fn do_it(&self);
}

// Wo unrichtig unpingerherrn:
unsafe impl MeineVertrag for Typ { ... }

Nur Unsafe-Code darf eine unsafe-Trait implementieren — denn die Implementierung trägt einen Vertrag.

Null-Zeiger

Rohe Zeiger dürfen null sein. Entwickle Konventionen, um das sicher zu handhaben:

fn option_to_raw<T>(opt: Option<&T>) -> *const T {
    match opt {
        Some(r) => r as *const T,
        None => std::ptr::null(),
    }
}

fn raw_to_option<'a, T>(raw: *const T) -> Option<&'a T> {
    if raw.is_null() {
        None
    } else {
        Some(unsafe { &*raw })
    }
}

• std::ptr::null() / null_mut() erzeugen Null-Zeiger
• .is_null() prüft auf null
• Bevor du &*raw machst: sicherstellen, dass nicht null und gültig

Übung: Null-Zeiger sicher behandeln

Zeiger-Arithmetik und Größen

Der Compiler kennt Größe und Ausrichtung jedes Typs. Für rohe Zeiger gibt es Methoden, die in Einheiten zählen (nicht in Bytes):

use std::mem;

let arr = [1u8, 2, 3, 4];
let ptr = arr.as_ptr();

// Zeiger n Elemente weiter bewegen (in T-Einheiten, hier Bytes):
let third = unsafe { *ptr.add(2) };
assert_eq!(third, 3);

println!("usize: {}", mem::size_of::<usize>());

• .add(n) bewegt um n Elemente (Typr-basiert), .offset(n) ähnlich
• size_of::<T>() / align_of::<T>() geben Größe/Ausrichtung
• Der Vertrag: nur innerhalb der Grenzen des ursprünglichen Objekts bewegen

Unions

Eine union ist ein Strukturtyp aus C, dessen Felder alle am selben Speicherort liegen:

union UnspecifiedShape {
    circle: u32,
    rectangle: u32,
}

Anders als ein enum trägt eine Union keine Kennung, welches Feld initialisiert ist. Deshalb ist das Lesen aus einem Feld einer Union unsafe — nur das Schreiben ist sicher. Unions nutzt du fast nur für FFI / C-Kompatibilität.

Projekt: Unsafe kapseln

Der Kern-Trick von gutem Unsafe: kleine Mengen Unsafe in sicheren Interfaces verstecken, damit der Rest des Programms sicher bleibt. Deine Aufgabe:

1. Definiere eine Funktion, die eine Vec<u8> (bekannt gültiges UTF-8) mit String::from_utf8_unchecked in einen String verwandelt — als unsafe fn mit # Safety-Doku.
2. Rufe sie in main aus einem unsafe-Block auf, mit // SAFETY:-Kommentar.
3. Erstelle einen rohen Zeiger auf ein i32, ändere den Wert im unsafe-Block über den Zeiger und zeige, dass die ursprüngliche Variable sich geändert hat.
4. Schreibe einen // SAFETY-Kommentar, der GENAU erklärt, warum dein Code den Vertrag nicht verletzt.

Das prüft: unsafe-Funktionen, unsafe-Blöcke, rohe Zeiger, und die Denkweise — Verantwortung für Verträge übernehmen — die dieses Modul vermittelt.

Übung: Sichere Hülle um Unsafe