Zurück zur Schwachstellen-Datenbank

Operation auf einer Ressource nach Ablauf oder Freigabe

Beschreibung

Operation auf einer Ressource nach Ablauf oder Freigabe tritt auf, wenn Code eine Ressource weiterhin verwendet, nachdem diese freigegeben, abgelaufen oder anderweitig ungültig geworden ist. Dies umfasst die Verwendung von Speicher nach dessen Freigabe (Use-After-Free), den Zugriff auf Dateien nach dem Schließen, die Nutzung von Netzwerkverbindungen nach der Trennung, die Verwendung abgelaufener Anmeldedaten oder Token sowie die Referenzierung von Objekten nach Ende ihrer Lebensdauer. Solche Operationen führen zu undefiniertem Verhalten und Sicherheitslücken.

Risiko

Use-After-Free ermöglicht die Ausführung beliebigen Codes. Abgelaufene Token gewähren weiterhin Zugriff. Geschlossene Verbindungen können Daten lecken oder Abstürze verursachen. Veraltete Anmeldedaten umgehen Widerrufe. Freigegebene Ressourcen können neu zugewiesen und missbraucht werden. Speicherkorruption durch baumelnde Pointer ist möglich. Datenintegritätsprobleme durch abgelaufene Cache-Einträge können auftreten.

Lösung

Setzen Sie Pointer nach dem Freigeben von Speicher auf NULL. Verfolgen Sie den Ressourcenstatus explizit. Verwenden Sie Smart Pointer und RAII-Muster. Implementieren Sie ordnungsgemäße Token-Ablaufprüfungen. Validieren Sie die Verfügbarkeit von Ressourcen vor der Verwendung. Nutzen Sie Sprachfeatures, die Use-After-Free verhindern. Implementieren Sie ordnungsgemäße Bereinigungssequenzen.

Häufige Auswirkungen

AuswirkungDetails
IntegritätBereich: Speicherkorruption

Use-After-Free korrumpiert den Speicherstatus.
VertraulichkeitBereich: Informationsoffenlegung

Freigegebener Speicher kann sensible Daten enthalten.
AutorisierungBereich: Zugriffskontrollumgehung

Abgelaufene Anmeldedaten gewähren weiterhin Zugriff.

Beispielcode und Lösung

Verwundbarer Code

// VERWUNDBAR: Use-After-Free und verwandte Probleme
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

// VERWUNDBAR: Klassisches Use-After-Free
void use_after_free_verwundbar() {
    char* buffer = malloc(100);
    strcpy(buffer, "sensible daten");

    free(buffer);

    // VERWUNDBAR: Verwendung von freigegebenem Speicher
    printf("Daten: %s\n", buffer);  // Use-After-Free
    strcpy(buffer, "neue daten");    // Schreiben in freigegebenen Speicher
}

// VERWUNDBAR: Baumelnder Pointer in Struktur
typedef struct {
    char* name;
    int id;
} User;

void baumelnder_zeiger_verwundbar(User* user) {
    free(user->name);
    // VERWUNDBAR: user->name baumelt jetzt
    // Anderer Code kann noch darauf zugreifen
}

# VERWUNDBAR: Python Ressourcenablaufprobleme
from datetime import datetime, timedelta

# VERWUNDBAR: Verwendung geschlossener Datei
def datei_nach_schließen_verwundbar():
    f = open('daten.txt', 'r')
    inhalt = f.read()
    f.close()

    # VERWUNDBAR: Datei ist geschlossen
    f.seek(0)  # ValueError: I/O-Operation auf geschlossener Datei
    mehr_inhalt = f.read()

# VERWUNDBAR: Abgelaufenes Token wird noch verwendet
class VerwundbareTokenAuth:
    def __init__(self):
        self.token = None
        self.expires_at = None

    def authenticate(self, token):
        self.token = token
        self.expires_at = datetime.now() + timedelta(hours=1)

    def make_request(self, endpoint):
        # VERWUNDBAR: Prüft nicht auf Ablauf
        headers = {'Authorization': f'Bearer {self.token}'}
        return requests.get(endpoint, headers=headers)

