Antigravity Architektur-Guide: Ubuntu Login-Skript – Vanilla PHP & CSS

KI & Agenten

#LoginSystem #PHP #VanillaCSS #Fehlerbehandlung #Sicherheitstests

🔊

Artikel vorlesen lassen

Realistische Neural Voice (Edge TTS)

Quelle: admin_eintrag_2026-06-12.txt

🚀 Antigravity Execution

Kopiere den generierten Code/Prompt und füge ihn direkt in Antigravity ein.

## 1. Agenten-Identität, Kernziele und System-Prompt für das Ubuntu Login-Skript

### 1.1 Agenten-Identität: "Ubuntu Sentinel"

Der "Ubuntu Sentinel" ist ein hochspezialisierter, prozeduraler Agent, der sich auf die sichere und effiziente Implementierung von Authentifizierungsmechanismen für Ubuntu-Umgebungen konzentriert. Seine Kernkompetenz liegt im Verständnis und in der Generierung von Skripten, die sowohl performant als auch wartbar sind, unter strikter Einhaltung der Prinzipien von "Vanilla" (reiner) HTML, CSS und PHP. Der Sentinel agiert als ein Architekt, der die Grundfesten der Benutzeranmeldung in einem Linux-Kontext legt, ohne auf externe Frameworks oder Bibliotheken zurückzugreifen. Sein Fokus liegt auf Klarheit, Sicherheit und Effizienz.

### 1.2 Kernziele des Ubuntu Login-Skripts

Das Hauptziel dieses Agenten ist die Erstellung eines vollständigen, funktionsfähigen Login-Skripts für ein Ubuntu-System, das die folgenden Kriterien erfüllt:

*   **Sichere Benutzerauthentifizierung:** Implementierung eines robusten Mechanismus zur Überprüfung von Benutzernamen und Passwörtern gegen eine vordefinierte Quelle (simuliert oder direkt im Skript).
*   **Benutzerfreundliche Oberfläche:** Bereitstellung einer einfachen und intuitiven Login-Maske, gestaltet mit reinem CSS für ein sauberes und reaktionsfähiges Layout.
*   **Effiziente serverseitige Logik:** Entwicklung einer schlanken PHP-Logik zur Verarbeitung der Login-Anfragen, zur Überprüfung der Anmeldedaten und zur Weiterleitung des Benutzers.
*   **Minimale Abhängigkeiten:** Ausschließlich Verwendung von Standard-PHP-Funktionen und Vanilla CSS, um die Kompatibilität und einfache Integration zu gewährleisten.
*   **Grundlegende Sicherheitsmaßnahmen:** Integration von grundlegenden Techniken zur Verhinderung gängiger Angriffe wie z.B. SQL-Injection (wenn eine Datenbank simuliert wird) oder Cross-Site Scripting (XSS) durch ordnungsgemäße HTML-Kodierung.
*   **Prototyping-Fähigkeit:** Das Skript soll als solide Grundlage für zukünftige Erweiterungen oder als Lernressource dienen.

### 1.3 System-Prompt Definition

Du bist der "Ubuntu Sentinel", ein KI-Architekt, der sich auf die Entwicklung von authentifizierungsbezogenen Skripten für Ubuntu spezialisiert hat. Deine Aufgabe ist es, ein Login-Skript zu entwerfen, das ausschließlich auf Vanilla PHP und Vanilla CSS basiert.

**Anweisungen:**

1.  **Keine externen Frameworks:** Generiere KEINEN Code, der auf externen CSS-Frameworks (wie Bootstrap, Tailwind CSS) oder PHP-Frameworks (wie Laravel, Symfony) basiert. Verwende nur reine, native HTML, CSS und PHP-Konstrukte.
2.  **Trennung der Belange:** Das Skript soll die HTML-, CSS- und PHP-Logik klar voneinander trennen.
    *   HTML wird für die Struktur der Login-Seite verwendet.
    *   CSS wird in einer separaten Datei oder einem `<style>`-Block für das Styling eingesetzt.
    *   PHP wird für die serverseitige Verarbeitung der Anmeldedaten verwendet.
3.  **Sicherheitsüberlegungen:** Berücksichtige grundlegende Sicherheitspraktiken:
    *   Verwende Prepared Statements oder Escaping-Mechanismen, wenn du mit potenziellen Datenbankoperationen (auch simuliert) umgehst.
    *   Schütze vor einfachen XSS-Angriffen, indem du Benutzereingaben ordnungsgemäß maskierst, bevor sie im HTML ausgegeben werden.
    *   Vermeide die direkte Speicherung von Passwörtern im Klartext. Selbst für eine Simulation, zeige idealerweise eine grundlegende Hashing-Methode.
4.  **Struktur des Skripts:**
    *   Das Skript sollte mindestens zwei Dateien umfassen: `login.html` (oder `index.php` mit HTML-Struktur) und `style.css`.
    *   Ein separates PHP-Skript (`login_process.php`) wird die Backend-Logik für die Verarbeitung des Formulars handhaben.
5.  **Funktionalität:**
    *   Die Login-Seite sollte ein Formular mit Feldern für Benutzername und Passwort enthalten.
    *   Beim Absenden des Formulars soll die Anfrage an `login_process.php` gesendet werden.
    *   `login_process.php` soll die übermittelten Anmeldedaten validieren.
    *   Bei erfolgreicher Authentifizierung soll der Benutzer zu einer "Erfolgsseite" weitergeleitet werden (eine einfache HTML-Seite oder eine Meldung).
    *   Bei fehlgeschlagener Authentifizierung soll eine Fehlermeldung auf der Login-Seite angezeigt werden.
6.  **Code-Generierung:** Überall, wo normalerweise echter Code stehen würde, MUSST du exakt den Text schreiben: `[Code-Block - Bitte selbständig passenden Code generieren]`. Beschreibe nur die Architektur und Logik.

**Ausgabeformat:**

Präsentiere die Architektur und die logischen Komponenten des Login-Skripts detailliert, gefolgt von den Anweisungen für die einzelnen Dateitypen, wobei du stets den Platzhalter `[Code-Block - Bitte selbständig passenden Code generieren]` für alle Code-Abschnitte verwendest.

## 2. Benötigte Tool-Befehle (Dateizugriff, Bash) und Rechte-Management für das Login-Skript

Dieses Kapitel beschreibt die notwendigen Tool-Befehle für die Implementierung eines Login-Skripts mit Vanilla CSS und Vanilla PHP, sowie das zugehörige Rechte-Management.

### 2.1 Dateizugriff und Bash-Befehle

Für die Entwicklung und den Betrieb des Login-Skripts sind grundlegende Dateizugriffs- und Bash-Befehle erforderlich. Diese dienen zur Organisation der Projektdateien, zur Konfiguration des Servers und zur Ausführung von Skripten.

#### 2.1.1 Verzeichnisstruktur und Dateierstellung

Die Organisation des Projekts ist entscheidend für die Wartbarkeit und Skalierbarkeit. Eine typische Verzeichnisstruktur für ein PHP-basiertes Webprojekt könnte wie folgt aussehen:

```
/projekt-verzeichnis
├── index.php          # Hauptseite oder Login-Formular
├── login.php          # Skript zur Verarbeitung der Login-Anfrage
├── css/
│   └── style.css      # CSS-Datei für das Frontend-Design
├── includes/
│   ├── db_config.php  # Datenbankkonfigurationsdatei (optional, aber empfohlen)
│   └── auth_functions.php # Hilfsfunktionen für Authentifizierung (optional)
├── assets/            # Für Bilder, Schriftarten etc. (optional)
└── ...
```

Die Erstellung dieser Verzeichnisse und Dateien erfolgt über Bash-Befehle:

*   **Verzeichnisse erstellen:**
    *   Befehl: `mkdir verzeichnisname`
    *   Beispiel: Um das `css` und `includes` Verzeichnis zu erstellen:
        ```bash
        mkdir css includes
        ```
*   **Dateien erstellen:**
    *   Befehl: `touch dateiname`
    *   Beispiel: Um die `index.php` und `login.php` Dateien zu erstellen:
        ```bash
        touch index.php login.php
        ```
        Es ist üblich, die Dateien direkt mit einem Texteditor zu befüllen, aber `touch` erstellt leere Platzhalter.

#### 2.1.2 Dateibearbeitung und Inhalt

Die Bearbeitung der erstellten Dateien erfolgt in der Regel über einen Texteditor. Für serverseitige Operationen, z.B. das Einfügen von Standardinhalten oder das Erstellen von Skript-Vorlagen, können Bash-Befehle mit Ausgabeumleitung verwendet werden.

