Unzureichendes Logging

Beschreibung

Unzureichendes Logging tritt auf, wenn ein sicherheitskritisches Ereignis eintritt, aber die Software das Ereignis entweder nicht aufzeichnet oder wichtige Details über das Ereignis auslässt. Angemessenes Logging ist essentiell für die Erkennung von Angriffen, die Untersuchung von Vorfällen und die Erfüllung von Compliance-Anforderungen. Ohne ordnungsgemäßes Logging können Organisationen laufende Einbrüche nicht erkennen, nicht verstehen was während eines Vorfalls passiert ist, oder keine Beweise für rechtliche Verfahren liefern.

Risiko

Unzureichendes Logging erhöht den Schäden durch Sicherheitsverletzungen erheblich. Angreifer können über längere Zeiträume unentdeckt operieren - die durchschnittliche Erkennungszeit für Einbrüche beträgt 197 Tage. Ohne Logs können Organisationen keine forensische Analyse durchführen, keine kompromittierten Konten identifizieren oder den Umfang von Einbrüchen bestimmen. Compliance-Frameworks (PCI-DSS, HIPAA, SOX) erfordern umfassendes Sicherheits-Logging. Fehlende Logs können zu regulatorischen Strafen und Rechtsstreitigkeiten führen.

Lösung

Loggen Sie alle sicherheitsrelevanten Ereignisse: Authentifizierungsversuche (Erfolg und Fehlschlag), Autorisierungsfehler, Eingabevalidierungsfehler, Anwendungsfehler und administrative Aktionen. Schließen Sie essenziellen Kontext ein: Zeitstempel, Benutzeridentität, Quell-IP, durchgeführte Aktion und Zielressource. Schützen Sie Log-Integrität durch Append-only-Speicher und zentralisiertes Logging. Implementieren Sie Echtzeitüberwachung und Alarmierung. Bewahren Sie Logs für angemessene Zeiträume basierend auf Compliance-Anforderungen auf. Loggen Sie niemals sensible Daten wie Passwörter oder Kreditkartennummern.

Häufige Auswirkungen

Auswirkung	Details
Nicht-Abstreitbarkeit	Bereich: Fehlende Verantwortlichkeit Ohne Logs können bösartige Aktionen nicht bestimmten Benutzern oder Prozessen zugeordnet werden.
Erkennung	Bereich: Verzögerte Einbruchserkennung Angriffe verlaufen ohne ordnungsgemäßes Logging und Überwachung unentdeckt.
Forensik	Bereich: Unvollständige Untersuchung Incident Response wird durch fehlende oder unvollständige Log-Daten behindert.

Beispielcode + Lösungscode

Verwundbarer Code

# VERWUNDBAR: Kein Logging von Sicherheitsereignissen
@app.route('/login', methods=['POST'])
def login():
    username = request.form['username']
    password = request.form['password']

    user = authenticate(username, password)
    if user:
        session['user_id'] = user.id
        return redirect('/dashboard')
    # Kein Logging des fehlgeschlagenen Login-Versuchs!
    return 'Ungültige Anmeldedaten', 401

# VERWUNDBAR: Sensible Daten loggen
import logging
logger = logging.getLogger(__name__)

@app.route('/payment', methods=['POST'])
def process_payment():
    card_number = request.form['card_number']
    cvv = request.form['cvv']

    # NICHT sensible Daten loggen!
    logger.info(f"Verarbeite Zahlung für Karte {card_number} mit CVV {cvv}")

    return process_card(card_number, cvv)

// VERWUNDBAR: Kein Sicherheitsereignis-Logging
@PostMapping("/login")
public ResponseEntity<?> login(@RequestBody LoginRequest request) {
    User user = userService.authenticate(
        request.getUsername(),
        request.getPassword()
    );

    if (user != null) {
        return ResponseEntity.ok(generateToken(user));
    }
    // Kein Logging des Authentifizierungsfehlers!
    return ResponseEntity.status(401).body("Ungültige Anmeldedaten");
}

// VERWUNDBAR: Ungenügender Kontext in Logs
@DeleteMapping("/users/{id}")
public ResponseEntity<?> deleteUser(@PathVariable Long id) {
    userRepository.deleteById(id);
    // Nutzloses Log - wer hat das gemacht? Wann? Von wo?
    System.out.println("Benutzer gelöscht");
    return ResponseEntity.ok().build();
}

Gefixter Code

# SICHER: Umfassendes Sicherheits-Logging
import logging
from datetime import datetime
import json

logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    level=logging.INFO
)
logger = logging.getLogger('security')

def log_security_event(event_type, user=None, success=True, details=None):
    """Sicherheitsereignisse mit vollem Kontext loggen."""
    event = {
        'timestamp': datetime.utcnow().isoformat(),
        'event_type': event_type,
        'success': success,
        'user': user or 'anonymous',
        'ip_address': request.remote_addr,
        'user_agent': request.headers.get('User-Agent'),
        'request_id': g.get('request_id'),
        'details': details or {}
    }
    logger.info(json.dumps(event))

