# Sicherheitsrichtlinien

## Übersicht

Diese Richtlinien definieren Standards und Best Practices für sichere Softwareentwicklung im Projekt.

## Grundprinzipien

### 1. Defense in Depth

- Mehrere Sicherheitsschichten implementieren
- Nicht auf eine einzelne Sicherheitsmaßnahme vertrauen
- Fail-Safe-Mechanismen einbauen

### 2. Least Privilege

- Minimale Berechtigungen für Funktionen und Benutzer
- Ressourcenzugriff nur bei Bedarf gewähren
- Temporäre Berechtigungen nach Gebrauch entziehen

### 3. Input-Validierung

- Alle Benutzereingaben validieren und bereinigen
- Whitelist-Ansatz bevorzugen (erlaubte Eingaben definieren)
- Typprüfung und Formatvalidierung durchführen

```php
// Beispiel: Sichere Input-Validierung
public function processUserInput(string $input): string
{
    // Länge prüfen
    if (strlen($input) > 100) {
        throw new ValidationException('Input zu lang (max 100 Zeichen)');
    }

    // Inhalt validieren (Whitelist-Ansatz)
    if (!preg_match('/^[a-zA-Z0-9\s\-_]+$/', $input)) {
        throw new ValidationException('Input enthält ungültige Zeichen');
    }

    // Bereinigung
    return htmlspecialchars($input, ENT_QUOTES, 'UTF-8');
}
```

## Spezifische Sicherheitsmaßnahmen

### 1. SQL-Injection-Prävention

- Prepared Statements für alle Datenbankabfragen
- Keine dynamischen SQL-Queries
- ORM-Framework bevorzugen

```php
// Sicher
$stmt = $pdo->prepare("SELECT * FROM users WHERE email = ?");
$stmt->execute([$email]);

// Unsicher - NIEMALS SO MACHEN
$query = "SELECT * FROM users WHERE email = '{$email}'";
```

### 2. Cross-Site Scripting (XSS) Prävention

- Output-Escaping für alle benutzergenerierten Inhalte
- Content-Security-Policy (CSP) implementieren
- HttpOnly und Secure Flags für Cookies

```php
// Ausgabe in HTML
echo htmlspecialchars($userInput, ENT_QUOTES, 'UTF-8');

// Ausgabe in JavaScript
echo json_encode($userInput, JSON_HEX_TAG | JSON_HEX_APOS | JSON_HEX_QUOT | JSON_HEX_AMP);
```

### 3. Cross-Site Request Forgery (CSRF) Schutz

- CSRF-Token für alle ändernden Anfragen
- SameSite-Attribut für Cookies

```php
// CSRF-Token generieren
public function generateCsrfToken(): string
{
    $token = bin2hex(random_bytes(32));
    $_SESSION['csrf_token'] = $token;
    return $token;
}

// CSRF-Token validieren
public function validateCsrfToken(string $token): bool
{
    return hash_equals($_SESSION['csrf_token'] ?? '', $token);
}
```

### 4. Sichere Authentifizierung

- Passwörter mit starken Algorithmen hashen (Argon2id)
- Multi-Faktor-Authentifizierung anbieten
- Ratelimiting für Login-Versuche

```php
// Passwort hashen
public function hashPassword(string $password): string
{
    return password_hash($password, PASSWORD_ARGON2ID);
}

// Passwort verifizieren
public function verifyPassword(string $password, string $hash): bool
{
    return password_verify($password, $hash);
}
```

### 5. Sichere Datenspeicherung

- Sensible Daten verschlüsseln
- Separate Schlüssel für unterschiedliche Daten
- Schlüsselrotation implementieren

```php
// Daten verschlüsseln
public function encrypt(string $data, string $purpose): string
{
    $key = $this->getEncryptionKey($purpose);
    $nonce = random_bytes(SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);

    $cipher = sodium_crypto_secretbox(
        $data,
        $nonce,
        $key
    );

    return base64_encode($nonce . $cipher);
}

// Daten entschlüsseln
public function decrypt(string $encrypted, string $purpose): string
{
    $key = $this->getEncryptionKey($purpose);
    $decoded = base64_decode($encrypted);

    $nonce = mb_substr($decoded, 0, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES, '8bit');
    $cipher = mb_substr($decoded, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES, null, '8bit');

    return sodium_crypto_secretbox_open(
        $cipher,
        $nonce,
        $key
    );
}
```

## Sicherheitstests

### 1. Automatisierte Sicherheitstests

- Static Application Security Testing (SAST)
- Dynamic Application Security Testing (DAST)
- Dependency-Scanning für bekannte Schwachstellen

### 2. Penetrationstests

- Regelmäßige Sicherheitsaudits
- Manuelle Penetrationstests
- Bug-Bounty-Programme

## Sicherheitskultur

### 1. Entwicklerschulungen

- Regelmäßige Sicherheitsschulungen
- Code-Reviews mit Sicherheitsfokus
- Sicherheits-Champions im Team

### 2. Incident Response

- Sicherheitsvorfälle dokumentieren
- Prozess für Sicherheitsmeldungen
- Notfallpläne für Sicherheitsvorfälle

## Zusammenfassung

Sicherheit ist ein kontinuierlicher Prozess, keine einmalige Aufgabe. Diese Richtlinien sollten regelmäßig überprüft und aktualisiert werden, um neuen Bedrohungen zu begegnen.