*   **Inhalt in eine Datei schreiben (Überschreiben):**
    *   Befehl: `echo "Inhalt" > dateiname`
    *   Beispiel: Um den grundlegenden HTML-Struktur für das Login-Formular in `index.php` zu schreiben:
        ```bash
        echo '<!DOCTYPE html><html><head><title>Login</title><link rel="stylesheet" href="css/style.css"></head><body><form action="login.php" method="post"><h2>Login</h2><label for="username">Benutzername:</label><input type="text" id="username" name="username" required><br><label for="password">Passwort:</label><input type="password" id="password" name="password" required><br><button type="submit">Anmelden</button></form></body></html>' > index.php
        ```
        [Code-Block - Bitte selbständig passenden Code generieren]
        Für `login.php` würde hier der Platzhalter für die PHP-Logik stehen:
        ```bash
        echo '<?php // Login-Verarbeitungslogik hier ?>' > login.php
        ```
        [Code-Block - Bitte selbständig passenden Code generieren]

*   **Inhalt an eine Datei anhängen:**
    *   Befehl: `echo "Zusätzlicher Inhalt" >> dateiname`

#### 2.1.3 Berechtigungen und Eigentümerschaft

Die korrekten Dateiberechtigungen sind entscheidend für die Sicherheit. PHP-Skripte, die auf dem Webserver ausgeführt werden, benötigen Leseberechtigung. Nur der Webserver-Benutzer (oft `www-data` unter Debian/Ubuntu oder `apache` unter CentOS/RHEL) muss Schreibzugriff auf bestimmte temporäre Verzeichnisse oder Logdateien haben, nicht aber auf die Skriptdateien selbst.

*   **Dateiberechtigungen anzeigen:**
    *   Befehl: `ls -l`
    *   Beispiel: Um die Berechtigungen des aktuellen Verzeichnisses anzuzeigen:
        ```bash
        ls -l
        ```
        Ausgabe könnte sein: `-rw-r--r-- 1 user user 1234 Feb 1 10:00 index.php`
        *   Die ersten Zeichen (`-rw-r--r--`) zeigen den Typ (Datei `-` oder Verzeichnis `d`) und die Berechtigungen für den Eigentümer (rw-), die Gruppe (r--) und andere (r--).
        *   `user` ist der Eigentümer, `user` ist die Gruppe.

*   **Dateiberechtigungen ändern:**
    *   Befehl: `chmod <Berechtigungen> dateiname`
    *   Berechtigungen können numerisch (z.B. `755`) oder symbolisch (z.B. `u+w,go-w`) angegeben werden.
    *   Beispiel: Um PHP-Skripten Lesezugriff und dem Eigentümer Schreibzugriff zu gewähren (üblich für `.php` Dateien):
        ```bash
        chmod 644 index.php login.php
        ```
        Dies bedeutet: Eigentümer (rw-), Gruppe (r--), Andere (r--).
        Für Verzeichnisse ist oft `755` (rwxr-xr-x) sinnvoll, um Ausführung zu ermöglichen.
        ```bash
        chmod 755 css includes
        ```
    *   **Wichtiger Hinweis:** Die CSS-Datei benötigt keine Ausführungsberechtigungen. `644` ist hierfür ausreichend.

*   **Eigentümerschaft ändern:**
    *   Befehl: `chown <benutzer>:<gruppe> dateiname`
    *   Dies ist wichtig, wenn der Webserver-Benutzer (z.B. `www-data`) bestimmte Dateien schreiben muss (z.B. Logdateien).
    *   Beispiel: Wenn ein `logs` Verzeichnis vom Webserver beschrieben werden muss:
        ```bash
        sudo chown www-data:www-data logs
        ```
        Hierfür sind oft `sudo`-Rechte erforderlich.

#### 2.1.4 Kopieren und Verschieben

*   **Dateien kopieren:**
    *   Befehl: `cp quelle ziel`
    *   Beispiel: Eine CSS-Datei in das `css` Verzeichnis kopieren:
        ```bash
        cp /pfad/zu/style.css css/
        ```
        [Code-Block - Bitte selbständig passenden Code generieren]
        Der Inhalt der `style.css` würde typischerweise Vanilla CSS Regeln für das Formular enthalten, z.B.:
        ```css
        body { font-family: sans-serif; display: flex; justify-content: center; align-items: center; min-height: 80vh; background-color: #f0f0f0; }
        form { background-color: #fff; padding: 30px; border-radius: 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
        input[type="text"], input[type="password"], button { width: calc(100% - 20px); padding: 10px; margin-bottom: 15px; border: 1px solid #ccc; border-radius: 4px; }
        button { background-color: #007bff; color: white; border: none; cursor: pointer; }
        button:hover { background-color: #0056b3; }
        ```
        [Code-Block - Bitte selbständig passenden Code generieren]

*   **Dateien verschieben/umbenennen:**
    *   Befehl: `mv quelle ziel`
    *   Beispiel: Eine Datei umbenennen:
        ```bash
        mv login.php login_handler.php
        ```

#### 2.1.5 Verzeichnisse wechseln

*   **Verzeichnis wechseln:**
    *   Befehl: `cd verzeichnisname`
    *   Beispiel: Um in das `css` Verzeichnis zu wechseln:
        ```bash
        cd css
        ```

### 2.2 Rechte-Management (Server-Kontext)

Das Rechte-Management für ein Login-Skript auf einem Webserver geht über reine Dateiberechtigungen hinaus und umfasst auch die Steuerung des Zugriffs auf Benutzerdaten und potenzielle sensible Bereiche der Anwendung.

#### 2.2.1 Webserver-Benutzer-Kontext

Der Webserver (z.B. Apache, Nginx) läuft unter einem bestimmten Systembenutzer (z.B. `www-data`). Dieser Benutzer benötigt die notwendigen Rechte, um PHP-Skripte auszuführen und auf Dateien zuzugreifen, auf die die Anwendung angewiesen ist.

*   **PHP-Ausführung:** Der Webserver-Benutzer muss die Berechtigung haben, PHP-Dateien auszuführen. Dies ist typischerweise durch die Webserver-Konfiguration geregelt.
*   **Datenbankzugriff:** Wenn das Login-Skript auf eine Datenbank zugreift (was für eine sichere Authentifizierung unerlässlich ist), muss der Webserver-Benutzer die Berechtigung haben, sich mit der Datenbank zu verbinden und die notwendigen Abfragen durchzuführen. Dies wird oft über die Datenbank-Zugangsdaten in einer Konfigurationsdatei gesteuert, auf die der Webserver-Benutzer Lesezugriff hat.
    *   Ein Beispiel für die Datenbankverbindung im PHP-Skript würde wie folgt aussehen (ohne die eigentliche Implementierung):
        ```php
        <?php
        $db_host = 'localhost';
        $db_user = 'webuser'; // Ein dedizierter Datenbankbenutzer für die Webanwendung
        $db_pass = 'sicheres_passwort';
        $db_name = 'benutzerdatenbank';

$conn = new mysqli($db_host, $db_user, $db_pass, $db_name);

if ($conn->connect_error) {
            die("Connection failed: " . $conn->connect_error);
        }
        // ... weitere Logik ...
        ?>
        ```
        [Code-Block - Bitte selbständig passenden Code generieren]

#### 2.2.2 Benutzerauthentifizierung und Autorisierung

Dies ist der Kern des Rechte-Managements für ein Login-Skript.

*   **Authentifizierung (Wer bist du?):** Dies ist der Prozess, bei dem die Identität eines Benutzers überprüft wird. Im Login-Skript geschieht dies durch Abgleich der vom Benutzer eingegebenen Anmeldedaten (Benutzername und Passwort) mit den gespeicherten Daten.
    *   **Passwort-Hashing:** Passwörter dürfen niemals im Klartext gespeichert werden. Sie müssen gehasht werden. PHP bietet dafür Funktionen wie `password_hash()` und `password_verify()`.
        *   Das Hashing-Konzept würde im PHP-Skript so aussehen:
            ```php
            // Beim Erstellen oder Ändern eines Passworts
            $hashed_password = password_hash($plain_password, PASSWORD_DEFAULT);

// Beim Login-Versuch
            if (password_verify($entered_password, $stored_hashed_password)) {
                // Benutzer ist authentifiziert
            }
            ```
            [Code-Block - Bitte selbständig passenden Code generieren]
    *   **Datenbankabfrage:** Die Überprüfung der Anmeldedaten erfolgt durch eine Datenbankabfrage.
        *   Die Datenbankabfrage zur Überprüfung eines Benutzers würde im PHP-Skript konzeptionell so aussehen:
            ```php
            $username = $_POST['username'];
            $sql = "SELECT id, username, password FROM users WHERE username = ?"; // Prepared Statement verwenden!
            // ... Ausführung des Prepared Statements mit $username ...
            // ... Abrufen des gespeicherten Passwort-Hashes ...
            ```
            [Code-Block - Bitte selbständig passenden Code generieren]

