Zurück zur Schwachstellen-Datenbank

Veraltete Funktion in UI

Beschreibung

Veraltete Funktion in UI ist eine Schwachstelle, bei der eine UI-Funktion veraltet ist und das Produkt den Benutzer nicht warnt. Wenn Software weiterhin veraltete oder obsolete Funktionen anzeigt und Interaktion damit erlaubt, ohne ihren Status klar an Benutzer zu kommunizieren, kann dies zu Sicherheitsproblemen führen. Benutzer können sich auf Sicherheitsfunktionen verlassen, die aufgrund von Änderungen im zugrunde liegenden System, Protokollen oder der Bedrohungslandschaft nicht mehr funktional, gepflegt oder effektiv sind.

Risiko

Veraltete Funktionen in UI stellen erhebliche Sicherheitsrisiken dar, wenn Benutzer unwissentlich auf veraltete Funktionalität für Schutz vertrauen. Legacy-Verschlüsselungsalgorithmen, die als Optionen angezeigt werden, können gebrochen aber noch auswählbar sein. Veraltete Authentifizierungsmethoden können bekannte Schwachstellen haben, bleiben aber verfügbar. Sicherheitsfunktionen, die von externen Diensten abhingen, die nicht mehr existieren, erscheinen weiterhin funktional. Benutzer, die Systeme basierend auf veralteter Dokumentation oder Schulung konfigurieren, können veraltete Funktionen aktivieren im Glauben, sie seien sicher. Das Fehlen von Warnungen erlaubt, dass unsichere Konfigurationen über System-Updates und Migrationen hinweg bestehen bleiben.

Lösung

Entfernen Sie veraltete Funktionalität aus der Benutzeroberfläche, wenn sie nicht mehr sicher oder unterstützt ist. Wenn Entfernung nicht sofort möglich ist, warnen Sie Benutzer klar, dass die Funktion veraltet oder obsolet ist und erklären Sie die Sicherheitsimplikationen. Bieten Sie Migrationspfade zu Ersatzfunktionen mit klarer Dokumentation. Implementieren Sie Veraltungswarnungen, die prominent sind und nicht leicht abgewiesen werden können. Erwägen Sie, veraltete Sicherheitsfunktionen als Opt-in statt Opt-out zu gestalten, was explizite Bestätigung der Risiken erfordert. Protokollieren Sie die Nutzung veralteter Funktionen für Audit-Zwecke.

Häufige Auswirkungen

AuswirkungDetails
SonstigesUmfang: Sonstiges

Qualitätsverschlechterung - Softwarequalität verschlechtert sich, wenn veraltete Funktionen zugänglich bleiben, was zu Wartungsaufwand und Benutzerverwirrung führt.
SonstigesUmfang: Sonstiges

Variiert je nach Kontext - Sicherheitsauswirkung hängt von der spezifischen veralteten Funktion ab. Veraltete Verschlüsselung kann Daten exponieren; veraltete Authentifizierung kann unbefugten Zugriff erlauben.

Beispielcode

Anfälliger Code

// Anfällig: Veraltete Verschlüsselungsoptionen ohne Warnungen
class VulnerableEncryptionSettings {

    getAvailableAlgorithms() {
        // Anfällig: Gibt alle Algorithmen zurück einschließlich gebrochener
        return [
            { id: 'des', name: 'DES', description: 'Data Encryption Standard' },
            { id: 'rc4', name: 'RC4', description: 'Rivest Cipher 4' },
            { id: '3des', name: '3DES', description: 'Triple DES' },
            { id: 'aes128', name: 'AES-128', description: 'Advanced Encryption Standard 128-bit' },
            { id: 'aes256', name: 'AES-256', description: 'Advanced Encryption Standard 256-bit' }
        ];
        // Kein Hinweis, dass DES und RC4 gebrochen sind
        // Keine Warnung, dass 3DES veraltet ist
    }

    // Anfällig: Akzeptiert veralteten Algorithmus ohne Warnung
    setEncryption(algorithm) {
        // Benutzer wählt 'DES' - keine Warnung, dass es gebrochen ist
        this.currentAlgorithm = algorithm;
        this.encrypt_with(algorithm);
        return { success: true, message: `Verschlüsselung auf ${algorithm} gesetzt` };
    }
}

