Zurück zur Schwachstellen-Datenbank

Nicht implementierte oder nicht unterstützte Funktion in UI

Beschreibung

Nicht implementierte oder nicht unterstützte Funktion in UI ist eine Schwachstelle, bei der eine UI-Funktion für eine Sicherheitsfunktion als unterstützt erscheint und dem Benutzer Feedback gibt, das dies suggeriert, aber die zugrunde liegende Funktionalität nicht implementiert ist. Benutzer interagieren mit Steuerelementen, die scheinbar Sicherheitseinstellungen konfigurieren, erhalten Bestätigung, dass Änderungen angewendet wurden, doch die Backend-Funktionalität existiert nicht oder ist nicht funktionsfähig. Dies erzeugt eine gefährliche Lücke zwischen wahrgenommener und tatsächlicher Sicherheitslage.

Risiko

Nicht implementierte Sicherheitsfunktionen in UI erzeugen schwerwiegende Sicherheitslücken. Benutzer und Administratoren konfigurieren, was sie für aktive Sicherheitskontrollen halten, aber es existiert kein tatsächlicher Schutz. Organisationen können Compliance-Audits basierend auf UI-Screenshots bestehen, die aktivierte Funktionen zeigen, während sie vollständig ungeschützt sind. Angreifer können diese Lücke ausnutzen, da sie wissen, dass in der UI sichtbare Sicherheitskontrollen nicht tatsächlich durchgesetzt werden. Das Risiko ist besonders schwerwiegend für Funktionen wie Zugriffskontrolllisten, Verschlüsselung, Intrusion Detection und Audit-Logging, bei denen das Fehlen einer tatsächlichen Implementierung Systeme vollständig exponiert, während sie geschützt erscheinen.

Lösung

Führen Sie umfassende Funktionalitätstests durch, bevor Anwendungen bereitgestellt werden, um zu verifizieren, dass alle UI-exponierten Sicherheitsfunktionen funktionierende Backend-Implementierungen haben. Implementieren Sie End-to-End-Tests, die validieren, dass Sicherheitskontrollen tatsächlich durchgesetzt werden, nachdem sie über die UI aktiviert wurden. Entfernen oder deaktivieren Sie UI-Elemente für Funktionen, die noch nicht implementiert sind, klar sichtbar. Wenn Funktionen geplant aber noch nicht fertig sind, kennzeichnen Sie sie deutlich als "Demnächst verfügbar" oder ähnlich. Stellen Sie sicher, dass Entwicklungsprozesse sowohl UI- als auch Backend-Implementierung erfordern, bevor Funktionen als abgeschlossen gelten. Verwenden Sie automatisierte Tests zur Verifizierung der Sicherheitsfunktions-Funktionalität.

Häufige Auswirkungen

AuswirkungDetails
SonstigesUmfang: Sonstiges

Variiert je nach Kontext - Auswirkung hängt von der spezifischen Sicherheitsfunktion ab, die funktional erscheint aber nicht implementiert ist.
SonstigesUmfang: Sonstiges

Unerwarteter Zustand - Systeme arbeiten in einem unerwarteten Sicherheitszustand, weil der Benutzer glaubt, Schutzmaßnahmen seien aktiv, obwohl sie es nicht sind.

Beispielcode

Anfälliger Code

// Anfällig: Sicherheitsfunktionen in UI ohne Backend-Implementierung
class VulnerableSecurityPanel {

    // Anfällig: Checkbox existiert aber Funktion nicht implementiert
    enableFirewallRule(rule) {
        console.log("Firewall-Regel-Konfiguration:", rule);

        // Anfällig: UI zeigt Erfolg aber keine tatsächliche Firewall-Konfiguration
        // Backend-Firewall-API nicht verbunden oder nicht implementiert

        // Zeigt grünes Häkchen: "Firewall-Regel aktiviert"
        return {
            success: true,
            message: `Regel "${rule.name}" wurde aktiviert`
        };

        // Angreifer umgeht "Firewall" die nicht existiert
    }