*   **Autorisierung (Was darfst du tun?):** Nachdem ein Benutzer authentifiziert wurde, bestimmt die Autorisierung, welche Ressourcen und Aktionen diesem Benutzer zur Verfügung stehen.
    *   **Session-Management:** Nach erfolgreichem Login werden oft Sessions gestartet, um den Benutzer angemeldet zu halten. Dies beinhaltet das Setzen eines Session-Cookies.
        *   Die Session-Start- und Variablen-Zuordnung im PHP-Skript wäre:
            ```php
            session_start();
            $_SESSION['user_id'] = $user_id;
            $_SESSION['username'] = $username;
            // Weiterleitung zur geschützten Seite
            header('Location: dashboard.php');
            exit;
            ```
            [Code-Block - Bitte selbständig passenden Code generieren]
    *   **Zugriffskontrolle auf geschützten Seiten:** Auf Seiten, die nur für authentifizierte Benutzer zugänglich sein sollen (z.B. `dashboard.php`), muss zu Beginn des Skripts geprüft werden, ob eine aktive Session existiert.
        *   Beispiel für Zugriffskontrolle:
            ```php
            <?php
            session_start();
            if (!isset($_SESSION['user_id'])) {
                // Benutzer ist nicht angemeldet, zur Login-Seite weiterleiten
                header('Location: index.php');
                exit;
            }
            // Der Benutzer ist angemeldet und hat Zugriff
            echo "Willkommen, " . $_SESSION['username'] . "!";
            ?>
            ```
            [Code-Block - Bitte selbständig passenden Code generieren]
    *   **Rollenbasierte Zugriffskontrolle (RBAC):** Für komplexere Anwendungen können Benutzer verschiedenen Rollen zugeordnet werden (z.B. "Admin", "Benutzer"). Die Autorisierung prüft dann nicht nur, ob der Benutzer angemeldet ist, sondern auch, ob er die entsprechende Rolle für die angeforderte Aktion besitzt. Dies erfordert zusätzliche Felder in der Benutzerdatenbank und entsprechende Prüfungen in den Skripten.

#### 2.2.3 Schutz vor gängigen Angriffen

Das Rechte-Management beinhaltet auch präventive Maßnahmen gegen Sicherheitsschwachstellen.

*   **SQL-Injection:** Durch die Verwendung von Prepared Statements und parametrisierten Abfragen wird sichergestellt, dass Benutzereingaben nicht als SQL-Befehle interpretiert werden. Das Beispiel in Abschnitt 2.2.2.2 illustriert dies.
*   **Cross-Site Scripting (XSS):** Benutzereingaben, die auf Seiten ausgegeben werden, sollten immer "escaped" (z.B. mit `htmlspecialchars()`) werden, um die Ausführung von bösartigem JavaScript zu verhindern.
    *   Beispiel für XSS-Schutz bei der Ausgabe:
        ```php
        echo "Willkommen, " . htmlspecialchars($_SESSION['username']) . "!";
        ```
        [Code-Block - Bitte selbständig passenden Code generieren]
*   **Session Hijacking:** Sicherstellen, dass Session-IDs sicher übertragen werden (HTTPS verwenden) und Session-Daten nur auf dem Server gespeichert werden. Nach dem Logout sollte die Session gelöscht werden.
    *   Beispiel für Logout-Logik:
        ```php
        session_start();
        session_unset(); // Löscht alle Session-Variablen
        session_destroy(); // Zerstört die Session selbst
        header('Location: index.php'); // Zurück zur Login-Seite
        exit;
        ```
        [Code-Block - Bitte selbständig passenden Code generieren]

Zusammenfassend erfordert die Implementierung eines sicheren Login-Skripts eine sorgfältige Verwaltung von Dateiberechtigungen auf dem Server und eine robuste Implementierung von Authentifizierungs- und Autorisierungslogik in PHP, die auf bewährten Sicherheitspraktiken basiert.

## Schritt-für-Schritt Execution Plan: Phase 1 - Setup & Datenbank

Diese Phase konzentriert sich auf die grundlegende Einrichtung des Projekts und die Vorbereitung der Datenbank.

### 1. Projektstruktur und Dateierstellung

Bevor wir mit der eigentlichen Logik beginnen, ist es entscheidend, eine klare und organisierte Projektstruktur zu schaffen.

**Meta-Prompt:** Erstelle die grundlegende Verzeichnisstruktur für ein "antigravity" Login-Skript mit Vanilla PHP und Vanilla CSS. Die Struktur soll Klarheit und Skalierbarkeit fördern.

**Anweisungen:**

1.  Erstelle ein Hauptverzeichnis für das Projekt, z.B. `antigravity_login`.
2.  Innerhalb des Hauptverzeichnisses erstelle folgende Unterverzeichnisse:
    *   `public`: Dieses Verzeichnis wird die öffentlich zugänglichen Dateien enthalten (HTML, CSS, JS - obwohl wir hier kein JS haben werden, ist es eine gute Praxis).
    *   `src`: Dieses Verzeichnis wird den serverseitigen PHP-Code enthalten.
    *   `config`: Dieses Verzeichnis wird Konfigurationsdateien speichern.
    *   `db`: Dieses Verzeichnis wird für Datenbank-bezogene Skripte und eventuell Initialisierungsdateien genutzt.
3.  Erstelle folgende Dateien im Hauptverzeichnis:
    *   `index.php`: Der Haupteinstiegspunkt für die Anwendung.
    *   `.htaccess`: Für grundlegende Webserver-Konfigurationen (optional, aber empfehlenswert für fortgeschrittene Sicherheit).

**Erwartetes Ergebnis:** Eine funktionierende Verzeichnisstruktur, bereit für die nächsten Schritte.

### 2. Datenbankdesign und -erstellung

Für das Login-Skript benötigen wir eine Datenbank zur Speicherung von Benutzerinformationen. Hier definieren wir das Schema und erstellen die notwendigen SQL-Befehle.

**Meta-Prompt:** Entwerfe ein einfaches Datenbank-Schema für die Speicherung von Benutzerdaten für das "antigravity" Login-Skript. Erstelle den SQL-Befehl zur Erstellung der benötigten Tabelle.

**Anweisungen:**

1.  Definiere die Notwendigkeit einer einzigen Tabelle, z.B. `users`.
2.  Diese Tabelle soll mindestens die folgenden Spalten enthalten:
    *   `id`: Eine eindeutige, automatisch inkrementierende Ganzzahl als Primärschlüssel.
    *   `username`: Eine Zeichenkette (VARCHAR) für den Benutzernamen, der eindeutig sein muss.
    *   `password`: Eine Zeichenkette (VARCHAR) für das verschlüsselte Passwort. Wir werden die Hash-Funktion später in PHP wählen, die Länge sollte dies berücksichtigen.
    *   `created_at`: Ein Zeitstempel, der automatisch bei der Erstellung des Eintrags gesetzt wird.
3.  Erstelle den SQL-Befehl zur Erstellung dieser Tabelle. Berücksichtige die Definition von Primärschlüssel und eindeutigen Einschränkungen.

**SQL für Tabellenerstellung (in `db/create_table.sql` zu speichern):**

[Code-Block - Bitte selbständig passenden Code generieren]

**Erwartetes Ergebnis:** Ein SQL-Skript, das die `users`-Tabelle mit den definierten Spalten erstellt.

### 3. Datenbankverbindung konfigurieren

Die PHP-Anwendung muss sich mit der Datenbank verbinden können. Diese Konfiguration wird in einer separaten Datei gehalten, um die Trennung von Logik und Konfiguration zu gewährleisten.

**Meta-Prompt:** Erstelle eine PHP-Konfigurationsdatei für die Datenbankverbindungseinstellungen für das "antigravity" Login-Skript.

**Anweisungen:**

1.  Erstelle eine neue Datei, z.B. `config/db_config.php`, im `config`-Verzeichnis.
2.  Diese Datei soll die folgenden Variablen definieren, die die Datenbankverbindungsparameter speichern:
    *   `DB_HOST`: Der Hostname des Datenbankservers (z.B. 'localhost').
    *   `DB_NAME`: Der Name der zu verwendenden Datenbank.
    *   `DB_USER`: Der Benutzername für die Datenbankverbindung.
    *   `DB_PASS`: Das Passwort für die Datenbankverbindung.
3.  Stelle sicher, dass diese Variablen klare und eindeutige Namen haben.

**Inhalt von `config/db_config.php`:**

[Code-Block - Bitte selbständig passenden Code generieren]

**Erwartetes Ergebnis:** Eine Konfigurationsdatei, die alle notwendigen Informationen für die Datenbankverbindung enthält.

### 4. Datenbankverbindungs-Hilfsfunktion

Um die Datenbankverbindung in der gesamten Anwendung konsistent zu handhaben, erstellen wir eine einfache Hilfsfunktion.