# Anfällig: Veraltete Authentifizierungsmethoden noch verfügbar
class VulnerableAuthConfig:
    def __init__(self):
        self.available_methods = [
            'md5_passwords',      # Gebrochener Hash
            'sha1_passwords',     # Schwacher Hash
            'cleartext_ldap',     # Keine Verschlüsselung
            'sslv3',              # Gebrochenes Protokoll
            'tlsv1',              # Veraltet
            'tlsv1.2',            # Aktuell
            'tlsv1.3'             # Aktuell
        ]

    def get_auth_methods(self):
        # Anfällig: Gibt alle Methoden ohne Veraltungsinfo zurück
        return self.available_methods

    def set_auth_method(self, method):
        # Anfällig: Keine Warnung für veraltete Methoden
        if method in self.available_methods:
            self.current_method = method
            return True
        return False

    # Benutzer setzt 'sslv3' - keine Warnung über POODLE-Schwachstelle
    # Benutzer setzt 'md5_passwords' - keine Warnung über Kollisionsangriffe

// Anfällig: Legacy-API-Endpunkte ohne Veraltungswarnungen
public class VulnerableAPIConfiguration {

    // Anfällig: Legacy-Authentifizierung noch verfügbar
    public List<String> getAuthenticationEndpoints() {
        return Arrays.asList(
            "/api/v1/auth/basic",    // Basic-Auth über HTTP (unsicher)
            "/api/v1/auth/digest",   // Digest-Auth (veraltet)
            "/api/v2/auth/oauth1",   // OAuth 1.0 (veraltet)
            "/api/v2/auth/oauth2",   // Aktuell
            "/api/v3/auth/oidc"      // Aktuell
        );
        // Kein Hinweis, welche Endpunkte obsolet sind
    }

    // Anfällig: Alte Zertifikatvalidierungsmethoden
    public void setCertificateValidation(String mode) {
        // Verfügbare Modi in UI angezeigt:
        // - "none" (keine Validierung - gefährlich)
        // - "basic" (nur Hostname-Prüfung - schwach)
        // - "standard" (CA-Kettenvalidierung)
        // - "strict" (Certificate Pinning)

        // Anfällig: "none" und "basic" ohne Warnung akzeptiert
        this.validationMode = mode;
        configureTrustManager(mode);
    }
}

<!-- Anfällig: Konfigurationsdatei mit veralteten Optionen -->
<security-config>
    <!-- Anfällig: Veraltete Cipher-Suites ohne Veralungshinweis aufgelistet -->
    <cipher-suites>
        <suite>SSL_RSA_WITH_RC4_128_MD5</suite>
        <suite>SSL_RSA_WITH_3DES_EDE_CBC_SHA</suite>
        <suite>TLS_RSA_WITH_AES_128_CBC_SHA</suite>
        <suite>TLS_RSA_WITH_AES_256_GCM_SHA384</suite>
    </cipher-suites>

    <!-- Anfällig: Veraltete Protokolle standardmäßig aktiviert -->
    <protocols>
        <protocol>SSLv3</protocol>
        <protocol>TLSv1</protocol>
        <protocol>TLSv1.1</protocol>
        <protocol>TLSv1.2</protocol>
    </protocols>

    <!-- Keine Warnungen oder Dokumentation, welche Optionen obsolet sind -->
</security-config>

Korrigierter Code

// Korrigiert: Verschlüsselungseinstellungen mit klaren Veraltungsinformationen
class SecureEncryptionSettings {

    getAvailableAlgorithms() {
        return [
            {
                id: 'des',
                name: 'DES',
                description: 'Data Encryption Standard',
                status: 'BROKEN',
                warning: 'DES ist kryptographisch gebrochen. Nicht verwenden.',
                recommendedAlternative: 'aes256'
            },
            {
                id: 'rc4',
                name: 'RC4',
                description: 'Rivest Cipher 4',
                status: 'BROKEN',
                warning: 'RC4 hat mehrere bekannte Schwachstellen. Nicht verwenden.',
                recommendedAlternative: 'aes256'
            },
            {
                id: '3des',
                name: '3DES',
                description: 'Triple DES',
                status: 'DEPRECATED',
                warning: '3DES ist wegen kleiner Blockgröße veraltet. Zu AES migrieren.',
                deprecationDate: '2023-12-31',
                recommendedAlternative: 'aes256'
            },
            {
                id: 'aes128',
                name: 'AES-128',
                description: 'Advanced Encryption Standard 128-bit',
                status: 'CURRENT',
                warning: null,
                recommendedAlternative: null
            },
            {
                id: 'aes256',
                name: 'AES-256',
                description: 'Advanced Encryption Standard 256-bit',
                status: 'RECOMMENDED',
                warning: null,
                recommendedAlternative: null
            }
        ];
    }

