Fehlende Authentifizierung für kritische Funktion

Beschreibung

Fehlende Authentifizierung für kritische Funktion tritt auf, wenn Software keine Authentifizierung für Funktionalität durchführt, die eine nachweisbare Benutzeridentität erfordert oder erhebliche Ressourcen verbraucht. Dies ist kein Fall von schwacher Authentifizierung - es ist das vollständige Fehlen von Authentifizierung für Operationen, die sie eindeutig erfordern sollten. Häufige Erscheinungsformen umfassen administrative APIs, die ohne Anmeldedaten zugänglich sind, kritische Konfigurationsendpunkte ohne Authentifizierung und privilegierte Operationen, die nicht authentifizierten Benutzern ausgesetzt sind.

Risiko

Fehlende Authentifizierung bei kritischen Funktionen stellt einen schwerwiegenden Sicherheitsfehler dar, der typischerweise eine sofortige Systemkompromittierung ermöglicht. Angreifer können direkt auf administrative Funktionen zugreifen, Konfigurationen ändern oder Systeme ohne jegliche Barrieren steuern. Aktuelle Schwachstellen in SpaceX Starlink-Schüsseln (CVE-2025-67780), Toto Link-Routern (CVE-2025-13184 mit CVSS 9.8) und Q-Free-Verkehrssystemen (CVE-2025-26366) zeigen, dass selbst anspruchsvolle Hardware keine grundlegende Authentifizierung an kritischen Schnittstellen implementiert. Die Auswirkungen reichen je nach exponierter Funktionalität von Informationsoffenlegung bis zur vollständigen Systemübernahme.

Lösung

Identifizieren Sie alle kritischen Funktionen während des Designs und fordern Sie für jede Authentifizierung. Verlassen Sie sich niemals auf "Security through Obscurity" für administrative Schnittstellen. Implementieren Sie Authentifizierung auf API-/Service-Ebene, nicht nur in der Benutzeroberfläche. Verwenden Sie etablierte Authentifizierungs-Frameworks anstelle von benutzerdefinierten Implementierungen. Führen Sie Bedrohungsmodellierung durch, um kritische Funktionen zu identifizieren, die Schutz benötigen. Testen Sie alle Endpunkte auf Authentifizierungsanforderungen während Sicherheitsbewertungen. Wenden Sie Defense in Depth an - auch interne APIs sollten Authentifizierung erfordern.

Häufige Auswirkungen

Auswirkung	Details
Zugriffskontrolle	Bereich: Vollständige Umgehung Angreifer erlangen direkten Zugang zu administrativen oder kritischen Funktionen ohne jegliche Authentifizierungsbarriere.
Integrität	Bereich: Konfigurationsmanipulation Nicht authentifizierter Zugriff auf Konfigurationsfunktionen ermöglicht Angreifern, Systemeinstellungen zu ändern.
Verfügbarkeit	Bereich: Dienststörung Administrativer Zugang ermöglicht Angreifern, Dienste zu deaktivieren, Daten zu löschen oder Systeme funktionsunfähig zu machen.

Beispielcode + Korrigierter Code

Anfälliger Code

# ANFÄLLIG: Admin-API ohne Authentifizierung
@app.route('/api/admin/users', methods=['GET'])
def list_all_users():
    # Keine Authentifizierungsprüfung - jeder kann zugreifen!
    return jsonify(User.query.all())

@app.route('/api/admin/config', methods=['POST'])
def update_config():
    # Kritische Konfigurationsaktualisierung ohne Authentifizierung
    config.update(request.json)
    return 'Konfiguration aktualisiert'

@app.route('/api/admin/restart', methods=['POST'])
def restart_service():
    # Nicht authentifizierter Dienstneustart!
    os.system('systemctl restart myservice')
    return 'Neugestartet'

// ANFÄLLIG: Express-Router ohne Auth-Middleware
const express = require('express');
const router = express.Router();

// Alle Routen ohne Authentifizierung zugänglich!
router.get('/admin/users', (req, res) => {
    res.json(database.getAllUsers());
});

router.post('/admin/delete-user/:id', (req, res) => {
    database.deleteUser(req.params.id);
    res.send('Gelöscht');
});

router.post('/admin/execute', (req, res) => {
    // Remote-Code-Ausführung ohne Authentifizierung!
    eval(req.body.command);
    res.send('Ausgeführt');
});

// ANFÄLLIG: Netzwerkdienst ohne Authentifizierung
void handle_admin_connection(int sock) {
    char command[256];
    read(sock, command, sizeof(command));

    // Führt jeden Befehl aus dem Netzwerk ohne Authentifizierung aus
    if (strncmp(command, "RESTART", 7) == 0) {
        system("reboot");
    } else if (strncmp(command, "CONFIG", 6) == 0) {
        update_configuration(command + 7);
    }
}

Korrigierter Code

from functools import wraps
from flask import request, jsonify, g