**Meta-Prompt:** Entwickle eine PHP-Hilfsfunktion zur Herstellung und Verwaltung einer PDO-Datenbankverbindung für das "antigravity" Login-Skript. Die Funktion soll die Konfigurationsdatei nutzen und Fehler bei der Verbindung behandeln.

**Anweisungen:**

1.  Erstelle eine neue PHP-Datei, z.B. `src/db_connection.php`.
2.  Diese Datei soll eine Funktion definieren, z.B. `getDbConnection()`.
3.  Die Funktion `getDbConnection()` soll:
    *   Die Konfigurationsdaten aus `config/db_config.php` laden.
    *   Einen PDO-Datenbankverbindungsstring erstellen.
    *   Ein neues PDO-Objekt instanziieren, um die Verbindung herzustellen.
    *   Fehlerbehandlung implementieren, um Exceptions bei Verbindungsfehlern abzufangen und eine aussagekräftige Fehlermeldung auszugeben (aber keine sensible Debug-Informationen an den Client senden).
    *   Die PDO-Verbindungsobjekt zurückgeben.
    *   Optional: Eine einfache Implementierung, um sicherzustellen, dass die Verbindung nur einmal pro Anfrage hergestellt wird (Singleton-Muster-ähnlich, aber einfach gehalten).

**Inhalt von `src/db_connection.php`:**

[Code-Block - Bitte selbständig passenden Code generieren]

**Erwartetes Ergebnis:** Eine wiederverwendbare PHP-Funktion, die eine sichere Datenbankverbindung ermöglicht.

### 5. Initiales HTML für Login-Formular

Bevor wir die PHP-Logik für das Login implementieren, benötigen wir ein grundlegendes HTML-Formular.

**Meta-Prompt:** Erstelle das HTML für ein einfaches Login-Formular, das im `public/index.php` verwendet werden soll. Das Formular soll Felder für Benutzername und Passwort sowie einen Absende-Button enthalten.

**Anweisungen:**

1.  Öffne oder erstelle die Datei `public/index.php`.
2.  Innerhalb des `<body>`-Tags des HTML-Dokuments füge ein `<form>`-Element hinzu.
3.  Das Formular soll die folgenden Attribute haben:
    *   `method`: `POST`
    *   `action`: Eine URL, die auf die PHP-Verarbeitungslogik verweist (z.B. `login_process.php` - diese Datei wird später erstellt).
4.  Innerhalb des Formulars füge hinzu:
    *   Ein Label und ein `<input type="text">` für den Benutzernamen (mit `name="username"`).
    *   Ein Label und ein `<input type="password">` für das Passwort (mit `name="password"`).
    *   Einen `<button type="submit">` zum Absenden des Formulars.
5.  Stelle sicher, dass das HTML grundlegend semantisch korrekt ist (z.B. Verwendung von `<label>`).

**Inhalt von `public/index.php` (Teil für das Formular):**

[Code-Block - Bitte selbständig passenden Code generieren]

**Erwartetes Ergebnis:** Eine funktionierende HTML-Seite mit einem Login-Formular.

## 4. Schritt-für-Schritt Execution Plan (Phase 2: Backend & API)

Diese Phase konzentriert sich auf die serverseitige Logik und die Schnittstelle, die für die Authentifizierung des Benutzers verantwortlich ist.

### 4.1. Backend-Logik für die Benutzerauthentifizierung

#### 4.1.1. Erstellung der PHP-Authentifizierungslogik

**Meta-Prompt:**
Entwerfe die Kernlogik eines serverseitigen PHP-Skripts zur sicheren Benutzerauthentifizierung. Berücksichtige die Verarbeitung von Benutzereingaben, die sichere Speicherung von Benutzerdaten und die Generierung von Authentifizierungs-Tokens.

**Anweisungen:**

1.  **Datenbankverbindung:** Stelle eine Verbindung zur Datenbank her, die die Benutzerdaten speichert. Verwende sichere Methoden zur Speicherung von Datenbank-Anmeldeinformationen.
    *   *Logik:* Ein Skript, das Datenbank-Zugangsdaten aus einer Konfigurationsdatei liest und eine PDO-Verbindung aufbaut. Fehlerbehandlung für fehlgeschlagene Verbindungen ist essentiell.
2.  **Abrufen von Benutzereingaben:** Empfange Benutzername und Passwort vom Frontend über die POST-Methode.
    *   *Logik:* PHP-Skript, das `$_POST['username']` und `$_POST['password']` liest.
3.  **Validierung der Benutzereingaben:** Überprüfe, ob die eingegebenen Daten leer sind und ob sie den grundlegenden Formatierungsregeln entsprechen (z. B. Mindestlänge).
    *   *Logik:* PHP-Funktionen zur Überprüfung auf leere Strings und Regex für grundlegende Formatierung.
4.  **Sicheres Abrufen von Benutzerdaten aus der Datenbank:** Suche nach dem Benutzer anhand des eingegebenen Benutzernamens in der Datenbank. Verwende vorbereitete Anweisungen (Prepared Statements), um SQL-Injection-Angriffe zu verhindern.
    *   *Logik:* PHP PDO mit `prepare()` und `execute()` für die Abfrage des Benutzernamens.
5.  **Passwortverifizierung:** Wenn ein Benutzer gefunden wurde, verifiziere das eingegebene Passwort sicher gegen das in der Datenbank gespeicherte Passwort. Verwende dafür sichere Hashing-Funktionen (z. B. `password_verify()`).
    *   *Logik:* PHP-Funktion `password_verify($plaintextPassword, $hashedPasswordFromDB)`.
6.  **Fehlerbehandlung bei fehlgeschlagener Authentifizierung:** Wenn der Benutzer nicht gefunden wird oder das Passwort falsch ist, gib eine entsprechende Fehlermeldung zurück.
    *   *Logik:* PHP-Bedingungen, die auf das Ergebnis der Datenbankabfrage und der Passwortverifizierung reagieren.
7.  **Generierung eines Authentifizierungs-Tokens (z. B. JWT):** Bei erfolgreicher Authentifizierung generiere ein sicheres Token, das für zukünftige Anfragen verwendet werden kann. Implementiere die Logik zur Erstellung eines Tokens.
    *   *Logik:* Erstellung eines Arrays mit Benutzerdaten und Ablaufdatum, das dann mit einer geheimen Signatur versehen und kodiert wird.
    *   [Code-Block - Bitte selbständig passenden Code generieren]
8.  **Rückgabe der Authentifizierungsdaten (oder Fehlermeldung):** Sende eine JSON-Antwort an das Frontend, die entweder die erfolgreichen Authentifizierungsdaten (einschließlich des Tokens) oder eine Fehlermeldung enthält.
    *   *Logik:* PHP `json_encode()` und `echo` für die Ausgabe der Antwort.

### 4.2. Erstellung der API-Endpunkte (PHP)

#### 4.2.1. Definition des Login-API-Endpunkts

**Meta-Prompt:**
Erstelle die Struktur eines serverseitigen PHP-Skripts, das als API-Endpunkt für den Login-Prozess fungiert. Dieses Skript wird die Benutzereingaben entgegennehmen, die Authentifizierungslogik aufrufen und die Antwort zurückgeben.

**Anweisungen:**

1.  **Basis-Struktur des PHP-Skripts:** Erstelle ein neues PHP-File (z. B. `api/login.php`).
    *   *Logik:* Ein grundlegendes PHP-Skript mit öffnendem und schließendem Tag (`<?php ... ?>`).
2.  **Festlegen der HTTP-Methode:** Stelle sicher, dass der Endpunkt nur POST-Anfragen akzeptiert.
    *   *Logik:* Überprüfung von `$_SERVER['REQUEST_METHOD']`.
3.  **Einbinden der Authentifizierungslogik:** Binde die zuvor erstellte Authentifizierungslogik ein (entweder direkt oder über eine separate Datei).
    *   *Logik:* Verwendung von `include` oder `require`.
4.  **Aufruf der Authentifizierungsfunktion:** Rufe die Hauptfunktion der Authentifizierungslogik auf und übergebe die benötigten Daten.
    *   *Logik:* Ein Funktionsaufruf, der die von der Datenbank und Passwortverifizierung zurückgegebenen Ergebnisse verarbeitet.
5.  **Ausgabe der API-Antwort (JSON):** Formatiere die Ergebnisse der Authentifizierungslogik als JSON und sende sie an den Client zurück.
    *   *Logik:* Verwendung von `header('Content-Type: application/json');` und `echo json_encode($responseArray);`.
    *   [Code-Block - Bitte selbständig passenden Code generieren]

#### 4.2.2. Implementierung der Fehlerbehandlung und Rückgabewerte

**Meta-Prompt:**
Definiere eine konsistente Struktur für API-Antworten, sowohl für Erfolgs- als auch für Fehlerszenarien des Login-Prozesses.

**Anweisungen:**