    setEncryption(algorithm) {
        const algoInfo = this.getAvailableAlgorithms().find(a => a.id === algorithm);

        // Korrigiert: Gebrochene Algorithmen blockieren
        if (algoInfo.status === 'BROKEN') {
            return {
                success: false,
                message: algoInfo.warning,
                recommendedAlternative: algoInfo.recommendedAlternative
            };
        }

        // Korrigiert: Bei veralteten Algorithmen warnen
        if (algoInfo.status === 'DEPRECATED') {
            // Explizite Bestätigung erforderlich
            return {
                success: false,
                requiresAcknowledgment: true,
                message: algoInfo.warning,
                deprecationDate: algoInfo.deprecationDate,
                recommendedAlternative: algoInfo.recommendedAlternative
            };
        }

        this.currentAlgorithm = algorithm;
        return { success: true, message: `Verschlüsselung auf ${algorithm} gesetzt` };
    }

    setEncryptionWithAcknowledgment(algorithm, acknowledgedRisks) {
        if (!acknowledgedRisks) {
            return {
                success: false,
                message: 'Veraltungsrisiken müssen bestätigt werden'
            };
        }

        // Korrigiert: Nutzung des veralteten Algorithmus protokollieren
        console.warn(`Veralteter Algorithmus ${algorithm} mit Bestätigung aktiviert`);
        auditLog.record('DEPRECATED_ALGORITHM_ENABLED', { algorithm, timestamp: Date.now() });

        this.currentAlgorithm = algorithm;
        return {
            success: true,
            message: `${algorithm} aktiviert (veraltet)`,
            warning: 'Dieser Algorithmus wird in einer zukünftigen Version entfernt'
        };
    }
}

# Korrigiert: Authentifizierungsmethoden mit Veraltungswarnungen
class SecureAuthConfig:
    AUTH_METHODS = {
        'md5_passwords': {
            'status': 'REMOVED',
            'message': 'MD5-Passwort-Hashing wurde wegen Kollisionsschwachstellen entfernt.',
            'alternative': 'argon2'
        },
        'sha1_passwords': {
            'status': 'DEPRECATED',
            'message': 'SHA1 ist veraltet. Zu Argon2 oder bcrypt migrieren.',
            'removal_date': '2024-06-01',
            'alternative': 'argon2'
        },
        'cleartext_ldap': {
            'status': 'DEPRECATED',
            'message': 'Klartext-LDAP exponiert Anmeldedaten. LDAPS verwenden.',
            'alternative': 'ldaps'
        },
        'sslv3': {
            'status': 'REMOVED',
            'message': 'SSLv3 wegen POODLE-Schwachstelle entfernt.',
            'alternative': 'tlsv1.3'
        },
        'tlsv1': {
            'status': 'DEPRECATED',
            'message': 'TLS 1.0 ist durch PCI-DSS veraltet. TLS 1.2+ verwenden.',
            'removal_date': '2024-01-01',
            'alternative': 'tlsv1.3'
        },
        'tlsv1.2': {
            'status': 'SUPPORTED',
            'message': None,
            'alternative': None
        },
        'tlsv1.3': {
            'status': 'RECOMMENDED',
            'message': None,
            'alternative': None
        },
        'argon2': {
            'status': 'RECOMMENDED',
            'message': None,
            'alternative': None
        }
    }

    def get_auth_methods(self):
        # Korrigiert: Methoden mit Statusinformationen zurückgeben
        return {
            method: info for method, info in self.AUTH_METHODS.items()
            if info['status'] != 'REMOVED'
        }

    def set_auth_method(self, method, acknowledge_deprecation=False):
        if method not in self.AUTH_METHODS:
            return {'success': False, 'message': 'Unbekannte Methode'}

        info = self.AUTH_METHODS[method]

        # Korrigiert: Entfernte Methoden blockieren
        if info['status'] == 'REMOVED':
            return {
                'success': False,
                'message': info['message'],
                'alternative': info['alternative']
            }

        # Korrigiert: Bestätigung für veraltete Methoden erforderlich
        if info['status'] == 'DEPRECATED':
            if not acknowledge_deprecation:
                return {
                    'success': False,
                    'requires_acknowledgment': True,
                    'message': info['message'],
                    'removal_date': info.get('removal_date'),
                    'alternative': info['alternative']
                }
            # Veraltete Nutzung protokollieren
            logger.warning(f"Veraltete Auth-Methode aktiviert: {method}")

        self.current_method = method
        return {'success': True, 'method': method, 'status': info['status']}