    // Anfällig: ACL-Konfiguration akzeptiert aber nicht angewendet
    setAccessControlList(acl) {
        // UI validiert Eingabeformat
        if (!this.validateACLFormat(acl)) {
            return { success: false, message: "Ungültiges ACL-Format" };
        }

        // Anfällig: ACL nur im UI-Zustand gespeichert
        this.displayedACL = acl;

        // Anfällig: Backend-Funktion ist ein Stub
        applyACL(acl);  // function applyACL(acl) { return true; }

        // Admin sieht "ACL angewendet" aber keine Zugriffsbeschränkungen existieren
        return {
            success: true,
            message: "Zugriffskontrollliste wurde angewendet"
        };
    }
}

// Anfällige Stub-Funktion
function applyACL(acl) {
    // TODO: ACL-Durchsetzung implementieren
    return true;
}

# Anfällig: Router-Konfiguration mit nicht implementierten Keywords
class VulnerableRouterConfig:
    def __init__(self):
        self.displayed_rules = []

    def add_firewall_rule(self, rule):
        # Anfällig: Regel-Keyword "established" nicht implementiert
        # UI akzeptiert Regel aber Backend ignoriert das Keyword

        # Regel: "permit tcp any any established"
        # "established" Keyword sollte nur etablierte Verbindungen erlauben
        # Aber Implementierung ignoriert es, erlaubt alles TCP

        if 'established' in rule:
            # Anfällig: Keyword geparst aber nicht durchgesetzt
            rule_parsed = self.parse_rule(rule)
            # rule_parsed.established ist gesetzt aber nie im Paketfilter geprüft

        self.displayed_rules.append(rule)

        # UI zeigt: "Regel hinzugefügt: permit tcp any any established"
        # Tatsächliches Verhalten: erlaubt ALLES tcp, nicht nur established
        return "Regel erfolgreich hinzugefügt"

    def enable_intrusion_detection(self):
        # Anfällig: IDS-Funktion in UI gezeigt aber nicht implementiert
        self.ids_enabled = True  # Nur UI-Zustand

        # Anfällig: Keine tatsächliche IDS-Funktionalität
        # start_intrusion_detection() existiert nicht oder ist leer

        return {
            'status': 'enabled',
            'message': 'Intrusion Detection System ist jetzt aktiv',
            'signatures_loaded': 15000  # Gefälschte Zahl
        }

// Anfällig: Sicherheitskonfigurationstool mit Stub-Implementierungen
public class VulnerableSecurityTool {

    private Map<String, Boolean> displayedSettings = new HashMap<>();

    // Anfällig: Verschlüsselungs-Toggle ohne Implementierung
    public ConfigResult enableEncryption(String algorithm) {
        // UI zeigt Algorithmus-Optionen: AES-256, RSA-2048, etc.
        // Aber keine tatsächliche Verschlüsselung wird durchgeführt

        displayedSettings.put("encryption", true);
        displayedSettings.put("algorithm", true);

        // Anfällig: Backend-Verschlüsselung nicht implementiert
        // Daten im Klartext gespeichert obwohl UI "Verschlüsselt" zeigt

        return new ConfigResult(
            true,
            "Verschlüsselung aktiviert mit " + algorithm,
            EncryptionStatus.ACTIVE  // Lüge
        );
    }

    // Anfällig: Passwort-Richtlinie erscheint durchgesetzt aber ist es nicht
    public ConfigResult setPasswordPolicy(PasswordPolicy policy) {
        // UI akzeptiert komplexe Passwort-Richtlinien-Konfiguration
        // Mindestlänge, Komplexität, Historie, Ablauf

        // Anfällig: Richtlinie zur Anzeige gespeichert aber nicht durchgesetzt
        this.displayedPolicy = policy;

        // Registrierung/Passwortänderung prüft Richtlinie nicht
        // Benutzer können "password123" setzen obwohl UI strenge Anforderungen zeigt

        return new ConfigResult(
            true,
            "Passwort-Richtlinie wurde aktualisiert",
            PolicyStatus.ENFORCED  // Lüge
        );
    }
}

Korrigierter Code

// Korrigiert: Sicherheitsfunktionen mit verifizierter Implementierung
class SecureSecurityPanel {