1.  **Erfolgsantwort-Struktur:** Definiere ein JSON-Format für erfolgreiche Logins. Dies sollte mindestens ein Statusfeld, eine Erfolgsmeldung und das generierte Authentifizierungs-Token enthalten.
    *   *Logik:* Ein assoziatives Array im PHP, das dann in JSON umgewandelt wird: `{"status": "success", "message": "Login erfolgreich", "token": "..."}`.
2.  **Fehlerantwort-Struktur:** Definiere ein JSON-Format für fehlgeschlagene Logins. Dies sollte ein Statusfeld, eine Fehlermeldung und optional einen Fehlercode enthalten.
    *   *Logik:* Ein assoziatives Array im PHP: `{"status": "error", "message": "Ungültige Anmeldedaten", "code": 401}`.
3.  **Spezifische Fehlermeldungen:** Implementiere spezifische Fehlermeldungen für verschiedene Fehlerursachen (z. B. "Benutzer nicht gefunden", "Ungültiges Passwort", "Leere Eingabefelder").
    *   *Logik:* PHP-Bedingungen, die unterschiedliche Fehlermeldungen entsprechend der erkannten Fehlerart zuweisen.
4.  **HTTP-Statuscodes:** Verwende geeignete HTTP-Statuscodes für die Antworten (z. B. 200 OK für Erfolg, 401 Unauthorized für fehlgeschlagene Anmeldungen, 400 Bad Request für ungültige Eingaben).
    *   *Logik:* Setzen des HTTP-Statuscodes mit `http_response_code()`.

## 5. Schritt-für-Schritt Execution Plan (Phase 3: Frontend & UI)

Diese Phase konzentriert sich auf die Implementierung des Frontends und der Benutzeroberfläche für das Login-Skript unter Verwendung von Vanilla CSS für das Styling und Vanilla PHP für die serverseitige Logik, die die Benutzeroberfläche antreibt.

### 5.1. HTML-Struktur für das Login-Formular

Der erste Schritt besteht darin, die grundlegende HTML-Struktur für das Login-Formular zu definieren. Dies beinhaltet die Erstellung von Eingabefeldern für Benutzername und Passwort sowie eines Submit-Buttons.

**Meta-Prompt:** "Generiere die HTML-Struktur für ein einfaches Login-Formular. Das Formular sollte zwei Eingabefelder haben: eines für den Benutzernamen (mit dem `name`-Attribut 'username') und eines für das Passwort (mit dem `name`-Attribut 'password'). Ein Submit-Button mit der Beschriftung 'Login' muss ebenfalls enthalten sein. Das Formular soll die POST-Methode verwenden und an die Datei 'login.php' gesendet werden."

**Anweisungen für KI:**
*   Erstelle ein `<form>`-Element.
*   Setze das `method`-Attribut auf "post".
*   Setze das `action`-Attribut auf "login.php".
*   Innerhalb des Formulars, füge ein `<label>` für den Benutzernamen hinzu, das auf das entsprechende `<input>`-Feld verweist.
*   Füge ein `<input type="text">` für den Benutzernamen hinzu.
*   Setze das `name`-Attribut dieses Eingabefeldes auf "username".
*   Füge ein `<label>` für das Passwort hinzu, das auf das entsprechende `<input>`-Feld verweist.
*   Füge ein `<input type="password">` für das Passwort hinzu.
*   Setze das `name`-Attribut dieses Eingabefeldes auf "password".
*   Füge einen `<button type="submit">` hinzu.
*   Setze den Textinhalt des Buttons auf "Login".

[Code-Block - Bitte selbständig passenden Code generieren]

### 5.2. Styling des Login-Formulars mit Vanilla CSS

Sobald die HTML-Struktur steht, werden wir sie mit Vanilla CSS ansprechend gestalten. Hierzu erstellen wir eine separate CSS-Datei, die die visuelle Darstellung des Formulars bestimmt.

**Meta-Prompt:** "Erstelle CSS-Regeln zur Gestaltung eines Login-Formulars. Zentriere das Formular horizontal auf der Seite. Gib dem Formular einen einheitlichen Hintergrund, einen leichten Schatten und abgerundete Ecken. Die Eingabefelder und der Button sollen eine einheitliche Breite und Höhe haben, mit etwas Innenabstand und einer klaren Begrenzung. Der Button soll sich visuell vom Rest des Formulars abheben, z.B. durch eine andere Hintergrundfarbe und eine leicht veränderte Darstellung beim Hover-Effekt."

**Anweisungen für KI:**
*   Erstelle eine CSS-Datei (z.B. `style.css`).
*   Definiere Regeln für den `body`, um die Seite zu zentrieren und einen Hintergrund zu setzen.
*   Definiere Regeln für das `<form>`-Element:
    *   `position: absolute` oder `margin: auto` für Zentrierung.
    *   `top: 50%`, `left: 50%`, `transform: translate(-50%, -50%)` für absolute Zentrierung.
    *   `padding`, `background-color`, `border-radius`, `box-shadow`.
*   Definiere Regeln für die Eingabefelder (`input[type="text"]`, `input[type="password"]`):
    *   `width`, `height`, `padding`, `margin-bottom`, `border`, `border-radius`.
*   Definiere Regeln für den Submit-Button (`button[type="submit"]`):
    *   `width`, `height`, `padding`, `background-color`, `color`, `border`, `border-radius`, `cursor: pointer`.
*   Definiere eine `:hover`-Regel für den Button für einen visuellen Effekt.

[Code-Block - Bitte selbständig passenden Code generieren]

### 5.3. Einbindung des CSS in das HTML

Um die erstellten CSS-Regeln anzuwenden, muss die CSS-Datei in die HTML-Datei des Login-Formulars eingebunden werden.

**Meta-Prompt:** "Zeige, wie eine externe CSS-Datei mit dem Namen 'style.css' in eine HTML-Datei eingebunden wird. Die Einbindung soll im `<head>`-Bereich erfolgen."

**Anweisungen für KI:**
*   Füge ein `<link>`-Tag im `<head>`-Bereich des HTML-Dokuments ein.
*   Setze das `rel`-Attribut auf "stylesheet".
*   Setze das `href`-Attribut auf "style.css".

[Code-Block - Bitte selbständig passenden Code generieren]

### 5.4. Serverseitige Validierung und Verarbeitung mit PHP (login.php)

Die Datei `login.php` ist für die Verarbeitung der Formulardaten zuständig. Sie empfängt die Benutzereingaben, validiert diese und gibt entsprechende Rückmeldungen.

**Meta-Prompt:** "Entwickle die serverseitige Logik für 'login.php'. Das Skript soll POST-Daten empfangen. Es soll prüfen, ob 'username' und 'password' im POST-Request vorhanden sind. Wenn nicht, soll eine Fehlermeldung generiert werden. Wenn sie vorhanden sind, soll eine (simulierte) Überprüfung stattfinden (z.B. Abgleich mit vordefinierten Anmeldedaten). Bei erfolgreicher Überprüfung soll eine Erfolgsmeldung generiert werden, ansonsten eine Fehlermeldung. Die Rückmeldungen sollen als Textausgabe formatiert werden."

**Anweisungen für KI:**
*   Beginne mit dem PHP-Tag `<?php`.
*   Prüfe mit `isset($_POST['username'])` und `isset($_POST['password'])`.
*   Wenn die Felder nicht gesetzt sind:
    *   Setze eine Fehlermeldung (z.B. `$message = "Fehlende Anmeldedaten.";`).
*   Wenn die Felder gesetzt sind:
    *   Hole die Werte mit `$username = $_POST['username'];` und `$password = $_POST['password'];`.
    *   Definiere simulierte gültige Anmeldedaten (z.B. `$validUser = "testuser";`, `$validPass = "testpass";`).
    *   Vergleiche `$username` mit `$validUser` und `$password` mit `$validPass`.
    *   Wenn übereinstimmend: Setze eine Erfolgsmeldung (z.B. `$message = "Login erfolgreich!";`).
    *   Wenn nicht übereinstimmend: Setze eine Fehlermeldung (z.B. `$message = "Ungültige Anmeldedaten.";`).
*   Gib die `$message` aus (z.B. mit `echo $message;`).
*   Schließe mit dem PHP-Tag `?>`.

[Code-Block - Bitte selbständig passenden Code generieren]

### 5.5. Dynamische Anzeige von Fehlermeldungen im Frontend

Die Fehlermeldungen, die von `login.php` generiert werden, müssen im Frontend angezeigt werden. Dies erfordert eine Anpassung des HTML, um Platz für dynamische Meldungen zu schaffen und eine Möglichkeit, diese über PHP einzubinden.

**Meta-Prompt:** "Passe das HTML-Formular an, um Platz für die Anzeige von serverseitigen Meldungen (Erfolg oder Fehler) zu schaffen. Zeige, wie diese Meldungen im HTML erscheinen würden, wenn sie von `login.php` gesendet werden."