# SICHER: Authentifizierung für alle Admin-Routen erforderlich
def require_admin_auth(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        # Auf Authentifizierungstoken prüfen
        auth_header = request.headers.get('Authorization')
        if not auth_header or not auth_header.startswith('Bearer '):
            return jsonify({'error': 'Authentifizierung erforderlich'}), 401

        token = auth_header.split(' ')[1]
        user = validate_admin_token(token)

        if not user:
            return jsonify({'error': 'Ungültige Anmeldedaten'}), 401

        if not user.is_admin:
            return jsonify({'error': 'Admin-Zugriff erforderlich'}), 403

        g.current_user = user
        return f(*args, **kwargs)
    return decorated

@app.route('/api/admin/users', methods=['GET'])
@require_admin_auth  # Authentifizierung erforderlich
def list_all_users():
    return jsonify([u.to_dict() for u in User.query.all()])

@app.route('/api/admin/config', methods=['POST'])
@require_admin_auth
@require_permission('config:write')  # Zusätzliche Berechtigungsprüfung
def update_config():
    audit_log(f"Konfiguration aktualisiert von {g.current_user.id}")
    config.update(request.json)
    return 'Konfiguration aktualisiert'

// SICHER: Express mit Authentifizierungs-Middleware
const express = require('express');
const router = express.Router();

// Authentifizierungs-Middleware für alle Admin-Routen
const requireAdmin = async (req, res, next) => {
    const token = req.headers.authorization?.split(' ')[1];

    if (!token) {
        return res.status(401).json({ error: 'Authentifizierung erforderlich' });
    }

    try {
        const user = await validateToken(token);
        if (!user || !user.isAdmin) {
            return res.status(403).json({ error: 'Admin-Zugriff erforderlich' });
        }
        req.user = user;
        next();
    } catch (err) {
        return res.status(401).json({ error: 'Ungültiges Token' });
    }
};

// Authentifizierung auf alle Admin-Routen anwenden
router.use(requireAdmin);

router.get('/users', async (req, res) => {
    const users = await database.getAllUsers();
    res.json(users);
});

router.post('/delete-user/:id', async (req, res) => {
    await auditLog(`Benutzer ${req.user.id} hat Benutzer ${req.params.id} gelöscht`);
    await database.deleteUser(req.params.id);
    res.send('Gelöscht');
});

// NIEMALS eval oder Befehlsausführung exponieren, auch nicht mit Auth

// SICHER: Authentifizierung vor Befehlsverarbeitung erforderlich
typedef struct {
    int authenticated;
    int is_admin;
    char username[64];
} session_t;

void handle_admin_connection(int sock) {
    session_t session = {0};
    char buffer[256];

    // Zuerst Authentifizierung erforderlich
    read(sock, buffer, sizeof(buffer));

    if (strncmp(buffer, "AUTH ", 5) == 0) {
        if (authenticate(buffer + 5, &session)) {
            write(sock, "OK\n", 3);
        } else {
            write(sock, "FEHLGESCHLAGEN\n", 15);
            close(sock);
            return;
        }
    } else {
        write(sock, "AUTH ERFORDERLICH\n", 18);
        close(sock);
        return;
    }

    // Nur Befehle nach Authentifizierung verarbeiten
    while (read(sock, buffer, sizeof(buffer)) > 0) {
        if (!session.authenticated || !session.is_admin) {
            write(sock, "NICHT AUTORISIERT\n", 18);
            continue;
        }

        process_admin_command(buffer, &session);
    }
}

---

Ausgenutzt in der Praxis

SpaceX Starlink-Schüssel (SpaceX, 2025)

CVE-2025-67780 in SpaceX Starlink-Schüsseln ermöglicht nicht authentifizierten Angreifern im lokalen Netzwerk, administrative Befehle über die gRPC-Schnittstelle auszuführen, die Befehle ohne Authentifizierung akzeptiert.

• https://www.starlink.com/

Toto Link X5000R Router (TotoLink, 2025)

CVE-2025-13184 (CVSS 9.8 Kritisch) ermöglicht nicht authentifizierten Angreifern, Telnet auf Routern über die cstecgi.cgi-Schnittstelle zu aktivieren, der Authentifizierung für kritische Funktionen fehlt.

• https://www.totolink.net/

Q-Free MaxTime Verkehrssystem (Q-Free, 2025)

CVE-2025-26366 in Q-Free MaxTime ermöglicht nicht authentifizierten Remote-Angreifern, die Frontpanel-Authentifizierung über manipulierte HTTP-Anfragen an kritische Funktionen zu deaktivieren.

• https://www.q-free.com/

---

Tools zum Testen/Ausnutzen

• Burp Suite — Test auf nicht authentifizierten Zugriff auf Endpunkte.

• OWASP ZAP — Automatisiertes Scannen auf fehlende Authentifizierung.

• Nuclei — Vorlagen zur Erkennung exponierter Admin-Schnittstellen.

---

CVE-Beispiele

• CVE-2025-67780 — SpaceX Starlink nicht authentifizierter Admin-Zugriff.

• CVE-2025-13184 — TotoLink Router kritische Funktion ohne Auth.

• CVE-2024-8530 — Schneider Electric nicht authentifizierte Datenexposition.

---

Referenzen

1. MITRE. "CWE-306: Missing Authentication for Critical Function." https://cwe.mitre.org/data/definitions/306.html

2. OWASP. "API Security Top 10 - API2:2023 Broken Authentication." https://owasp.org/API-Security/