    async enableFirewallRule(rule) {
        try {
            // Korrigiert: Prüfen ob Firewall-Backend verfügbar ist
            const firewallStatus = await this.checkFirewallBackend();
            if (!firewallStatus.available) {
                return {
                    success: false,
                    message: "Firewall-Dienst ist nicht verfügbar"
                };
            }

            // Korrigiert: Tatsächlich Firewall konfigurieren
            const result = await this.firewallAPI.addRule(rule);

            if (!result.success) {
                return {
                    success: false,
                    message: `Regel könnte nicht hinzugefügt werden: ${result.error}`
                };
            }

            // Korrigiert: Verifizieren, dass Regel aktiv ist
            const verification = await this.firewallAPI.verifyRule(rule.id);
            if (!verification.active) {
                // Korrigiert: Zurücksetzen und Fehler melden
                await this.firewallAPI.removeRule(rule.id);
                return {
                    success: false,
                    message: "Regel könnte nicht als aktiv verifiziert werden"
                };
            }

            return {
                success: true,
                message: `Regel "${rule.name}" aktiviert und verifiziert`,
                ruleId: result.ruleId
            };

        } catch (error) {
            return {
                success: false,
                message: `Firewall-Konfigurationsfehler: ${error.message}`
            };
        }
    }

    async setAccessControlList(acl) {
        if (!this.validateACLFormat(acl)) {
            return { success: false, message: "Ungültiges ACL-Format" };
        }

        try {
            // Korrigiert: ACL über tatsächliches Backend anwenden
            const result = await this.aclBackend.apply(acl);

            if (!result.success) {
                return {
                    success: false,
                    message: `ACL-Anwendung fehlgeschlagen: ${result.error}`
                };
            }

            // Korrigiert: Testen, dass ACL durchgesetzt wird
            const testResult = await this.testACLEnforcement(acl);
            if (!testResult.enforced) {
                return {
                    success: false,
                    message: "ACL-Verifizierung fehlgeschlagen - Regeln werden nicht durchgesetzt"
                };
            }

            return {
                success: true,
                message: "Zugriffskontrollliste angewendet und verifiziert",
                appliedRules: result.appliedCount
            };

        } catch (error) {
            return {
                success: false,
                message: `ACL-Fehler: ${error.message}`
            };
        }
    }
}

# Korrigiert: Router-Konfiguration mit implementierten Keywords
class SecureRouterConfig:
    def __init__(self):
        self.active_rules = []
        self.packet_filter = PacketFilter()

    def add_firewall_rule(self, rule):
        try:
            rule_parsed = self.parse_rule(rule)

            # Korrigiert: Verifizieren, dass alle Keywords implementiert sind
            unsupported = self.check_unsupported_keywords(rule_parsed)
            if unsupported:
                return {
                    'success': False,
                    'message': f'Nicht unterstützte Keywords: {", ".join(unsupported)}'
                }

            # Korrigiert: Regel tatsächlich im Paketfilter implementieren
            if rule_parsed.get('established'):
                # Korrigiert: Connection Tracking implementieren
                self.packet_filter.add_stateful_rule(rule_parsed)
            else:
                self.packet_filter.add_stateless_rule(rule_parsed)

            # Korrigiert: Verifizieren, dass Regel aktiv ist
            if not self.packet_filter.verify_rule(rule_parsed.id):
                return {
                    'success': False,
                    'message': 'Regel könnte nicht aktiviert werden'
                }

            self.active_rules.append(rule_parsed)

            return {
                'success': True,
                'message': f'Regel hinzugefügt und verifiziert: {rule}',
                'rule_id': rule_parsed.id
            }

        except NotImplementedError as e:
            return {
                'success': False,
                'message': f'Funktion nicht implementiert: {e}'
            }

    def check_unsupported_keywords(self, rule):
        """Gibt Liste von Keywords in Regel zurück, die nicht implementiert sind."""
        supported = {'permit', 'deny', 'tcp', 'udp', 'icmp', 'any',
                     'established', 'eq', 'gt', 'lt', 'range'}
        rule_keywords = set(rule.keywords)
        return list(rule_keywords - supported)

    def enable_intrusion_detection(self):
        # Korrigiert: Prüfen ob IDS tatsächlich verfügbar ist
        if not self.ids_engine.is_available():
            return {
                'success': False,
                'message': 'IDS-Engine nicht installiert oder nicht lizenziert'
            }

        try:
            # Korrigiert: IDS tatsächlich starten
            self.ids_engine.start()

            # Korrigiert: Verifizieren, dass IDS läuft und erkennt
            test_result = self.ids_engine.self_test()
            if not test_result.passed:
                self.ids_engine.stop()
                return {
                    'success': False,
                    'message': f'IDS-Selbsttest fehlgeschlagen: {test_result.error}'
                }

            return {
                'success': True,
                'message': 'Intrusion Detection System aktiv',
                'signatures_loaded': self.ids_engine.signature_count,
                'engine_version': self.ids_engine.version
            }

        except Exception as e:
            return {
                'success': False,
                'message': f'IDS könnte nicht gestartet werden: {e}'
            }