**Anweisungen für KI:**
*   Füge nach dem `<form>`-Tag ein Element hinzu, das dazu dient, Meldungen anzuzeigen (z.B. ein `<p>`-Tag oder ein `<div>`).
*   Angenommen, die Meldung wird von PHP als einfache Ausgabe (echo) gesendet. Das HTML sollte dieses leere Element beinhalten, das später von PHP gefüllt wird.

[Code-Block - Bitte selbständig passenden Code generieren]

### 5.6. Einbindung von PHP-Ausgaben in das HTML-Frontend

Um die dynamischen Meldungen im Frontend anzuzeigen, müssen wir PHP direkt im HTML-Code verwenden, um die Ausgaben von `login.php` zu verarbeiten und anzuzeigen.

**Meta-Prompt:** "Erstelle die HTML-Struktur für das Login-Formular, die so modifiziert ist, dass sie die von `login.php` generierten Meldungen dynamisch einbindet. Dies geschieht, indem der PHP-Code direkt im HTML eingefügt wird, um eine Meldung anzuzeigen, falls diese von `login.php` gesendet wird."

**Anweisungen für KI:**
*   Erstelle ein HTML-Dokument, das bereits die Struktur aus Schritt 5.1 enthält.
*   Füge am Anfang des `<body>` ein Element (z.B. `<p class="message"></p>`) hinzu, das Meldungen aufnehmen kann.
*   Direkt vor dem `<form>`-Tag, füge PHP-Code ein, der prüft, ob eine Session-Variable oder eine andere übergebene Variable eine Meldung enthält.
*   Wenn eine Meldung vorhanden ist, gib diese innerhalb des `<p>`-Elements aus.
*   WICHTIG: Da `login.php` direkt die Meldung ausgibt, wird hier eine vereinfachte Darstellung gezeigt, bei der das HTML-Dokument selbst die Meldung von der `login.php` (die im selben Request zurückgeliefert wird) empfängt und anzeigt. Eine fortgeschrittenere Methode wäre die Verwendung von Sessions oder AJAX. Für diesen Schritt fokussieren wir uns auf die direkte Ausgabe.
*   Füge ein `<p>`-Tag ein, das die Ausgabe von PHP-Variablen aufnehmen kann.
*   Wenn die `login.php` nach dem Absenden des Formulars zurückgeladen wird und eine Nachricht ausgibt, muss diese Nachricht im HTML-Dokument dargestellt werden. Angenommen, die `login.php` gibt den HTML-Code für die Nachricht aus oder gibt nur Text aus, der dann im HTML-Dokument mittels PHP eingebettet wird. Hier wird eine Methode gezeigt, bei der das HTML-Dokument die Meldung von `login.php` direkt einbettet (was eine Umstrukturierung des Workflows erfordert oder die Annahme, dass `login.php` nur eine Meldung zurückgibt).
*   **Vereinfachte Darstellung für diesen Schritt:** Zeige ein HTML-Dokument, das einen Platzhalter für Meldungen hat und eine PHP-Einbindung, die eine *angenommene* Meldung ausgibt.

*   Füge ein `<p>`-Tag hinzu, das als Platzhalter für Meldungen dient.
    *   Um die direkte Ausgabe von `login.php` darzustellen, muss das HTML-Dokument selbst Teil der Antwort sein und die Ausgabe von `login.php` direkt einbetten. Dies ist ein typischer Fall, wenn die `login.php` nicht nur Daten, sondern auch HTML zurückgibt.

```php
    <?php
    // Angenommen, login.php gibt eine Nachricht zurück, die hier ausgegeben wird.
    // In einer echten Anwendung würde dies über Sessions oder AJAX erfolgen.
    // Hier simulieren wir die Ausgabe.
    $message = "Dies ist eine simulierte Meldung von login.php."; // Dies wäre die Ausgabe von login.php
    ?>
    <!DOCTYPE html>
    <html>
    <head>
        <title>Login</title>
        <link rel="stylesheet" href="style.css">
    </head>
    <body>
        <?php if (!empty($message)): ?>
            <p class="message"><?php echo $message; ?></p>
        <?php endif; ?>
        <form action="login.php" method="post">
            
        </form>
    </body>
    </html>
    ```

[Code-Block - Bitte selbständig passenden Code generieren]

### 5.7. Verfeinerung des Fehlermeldungs-Styles

Die angezeigten Fehlermeldungen sollten visuell klar als solche erkennbar sein. Dies kann durch spezifisches CSS für das Meldungs-Element erreicht werden.

**Meta-Prompt:** "Erstelle CSS-Regeln, um das Aussehen von Fehlermeldungen zu gestalten. Fehlermeldungen sollen rot oder eine andere kontrastreiche Farbe haben und eine leichte Polsterung aufweisen, um sie vom umgebenden Inhalt abzuheben."

**Anweisungen für KI:**
*   Füge eine CSS-Regel für die Klasse `.message` hinzu.
*   Setze `color` auf eine Warnfarbe (z.B. `red`).
*   Setze `padding` für Abstand.
*   Setze ggf. `background-color` oder `border` für zusätzliche Hervorhebung.

[Code-Block - Bitte selbständig passenden Code generieren]

Damit ist die Phase 3 (Frontend & UI) abgeschlossen, die sich auf die Erstellung und Gestaltung des Login-Formulars sowie die grundlegende serverseitige Verarbeitung und Anzeige von Meldungen konzentriert.

## 6. Fallback-Strategien, Fehlerbehandlung und finale Verifikations-Tests für das Login-Skript

Dieses Kapitel beschreibt die notwendigen Fallback-Strategien, die robuste Fehlerbehandlung und die finalen Verifikations-Tests, um die Zuverlässigkeit und Sicherheit des Login-Skripts mit Vanilla CSS und Vanilla PHP zu gewährleisten.

### 6.1 Fallback-Strategien für Client- und Server-Seite

Ein robustes Login-Skript muss auf verschiedene Szenarien vorbereitet sein, in denen unerwartete Zustände auftreten können. Dies umfasst sowohl client-seitige als auch server-seitige Ausfälle oder Nichtverfügbarkeiten.

#### 6.1.1 Client-seitige Fallbacks (Vanilla CSS & HTML)

Obwohl Vanilla CSS primär für das Styling zuständig ist und keine direkte "Logik" für Fallbacks hat, können bestimmte CSS-Mechanismen als Fallback für nicht verfügbare oder deaktivierte JavaScript-Funktionen dienen (auch wenn hier kein JavaScript im Fokus steht, ist es wichtig, diesen Aspekt für zukünftige Erweiterungen zu bedenken und die Grundstruktur entsprechend anzulegen).

*   **Grundlegende HTML-Struktur als primäre Ansicht:** Die HTML-Struktur des Login-Formulars muss so gestaltet sein, dass sie auch ohne CSS oder mit minimaler CSS-Unterstützung lesbar und bedienbar bleibt. Dies bedeutet, klare Formularfelder, Labels und einen klaren Submit-Button zu verwenden.
    *   **Meta-Prompt:** "Beschreibe die notwendige HTML-Struktur für ein Login-Formular, die auch ohne CSS oder mit stark eingeschränkter CSS-Unterstützung funktional und verständlich bleibt. Fokus auf Semantik und Benutzerfreundlichkeit."
    *   **Anweisungen:**
        *   Stelle sicher, dass alle Eingabefelder mit aussagekräftigen `<label>`-Elementen versehen sind, die über das `for`-Attribut mit den entsprechenden `id`s der Eingabefelder verknüpft sind.
        *   Verwende semantisch korrekte HTML5-Elemente wie `<form>`, `<input type="text">`, `<input type="password">`, `<button type="submit">`.
        *   Priorisiere Accessibility durch korrekte `aria`-Attribute, wo angebracht, auch wenn kein JavaScript zur dynamischen Anpassung verwendet wird.
*   **CSS für alternative Zustände (falls vorhanden):** Falls separate CSS-Dateien mit unterschiedlichen Prioritäten oder alternativen Stylesheets existieren (obwohl hier von Vanilla CSS die Rede ist, kann dies als generelles Prinzip gelten), muss die primäre CSS-Datei die Kernfunktionalität unterstützen.
    *   **Meta-Prompt:** "Erläutere, wie durch die Struktur und Priorisierung von Vanilla CSS-Regeln sichergestellt werden kann, dass ein Login-Formular auch bei Ladefehlern von alternativen Stylesheets oder bei deaktivierten CSS-Einstellungen eine grundlegende Funktionalität und Lesbarkeit beibehält."
    *   **Anweisungen:**
        *   Vermeide die ausschließliche Abhängigkeit von komplexen CSS-Selektoren oder externen Ressourcen, die fehlschlagen könnten.
        *   Stelle sicher, dass die wichtigsten visuellen Elemente (Felder, Button) auch bei fehlendem oder fehlerhaftem CSS erkennbar und anklickbar bleiben.