Sichere Lösung

// SICHER: Korrekte Ressourcenlebenszyklusverwaltung
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

// SICHER: Nach free auf NULL setzen
void use_after_free_sicher() {
    char* buffer = malloc(100);
    if (!buffer) return;

    strcpy(buffer, "sensible daten");

    // Sensible Daten vor free löschen
    memset(buffer, 0, 100);
    free(buffer);
    buffer = NULL;  // SICHER: Verhindert Use-After-Free

    // Sicher: NULL-Prüfung verhindert Probleme
    if (buffer) {
        printf("Daten: %s\n", buffer);
    }
}

// SICHER: Strukturierte Bereinigung
typedef struct {
    char* name;
    int id;
    int name_valid;  // Verfolgt ob name gültig ist
} SafeUser;

void cleanup_user_sicher(SafeUser* user) {
    if (user && user->name && user->name_valid) {
        free(user->name);
        user->name = NULL;
        user->name_valid = 0;
    }
}

# SICHER: Python korrekter Ressourcenlebenszyklus
from datetime import datetime, timedelta
from contextlib import contextmanager

# SICHER: Verwendung von Kontextmanagern
def datei_mit_kontext_sicher():
    with open('daten.txt', 'r') as f:
        inhalt = f.read()
        # Datei automatisch nach Block geschlossen
        # Kann geschlossene Datei nicht versehentlich verwenden

# SICHER: Token mit Ablaufprüfung
class SichereTokenAuth:
    def __init__(self):
        self.token = None
        self.expires_at = None

    def authenticate(self, token, expires_in=3600):
        self.token = token
        self.expires_at = datetime.now() + timedelta(seconds=expires_in)

    def is_expired(self):
        return not self.expires_at or datetime.now() >= self.expires_at

    def get_token(self):
        if self.is_expired():
            raise TokenExpiredError("Token ist abgelaufen")
        return self.token

    def make_request(self, endpoint):
        if self.is_expired():
            self.refresh_token()  # Vor Verwendung aktualisieren

        headers = {'Authorization': f'Bearer {self.token}'}
        return requests.get(endpoint, headers=headers)

Ausgenutzt in der Praxis

Chrome V8 Use-After-Free (Google Chrome, 2021)

Eine Use-After-Free-Schwachstelle in der V8 JavaScript-Engine von Google Chrome ermöglichte es Angreifern, beliebigen Code im Kontext des Browsers auszuführen. Die Schwachstelle wurde aktiv ausgenutzt, bevor Google einen Notfall-Patch veröffentlichte.

Firefox Use-After-Free Angriffe (Mozilla Firefox, 2020)

Mozilla patched mehrere kritische Use-After-Free-Schwachstellen in Firefox, die aktiv von Angreifern ausgenutzt wurden. Die Schwachstellen ermöglichten Remote-Code-Ausführung durch speziell präparierte Webseiten.

iOS Use-After-Free Exploit (Apple, 2021)

Forscher entdeckten eine Use-After-Free-Schwachstelle in iOS, die von der Pegasus-Spyware ausgenutzt wurde, um iPhones ohne Benutzerinteraktion zu kompromittieren.

Tools zum Testen und Ausnutzen

  • AddressSanitizer (ASan) — Compiler-Tool zur Erkennung von Speicherfehlern einschließlich Use-After-Free.

  • Valgrind — Speicherprüfungswerkzeug zur Erkennung von Speicherlecks und Use-After-Free.

  • Dr. Memory — Speicherüberwachungstool für Windows und Linux.

CVE-Beispiele

Referenzen

  1. MITRE Corporation. "CWE-672: Operation on a Resource after Expiration or Release." https://cwe.mitre.org/data/definitions/672.html

  2. OWASP. "Memory Management Cheat Sheet." https://cheatsheetseries.owasp.org/cheatsheets/Memory_Management_Cheat_Sheet.html

  3. CERT Secure Coding. "MEM30-C: Do not access freed memory." https://wiki.sei.cmu.edu/confluence/display/c/MEM30-C.+Do+not+access+freed+memory