Zurück zur Schwachstellen-Datenbank

Quellcodedatei mit übermäßiger Anzahl von Codezeilen

Beschreibung

Quellcodedatei mit übermäßiger Anzahl von Codezeilen tritt auf, wenn eine Quellcodedatei zu viele Codezeilen enthält. CISQ empfiehlt einen Standardschwellenwert von 1000 Zeilen als Maß für übermäßigen Code. Größe Dateien sind schwer zu verstehen, zu warten, zu navigieren und auf Sicherheitsprobleme zu prüfen. Sie deuten oft darauf hin, dass die Datei mehrere Verantwortlichkeiten enthält, die gemäß dem Single-Responsibility-Prinzip getrennt werden sollten.

Risiko

Übermäßig große Dateien haben indirekte Sicherheitsimplikationen. Sicherheits-Code-Reviews werden für sehr große Dateien unpraktisch. Entwickler können gründliche Überprüfung aufgrund kognitiver Überlastung überspringen. Schwachstellen sind leichter in großen Dateien zu verstecken. Die Komplexität erhöht die Wahrscheinlichkeit, Fehler während der Wartung einzuführen. Merge-Konflikte sind häufiger und können zu Sicherheitsregressionen führen. Testabdeckung ist typischerweise niedriger für komplexe Dateien. Automatisierte Sicherheitstools können Timeouts haben oder überwältigende Ergebnisse liefern.

Lösung

Wenden Sie das Single-Responsibility-Prinzip an - jede Datei sollte einen Grund zur Änderung haben. Extrahieren Sie verwandte Funktionalität in separate Module oder Klassen. Verwenden Sie funktionsbasierte Dateiorganisation. Erstellen Sie Hilfsmodule für gemeinsam genutzte Funktionalität. Teilen Sie große Klassen in kleinere, fokussierte Klassen auf. Wenden Sie Design Patterns an, um Komplexität zu reduzieren. Setzen Sie maximale Dateilange als Codierungsstandard. Verwenden Sie statische Analyse, um Dateigrößenlimits durchzusetzen. Refaktorisieren Sie Legacy-Großdateien inkrementell. Erwägen Sie Domain-Driven Design für Codeorganisation.

Häufige Auswirkungen

AuswirkungDetails
AndereBereich: Ändere

Reduzierte Wartbarkeit - Größe Dateien sind schwer zu verstehen und sicher zu modifizieren.
AndereBereich: Ändere

Erhöhte analytische Komplexität - Sicherheitsüberprüfung größer Dateien ist unpraktisch.
AndereBereich: Ändere

Qualitätsverschlechterung - Test- und Code-Review-Abdeckung leiden unter großen Dateien.

Beispielcode

Anfälliger Code

// Anfällig: Einzelne Datei mit übermäßigem Code (abgekürztes Beispiel)
// In Wirklichkeit hat diese Datei 5000+ Zeilen

public class VulnerableMonolithicService {

    // ===== Authentifizierungsabschnitt (Zeilen 1-500) =====
    private Map<String, User> users = new HashMap<>();
    private Map<String, Session> sessions = new HashMap<>();

    public boolean authenticate(String username, String password) {
        // 50 Zeilen Authentifizierungscode
    }

    public Session createSession(User user) {
        // 30 Zeilen Sitzungserstellung
    }

    // ... 20 weitere Authentifizierungsmethoden ...

    // ===== Autorisierungsabschnitt (Zeilen 501-1000) =====
    private Map<String, List<Permission>> rolePermissions = new HashMap<>();

    public boolean hasPermission(User user, String permission) {
        // 40 Zeilen Berechtigungsprüfung
    }

    // ... 25 weitere Autorisierungsmethoden ...

    // ===== Benutzerverwaltungsabschnitt (Zeilen 1001-1800) =====
    public User createUser(UserDTO dto) {
        // 80 Zeilen Benutzererstellung
    }

    public void updateUser(String userId, UserDTO dto) {
        // 60 Zeilen Benutzeraktualisierung
    }

    // ... 30 weitere Benutzerverwaltungsmethoden ...