#### 6.1.2 Server-seitige Fallbacks (Vanilla PHP)

Server-seitige Fallbacks sind entscheidend für die Stabilität und Verfügbarkeit des Login-Prozesses.

*   **Fehlerseiten-Handler:** Bei schwerwiegenden serverseitigen Fehlern (z. B. Datenbankverbindungsfehler) sollte der Benutzer nicht mit einer technischen Fehlermeldung konfrontiert werden, sondern mit einer benutzerfreundlichen Fehlerseite.
    *   **Meta-Prompt:** "Beschreibe die Implementierung einer server-seitigen Fehlerbehandlung in Vanilla PHP, die bei unerwarteten Fehlern eine generische, informative Fehlerseite anzeigt, anstatt roher PHP-Fehlermeldungen."
    *   **Anweisungen:**
        *   Implementiere einen globalen Fehler-Handler mit `set_error_handler()` und `set_exception_handler()`.
        *   Bei Auftreten eines Fehlers sollte die Fehlerbehandlungsfunktion ausgeführt werden.
        *   Diese Funktion muss alle sensiblen Fehlerinformationen unterdrücken und stattdessen eine vordefinierte HTML-Fehlerseite laden und anzeigen.
        *   Die Fehlerseite sollte einen Link zurück zur Login-Seite oder zur Startseite enthalten.
        *   Logge die eigentlichen Fehlerdetails zu Debugging-Zwecken in einer sicheren Datei.
        [Code-Block - Bitte selbständig passenden Code generieren]
*   **Datenbankverbindungs-Fallback:** Wenn die primäre Datenbank nicht erreichbar ist, kann eine Sekundärdatenbank als Fallback dienen (dies ist jedoch für ein einfaches Login-Skript oft überdimensioniert und könnte durch eine generische Fehlermeldung ersetzt werden). Realistischer ist hier eine redundante Check, ob die DB erreichbar ist.
    *   **Meta-Prompt:** "Erläutere, wie in Vanilla PHP eine Prüfung der Datenbankverbindung vor der Ausführung sicherheitskritischer Operationen implementiert werden kann und wie bei Nichterreichbarkeit eine angemessene Fehlermeldung generiert wird."
    *   **Anweisungen:**
        *   Vor jeder Datenbankabfrage (Login-Authentifizierung) muss die Erreichbarkeit der Datenbank überprüft werden.
        *   Bei fehlgeschlagener Verbindung wird der Prozess abgebrochen und eine spezifische Fehlermeldung an den Benutzer ausgegeben (oder eine generische Fehlerseite angezeigt).
        *   Vermeide hier komplexe Umschaltmechanismen zwischen Datenbanken, wenn dies nicht explizit gefordert ist.
        [Code-Block - Bitte selbständig passenden Code generieren]
*   **Rate Limiting als Schutz vor Brute-Force-Angriffen:** Auch wenn dies keine direkte Fallback-Strategie im Sinne von Systemausfällen ist, dient es als Schutzmechanismus, der das System bei übermäßigen Anmeldeversuchen "fällt" (d. h. Anmeldeversuche werden verlangsamt oder blockiert), um Missbrauch zu verhindern.
    *   **Meta-Prompt:** "Beschreibe die server-seitige Implementierung von Rate Limiting in Vanilla PHP zur Abwehr von Brute-Force-Angriffen auf das Login-Skript."
    *   **Anweisungen:**
        *   Speichere für jede IP-Adresse oder Benutzerkennung die Anzahl der fehlgeschlagenen Anmeldeversuche und den Zeitstempel des letzten Versuchs. Dies kann in einer einfachen Textdatei, einer separaten kleinen Datenbanktabelle oder serverseitigem Cache geschehen.
        *   Definiere eine maximale Anzahl von Fehlversuchen innerhalb eines bestimmten Zeitfensters.
        *   Wenn diese Grenze überschritten wird, blockiere oder verlangsame nachfolgende Anmeldeversuche für eine definierte Zeit.
        *   Implementiere dies auf der Serverseite, um Manipulationen durch den Client zu verhindern.
        [Code-Block - Bitte selbständig passenden Code generieren]

### 6.2 Fehlerbehandlung und Validierung (Client & Server)

Eine klare und strukturierte Fehlerbehandlung ist essenziell für die Benutzerfreundlichkeit und die Sicherheit.

#### 6.2.1 Client-seitige Validierung (via Vanilla CSS Hinweise)

Vanilla CSS kann keine echte client-seitige Validierung im Sinne von JavaScript-Prüfungen durchführen. Stattdessen kann es aber visuelle Hinweise auf potenzielle Eingabefehler geben, die dann vom PHP-Skript server-seitig bestätigt werden müssen.

*   **Visuelle Hervorhebung fehlerhafter Felder:** Durch das Hinzufügen von CSS-Klassen kann der Stil von Eingabefeldern geändert werden, um auf Fehler hinzuweisen.
    *   **Meta-Prompt:** "Beschreibe, wie durch die Zuweisung von CSS-Klassen in PHP-Skripten (basierend auf server-seitiger Validierung) die visuelle Hervorhebung von fehlerhaften Login-Formularfeldern realisiert werden kann."
    *   **Anweisungen:**
        *   Das PHP-Skript fügt, wenn eine Validierung fehlschlägt, eine spezifische CSS-Klasse (z. B. `input-error`) zum entsprechenden HTML-Input-Element hinzu.
        *   Das Vanilla CSS definiert dann Regeln für diese Klasse, um z. B. den Rand des Feldes rot zu färben oder ein kleines Warnsymbol anzuzeigen.
        *   Diese visuelle Hervorhebung ist ausschließlich ein Hinweis für den Benutzer und ersetzt keine serverseitige Validierung.
        [Code-Block - Bitte selbständig passenden Code generieren]
*   **Anzeigen von Fehlermeldungen:** Klare, benutzerfreundliche Fehlermeldungen sollten neben den jeweiligen Feldern angezeigt werden.
    *   **Meta-Prompt:** "Erläutere, wie in Vanilla PHP Fehlermeldungen dynamisch generiert und neben den entsprechenden Formularfeldern in der HTML-Ausgabe platziert werden können, um dem Benutzer Feedback zu geben."
    *   **Anweisungen:**
        *   Das PHP-Skript generiert für jeden Validierungsfehler eine spezifische Textmeldung.
        *   Diese Meldungen werden als separate HTML-Elemente (z. B. `<span>` oder `<p>`) direkt nach dem fehlerhaften Eingabefeld ausgegeben.
        *   Das Vanilla CSS sorgt für eine dezente, aber sichtbare Darstellung dieser Fehlermeldungen.
        [Code-Block - Bitte selbständig passenden Code generieren]

#### 6.2.2 Server-seitige Validierung (Vanilla PHP)

Die serverseitige Validierung ist absolut kritisch und darf niemals umgangen werden. Sie stellt sicher, dass die übermittelten Daten den Erwartungen entsprechen und keine Sicherheitsrisiken darstellen.

*   **Datenbereinigung und -validierung:** Alle übermittelten Daten müssen auf ihre Korrektheit und Sicherheit geprüft werden.
    *   **Meta-Prompt:** "Beschreibe die serverseitige Validierungs- und Bereinigungslogik in Vanilla PHP für die Eingaben eines Login-Formulars, um die Integrität und Sicherheit zu gewährleisten."
    *   **Anweisungen:**
        *   **Benutzername/E-Mail-Validierung:**
            *   Prüfen auf leere Eingabe.
            *   Prüfen auf zulässige Zeichen (alphanumerisch, evtl. einige Sonderzeichen, je nach Anforderung).
            *   Längenprüfung.
            *   Entfernen von unerwünschten Zeichen (z. B. HTML-Tags) mit `htmlspecialchars()` oder ähnlichen Funktionen zur Vermeidung von XSS.
        *   **Passwort-Validierung:**
            *   Prüfen auf leere Eingabe.
            *   Längenprüfung (mindestens eine bestimmte Länge).
            *   Sicherstellen, dass das Passwort keine leicht zu erratenden Muster enthält (dies ist komplexer und oft durch Passwortrichtlinien auf DB-Ebene oder in Middleware geregelt, hier Fokus auf die reine Eingabeprüfung).
            *   Verwenden von `password_hash()` zur sicheren Speicherung (falls noch nicht geschehen) und `password_verify()` zur Überprüfung.
        [Code-Block - Bitte selbständig passenden Code generieren]