// Korrigiert: API-Konfiguration mit Veraltungsbehandlung
public class SecureAPIConfiguration {

    private static final Map<String, EndpointInfo> ENDPOINTS = Map.of(
        "/api/v1/auth/basic", new EndpointInfo(
            Status.REMOVED,
            "Basic-Auth entfernt - Anmeldedaten über HTTP exponiert",
            "/api/v3/auth/oidc"
        ),
        "/api/v1/auth/digest", new EndpointInfo(
            Status.DEPRECATED,
            "Digest-Auth veraltet - schwache Sicherheit",
            "/api/v3/auth/oidc",
            LocalDate.of(2024, 6, 1)
        ),
        "/api/v2/auth/oauth1", new EndpointInfo(
            Status.DEPRECATED,
            "OAuth 1.0 veraltet - zu OAuth 2.0 oder OIDC migrieren",
            "/api/v3/auth/oidc",
            LocalDate.of(2024, 3, 1)
        ),
        "/api/v2/auth/oauth2", new EndpointInfo(Status.SUPPORTED),
        "/api/v3/auth/oidc", new EndpointInfo(Status.RECOMMENDED)
    );

    public List<EndpointInfo> getAuthenticationEndpoints() {
        // Korrigiert: Vollständige Informationen einschließlich Status zurückgeben
        return ENDPOINTS.entrySet().stream()
            .filter(e -> e.getValue().getStatus() != Status.REMOVED)
            .map(e -> new EndpointInfo(e.getKey(), e.getValue()))
            .collect(Collectors.toList());
    }

    public ConfigResult setCertificateValidation(String mode) {
        ValidationModeInfo info = getValidationModeInfo(mode);

        // Korrigiert: Unsichere Modi blockieren
        if (info.status == Status.BLOCKED) {
            return new ConfigResult(
                false,
                info.message,
                info.alternative
            );
        }

        // Korrigiert: Bei schwachen Modi warnen
        if (info.status == Status.DEPRECATED) {
            logger.warn("Schwacher Zertifikatvalidierungsmodus gewählt: " + mode);
            return new ConfigResult(
                false,
                info.message,
                true,  // requiresAcknowledgment
                info.alternative
            );
        }

        configureTrustManager(mode);
        return new ConfigResult(true, "Zertifikatvalidierung konfiguriert");
    }

    private ValidationModeInfo getValidationModeInfo(String mode) {
        switch (mode) {
            case "none":
                return new ValidationModeInfo(
                    Status.BLOCKED,
                    "Deaktivierung der Zertifikatvalidierung ist nicht erlaubt",
                    "strict"
                );
            case "basic":
                return new ValidationModeInfo(
                    Status.DEPRECATED,
                    "Basic-Validierung ist unsicher - standard oder strict verwenden",
                    "standard"
                );
            case "standard":
                return new ValidationModeInfo(Status.SUPPORTED);
            case "strict":
                return new ValidationModeInfo(Status.RECOMMENDED);
            default:
                return new ValidationModeInfo(Status.UNKNOWN);
        }
    }
}

CVE-Beispiele

Für diese CWE sind keine spezifischen CVEs in der MITRE-Datenbank aufgeführt. Das Muster ist jedoch häufig bei:

  • Legacy-Cipher-Suite-Verfügbarkeit in TLS-Konfigurationen
  • Veraltete Hash-Funktionsoptionen in Authentifizierungssystemen
  • Obsolete API-Versionen, die zugänglich bleiben

Referenzen

  1. MITRE Corporation. "CWE-448: Obsolete Feature in UI." https://cwe.mitre.org/data/definitions/448.html
  2. NIST. "Transitioning the Use of Cryptographic Algorithms and Key Lengths." SP 800-131A.