Quellcode-Element ohne standardisierten Prolog

Beschreibung

Quellcode-Element ohne standardisierten Prolog tritt auf, wenn Quellcodedateien oder bedeutende Codeelemente im gesamten Projekt keine konsistenten standardisierten Prologe oder Header aufweisen. Standardprologe enthalten typischerweise Informationen wie Modulname, Versionsnummer, Autor, Datum, Zweck, Funktion, Annahmen, Einschränkungen, Genauigkeitsüberlegungen, Sicherheitshinweise und Lizenzinformationen. Ohne konsistente Prologe wird das Codeverständnis schwieriger und sicherheitsrelevante Informationen können fehlen oder inkonsistent dokumentiert sein.

Risiko

Fehlende Standardprologe haben indirekte Sicherheitsauswirkungen. Sicherheitskritische Module werden ohne ordnungsgemäße Header möglicherweise nicht klar identifiziert. Das Fehlen von Versionsinformationen erschwert die Nachverfolgung von Sicherheitspatches. Fehlende Autorinformationen machen es schwerer, Entwickler bezüglich Sicherheitsproblemen zu kontaktieren. Nicht dokumentierte Annahmen und Einschränkungen können zu Fehlbenutzung führen. Sicherheitsanforderungen für bestimmte Module werden möglicherweise nicht kommuniziert. Die Code-Herkunft ist ohne konsistente Header schwerer festzustellen. Es können Lizenz-Compliance-Probleme auftreten. Audit-Trails werden unvollständig. Code-Reviews werden ohne Kontextinformationen zeitaufwändiger.

Lösung

Etablieren Sie Standard-Prolog-Vorlagen für das Projekt. Fügen Sie Modulname, Zweck und Beschreibung hinzu. Dokumentieren Sie Versionshistorie und Änderungsprotokoll. Fügen Sie Autor- und Maintainer-Informationen hinzu. Listen Sie sicherheitsrelevante Annahmen und Einschränkungen auf. Dokumentieren Sie Abhängigkeiten und Anforderungen. Fügen Sie Lizenzinformationen hinzu. Verwenden Sie automatisierte Tools zur Durchsetzung der Prolog-Präsenz. Fügen Sie Sicherheitsklassifikationen für sensible Module hinzu. Dokumentieren Sie Eingabe-/Ausgabespezifikationen. Halten Sie Prologe mit Codeänderungen aktuell. Verwenden Sie IDE-Vorlagen oder Snippets für konsistente Formatierung.

Häufige Auswirkungen

Auswirkung	Details
Sonstiges	Bereich: Sonstiges Reduzierte Wartbarkeit -- Fehlende Prologe machen das Codeverständnis langsamer und schwieriger, was die Sicherheit indirekt beeinträchtigt, indem Schwachstellen schwerer zu finden und zu beheben sind.
Sonstiges	Bereich: Sonstiges Erhöhte analytische Komplexität -- Unzureichende Analysierbarkeit erschwert die Sicherheitsüberprüfung ohne ordnungsgemäße Moduldokumentation.

Beispielcode und Lösung

Verwundbarer Code

// Verwundbar: Kein Standard-Prolog

package com.example.security;

import java.util.*;

public class AuthenticationService {
    // Keine Dokumentation über:
    // - Zweck dieser Klasse
    // - Sicherheitsannahmen
    // - Erforderliche Berechtigungen
    // - Thread-Sicherheit
    // - Versionshistorie

    private Map<String, User> sessions = new HashMap<>();

    public boolean authenticate(String username, String password) {
        // Implementierung ohne Kontext
        User user = findUser(username);
        if (user != null && checkPassword(user, password)) {
            createSession(user);
            return true;
        }
        return false;
    }

    // Weitere Methoden ohne Dokumentation...
}

# Verwundbar: Kein Modul-Prolog

import hashlib
import secrets

def hash_password(password, salt=None):
    # Keine Dokumentation über:
    # - Begründung der Algorithmuswahl
    # - Salt-Anforderungen
    # - Sicherheitsüberlegungen
    if salt is None:
        salt = secrets.token_hex(16)
    return hashlib.sha256((password + salt).encode()).hexdigest(), salt


def verify_password(password, hash, salt):
    computed, _ = hash_password(password, salt)
    return computed == hash


# Keine Dokumentation auf Modulebene über:
# - Was dieses Modul tut
# - Sicherheitsanforderungen
# - Abhängigkeiten
# - Versionshistorie
# - Autor/Maintainer

// Verwundbar: Kein Datei-Header

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Keine Dokumentation über:
// - Dateizweck
// - Sicherheitsüberlegungen
// - Puffergrößenannahmen
// - Thread-Sicherheit

void process_input(char *input) {
    char buffer[256];
    strcpy(buffer, input);  // Potenzieller Overflow - nicht dokumentiert
    // ...
}

int main(int argc, char *argv[]) {
    if (argc > 1) {
        process_input(argv[1]);
    }
    return 0;
}

// Verwundbar: Keine Moduldokumentation

const crypto = require('crypto');