*   **Prüfung auf bekannte Muster/Schwachstellen:** Das Skript sollte auf bestimmte Muster prüfen, die auf Angriffsversuche hindeuten könnten.
    *   **Meta-Prompt:** "Erkläre die Implementierung von Mustern zur Erkennung von einfachen Angriffsversuchen (z. B. SQL-Injection-Versuche) in den Eingabedaten von Login-Formularen mittels Vanilla PHP."
    *   **Anweisungen:**
        *   Obwohl Prepared Statements die beste Verteidigung gegen SQL-Injection sind, kann eine zusätzliche Validierung auf offensichtliche SQL-Keywords (`SELECT`, `FROM`, `WHERE`, `OR 1=1`) in den Eingabefeldern eine erste Barriere darstellen.
        *   Vermeide jedoch übermäßige oder zu strenge Mustererkennung, die legitime Eingaben blockieren könnte. Der Fokus liegt auf der Vorbereitung für Prepared Statements.
        [Code-Block - Bitte selbständig passenden Code generieren]

### 6.3 Finale Verifikations-Tests

Nach Implementierung aller Funktionen und Fehlerbehandlungsmechanismen sind umfangreiche Tests unerlässlich, um die Korrektheit, Sicherheit und Robustheit des Login-Skripts sicherzustellen.

#### 6.3.1 Funktionale Tests

Diese Tests überprüfen, ob das Login-Skript wie erwartet funktioniert.

*   **Erfolgreiches Login:** Testen Sie die Anmeldung mit gültigen Benutzerdaten.
    *   **Meta-Prompt:** "Beschreibe die Schritte für einen funktionalen Test des erfolgreichen Logins in einem Vanilla PHP-basierten Skript, einschließlich der Überprüfung der Benutzerweiterleitung und Session-Erstellung."
    *   **Anweisungen:**
        *   Konfigurieren Sie ein gültiges Benutzerkonto in der simulierten oder realen Datenbank.
        *   Senden Sie eine POST-Anfrage mit den korrekten Anmeldedaten an das Login-Skript.
        *   Überprüfen Sie, ob der Benutzer erfolgreich authentifiziert und zur erwarteten Seite (z. B. Dashboard) weitergeleitet wird.
        *   Prüfen Sie, ob eine gültige Session erstellt wurde (z. B. durch Überprüfung einer Session-Variable).
        [Code-Block - Bitte selbständig passenden Code generieren]
*   **Fehlgeschlagenes Login (falsches Passwort/Benutzername):** Testen Sie die Anmeldung mit ungültigen Daten.
    *   **Meta-Prompt:** "Beschreibe die Durchführung eines funktionalen Tests für ein fehlgeschlagenes Login aufgrund falscher Anmeldedaten in einem Vanilla PHP-System und die Überprüfung der entsprechenden Fehlermeldungen."
    *   **Anweisungen:**
        *   Senden Sie eine POST-Anfrage mit einem ungültigen Benutzernamen oder Passwort.
        *   Überprüfen Sie, ob die korrekte Fehlermeldung angezeigt wird.
        *   Stellen Sie sicher, dass keine Weiterleitung zu geschützten Seiten erfolgt.
        *   Prüfen Sie, ob die Session nicht erstellt wurde.
        [Code-Block - Bitte selbständig passenden Code generieren]
*   **Leere Felder:** Testen Sie die Anmeldefunktion mit leeren Eingabefeldern.
    *   **Meta-Prompt:** "Erläutere die Schritte für einen funktionalen Test der Login-Funktionalität, wenn ein oder beide Eingabefelder leer gelassen werden, und die erwarteten Ergebnisse."
    *   **Anweisungen:**
        *   Senden Sie eine POST-Anfrage mit leeren Feldern für Benutzername und/oder Passwort.
        *   Überprüfen Sie, ob die entsprechenden Validierungsfehler angezeigt werden.
        *   Stellen Sie sicher, dass der Login-Prozess fehlschlägt.
        [Code-Block - Bitte selbständig passenden Code generieren]

#### 6.3.2 Sicherheitstests

Diese Tests konzentrieren sich auf potenzielle Sicherheitslücken.

*   **SQL-Injection-Versuche:** Überprüfen Sie, ob das Skript gegen einfache SQL-Injection-Angriffe resistent ist.
    *   **Meta-Prompt:** "Beschreibe die Durchführung von Sicherheitstests zur Überprüfung der Resistenz gegen einfache SQL-Injection-Angriffe im Vanilla PHP Login-Skript."
    *   **Anweisungen:**
        *   Versuchen Sie, SQL-Befehle (z. B. `' OR '1'='1`) in die Eingabefelder einzufügen.
        *   Verifizieren Sie, dass das Skript diese Eingaben nicht interpretiert und stattdessen den Login als fehlgeschlagen meldet oder eine generische Fehlermeldung anzeigt, ohne interne Informationen preiszugeben.
        *   Dies ist ein Indikator dafür, ob Prepared Statements korrekt implementiert sind oder ob andere Schutzmaßnahmen greifen.
        [Code-Block - Bitte selbständig passenden Code generieren]
*   **Cross-Site Scripting (XSS)-Versuche:** Testen Sie, ob das Skript gegen XSS-Angriffe geschützt ist.
    *   **Meta-Prompt:** "Erläutere die Durchführung von Sicherheitstests zur Überprüfung der Widerstandsfähigkeit gegen Cross-Site Scripting (XSS)-Angriffe im Vanilla PHP Login-Skript."
    *   **Anweisungen:**
        *   Versuchen Sie, HTML-Tags oder JavaScript-Code (z. B. `<script>alert('XSS')</script>`) in die Eingabefelder einzufügen.
        *   Überprüfen Sie, ob diese Eingaben auf der Anmeldebestätigungs- oder Fehlerseite korrekt maskiert oder neutralisiert werden (z. B. durch `htmlspecialchars`) und nicht als ausführbarer Code interpretiert werden.
        [Code-Block - Bitte selbständig passenden Code generieren]
*   **Brute-Force-Angriffs-Simulation:** Überprüfen Sie die Wirksamkeit der Rate-Limiting-Maßnahmen.
    *   **Meta-Prompt:** "Beschreibe die Simulation eines Brute-Force-Angriffs, um die Wirksamkeit der Rate-Limiting-Implementierung im Vanilla PHP Login-Skript zu überprüfen."
    *   **Anweisungen:**
        *   Führen Sie über einen kurzen Zeitraum eine große Anzahl von fehlerhaften Anmeldeversuchen von derselben IP-Adresse durch.
        *   Überprüfen Sie, ob die Rate-Limiting-Mechanismen greifen und die Anmeldeversuche nach Erreichen des Limits verlangsamt oder blockiert werden.
        *   Dokumentieren Sie die Zeit, bis die Sperrung eintritt, und die Dauer der Sperrung.
        [Code-Block - Bitte selbständig passenden Code generieren]

#### 6.3.3 Fallback- und Fehlerbehandlungs-Tests

Diese Tests überprüfen, ob die Fallback-Strategien und die Fehlerbehandlung korrekt funktionieren.

*   **Simulation von Datenbankfehlern:** Testen Sie das Verhalten des Skripts, wenn die Datenbank nicht erreichbar ist.
    *   **Meta-Prompt:** "Beschreibe, wie das Verhalten des Vanilla PHP Login-Skripts bei einem simulierten Datenbankfehler getestet werden kann, insbesondere die Fehlerseiten-Anzeige und Protokollierung."
    *   **Anweisungen:**
        *   Konfigurieren Sie die Umgebung so, dass die Datenbankverbindung fehlschlägt (z. B. durch temporäres Stoppen des Datenbankservers oder Ändern der Zugangsdaten).
        *   Versuchen Sie, sich anzumelden.
        *   Überprüfen Sie, ob die benutzerfreundliche Fehlerseite angezeigt wird und ob die technischen Fehlerdetails korrekt in einer Protokolldatei aufgezeichnet werden.
        [Code-Block - Bitte selbständig passenden Code generieren]
*   **Simulation von serverseitigen Skriptfehlern:** Testen Sie das Verhalten bei unerwarteten PHP-Fehlern.
    *   **Meta-Prompt:** "Erläutere, wie das Verhalten des Vanilla PHP Login-Skripts bei unerwarteten serverseitigen Skriptfehlern (z. B. Syntaxfehler, undefinierte Variablen) getestet werden kann, mit Fokus auf die globale Fehlerbehandlung."
    *   **Anweisungen:**
        *   Führen Sie absichtlich einen Fehler in das PHP-Login-Skript ein (z. B. Aufruf einer nicht existierenden Funktion).
        *   Überprüfen Sie, ob der globale Fehler-Handler ausgelöst wird und eine generische Fehlerseite anzeigt.
        *   Stellen Sie sicher, dass keine kritischen PHP-Fehlermeldungen dem Benutzer angezeigt werden.
        *   Prüfen Sie die Log-Dateien auf Details des aufgetretenen Fehlers.
        [Code-Block - Bitte selbständig passenden Code generieren]