UI-Diskrepanz für Sicherheitsfunktion
Beschreibung
UI-Diskrepanz für Sicherheitsfunktion ist eine Schwachstelle, bei der die Benutzeroberfläche eine Sicherheitsfunktion nicht korrekt aktiviert oder konfiguriert, aber die Oberfläche Feedback liefert, das den Benutzer glauben lässt, dass die Funktion in einem sicheren Zustand ist. Wenn Benutzeroberflächenfeedback nicht mit dem tatsächlichen Systemverhalten übereinstimmt, entwickeln Benutzer falsches Vertrauen in Sicherheitskontrollen. Dies kann auftreten, wenn Benutzer ein Verschlüsselungs-Kontrollkästchen aktivieren, das die Verschlüsselung nicht tatsächlich aktiviert, oder wenn Zugriffskontrollregeln angewendet werden, die restriktiv erscheinen, aber nur teilweise im Backend implementiert sind.
Risiko
UI-Diskrepanzen für Sicherheitsfunktionen erzeugen gefährliches falsches Vertrauen in Sicherheitskontrollen. Benutzer glauben, Verschlüsselung, Zugriffsbeschränkungen oder anderen Schutz aktiviert zu haben, wenn diese Funktionen tatsächlich falsch konfiguriert, deaktiviert oder nicht funktionsfähig sind. Angreifer können diese Lücke zwischen wahrgenommener und tatsächlicher Sicherheit ausnutzen, um auf Daten zuzugreifen, von denen Benutzer glaubten, sie seien geschützt. Das Risiko wird verstärkt, weil Benutzer keinen Grund haben zu verifizieren, dass Sicherheitskontrollen tatsächlich wie angezeigt funktionieren. Unternehmensumgebungen sind besonders anfällig, wenn Administratoren Sicherheitsrichtlinien über Schnittstellen konfigurieren, die die Backend-Implementierung nicht genau widerspiegeln.
Lösung
Stellen Sie sicher, dass Benutzeroberflächenfeedback den tatsächlichen Zustand von Sicherheitsfunktionen genau widerspiegelt. Implementieren Sie umfassende Tests, die verifizieren, dass UI-Zustand mit Backend-Sicherheitsimplementierung übereinstimmt. Verwenden Sie automatisierte Tests, die bestätigen, dass Sicherheitsfunktionen korrekt aktiviert sind, wenn Benutzer sie über die UI aktivieren. Liefern Sie klare Fehlermeldungen, wenn Sicherheitsfunktionen nicht aktiviert werden können. Implementieren Sie Backend-Validierung, die bestätigt, dass Sicherheitskontrollen aktiv sind und den Status genau an die UI meldet. Erwägen Sie die Hinzufügung von Verifizierungsmechanismen, die Benutzer verwenden können, um zu bestätigen, dass Sicherheitsfunktionen wie erwartet funktionieren.
Häufige Auswirkungen
| Auswirkung | Details |
|---|---|
| Sonstiges | Umfang: Sonstiges Variiert je nach Kontext - Die spezifische Auswirkung hängt von der falsch dargestellten Sicherheitsfunktion ab. Benutzer können glauben, Daten seien verschlüsselt, obwohl sie es nicht sind, Zugriffskontrollen seien aktiv, obwohl sie fehlen, oder Audit-Logging sei aktiv, obwohl es fehlgeschlagen ist. |
Beispielcode
Anfälliger Code
// Anfällig: UI zeigt Verschlüsselung aktiviert, aber Backend implementiert sie nicht
class VulnerableSecuritySettings {
constructor() {
this.uiState = {
encryptionEnabled: false,
accessControlEnabled: false
};
}
// Anfällig: Aktualisiert UI-Zustand aber aktiviert keine tatsächliche Verschlüsselung
toggleEncryption() {
this.uiState.encryptionEnabled = !this.uiState.encryptionEnabled;
// Anfällig: Aktualisiert nur UI-Checkbox, Backend-Verschlüsselung nicht implementiert
this.updateUI();
// Fehlt: tatsächlicher Aufruf zur Verschlüsselungsaktivierung
// enableDataEncryption(this.uiState.encryptionEnabled);
// Benutzer sieht "Verschlüsselung: Aktiviert" aber Daten werden im Klartext gespeichert
return { success: true, message: "Verschlüsselungseinstellungen aktualisiert" };
}
// Anfällig: Zugriffskontrolle erscheint aktiviert aber Regelanwendung ist partiell
setAccessControl(rule) {
// UI akzeptiert "restrict ALL" aber Backend implementiert nur "restrict SOME"
this.uiState.accessControlEnabled = true;
// Anfällig: Backend hat Bugs, die nicht alle Einschränkungen anwenden
// Backend ignoriert stillschweigend bestimmte Ressourcentypen
applyPartialAccessControl(rule); // Beschränkt nicht tatsächlich allen Zugriff
// Benutzer sieht "Zugriffskontrolle: ALLE Ressourcen eingeschränkt"
return { success: true, message: "Zugriffskontrolle für alle Ressourcen aktiviert" };
}
}
# Anfällig: Sicherheitskonfigurationspanel mit UI/Backend-Mismatch
class VulnerableConfigPanel:
def __init__(self):
self.settings_display = {}
def enable_two_factor_auth(self, user_id):
# Anfällig: Aktualisiert UI aber 2FA nicht tatsächlich konfiguriert
self.settings_display[user_id] = {'2fa_enabled': True}
# Anfällig: Backend-Aufruf versagt stillschweigend
try:
configure_2fa(user_id) # Kann Ausnahme werfen
except Exception:
pass # Fehler verschluckt, UI zeigt noch 2FA aktiviert
# Benutzer sieht "Zwei-Faktor-Authentifizierung: Aktiviert"
# Aber 2FA schützt nicht tatsächlich ihr Konto
return True
def enable_audit_logging(self):
# Anfällig: Zeigt Logging aktiviert aber Log-Ziel nicht konfiguriert
self.settings_display['audit_logging'] = True
# Anfällig: Logging aktiviert aber Logs gehen nach /dev/null
# oder Log-Ziel ist nicht beschreibbar
configure_logging(destination=None) # Loggt nirgendwo
# Admin sieht "Audit-Logging: Aktiv"
# Sicherheitsereignisse werden nicht aufgezeichnet
return "Audit-Logging ist jetzt aktiv"
// Anfällig: Browser-Sicherheitseinstellungen UI-Mismatch
public class VulnerableSecurityUI {
private boolean displayedSSLEnabled = false;
private boolean displayedCertValidation = true;
// Anfällig: SSL erscheint aktiviert aber Implementierung ist fehlerhaft
public void enableSSL() {
displayedSSLEnabled = true;
updateUICheckbox("ssl_enabled", true);
// Anfällig: SSL/TLS konfiguriert aber mit unsicheren Standardwerten
SSLContext ctx = SSLContext.getInstance("SSL");
ctx.init(null, new TrustManager[] {
// Anfällig: Trust-Manager akzeptiert alle Zertifikate
new X509TrustManager() {
public void checkClientTrusted(X509Certificate[] chain, String auth) {}
public void checkServerTrusted(X509Certificate[] chain, String auth) {}
public X509Certificate[] getAcceptedIssuers() { return null; }
}
}, null);
// Benutzer sieht "SSL: Aktiviert" mit grünem Häkchen
// Aber alle Zertifikate werden akzeptiert, bietet keine echte Sicherheit
}
// Anfällig: Zertifikatvalidierungs-UI entspricht nicht dem Verhalten
public boolean validateCertificate(Certificate cert) {
// UI zeigt "Zertifikatvalidierung: Strikt"
// Aber Validierung gibt immer true zurück
return true; // Anfällig: Keine tatsächliche Validierung
}
}
Korrigierter Code
// Korrigiert: UI spiegelt Backend-Sicherheitszustand genau wider
class SecureSecuritySettings {
constructor() {
this.uiState = {
encryptionEnabled: false,
accessControlEnabled: false
};
}
async toggleEncryption() {
const previousState = this.uiState.encryptionEnabled;
const newState = !previousState;
try {
// Korrigiert: Tatsächlich Verschlüsselung im Backend aktivieren/deaktivieren
const result = await enableDataEncryption(newState);
if (result.success) {
// Korrigiert: UI nur nach Backend-Bestätigung aktualisieren
this.uiState.encryptionEnabled = newState;
this.updateUI();
// Korrigiert: Verifizieren, dass Verschlüsselung tatsächlich funktioniert
const verification = await verifyEncryptionActive();
if (!verification.active) {
throw new Error('Verschlüsselungsverifizierung fehlgeschlagen');
}
return { success: true, message: "Verschlüsselung aktiviert und verifiziert" };
} else {
throw new Error(result.error);
}
} catch (error) {
// Korrigiert: UI bei Fehler zurücksetzen
this.uiState.encryptionEnabled = previousState;
this.updateUI();
// Korrigiert: Klare Fehlermeldung an Benutzer zeigen
return {
success: false,
message: `Verschlüsselung könnte nicht geändert werden: ${error.message}`
};
}
}
async setAccessControl(rule) {
try {
// Korrigiert: Zugriffskontrolle anwenden und verifizieren
const result = await applyAccessControl(rule);
if (!result.fullyApplied) {
// Korrigiert: Partielle Anwendung klar melden
const unprotected = result.unprotectedResources.join(', ');
return {
success: false,
message: `Zugriffskontrolle könnte nicht angewendet werden auf: ${unprotected}`
};
}
// Korrigiert: Verifizieren, dass Zugriffskontrolle tatsächlich blockiert
const verification = await testAccessControl(rule);
if (!verification.allBlöcked) {
throw new Error('Zugriffskontrolle-Verifizierung fehlgeschlagen');
}
this.uiState.accessControlEnabled = true;
this.updateUI();
return { success: true, message: "Zugriffskontrolle aktiviert und verifiziert" };
} catch (error) {
return {
success: false,
message: `Zugriffskontrolle fehlgeschlagen: ${error.message}`
};
}
}
}
# Korrigiert: Sicherheitskonfiguration mit genauem UI-Feedback
class SecureConfigPanel:
def __init__(self):
self.settings_display = {}
def enable_two_factor_auth(self, user_id):
try:
# Korrigiert: 2FA konfigurieren und verifizieren
result = configure_2fa(user_id)
if not result.success:
# Korrigiert: Fehler klar melden
return {
'success': False,
'message': f'2FA-Konfiguration fehlgeschlagen: {result.error}'
}
# Korrigiert: Verifizieren, dass 2FA tatsächlich für Login erforderlich ist
verification = verify_2fa_required(user_id)
if not verification.enforced:
# Korrigiert: Bei Verifizierungsfehler zurücksetzen
remove_2fa(user_id)
return {
'success': False,
'message': '2FA könnte nicht als aktiv verifiziert werden'
}
# Korrigiert: UI nur nach Verifizierung aktualisieren
self.settings_display[user_id] = {'2fa_enabled': True}
return {
'success': True,
'message': '2FA aktiviert und verifiziert'
}
except Exception as e:
# Korrigiert: Klare Fehlermeldung
logger.error(f"2FA-Konfigurationsfehler: {e}")
return {
'success': False,
'message': '2FA könnte nicht aktiviert werden. Bitte Support kontaktieren.'
}
def enable_audit_logging(self):
try:
# Korrigiert: Verifizieren, dass Log-Ziel beschreibbar ist
destination = get_log_destination()
if not destination or not is_writable(destination):
return {
'success': False,
'message': 'Audit-Log-Ziel nicht konfiguriert oder nicht beschreibbar'
}
# Korrigiert: Logging aktivieren und verifizieren
configure_logging(destination=destination)
# Korrigiert: Testeintrag schreiben und verifizieren, dass er geloggt wurde
test_id = write_audit_test_entry()
if not verify_audit_entry_exists(test_id):
return {
'success': False,
'message': 'Audit-Logging-Verifizierung fehlgeschlagen'
}
self.settings_display['audit_logging'] = True
return {
'success': True,
'message': f'Audit-Logging aktiv, schreibt nach {destination}'
}
except Exception as e:
logger.error(f"Audit-Logging-Fehler: {e}")
return {
'success': False,
'message': 'Audit-Logging könnte nicht aktiviert werden'
}
// Korrigiert: Genaue Sicherheits-UI mit ordnungsgemäßer Implementierung
public class SecureSecurityUI {
private boolean sslEnabled = false;
private boolean certValidationEnabled = true;
public boolean enableSSL() throws SecurityException {
try {
// Korrigiert: SSL mit sicheren Standardwerten konfigurieren
SSLContext ctx = SSLContext.getInstance("TLSv1.3");
// Korrigiert: Ordnungsgemäße Zertifikatvalidierung verwenden
TrustManagerFactory tmf = TrustManagerFactory.getInstance(
TrustManagerFactory.getDefaultAlgorithm()
);
tmf.init((KeyStore) null); // System-Trust-Store verwenden
ctx.init(null, tmf.getTrustManagers(), new SecureRandom());
// Korrigiert: Verifizieren, dass SSL korrekt funktioniert
HttpsURLConnection.setDefaultSSLSocketFactory(ctx.getSocketFactory());
// Korrigiert: Verbindung testen um SSL zu verifizieren
if (!testSSLConnection()) {
throw new SecurityException("SSL-Verifizierung fehlgeschlagen");
}
sslEnabled = true;
updateUICheckbox("ssl_enabled", true);
return true;
} catch (Exception e) {
// Korrigiert: Klarer Fehler, UI spiegelt Fehler wider
sslEnabled = false;
updateUICheckbox("ssl_enabled", false);
showError("SSL könnte nicht aktiviert werden: " + e.getMessage());
return false;
}
}
public ValidationResult validateCertificate(Certificate cert) {
// Korrigiert: Tatsächliche Zertifikatvalidierung
try {
X509Certificate x509 = (X509Certificate) cert;
// Korrigiert: Ablauf prüfen
x509.checkValidity();
// Korrigiert: Gegen Trust-Store verifizieren
TrustManagerFactory tmf = TrustManagerFactory.getInstance(
TrustManagerFactory.getDefaultAlgorithm()
);
tmf.init((KeyStore) null);
for (TrustManager tm : tmf.getTrustManagers()) {
if (tm instanceof X509TrustManager) {
((X509TrustManager) tm).checkServerTrusted(
new X509Certificate[]{x509}, "RSA"
);
}
}
return ValidationResult.valid();
} catch (CertificateExpiredException e) {
// Korrigiert: Spezifischen Fehler melden
return ValidationResult.invalid("Zertifikat abgelaufen");
} catch (CertificateNotYetValidException e) {
return ValidationResult.invalid("Zertifikat noch nicht gültig");
} catch (CertificateException e) {
return ValidationResult.invalid("Zertifikatvalidierung fehlgeschlagen: " + e.getMessage());
}
}
}
CVE-Beispiele
- CVE-1999-1446 - Die 'Verlauf löschen'-Option des Browsers löschte nicht tatsächlich die Liste besuchter URLs, wodurch der Browserverlauf trotz UI-Anzeige zugänglich blieb.
Referenzen
- MITRE Corporation. "CWE-446: UI Discrepancy for Security Feature." https://cwe.mitre.org/data/definitions/446.html
- OWASP. "Testing for Client-side Security." https://owasp.org/www-project-web-security-testing-guide/