// Kein Modul-Prolog, der erklärt:
// - Modulzweck
// - Sicherheitsanforderungen
// - API-Stabilität
// - Abhängigkeiten

function encryptData(data, key) {
    const cipher = crypto.createCipher('aes-256-cbc', key);
    let encrypted = cipher.update(data, 'utf8', 'hex');
    encrypted += cipher.final('hex');
    return encrypted;
}

function decryptData(encryptedData, key) {
    const decipher = crypto.createDecipher('aes-256-cbc', key);
    let decrypted = decipher.update(encryptedData, 'hex', 'utf8');
    decrypted += decipher.final('utf8');
    return decrypted;
}

module.exports = { encryptData, decryptData };

Sichere Lösung

/*
 * ============================================================================
 * Modul:       AuthenticationService.java
 * Paket:       com.example.security
 * Version:     2.3.0
 * Autor:       Security Team <[email protected]>
 * Erstellt:    2024-01-15
 * Geändert:    2024-03-20
 * ============================================================================
 *
 * ZWECK:
 * Bietet Benutzerauthentifizierungs- und Session-Management-Dienste.
 * Dies ist eine sicherheitskritische Komponente, die Anmeldedaten-Validierung
 * durchführt.
 *
 * SICHERHEITSKLASSIFIKATION: HOCH
 *
 * SICHERHEITSANFORDERUNGEN:
 * - Alle Passwortvergleiche müssen zeitkonstant sein, um Timing-Angriffe zu verhindern
 * - Session-Token müssen kryptografisch zufällig sein (mindestens 256 Bit)
 * - Fehlgeschlagene Authentifizierungsversuche müssen ratenlimitiert werden
 * - Alle Authentifizierungsereignisse müssen für Audits protokolliert werden
 *
 * ANNAHMEN:
 * - Benutzerpasswörter sind bereits mit bcrypt gehasht (Kostenfaktor 12+)
 * - Datenbankverbindungen sind verschlüsselt (TLS 1.2+)
 * - Dieser Dienst läuft in einer vertrauenswürdigen Netzwerkzone
 *
 * EINSCHRÄNKUNGEN:
 * - Maximale gleichzeitige Sessions pro Benutzer: 5
 * - Session-Timeout: 30 Minuten Inaktivität
 * - Nicht für Multi-Mandanten-Deployments ohne Anpassung konzipiert
 *
 * THREAD-SICHERHEIT:
 * Diese Klasse ist thread-sicher. Aller gemeinsam genutzter Zustand ist
 * ordnungsgemäß synchronisiert.
 *
 * ABHÄNGIGKEITEN:
 * - BCrypt-Bibliothek (org.mindrot:jbcrypt:0.4)
 * - SLF4J-Logging-Framework
 *
 * ÄNDERUNGSPROTOKOLL:
 * 2.3.0 (2024-03-20) - Rate-Limiting für fehlgeschlagene Versuche hinzugefügt
 * 2.2.0 (2024-02-10) - Session-Token-Generierung verbessert
 * 2.1.0 (2024-01-20) - Audit-Protokollierung hinzugefügt
 * 2.0.0 (2024-01-15) - Initiale sichere Implementierung
 *
 * LIZENZ: Proprietär - Nur für internen Gebrauch
 * ============================================================================
 */

package com.example.security;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Authentifizierungsdienst für Benutzer-Anmeldedaten-Validierung und Session-Management.
 *
 * <p><strong>Sicherheitshinweis:</strong> Dieser Dienst verarbeitet sensible Anmeldedaten.
 * Alle Implementierungen müssen sichere Codierungsrichtlinien befolgen.</p>
 *
 * @author Security Team
 * @version 2.3.0
 * @since 2.0.0
 * @see SessionManager
 * @see AuditLogger
 */
public class AuthenticationService {

    private final ConcurrentHashMap<String, User> sessions;
    private final RateLimiter rateLimiter;
    private final AuditLogger auditLogger;

    /**
     * Authentifiziert einen Benutzer mit Benutzername und Passwort.
     *
     * <p><strong>Sicherheit:</strong> Passwortvergleich verwendet zeitkonstanten
     * Algorithmus. Fehlgeschlagene Versuche werden ratenlimitiert und protokolliert.</p>
     *
     * @param username Der Benutzername, darf nicht null oder leer sein
     * @param password Das Passwort, darf nicht null sein, wird sicher behandelt
     * @return true wenn Authentifizierung erfolgreich, false andernfalls
     * @throws RateLimitExceededException wenn zu viele fehlgeschlagene Versuche
     */
    public boolean authenticate(String username, String password) {
        // Implementierung mit dokumentierten Sicherheitsmaßnahmen
        Objects.requireNonNull(username, "Username must not be null");
        Objects.requireNonNull(password, "Password must not be null");

        rateLimiter.checkLimit(username);

        User user = findUser(username);
        if (user != null && securePasswordCheck(user, password)) {
            createSession(user);
            auditLogger.logSuccess(username);
            return true;
        }

        auditLogger.logFailure(username);
        return false;
    }
}

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
============================================================================
Modul:      password_utils.py
Version:    1.2.0
Autor:      Security Team <[email protected]>
Erstellt:   2024-01-15
Geändert:   2024-03-20
============================================================================

