Ungenaue Kommentare

Beschreibung

Ungenaue Kommentare treten auf, wenn Quellcode Kommentare enthält, die Aspekte des zugehörigen Codeabschnitts nicht korrekt beschreiben oder erklären. Dies umfasst veraltete Kommentare, die das aktuelle Codeverhalten nicht mehr widerspiegeln, Kommentare die falsche Funktionalität beschreiben, irreführende Erklärungen von Algorithmen oder Logik, kopierte Kommentare die nicht aktualisiert wurden, und Kommentare die dem tatsächlichen Code widersprechen. Ungenaue Kommentare können Entwickler und Sicherheitsprüfer in die Irre führen und potenziell dazu beitragen, dass Schwachstellen übersehen oder neue Bugs eingeführt werden.

Risiko

Ungenaue Kommentare haben signifikante indirekte Sicherheitsauswirkungen. Sicherheitsprüfer vertrauen möglicherweise irreführenden Kommentaren, anstatt den tatsächlichen Code zu analysieren. Entwickler warten Code möglicherweise basierend auf falschen Kommentarbeschreibungen. Bugs können eingeführt werden, wenn Code gemäß falscher Kommentare korrigiert wird. Sicherheitskritisches Verhalten kann missverstanden werden. Auditoren übersehen möglicherweise Schwachstellen, wenn Kommentare suggerieren, dass Code sicher ist. Codeänderungen können Funktionalität brechen, die Kommentare falsch beschreiben. Compliance-Audits können durch irreführende Dokumentation beeinträchtigt werden. Zeit wird verschwendet beim Versuch, Kommentarbeschreibungen mit tatsächlichem Verhalten in Einklang zu bringen.

Lösung

Halten Sie Kommentare synchron mit Codeänderungen. Überprüfen Sie Kommentare während Code-Reviews auf Genauigkeit. Löschen Sie Kommentare, anstatt veraltete stehen zu lassen. Verwenden Sie selbstdokumentierenden Code, um den Bedarf an erklärenden Kommentaren zu reduzieren. Schreiben Sie Kommentare, die das "Warum" erklären statt das "Was" (der Code zeigt das Was). Aktualisieren Sie Kommentare sofort, wenn zugehöriger Code geändert wird. Verwenden Sie automatisierte Tools zur Erkennung veralteter Kommentare. Entfernen Sie auskommentierten Code, anstatt ihn stehen zu lassen. Überprüfen Sie Kommentare gegen das tatsächliche Codeverhalten. Etablieren Sie Teamprozesse für die Kommentarwartung.

Häufige Auswirkungen

Auswirkung	Details
Sonstiges	Bereich: Sonstiges Reduzierte Wartbarkeit -- Schwierigkeit bei der Produktwartung beeinträchtigt die Sicherheit indirekt, indem Schwachstellen schwerer zu finden und zu beheben sind.
Sonstiges	Bereich: Sonstiges Erhöhte analytische Komplexität -- Nicht übereinstimmende Kommentare verwirren Prüfer und erschweren die Validierung des beabsichtigten Verhaltens.

Beispielcode und Lösung

Verwundbarer Code

// Verwundbar: Durchgehend ungenaue Kommentare

public class MedicationCalculator {

    /**
     * Addiere das Patientengewicht und Mg/Kg um die Tagesdosis zu erhalten.
     *
     * HINWEIS: Kommentar sagt "Addiere", aber Code multipliziert!
     * Dies könnte zu schweren Dosierungsfehlern führen, wenn jemand
     * den Code "korrigiert", um dem Kommentar zu entsprechen.
     */
    public double calculateDailyDose(double weightKg, double mgPerKg) {
        return weightKg * mgPerKg;  // Multipliziert tatsächlich, addiert nicht
    }

    // Validiert, dass Passwort Sicherheitsanforderungen erfüllt
    // (Tatsächlich prüft dies nur ob es nicht null ist!)
    public boolean validatePassword(String password) {
        return password != null;
    }

    /**
     * Verschlüsselt Daten mit AES-256-Verschlüsselung.
     *
     * HINWEIS: Kommentar ist völlig falsch - dies verwendet XOR-"Verschlüsselung",
     * die keine echte Sicherheit bietet!
     */
    public byte[] encryptData(byte[] data, byte[] key) {
        byte[] result = new byte[data.length];
        for (int i = 0; i < data.length; i++) {
            result[i] = (byte) (data[i] ^ key[i % key.length]);
        }
        return result;
    }

    // Gibt die Benutzerrolle aus der Datenbank zurück
    // (Gibt tatsächlich eine hartcodierte Admin-Rolle zurück - Sicherheitsproblem!)
    public String getUserRole(String userId) {
        return "admin";  // TODO: Tatsächliche Abfrage implementieren
    }
}

# Verwundbar: Python mit ungenauen Kommentaren