// Korrigiert: Sicherheitstool mit verifizierten Implementierungen
public class SecureSecurityTool {

    private final EncryptionService encryptionService;
    private final PolicyEnforcer policyEnforcer;

    public SecureSecurityTool(EncryptionService encryption, PolicyEnforcer policy) {
        this.encryptionService = Objects.requireNonNull(encryption);
        this.policyEnforcer = Objects.requireNonNull(policy);
    }

    public ConfigResult enableEncryption(String algorithm) {
        // Korrigiert: Verifizieren, dass Verschlüsselungsdienst verfügbar ist
        if (!encryptionService.isAvailable()) {
            return new ConfigResult(
                false,
                "Verschlüsselungsdienst nicht verfügbar",
                EncryptionStatus.UNAVAILABLE
            );
        }

        // Korrigiert: Verifizieren, dass Algorithmus unterstützt wird
        if (!encryptionService.supportsAlgorithm(algorithm)) {
            return new ConfigResult(
                false,
                "Algorithmus nicht unterstützt: " + algorithm,
                EncryptionStatus.UNSUPPORTED
            );
        }

        try {
            // Korrigiert: Verschlüsselung tatsächlich aktivieren
            encryptionService.enable(algorithm);

            // Korrigiert: Verifizieren, dass Verschlüsselung funktioniert
            String testData = "verification_test";
            byte[] encrypted = encryptionService.encrypt(testData.getBytes());
            byte[] decrypted = encryptionService.decrypt(encrypted);

            if (!testData.equals(new String(decrypted))) {
                encryptionService.disable();
                return new ConfigResult(
                    false,
                    "Verschlüsselungsverifizierung fehlgeschlagen",
                    EncryptionStatus.VERIFICATION_FAILED
                );
            }

            return new ConfigResult(
                true,
                "Verschlüsselung aktiviert und verifiziert mit " + algorithm,
                EncryptionStatus.ACTIVE
            );

        } catch (Exception e) {
            return new ConfigResult(
                false,
                "Verschlüsselungsfehler: " + e.getMessage(),
                EncryptionStatus.ERROR
            );
        }
    }

    public ConfigResult setPasswordPolicy(PasswordPolicy policy) {
        try {
            // Korrigiert: Richtlinie auf tatsächliche Durchsetzungs-Engine anwenden
            policyEnforcer.setPolicy(policy);

            // Korrigiert: Testen, dass Richtlinie durchgesetzt wird
            String weakPassword = "123";
            if (policyEnforcer.validatePassword(weakPassword)) {
                return new ConfigResult(
                    false,
                    "Richtlinie wird nicht korrekt durchgesetzt",
                    PolicyStatus.VERIFICATION_FAILED
                );
            }

            return new ConfigResult(
                true,
                "Passwort-Richtlinie aktualisiert und verifiziert",
                PolicyStatus.ENFORCED
            );

        } catch (Exception e) {
            return new ConfigResult(
                false,
                "Richtlinienfehler: " + e.getMessage(),
                PolicyStatus.ERROR
            );
        }
    }
}

CVE-Beispiele

  • CVE-2000-0127 - Konfigurationstool-Checkbox aktivierte Sicherheitsoption nicht, obwohl sie als ausgewählt erschien.
  • CVE-2001-0863 - Router-ACL-Keyword nicht implementiert, erlaubte Filter-Umgehung während sie als konfiguriert erschien.
  • CVE-2001-0865 - Router-ACL-Keyword-Implementierungslücke ermöglichte Sicherheitsumgehung.
  • CVE-2004-0979 - Browser-Sicherheitseinstellungen wurden nicht tatsächlich modifiziert, wenn Benutzer sie über UI änderte.

Referenzen

  1. MITRE Corporation. "CWE-447: Unimplemented or Unsupported Feature in UI." https://cwe.mitre.org/data/definitions/447.html
  2. OWASP Testing Guide. "Configuration and Deployment Management Testing."