Passwort-Hashing- und Verifizierungs-Dienstprogramme.

Dieses Modul bietet sicheres Passwort-Hashing mit modernen Algorithmen,
ordnungsgemäßer Salt-Behandlung und timing-angriff-resistentem Vergleich.

Sicherheitsklassifikation: HOCH

Sicherheitsanforderungen:
    - Verwendet PBKDF2 mit SHA-256 (mindestens 100.000 Iterationen)
    - Salts sind 32 Bytes kryptografische Zufallsdaten
    - Alle Vergleiche sind zeitkonstant
    - Passwörter werden nie im Klartext protokolliert oder gespeichert

Annahmen:
    - Ausführung auf einem System mit sicherer Zufallszahlengenerierung
    - Python 3.8+ mit hashlib-Unterstützung für PBKDF2

Einschränkungen:
    - Maximale Passwortlänge: 128 Zeichen (um DoS zu verhindern)
    - Minimale Passwortlänge: 8 Zeichen (extern erzwungen)

Thread-Sicherheit:
    Alle Funktionen sind thread-sicher und zustandslos.

Abhängigkeiten:
    - hashlib (Standardbibliothek)
    - secrets (Standardbibliothek)
    - hmac (Standardbibliothek)

Beispiel:
    >>> hashed, salt = hash_password("secure_password")
    >>> verify_password("secure_password", hashed, salt)
    True

Änderungsprotokoll:
    1.2.0 (2024-03-20) - Iterationen auf 100.000 erhöht
    1.1.0 (2024-02-10) - Zeitkonstanten Vergleich hinzugefügt
    1.0.0 (2024-01-15) - Initiale Implementierung

Lizenz: MIT
============================================================================
"""

import hashlib
import secrets
import hmac
from typing import Tuple

# Sicherheitskonstanten - für Audit dokumentiert
HASH_ALGORITHM = 'sha256'
ITERATIONS = 100_000  # OWASP empfohlenes Minimum für PBKDF2-SHA256
SALT_LENGTH = 32  # 256 Bits
HASH_LENGTH = 32  # 256 Bits


def hash_password(password: str, salt: bytes = None) -> Tuple[str, bytes]:
    """
    Hasht ein Passwort mit PBKDF2-SHA256.

    Sicherheitshinweise:
        - Verwendet kryptografisch sichere Salt-Generierung
        - 100.000 Iterationen gemäß OWASP-Richtlinien
        - Salt muss zusammen mit dem Hash gespeichert werden

    Args:
        password: Das zu hashende Klartext-Passwort (max. 128 Zeichen)
        salt: Optionale Salt-Bytes. Wenn None, wird sicheres zufälliges Salt generiert.

    Returns:
        Tuple aus (hex-kodierter Hash, Salt-Bytes)

    Raises:
        ValueError: Wenn Passwort maximale Länge überschreitet
    """
    if len(password) > 128:
        raise ValueError("Password exceeds maximum length")

    if salt is None:
        salt = secrets.token_bytes(SALT_LENGTH)

    hash_bytes = hashlib.pbkdf2_hmac(
        HASH_ALGORITHM,
        password.encode('utf-8'),
        salt,
        ITERATIONS,
        dklen=HASH_LENGTH
    )

    return hash_bytes.hex(), salt


def verify_password(password: str, expected_hash: str, salt: bytes) -> bool:
    """
    Verifiziert ein Passwort gegen einen gespeicherten Hash.

    Sicherheitshinweise:
        - Verwendet zeitkonstanten Vergleich um Timing-Angriffe zu verhindern
        - Verrät nicht, welches Zeichen falsch war

    Args:
        password: Das zu verifizierende Klartext-Passwort
        expected_hash: Der gespeicherte Hash (hex-kodiert)
        salt: Das bei der Hash-Erstellung verwendete Salt

    Returns:
        True wenn Passwort übereinstimmt, False andernfalls
    """
    computed_hash, _ = hash_password(password, salt)
    # Zeitkonstanter Vergleich
    return hmac.compare_digest(computed_hash, expected_hash)

---

CVE-Beispiele

Diese CWE ist als VERBOTEN für direkte CVE-Zuordnung markiert, da sie ein Codequalitätsproblem darstellt und keine direkte Sicherheitslücke.

---

Verwandte CWEs

• CWE-1078: Unangemessener Quellcode-Stil oder Formatierung (Eltern)
• CWE-1006: Schlechte Codierungspraktiken (Kategoriemitglied)
• CWE-1113: Unangemessener Kommentarstil (verwandt)
• CWE-1110: Unvollständige Design-Dokumentation (verwandt)

---

Referenzen

1. MITRE Corporation. "CWE-1115: Source Code Element without Standard Prologue." https://cwe.mitre.org/data/definitions/1115.html
2. IEEE Std 830 - Software Requirements Specifications
3. Verschiedene Sprach-Style-Guides (PEP 257, Javadoc, JSDoc)