class SecurityValidator:

    def validate_input(self, user_input):
        """
        Bereinigt Eingabe um SQL Injection zu verhindern.

        Tut tatsächlich nichts um SQL Injection zu verhindern!
        Der Kommentar ist völlig irreführend.
        """
        # Gibt nur die Eingabe unverändert zurück
        return user_input

    def check_admin_access(self, user):
        # Zugriff nur erlauben wenn Benutzer authentifiziert ist
        #
        # FALSCH: Erlaubt tatsächlich Zugriff wenn Benutzer NICHT authentifiziert ist
        # Dies ist ein kritischer Sicherheitsbug, verborgen durch ungenauen Kommentar
        if not user.is_authenticated:
            return True  # Kommentar sagt authentifiziert erforderlich, aber...
        return False

    def hash_password(self, password):
        """
        Verwendet bcrypt mit 12 Runden für sicheres Passwort-Hashing.

        Verwendet tatsächlich MD5, das kryptografisch gebrochen ist!
        """
        import hashlib
        return hashlib.md5(password.encode()).hexdigest()

    # Begrenzt auf 100 Anfragen pro Minute
    # (Begrenzt tatsächlich auf 1000 Anfragen - 10x das dokumentierte Limit)
    def rate_limit(self, requests):
        return len(requests) < 1000


# Authentifiziert Benutzer mit Zwei-Faktor-Authentifizierung
# (Prüft tatsächlich nur Passwort - kein 2FA implementiert!)
def authenticate(username, password):
    user = find_user(username)
    return user and user.password == password

// Verwundbar: JavaScript mit irreführenden Kommentaren

class PaymentProcessor {

    /**
     * Validiert Kreditkartennummer mit Luhn-Algorithmus
     * und prüft gegen bekannte betrügerische Muster.
     *
     * REALITÄT: Prüft nur ob es 16 Ziffern sind - kein Luhn, keine Betrugsprüfung!
     */
    validateCard(cardNumber) {
        return /^\d{16}$/.test(cardNumber);
    }

    // Verarbeitet Zahlung sicher über PCI-konforme Schnittstelle
    // (Protokolliert tatsächlich Kartennummer in Konsole - massive Sicherheitsverletzung!)
    processPayment(cardNumber, amount) {
        console.log(`Processing card: ${cardNumber}`);  // UNSICHER!
        return { success: true, amount: amount };
    }

    /**
     * Rückerstattungen sind auf den ursprünglichen Transaktionsbetrag begrenzt.
     *
     * BUG: Keine Limitprüfung implementiert - kann jeden Betrag erstatten!
     */
    refund(transactionId, amount) {
        // Fehlende Validierung, die der Kommentar behauptet
        return this.gateway.refund(transactionId, amount);
    }

    // Verschlüsselte Speicherung sensibler Zahlungsdaten
    // (Speichert tatsächlich im Klartext!)
    storePaymentData(data) {
        localStorage.setItem('payment', JSON.stringify(data));
    }
}

// Verwundbar: C mit gefährlich ungenauen Kommentaren

/**
 * Kopiert src nach dest sicher mit Bereichsprüfung.
 * Buffer Overflow wird durch diese Funktion verhindert.
 *
 * FALSCH: Verwendet strcpy ohne Bereichsprüfung!
 */
void safe_copy(char *dest, const char *src) {
    strcpy(dest, src);  // Keinerlei Bereichsprüfung!
}

// Validiert, dass Eingabelänge innerhalb sicherer Grenzen liegt
// (Hat tatsächlich einen Off-by-one-Fehler im Vergleich)
int validate_length(const char *input, int max_len) {
    // Kommentar sagt validiert "innerhalb" der Grenzen
    // aber <= sollte < sein (erlaubt ein zusätzliches Byte)
    return strlen(input) <= max_len;
}

/**
 * Gibt Speicher frei und setzt Pointer auf NULL um Use-after-free zu verhindern.
 *
 * FALSCH: Setzt Pointer nicht auf NULL!
 */
void secure_free(void *ptr) {
    free(ptr);
    // Fehlt: ptr = NULL;
}

// Thread-sichere Zähler-Implementierung
// (Tatsächlich nicht thread-sicher - keine Synchronisierung!)
static int counter = 0;
int increment_counter() {
    return ++counter;  // Race Condition!
}

Sichere Lösung

// Behoben: Genaue Kommentare, die dem Codeverhalten entsprechen

public class MedicationCalculator {

    /**
     * Berechne die tägliche Medikamentendosis.
     *
     * <p>Multipliziert das Körpergewicht des Patienten mit dem verschriebenen
     * mg/kg-Verhältnis, um die Gesamttagesdosis in Milligramm zu bestimmen.
     *
     * @param weightKg Patientengewicht in Kilogramm
     * @param mgPerKg Verschriebene Milligramm pro Kilogramm
     * @return Gesamte Tagesdosis in Milligramm
     */
    public double calculateDailyDose(double weightKg, double mgPerKg) {
        return weightKg * mgPerKg;
    }

    /**
     * Prüfe ob Passwort angegeben wurde.
     *
     * <p><strong>Hinweis:</strong> Dies prüft nur auf null. Zusätzliche
     * Validierung (Länge, Komplexität) sollte durch PasswordValidator erfolgen.
     *
     * @param password Das zu prüfende Passwort
     * @return true wenn Passwort nicht null, false andernfalls
     * @see PasswordValidator#validateStrength für vollständige Validierung
     */
    public boolean isPasswordProvided(String password) {
        return password != null;
    }