    // ===== Datenzugriffsabschnitt (Zeilen 1801-2800) =====
    private Connection getConnection() {
        // Datenbankverbindungscode
    }

    public List<User> findUsers(SearchCriteria criteria) {
        // 100 Zeilen komplexe Abfrageerstellung
    }

    // ... 40 weitere Datenzugriffsmethoden ...

    // ===== E-Mail-Abschnitt (Zeilen 2801-3500) =====
    public void sendEmail(String to, String subject, String body) {
        // 70 Zeilen E-Mail-Versand
    }

    // ... 20 weitere E-Mail-Methoden ...

    // ===== Protokollierungsabschnitt (Zeilen 3501-4000) =====
    private void logActivity(String action, User user) {
        // 40 Zeilen Aktivitätsprotokollierung
    }

    // ... 15 weitere Protokollierungsmethoden ...

    // ===== Berichtsabschnitt (Zeilen 4001-5000) =====
    public Report generateUserReport(Date start, Date end) {
        // 200 Zeilen Berichtserstellung
    }

    // ... 30 weitere Berichtsmethoden ...

    // Probleme:
    // 1. 5000+ Zeilen in einer Datei
    // 2. Mehrere Verantwortlichkeiten (Auth, Benutzer, E-Mail, Berichte)
    // 3. Sicherheitsüberprüfung ist nahezu unmöglich
    // 4. Testen ist extrem schwierig
    // 5. Jede Änderung riskiert, nicht verwandte Funktionalität zu brechen
}

Korrigierter Code

// Korrigiert: Separate Dateien für jede Verantwortlichkeit

// ===== Datei 1: AuthenticationService.java (150 Zeilen) =====
package com.example.security;

public class AuthenticationService {
    private final UserRepository userRepository;
    private final PasswordEncoder passwordEncoder;
    private final SessionManager sessionManager;

    public AuthenticationService(UserRepository userRepository,
                                 PasswordEncoder passwordEncoder,
                                 SessionManager sessionManager) {
        this.userRepository = userRepository;
        this.passwordEncoder = passwordEncoder;
        this.sessionManager = sessionManager;
    }

    public AuthResult authenticate(String username, String password) {
        User user = userRepository.findByUsername(username);
        if (user == null) {
            return AuthResult.userNotFound();
        }

        if (!passwordEncoder.matches(password, user.getPasswordHash())) {
            return AuthResult.invalidPassword();
        }

        Session session = sessionManager.createSession(user);
        return AuthResult.success(session);
    }

    public void logout(String sessionId) {
        sessionManager.invalidateSession(sessionId);
    }
}

// ===== Datei 2: AuthorizationService.java (120 Zeilen) =====
package com.example.security;

public class AuthorizationService {
    private final RoleRepository roleRepository;
    private final PermissionCache permissionCache;

    public AuthorizationService(RoleRepository roleRepository,
                               PermissionCache permissionCache) {
        this.roleRepository = roleRepository;
        this.permissionCache = permissionCache;
    }

    public boolean hasPermission(User user, String permission) {
        Set<Permission> permissions = permissionCache.getPermissions(user.getRoleId());
        return permissions.stream()
            .anyMatch(p -> p.getName().equals(permission));
    }

    public boolean hasRole(User user, String roleName) {
        Role role = roleRepository.findById(user.getRoleId());
        return role != null && role.getName().equals(roleName);
    }
}

// ===== Datei 3: UserService.java (200 Zeilen) =====
package com.example.users;

public class UserService {
    private final UserRepository userRepository;
    private final UserValidator validator;
    private final EventPublisher eventPublisher;

    public UserService(UserRepository userRepository,
                      UserValidator validator,
                      EventPublisher eventPublisher) {
        this.userRepository = userRepository;
        this.validator = validator;
        this.eventPublisher = eventPublisher;
    }

    public User createUser(CreateUserRequest request) {
        validator.validateCreateRequest(request);

        User user = new User();
        user.setUsername(request.getUsername());
        user.setEmail(request.getEmail());
        // ... weitere Felder zuordnen

        User saved = userRepository.save(user);
        eventPublisher.publish(new UserCreatedEvent(saved));

        return saved;
    }

