Zurück zur Schwachstellen-Datenbank

Versteckte Funktionalität

Beschreibung

Versteckte Funktionalität bezieht sich auf undokumentierte Features, Fähigkeiten oder Code innerhalb eines Produkts, die nicht Teil der offiziellen Spezifikation sind und nicht über dokumentierte Schnittstellen zugänglich sind. Dies umfasst absichtliche Hintertüren, bösartigen Code, der von Insidern eingefügt wurde, Entwickler-Debugging-Features, die in der Produktion verblieben sind, Easter Eggs, hart codierte Zugangsdaten und undokumentierte administrative Schnittstellen. Versteckte Funktionalität vergrößert die Angriffsfläche der Software und kann zusätzliche Schwachstellen exponieren, derer sich Benutzer und Sicherheitsauditoren nicht bewusst sind.

Risiko

Versteckte Funktionalität birgt erhebliche Sicherheitsrisiken, da sie außerhalb des normalen Sicherheitsüberprüfungsprozesses operiert. Hintertüren können unbefugten Zugang zu Systemen ermöglichen und dabei Authentifizierungs- und Autorisierungskontrollen umgehen. Bösartiger Code kann sensible Daten exfiltrieren, Command-and-Control-Kanäle erstellen oder Operationen sabotieren. Entwicklerkürzungen wie Debug-Schnittstellen oder hart codierte Passwörter können durch Reverse Engineering von Angreifern entdeckt werden. Easter Eggs können Schwachstellen enthalten, die nie auf Sicherheit getestet wurden. Undokumentierte Telnet-, SSH- oder Web-Schnittstellen bieten unerwartete Angriffsvektoren. Die versteckte Natur dieser Funktionalität bedeutet, dass sie oft über längere Zeiträume unentdeckt bleibt.

Lösung

Implementieren Sie strenge Code-Review-Prozesse, die speziell nach undokumentierter Funktionalität suchen. Verwenden Sie automatisierte Tools zur Erkennung potenzieller Hintertüren, hart codierter Zugangsdaten und Debug-Code. Etablieren Sie klare Richtlinien, die undokumentierte Features in Produktionscode verbieten. Entfernen oder deaktivieren Sie alle Entwicklungs- und Debugging-Features vor der Veröffentlichung. Führen Sie regelmäßige Sicherheitsaudits durch, die Dekompilierung und Reverse Engineering einschließen. Implementieren Sie Code-Signierung und Integritätsverifizierung, um unbefugte Änderungen zu erkennen. Etablieren Sie Incident-Response-Verfahren für erkannte versteckte Funktionalität. Überwachen Sie auf ungewöhnliche Netzwerkaktivität, die auf Hintertür-Kommunikation hinweisen könnte. Dokumentieren Sie alle legitime Funktionalität und vergleichen Sie sie mit dem tatsächlichen Code-Verhalten.

Häufige Auswirkungen

AuswirkungDetails
VertraulichkeitBereich: Vertraulichkeit

Anwendungsdaten lesen - Versteckte Funktionalität kann sensible Daten exfiltrieren oder unbefugten Zugang zu Informationen ermöglichen.
IntegritätBereich: Integrität

Ausführungslogik ändern - Undokumentierte Features können das Systemverhalten auf unerwartete Weise ändern.
ZugriffskontrolleBereich: Zugriffskontrolle

Schutzmechanismus umgehen - Hintertüren umgehen Authentifizierungs- und Autorisierungskontrollen.
AndereBereich: Ändere

Variiert je nach Kontext - Die Auswirkung hängt von der Art der versteckten Funktionalität und ihrer Ausnutzbarkeit ab.

Beispielcode + Lösungscode

Verwundbarer Code

# Verwundbar: Versteckte Hintertür mit hart codierten Zugangsdaten
class VulnerableAuthSystem:

    def authenticate(self, username, password):
        # Versteckte Hintertür - hart codiertes Master-Passwort
        if password == "master_override_2024":
            return True  # Alle Authentifizierung umgehen

        # Normale Authentifizierung
        return self.verify_credentials(username, password)

    def verify_credentials(self, username, password):
        user = self.get_user(username)
        if user and check_password(password, user.password_hash):
            return True
        return False

