Inkonsistente Namenskonventionen für Bezeichner

Beschreibung

Inkonsistente Namenskonventionen für Bezeichner tritt auf, wenn ein Produkt keine konsistente Namenskonvention im gesamten Quellcode, der Dokumentation und verwandten Artefakten verwendet. Dies betrifft Bezeichner wie Variablennamen, Funktionsnamen, Klassennamen, Datentypen, Dateinamen und Konstanten. Wenn Namenskonventionen inkonsistent sind, wird es schwieriger, die Codebasis zu verstehen, verwandte Komponenten zu identifizieren und die Software sicher zu warten.

Risiko

Inkonsistente Benennung hat indirekte Sicherheitsimplikationen. Code wird schwerer zu verstehen, was die Wahrscheinlichkeit von Sicherheitsfehlern während der Entwicklung erhöht. Wartung wird fehleranfällig, wenn ähnliche Konzepte unterschiedliche Namen haben. Sicherheitsüberprüfungen werden durch inkonsistente Terminologie erschwert. Verwandte Sicherheitskontrollen können schwerer zu identifizieren und zu verifizieren sein. Copy-Paste-Fehler sind wahrscheinlicher, wenn ähnliche Elemente unterschiedliche Namen haben. Automatisierte Sicherheitsanalyse kann Muster aufgrund von Namensinkonsistenzen übersehen. Dokumentationsabweichungen können zu falscher Verwendung sicherheitsrelevanter APIs führen.

Lösung