    public User updateUser(String userId, UpdateUserRequest request) {
        validator.validateUpdateRequest(request);

        User user = userRepository.findById(userId);
        if (user == null) {
            throw new UserNotFoundException(userId);
        }

        // ... Felder aktualisieren

        return userRepository.save(user);
    }
}

// ===== Datei 4: UserRepository.java (80 Zeilen) =====
package com.example.users;

public interface UserRepository {
    User findById(String id);
    User findByUsername(String username);
    User findByEmail(String email);
    List<User> findAll(Pageable pageable);
    User save(User user);
    void delete(String id);
}

// ===== Datei 5: EmailService.java (100 Zeilen) =====
package com.example.notifications;

public class EmailService {
    private final EmailClient emailClient;
    private final TemplateEngine templateEngine;

    public EmailService(EmailClient emailClient,
                       TemplateEngine templateEngine) {
        this.emailClient = emailClient;
        this.templateEngine = templateEngine;
    }

    public void sendWelcomeEmail(User user) {
        String content = templateEngine.render("welcome", Map.of("user", user));
        emailClient.send(user.getEmail(), "Willkommen!", content);
    }

    public void sendPasswordReset(User user, String token) {
        String content = templateEngine.render("password-reset",
            Map.of("user", user, "token", token));
        emailClient.send(user.getEmail(), "Passwort zurücksetzen", content);
    }
}

// ===== Datei 6: ReportService.java (150 Zeilen) =====
package com.example.reports;

public class ReportService {
    private final ReportRepository reportRepository;
    private final ReportGenerator generator;

    public ReportService(ReportRepository reportRepository,
                        ReportGenerator generator) {
        this.reportRepository = reportRepository;
        this.generator = generator;
    }

    public Report generateUserReport(ReportCriteria criteria) {
        List<User> users = reportRepository.findUsersForReport(criteria);
        return generator.generate(users, criteria);
    }
}

Korrigierte Projektstruktur:
----------------------------
src/main/java/com/example/
├── security/
│   ├── AuthenticationService.java   (150 Zeilen)
│   ├── AuthorizationService.java    (120 Zeilen)
│   ├── SessionManager.java          (80 Zeilen)
│   ├── PasswordEncoder.java         (50 Zeilen)
│   └── PermissionCache.java         (60 Zeilen)
├── users/
│   ├── UserService.java             (200 Zeilen)
│   ├── UserRepository.java          (80 Zeilen)
│   ├── UserValidator.java           (100 Zeilen)
│   └── dto/
│       ├── CreateUserRequest.java   (30 Zeilen)
│       └── UpdateUserRequest.java   (30 Zeilen)
├── notifications/
│   ├── EmailService.java            (100 Zeilen)
│   ├── EmailClient.java             (60 Zeilen)
│   └── TemplateEngine.java          (80 Zeilen)
├── reports/
│   ├── ReportService.java           (150 Zeilen)
│   ├── ReportGenerator.java         (120 Zeilen)
│   └── ReportRepository.java        (70 Zeilen)
└── logging/
    ├── ActivityLogger.java          (80 Zeilen)
    └── AuditService.java            (100 Zeilen)

Vorteile:
- Jede Datei unter 200 Zeilen
- Einzelne Verantwortlichkeit pro Datei
- Einfach auf Sicherheitsprobleme zu prüfen
- Isoliert testbar
- Klare Trennung der Belange

CVE-Beispiele

Diese CWE ist für direkte CVE-Zuordnung als VERBOTEN markiert, da sie ein Codequalitäts-/Wartbarkeitsproblem und keine direkte Sicherheitsschwachstelle darstellt.

Verwandte CWEs

  • CWE-1120: Excessive Code Complexity (Eltern)
  • CWE-1226: Complexity Issues (Kategoriemitglied)
  • CWE-1047: Modules with Circular Dependencies (verwandt)

Referenzen

  1. MITRE Corporation. "CWE-1080: Source Code File with Excessive Number of Lines of Code." https://cwe.mitre.org/data/definitions/1080.html

  2. CISQ. "Automated Source Code Quality Measures."

  3. Martin, Robert C. "Clean Code: A Handbook of Agile Software Craftsmanship."