// Verwundbar: Versteckte Debug-Schnittstelle in Produktion verblieben
#include <stdio.h>
#include <string.h>

int handle_command(char *cmd) {
    // Normale Befehle
    if (strcmp(cmd, "status") == 0) {
        return show_status();
    } else if (strcmp(cmd, "help") == 0) {
        return show_help();
    }

    // Versteckter Debug-Befehl - nicht dokumentiert
    // Von Entwickler zum Testen im Code belassen
    else if (strcmp(cmd, "debug_dump_all") == 0) {
        // Dumpt gesamten Speicher einschließlich Passwörter und Schlüssel!
        dump_memory();
        return 0;
    }

    // Ein weiterer versteckter Befehl
    else if (strcmp(cmd, "___admin___") == 0) {
        // Erhöht zu Admin ohne Authentifizierung
        set_privilege_level(ADMIN);
        return 0;
    }

    return -1;  // Unbekannter Befehl
}

Sicherer Code

# Behoben: Keine Hintertüren, ordnungsgemäße Authentifizierung
class FixedAuthSystem:

    def __init__(self, credential_store):
        self.credential_store = credential_store

    def authenticate(self, username, password):
        # Keine Hintertüren oder Master-Passwörter

        # Nur Standard-Authentifizierung
        user = self.credential_store.get_user(username)
        if not user:
            # Timing-sichere Ablehnung
            self._dummy_hash_check()
            return False

        return self._verify_password(password, user.password_hash)

    def _verify_password(self, password, password_hash):
        # Ordnungsgemäße Passwort-Verifizierung verwenden
        return bcrypt.checkpw(
            password.encode('utf-8'),
            password_hash.encode('utf-8')
        )

    def _dummy_hash_check(self):
        # Timing-Angriffe auf Benutzernamen-Enumeration verhindern
        bcrypt.checkpw(b"dummy", b"$2b$12$dummy.hash.for.timing")

// Behoben: Nur dokumentierte Befehle, keine Debug-Features in Produktion
#include <stdio.h>
#include <string.h>

// Befehls-Whitelist - alle Befehle sind dokumentiert
static const char *VALID_COMMANDS[] = {
    "status",
    "help",
    "version",
    "restart",
    NULL
};

int is_valid_command(const char *cmd) {
    for (int i = 0; VALID_COMMANDS[i] != NULL; i++) {
        if (strcmp(cmd, VALID_COMMANDS[i]) == 0) {
            return 1;
        }
    }
    return 0;
}

int handle_command(char *cmd) {
    // Gegen Whitelist validieren
    if (!is_valid_command(cmd)) {
        log_security_event("Unbekannter Befehl versucht: %s", cmd);
        return -1;
    }

    // Nur dokumentierte Befehle
    if (strcmp(cmd, "status") == 0) {
        return show_status();
    } else if (strcmp(cmd, "help") == 0) {
        return show_help();
    } else if (strcmp(cmd, "version") == 0) {
        return show_version();
    } else if (strcmp(cmd, "restart") == 0) {
        return request_restart();  // Erfordert Authentifizierung
    }

    return -1;
}

// Debug-Features sind zur Kompilierzeit in Produktion deaktiviert
#ifdef DEBUG_BUILD
int handle_debug_command(char *cmd) {
    // Nur in Debug-Builds verfügbar
    // Wird nie in Produktion kompiliert
}
#endif

CVE-Beispiele

  • CVE-2022-31260: Undokumentierte Hintertür in altem PHP-Skript ermöglichte unbefugten Export von Metadaten.
  • CVE-2022-3203: Wireless Access Point hatte undokumentierten Telnet-Server, obwohl Dokumentation nur Web-Konfiguration beanspruchte.

Verwandte CWEs

  • CWE-684: Falsche Bereitstellung spezifizierter Funktionalität (Eltern)
  • CWE-506: Eingebetteter bösartiger Code (Kind)
  • CWE-1242: Einschluss undokumentierter Features oder Chicken Bits (Kind)
  • CWE-798: Verwendung hart codierter Zugangsdaten (verwandt)

Referenzen

  1. MITRE Corporation. "CWE-912: Hidden Functionality." https://cwe.mitre.org/data/definitions/912.html
  2. OWASP. "Backdoor Detection."
  3. NIST. "Guidelines for Securing Software Development."