@app.route('/login', methods=['POST'])
def login():
    username = request.form['username']
    password = request.form['password']

    user = authenticate(username, password)

    if user:
        log_security_event(
            'authentication',
            user=username,
            success=True,
            details={'method': 'password'}
        )
        session['user_id'] = user.id
        return redirect('/dashboard')

    log_security_event(
        'authentication',
        user=username,
        success=False,
        details={'reason': 'invalid_credentials'}
    )
    return 'Ungültige Anmeldedaten', 401

# SICHER: Sensible Daten maskieren
def mask_card_number(card_number):
    """Maskierte Kartennummer für Logging zurückgeben."""
    return f"****{card_number[-4:]}"

@app.route('/payment', methods=['POST'])
def process_payment():
    card_number = request.form['card_number']
    cvv = request.form['cvv']

    # Mit maskierten Daten loggen
    log_security_event(
        'payment_attempt',
        user=current_user.username,
        details={
            'card_last_four': card_number[-4:],
            'amount': request.form['amount']
        }
    )

    try:
        result = process_card(card_number, cvv)
        log_security_event(
            'payment_success',
            user=current_user.username,
            details={'transaction_id': result.id}
        )
        return jsonify(result)
    except PaymentError as e:
        log_security_event(
            'payment_failure',
            user=current_user.username,
            success=False,
            details={'error': str(e)}
        )
        raise

// SICHER: Umfassendes Sicherheits-Logging
@Service
public class AuditService {

    private static final Logger auditLogger = LoggerFactory.getLogger("audit");

    public void logSecurityEvent(SecurityEvent event) {
        MDC.put("requestId", RequestContext.getCurrentRequestId());
        MDC.put("userId", SecurityContext.getCurrentUser());
        MDC.put("ipAddress", RequestContext.getClientIP());

        auditLogger.info("{}", objectMapper.writeValueAsString(event));

        MDC.clear();
    }
}

@RestController
public class SecureAuthController {

    @Autowired
    private AuditService auditService;

    @PostMapping("/login")
    public ResponseEntity<?> login(
            @RequestBody LoginRequest request,
            HttpServletRequest httpRequest) {

        User user = userService.authenticate(
            request.getUsername(),
            request.getPassword()
        );

        if (user != null) {
            auditService.logSecurityEvent(SecurityEvent.builder()
                .type("AUTHENTICATION_SUCCESS")
                .username(request.getUsername())
                .ipAddress(getClientIP(httpRequest))
                .userAgent(httpRequest.getHeader("User-Agent"))
                .build());

            return ResponseEntity.ok(generateToken(user));
        }

        auditService.logSecurityEvent(SecurityEvent.builder()
            .type("AUTHENTICATION_FAILURE")
            .username(request.getUsername())
            .ipAddress(getClientIP(httpRequest))
            .reason("INVALID_CREDENTIALS")
            .build());

        return ResponseEntity.status(401).body("Ungültige Anmeldedaten");
    }
}

---

Ausgenutzt in der Praxis

Equifax-Einbruch (2017)

Der Equifax-Einbruch blieb 76 Tage unentdeckt, teilweise aufgrund unzureichenden Loggings und Überwachung. Bessere Sicherheitsüberwachung hätte die Datenexfiltration früher erkennen können.

Target-Datenverletzung (2013)

Target hatte Warnungen von ihren Sicherheitstools, aber es fehlte eine ordnungsgemäße Logging-Infrastruktur, um diese zu korrelieren und darauf zu reagieren, was zu einem 40-Millionen-Karten-Einbruch beitrug.

SolarWinds Supply Chain-Angriff (2020)

Die Raffiniertheit des Angriffs wurde durch die Unfähigkeit von Organisationen begünstigt, anomales Verhalten aufgrund unzureichenden Loggings von sicherheitsrelevanten Ereignissen zu erkennen.

---

Tools zum Testen/Ausnutzen

• ELK Stack - Zentralisiertes Logging und Analyse.

• Splunk - Security Information and Event Management.

• OWASP ZAP - Kann Logging-Defizite identifizieren.

• Graylog - Log-Management-Plattform.

---

CVE-Beispiele

• CVE-2021-44228 - Log4Shell (Logging-Bibliothek-Schwachstelle).

• CVE-2018-0147 - Cisco unzureichendes Logging.

---

Referenzen

1. MITRE. "CWE-778: Insufficient Logging." https://cwe.mitre.org/data/definitions/778.html

2. OWASP. "A09:2021 - Security Logging and Monitoring Failures." https://owasp.org/Top10/A09_2021-Security_Logging_and_Monitoring_Failures/