    /**
     * XOR-Operation auf Daten (KEINE sichere Verschlüsselung).
     *
     * <p><strong>WARNUNG:</strong> Dies ist KEINE kryptografische Verschlüsselung!
     * XOR bietet keine Sicherheit gegen entschlossene Angreifer.
     * Verwenden Sie {@link AESEncryptor} für tatsächliche Verschlüsselungsbedürfnisse.
     *
     * @param data Die zu transformierenden Daten
     * @param key Der XOR-Schlüssel
     * @return XOR-transformierte Daten
     * @deprecated Verwenden Sie AESEncryptor.encrypt() für sichere Verschlüsselung
     */
    @Deprecated
    public byte[] xorTransform(byte[] data, byte[] key) {
        byte[] result = new byte[data.length];
        for (int i = 0; i < data.length; i++) {
            result[i] = (byte) (data[i] ^ key[i % key.length]);
        }
        return result;
    }

    /**
     * Benutzerrolle aus der Datenbank abrufen.
     *
     * @param userId Die abzufragende Benutzer-ID
     * @return Die Rolle des Benutzers, oder "guest" wenn nicht gefunden
     */
    public String getUserRole(String userId) {
        User user = userRepository.findById(userId);
        return user != null ? user.getRole() : "guest";
    }
}

# Behoben: Python mit genauen Kommentaren

class SecurityValidator:

    def get_raw_input(self, user_input):
        """
        Gibt Benutzereingabe unverändert zurück.

        Hinweis:
            Diese Methode bereinigt die Eingabe NICHT. Verwenden Sie SqlParameterizer
            für Datenbankabfragen und HtmlEscaper für die Ausgabe.

        Args:
            user_input: Rohe Eingabezeichenkette vom Benutzer

        Returns:
            Die unveränderte Eingabe

        Siehe auch:
            SqlParameterizer: Für sichere Datenbankabfragekonstruktion
            HtmlEscaper: Für sichere HTML-Ausgabe
        """
        return user_input

    def is_unauthenticated(self, user):
        """
        Prüft ob Benutzer NICHT authentifiziert ist.

        Returns:
            True wenn Benutzer nicht authentifiziert, False wenn authentifiziert
        """
        return not user.is_authenticated

    def hash_password_md5_unsafe(self, password):
        """
        Hasht Passwort mit MD5.

        Warnung:
            MD5 ist kryptografisch gebrochen und sollte NICHT für
            Passwort-Hashing verwendet werden! Verwenden Sie stattdessen
            bcrypt_hash_password().

        Diese Methode existiert nur für Legacy-Kompatibilität.

        Args:
            password: Das zu hashende Passwort

        Returns:
            MD5-Hash (UNSICHER)

        Veraltet:
            Verwenden Sie bcrypt_hash_password() für sicheres Passwort-Hashing.
        """
        import hashlib
        import warnings
        warnings.warn("MD5 is insecure. Use bcrypt_hash_password().",
                      DeprecationWarning)
        return hashlib.md5(password.encode()).hexdigest()

    def check_rate_limit(self, requests, limit=1000):
        """
        Prüft ob Anfragezahl innerhalb des Rate-Limits liegt.

        Args:
            requests: Liste der letzten Anfragen
            limit: Maximal erlaubte Anfragen (Standard: 1000)

        Returns:
            True wenn unter Limit, False wenn Limit überschritten
        """
        return len(requests) < limit


def authenticate_password_only(username, password):
    """
    Authentifiziert Benutzer nur mit Passwort.

    Warnung:
        Dies implementiert KEINE Zwei-Faktor-Authentifizierung.
        Für 2FA verwenden Sie die TwoFactorAuthenticator-Klasse.

    Args:
        username: Benutzername des Benutzers
        password: Passwort des Benutzers

    Returns:
        True wenn Anmeldedaten gültig, False andernfalls
    """
    user = find_user(username)
    return user and secure_compare(user.password_hash, hash_password(password))

---

CVE-Beispiele

Diese CWE ist als VERBOTEN für direkte CVE-Zuordnung markiert, da sie ein Codequalitätsproblem darstellt und keine direkte Sicherheitslücke.

---

Verwandte CWEs

• CWE-1078: Unangemessener Quellcode-Stil oder Formatierung (Eltern)
• CWE-1006: Schlechte Codierungspraktiken (Kategoriemitglied)
• CWE-1113: Unangemessener Kommentarstil (verwandt)
• CWE-1110: Unvollständige Design-Dokumentation (verwandt)

---

Referenzen

1. MITRE Corporation. "CWE-1116: Inaccurate Comments." https://cwe.mitre.org/data/definitions/1116.html
2. "Code Complete" von Steve McConnell - Kapitel über Code-Dokumentation
3. "Clean Code" von Robert C. Martin - Kapitel über Kommentare