Etablieren und dokumentieren Sie Namenskonventionen für das Projekt. Verwenden Sie konsistente Präfixe oder Suffixe für verwandte Konzepte (z.B. alle Validatoren enden mit "Validator"). Befolgen Sie sprachspezifische Konventionen (z.B. PascalCase für C#-Klassen, snake_case für Python). Verwenden Sie automatisierte Linting-Tools zur Durchsetzung von Namenskonventionen. Wenden Sie konsistente Benennung für sicherheitsrelevante Konzepte an (Authentifizierung, Autorisierung, Validierung). Führen Sie Code-Reviews durch, die Namenskonsistenz prüfen. Refaktorieren Sie inkonsistent benannten Code, wenn er entdeckt wird. Verwenden Sie IDE-Funktionen zur Durchsetzung von Namensregeln.

Häufige Auswirkungen

Auswirkung	Details
Andere	Bereich: Ändere Reduzierte Wartbarkeit - Inkonsistente Benennung macht Code schwerer zu verstehen und zu warten.
Andere	Bereich: Ändere Erhöhte analytische Komplexität - Sicherheitsanalyse wird durch Namensinkonsistenzen erschwert.

Beispielcode

Anfälliger Code

// Anfällig: Inkonsistente Namenskonventionen
public class VulnerableUserManager {

    // Inkonsistent: Einige verwenden camelCase, andere nicht
    private UserRepository user_repository;  // snake_case
    private SessionService sessionSvc;       // Abgekürzt
    private AuthenticationHelper AUTH_HELPER; // SCREAMING_CASE für Nicht-Konstante
    private ValidationUtil valUtil;          // Inkonsistente Abkürzung

    // Inkonsistente Methodenbenennung
    public User GetUserById(long id) {       // PascalCase (falsch für Java)
        return user_repository.findById(id);
    }

    public User fetch_user_by_email(String email) {  // snake_case
        return user_repository.findByEmail(email);
    }

    public User retrieveUserByUsername(String username) {  // Volles Wort
        return user_repository.findByUsername(username);
    }

    // Inkonsistente Boolean-Benennung
    public boolean checkUserActive(User user) {     // "check"
        return user.isActive();
    }

    public boolean isUserValid(User user) {         // "is"-Präfix
        return valUtil.validate(user);
    }

    public boolean hasUserPermission(User u, String perm) {  // "has"-Präfix
        return AUTH_HELPER.checkPermission(u, perm);
    }

    public boolean userCanAccess(User user, Resource r) {    // "can"
        return user.hasAccessTo(r);
    }

    // Inkonsistente Parameterbenennung
    public void updateUser(User usr, String newName) {       // "usr"
        usr.setName(newName);
    }

    public void deleteUser(User theUser) {                   // "theUser"
        user_repository.delete(theUser);
    }

    public void saveUser(User u) {                           // "u"
        user_repository.save(u);
    }
}

# Anfällig: Gemischte Namenskonventionen
class VulnerableDataProcessor:

    def __init__(self):
        # Inkonsistente Attributbenennung
        self.dataCache = {}           # camelCase
        self.user_manager = None      # snake_case
        self.HTTPClient = None        # PascalCase
        self.db_connection = None     # snake_case
        self.ValidationService = None # PascalCase

    # Inkonsistente Methodenbenennung
    def processData(self, data):       # camelCase
        pass

    def validate_input(self, input):   # snake_case
        pass

    def DoCalculation(self, values):   # PascalCase
        pass

    def fetch_and_process(self, id):   # snake_case
        pass

    def GetUserData(self, user_id):    # PascalCase
        pass

    # Inkonsistente Konstantenverwendung
    MAX_RETRIES = 3                    # SCREAMING_SNAKE
    defaultTimeout = 30                # camelCase
    api_endpoint = "/api/v1"           # snake_case


# Inkonsistente Klassenbenennung im gleichen Projekt
class userValidator:                   # Kleinbuchstaben (falsch)
    pass

class DataProcessor:                   # PascalCase (korrekt)
    pass

class order_handler:                   # snake_case (falsch)
    pass

class HTTPHelper:                      # Akronym-Stil
    pass

class HttpClient:                      # Gemischtes Akronym
    pass

// Anfällig: C# mit inkonsistenter Benennung
public class VulnerableOrderService
{
    // Inkonsistente Feldbenennung
    private IOrderRepository _orderRepo;      // Unterstrich-Präfix
    private ICustomerService customerService; // Kein Präfix
    private ILogger m_logger;                 // m_-Präfix
    private IValidator validator;             // Kein Präfix

    // Inkonsistente Eigenschaftsbenennung
    public int orderCount { get; set; }       // camelCase (falsch)
    public string CustomerName { get; set; }  // PascalCase (korrekt)
    public bool is_active { get; set; }       // snake_case (falsch)

    // Inkonsistente Methodenbenennung
    public void ProcessOrder(Order order)     // Korrekt
    {
    }

    public void process_payment(Payment p)    // Falsch: snake_case
    {
    }

    public void validateOrder(Order o)        // Falsch: camelCase
    {
    }

    // Inkonsistente Parameterbenennung
    public void UpdateOrder(Order Order)      // Gleich wie Typname!
    {
    }

    public void DeleteOrder(Order ord)        // Abgekürzt
    {
    }

    public void SaveOrder(Order theOrder)     // "the"-Präfix
    {
    }

    // Inkonsistente Async-Methodenbenennung
    public async Task GetOrderAsync()         // Korrekt: Async-Suffix
    {
    }

    public async Task FetchCustomer()         // Falsch: Async fehlt
    {
    }

    public async Task LoadDataAsync_New()     // Falsch: Extra Suffix
    {
    }
}

Korrigierter Code

// Korrigiert: Konsistente Namenskonventionen nach Java-Standards
public class FixedUserManager {

    // Konsistente Feldbenennung: camelCase
    private final UserRepository userRepository;
    private final SessionService sessionService;
    private final AuthenticationHelper authenticationHelper;
    private final ValidationUtil validationUtil;

    // Konstruktor mit konsistenter Parameterbenennung
    public FixedUserManager(
            UserRepository userRepository,
            SessionService sessionService,
            AuthenticationHelper authenticationHelper,
            ValidationUtil validationUtil) {
        this.userRepository = userRepository;
        this.sessionService = sessionService;
        this.authenticationHelper = authenticationHelper;
        this.validationUtil = validationUtil;
    }

    // Konsistente Methodenbenennung: Verb + Substantiv, camelCase
    public User findUserById(long id) {
        return userRepository.findById(id);
    }

    public User findUserByEmail(String email) {
        return userRepository.findByEmail(email);
    }

    public User findUserByUsername(String username) {
        return userRepository.findByUsername(username);
    }

    // Konsistente Boolean-Benennung: "is"-Präfix für Zustand
    public boolean isUserActive(User user) {
        return user.isActive();
    }

    public boolean isUserValid(User user) {
        return validationUtil.validate(user);
    }

    // Konsistente Boolean-Benennung: "has"-Präfix für Besitz
    public boolean hasPermission(User user, String permission) {
        return authenticationHelper.checkPermission(user, permission);
    }

    // Konsistente Boolean-Benennung: "can"-Präfix für Fähigkeit
    public boolean canAccessResource(User user, Resource resource) {
        return user.hasAccessTo(resource);
    }

    // Konsistente Parameterbenennung: vollständige beschreibende Namen
    public void updateUser(User user, String newName) {
        user.setName(newName);
        userRepository.save(user);
    }

    public void deleteUser(User user) {
        userRepository.delete(user);
    }

    public void saveUser(User user) {
        userRepository.save(user);
    }
}

// Konsistente Konstantenbenennung: SCREAMING_SNAKE_CASE
public final class SecurityConstants {
    public static final int MAX_LOGIN_ATTEMPTS = 5;
    public static final int SESSION_TIMEOUT_MINUTES = 30;
    public static final String AUTH_HEADER_NAME = "Authorization";

    private SecurityConstants() {}  // Instanziierung verhindern
}

# Korrigiert: Konsistente Python-Namenskonventionen (PEP 8)
class FixedDataProcessor:
    """Datenverarbeiter nach PEP 8-Namenskonventionen."""

    # Klassenkonstanten: SCREAMING_SNAKE_CASE
    MAX_RETRIES = 3
    DEFAULT_TIMEOUT = 30
    API_ENDPOINT = "/api/v1"

    def __init__(self):
        # Instanzattribute: snake_case
        self.data_cache = {}
        self.user_manager = None
        self.http_client = None
        self.db_connection = None
        self.validation_service = None

    # Methoden: snake_case mit Verb + Substantiv
    def process_data(self, data):
        """Verarbeitet die gegebenen Daten."""
        pass

    def validate_input(self, input_data):
        """Validiert Eingabedaten."""
        pass

    def calculate_total(self, values):
        """Berechnet Summe aus Werten."""
        pass

    def fetch_and_process_data(self, data_id):
        """Holt Daten nach ID und verarbeitet sie."""
        pass

    def get_user_data(self, user_id):
        """Holt Benutzerdaten nach Benutzer-ID."""
        pass

    # Boolean-Methoden: is_, has_, can_-Präfixe verwenden
    def is_valid(self, data):
        """Prüft, ob Daten gültig sind."""
        pass

    def has_permission(self, user, permission):
        """Prüft, ob Benutzer Berechtigung hat."""
        pass

    def can_process(self, data):
        """Prüft, ob Daten verarbeitet werden können."""
        pass


# Konsistente Klassenbenennung: PascalCase
class UserValidator:
    """Validiert Benutzerdaten."""
    pass


class DataProcessor:
    """Verarbeitet Daten."""
    pass


class OrderHandler:
    """Behandelt Bestelloperationen."""
    pass


class HttpHelper:
    """HTTP-Hilfsklasse."""
    pass


class HttpClient:
    """HTTP-Client für API-Aufrufe."""
    pass


# Privat/intern: Einfacher Unterstrich-Präfix
class _InternalCache:
    """Interne Cache-Implementierung."""
    pass


def _helper_function():
    """Interne Hilfsfunktion."""
    pass

// Korrigiert: Konsistente C#-Namenskonventionen
public class FixedOrderService
{
    // Private Felder: Unterstrich-Präfix + camelCase
    private readonly IOrderRepository _orderRepository;
    private readonly ICustomerService _customerService;
    private readonly ILogger _logger;
    private readonly IValidator _validator;

    public FixedOrderService(
        IOrderRepository orderRepository,
        ICustomerService customerService,
        ILogger logger,
        IValidator validator)
    {
        _orderRepository = orderRepository;
        _customerService = customerService;
        _logger = logger;
        _validator = validator;
    }

    // Eigenschaften: PascalCase
    public int OrderCount { get; private set; }
    public string CustomerName { get; set; }
    public bool IsActive { get; set; }

    // Methoden: PascalCase mit Verb + Substantiv
    public void ProcessOrder(Order order)
    {
        ValidateOrder(order);
        // Verarbeiten...
    }

    public void ProcessPayment(Payment payment)
    {
        // Zahlung verarbeiten...
    }

    public void ValidateOrder(Order order)
    {
        _validator.Validate(order);
    }

    // Konsistente Parameterbenennung: camelCase, beschreibend
    public void UpdateOrder(Order order)
    {
        _orderRepository.Update(order);
    }

    public void DeleteOrder(Order order)
    {
        _orderRepository.Delete(order);
    }

    public void SaveOrder(Order order)
    {
        _orderRepository.Save(order);
    }

    // Async-Methoden: Async-Suffix
    public async Task<Order> GetOrderAsync(int orderId)
    {
        return await _orderRepository.GetByIdAsync(orderId);
    }

    public async Task<Customer> FetchCustomerAsync(int customerId)
    {
        return await _customerService.GetByIdAsync(customerId);
    }

    public async Task LoadDataAsync()
    {
        // Daten laden...
    }

    // Boolean-Methoden: Is, Has, Can-Präfixe
    public bool IsOrderValid(Order order)
    {
        return _validator.IsValid(order);
    }

    public bool HasDiscount(Order order)
    {
        return order.DiscountCode != null;
    }

    public bool CanProcess(Order order)
    {
        return IsOrderValid(order) && order.Status == OrderStatus.Pending;
    }
}

// Konsistente Interface-Benennung: I-Präfix
public interface IOrderRepository { }
public interface ICustomerService { }
public interface IValidator { }

// Konsistente Enum-Benennung: PascalCase
public enum OrderStatus
{
    Pending,
    Processing,
    Completed,
    Cancelled
}

---

CVE-Beispiele

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

---

Verwandte CWEs

• CWE-1078: Inappropriate Source Code Style or Formatting (Eltern)
• CWE-1006: Bad Coding Practices (Kategoriemitglied)
• CWE-1078: Inappropriate Source Code Style or Formatting (verwandt)

---

Referenzen

1. MITRE Corporation. "CWE-1099: Inconsistent Naming Conventions for Identifiers." https://cwe.mitre.org/data/definitions/1099.html
2. PEP 8 - Style Guide for Python Code.
3. Microsoft C# Naming Guidelines.
4. Google Java Style Guide.