Praktikumsversuch PHP

Dieses Praktikum dient der praktischen Erprobung von PHP.

Entwicklungsserver

Zum Testen der eigenen PHP-Programme kann ein lokaler Server verwendet werden (VSCode, XAMPP, php -S). Das fertige Programm kann über den Webserver der Fakultät Informatik/Mathematik genutzt werden.

Aufgabe 1: PHP-Datei erstellen

Erstellen Sie die Datei hallo.php mit folgendem Inhalt:

HTML5-Gerüst mit einer Überschrift
Ein Absatz mit der PHP-Ausgabe: <?php echo date('d.m.Y'); ?>

Aufgabe 2: Formularverarbeitung

Nutze das bereits erstellte Adress-Formular und konfiguriere dieses auf die HTTP-Methode POST und den Skriptnamen: ausgabe.php
Erstelle die Datei ausgabe.php mit der Eigenschaft:
- Ausgabe der Feldinhalte
- Nutze: var_dump() und print_r() für Debugging-Zwecke zusammen mit der Variable $_POST bzw. $_POST["name"]
- Sie können gern weitere Superglobals ausgeben wie z.B. $_SERVER oder $_REQUEST
- Geben Sie in ein Eingabefeld folgenden Text ein: <script>alert('Hacked!');</script>
- Nutzung Sie die Funktion: htmlspecialchars() bei der Auswertung der Nutzerdaten, um gegen XSS-Angriffe wie dem simulierten obigen immun zu sein.
- Cross-Site-Scripting (XSS): Einschleusen von bösartigem Javascript-Code in eine vertrauenswürdige Webseite mit dem Ziel, bei einem anderen Nutzer Daten wie z.B. Sitzungs-Cookies zu kopieren
- weiterer Schutz für XSS ist Content Security Policy (CSP)
  - blockiert Inline-Skripte
  - Whitelist-Prinzip: nur Skripte vom eigenen Server werden ausgeführt
  - Schutz vor Datendiebstahl: Skripte können keine Verbindung zu einer fremden Domain aufbauen

<?php
// Erlaubt nur Skripte von der eigenen Domain und blockiert Inline-JavaScript
header("Content-Security-Policy: default-src 'self'; script-src 'self'");
?>

Aufgabe 3: Datenbanknutzung

Datenbank-Abstraktionsschicht PDO (PHP Data Objects)

Wir nutzen die filebasierte Datenbank SQLite mit einer Anbindung mittels PDO (PHP Data Objects).
Vorteil von PDO: einfacher Umstieg auf MySQL
Extensions müssen aktiviert sein: extension=pdo, pdo_sqlite
SQlite nutzt intern Unicode, der PDO-Treiber standardmäßig UTF-8, seit PHP 5.6 ist UTF-8 Standard
mögliche Fehlermodi: Silent, Warning, Exception -> wir nutzen Exception -> Fehler abfangen mittels try … catch
wichtige PDO-Funktionen:
- exec(string $sql): direkte Ausführung von Befehlen ohne Result (INSERT, UPDATE,…)
- query(string $sql): liefert PDOStatement als Ergebnis
- prepare(string $sql): Vorbereitung einer SQL-Anweisung
- execute(): vorbereitetes Statement ausführen, optional mit Parameterübergabe
- bindParam(): Bindet eine Variable
- bindValue(): Bindet einen konkreten Wert
- fetch(): liefert eine Zeile des PDOStatments
- fetchAll(): liefert alle Zeilen des PDOStatements
- beginTransaction(): ACID - Atomicity, Consistency, Isolation, Durability
- commit/rollBack schreibt alle Änderungen oder verwirft alle Änderungen
- lastInsertId(): letzte ID
👉 Zum Schutz gegen SQL-Injection sollten generell INSERT-Anweisungen durch PDO mit Prepared Statements ersetzt werden.

Grundlegenden SQL-Operationen (CRUD: Create, Read, Update, Delete):

SELECT: Daten aus einer Tabelle abfragen
Beispiel: SELECT * FROM Kunden;
INSERT INTO: Neue Daten einfügen
Beispiel: INSERT INTO Kunden (Name, Stadt) VALUES ('Anna', 'Berlin');
UPDATE: Bestehende Daten ändern
Beispiel: UPDATE Kunden SET Stadt = 'Hamburg' WHERE Name = 'Anna';
DELETE FROM: Daten löschen
Beispiel: DELETE FROM Kunden WHERE Name = 'Anna';
CREATE TABLE: Neue Tabelle erstellen
Beispiel: CREATE TABLE Kunden (ID INT, Name VARCHAR(50), Stadt VARCHAR(50));
UPSERT: Daten einfügen oder ändern
Beispiel: INSERT INTO scores (name, points) VALUES (:name, :points) ON CONFLICT(name) DO UPDATE SET points = points + excluded.points;

Optionen

Filter: WHERE (Nachname="Maier" AND Vorname="Thomas")
Reihenfolge: ORDER BY Nachname, Vorname DESC; -- absteigend
Anzahl: LIMIT 10; -- nur die ersten 10 Zeilen

Codebeispiele für verschiedene Datenbankoperationen:

// absoluter Pfad des aktuellen Arbeitsverzeichnisses
$dbFile = __DIR__ . '/scores.db';  
// Nutzung des PDP-Interfaces mit dem SQlite-Treiber
try {
  $pdo = new PDO('sqlite:' . $dbFile);
  // Options
  $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);        // Exceptions on
  $pdo->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE=> PDO::FETCH_ASSOC); // fetch mit asssoziativem Array
  } catch (Exception $e) {
    http_response_code(500);
    echo json_encode(['error' => 'Datenbank‑Fehler: ' . $e->getMessage()]);
    exit;
}
  
// Tabelle anlegen
// Heredoc‑Syntax mit Kennung SQL
$createTableSQL = <<<SQL
CREATE TABLE IF NOT EXISTS scores (
    id         INTEGER PRIMARY KEY AUTOINCREMENT,
    name       TEXT NOT NULL UNIQUE,
    points     INTEGER NOT NULL,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);
SQL;
$pdo->exec($createTableSQL);


// 1. Direktes Query (SELECT)
foreach ($pdo->query('SELECT id, name FROM users') as $row) {
    echo $row['id'] . ': ' . $row['name'] . PHP_EOL;
}

// 2. Exec (INSERT/UPDATE/DELETE ohne Rückgabe)
$affected = $pdo->exec('DELETE FROM sessions WHERE expires < datetime(\'now\')');

// 3. Prepared Statement mit benannten Parametern
$stmt = $pdo->prepare('SELECT * FROM posts WHERE author = :author AND created > :date');
$stmt->execute([':author' => $author, ':date' => $date]);
$posts = $stmt->fetchAll();   // bereits assoziativ dank DEFAULT_FETCH_MODE

// 4. Transaktion
$pdo->beginTransaction();
try {
    $pdo->exec('INSERT INTO orders (user_id,total) VALUES (1,99.95)');
    $pdo->exec('UPDATE users SET balance = balance - 99.95 WHERE id = 1');
    $pdo->commit();
} catch (PDOException $e) {
    $pdo->rollBack();
    throw $e; // oder loggen
}

// 5. Letzte Insert‑ID
$newId = $pdo->lastInsertId();

Aufgabe 3.1: Highscore per Formular

Erstellen Sie ein PHP-Skript, welches folgende Daten entgegennimmt und in einer SQLite-Datenbank speichert:
- Name
- Punktanzahl
Wenn ein Name nicht vorhanden ist, soll ein neuer Datenbankeintrag erzeugt werden
Wenn ein Name schon vorhanden ist, sollen die Punkte addiert werden
Das Skript soll die ersten 5 Einträge mit dem höchsten Punktestand per HTML-Ausgabe auflisten

Aufgabe 3.2: Highscore per Ajax

Erweitern Sie die obige Aufgabe um einen asynchronen Zugriff
Die Datenübergabe soll jeweils per JSON erfolgen
Gesendete JSON-Daten müssen im Skript per file_get_contents('php://input') geholt werden, da der Zugriff über die POST-Variable nur für die Codierung von Formularen (application/x-www-form-urlencoded) funktioniert.

Aufgabe 3.3 Highscore per REST-API

Erweitern Sie das obige Beispiel mit einer REST-API.
Steuerung des URL-Zugriffs mittels Apache/.htaccess.
Vollziehen Sie dazu das unten stehende Beispiel nach.
Achtung: Das api-Verzeichnis muss Leserechte für jeden haben

Beispiel für `.htaccess`

# Erlaube HTTP-Methoden
<Limit GET POST PUT DELETE OPTIONS HEAD>
    Require all granted
</Limit>

RewriteEngine On
# Leitet Anfragen wie /api/users an index.php weiter
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php [L,QSA]

Beispiel für PHP-Skript

<?php
header("Content-Type: application/json; charset=UTF-8");
header("Access-Control-Allow-Origin: *");


// Methode ermitteln (GET, POST, etc.)
$method = $_SERVER['REQUEST_METHOD'];
$request_uri = $_SERVER['REQUEST_URI'];

echo "Anfrage-Pfad: " . $request_uri;


// Beispieldaten (würden normalerweise aus einer DB kommen)
$users = [
    ["id" => 1, "name" => "Max Mustermann"],
    ["id" => 2, "name" => "Erika Musterfrau"]
];

switch ($method) {
    case 'GET':
        // Rückgabe aller Benutzer
        echo json_encode($users);
        break;

    case 'POST':
        // Neuen Benutzer empfangen (simuliert)
        $input = json_decode(file_get_contents('php://input'), true);
        if (!empty($input['name'])) {
            http_response_code(201); // Created
            echo json_encode(["message" => "Benutzer erstellt", "data" => $input]);
        } else {
            http_response_code(400); // Bad Request
            echo json_encode(["error" => "Name fehlt"]);
        }
        break;

    default:
        http_response_code(405); // Method Not Allowed
        echo json_encode(["error" => "Methode nicht erlaubt"]);
        break;
}
?>

Ergebnisse

Skript: aufgabe.php

<!DOCTYPE html>
<html lang="de">
<head>
    <meta charset="UTF-8">
    <title>Aufgabenliste</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; }
        h1 { color: #333; }
        form { margin: 20px 0; }
        input[type="text"] { padding: 8px; width: 300px; }
        button { padding: 8px 16px; background: #007BFF; color: white; border: none; cursor: pointer; }
        button:hover { background: #0056b3; }
        ul { list-style: none; padding: 0; }
        li { padding: 10px; border-bottom: 1px solid #eee; }
        .zeit { font-size: 0.8em; color: #666; }
    </style>
</head>
<body>

<h1>Meine Aufgabenliste</h1>

<!-- Formular zum Hinzufügen einer neuen Aufgabe -->
<form method="POST" action="">
    <input type="text" name="aufgabe" placeholder="Neue Aufgabe eingeben..." required>
    <button type="submit">Hinzufügen</button>
</form>

<?php
// Verbindung zur SQLite-Datenbank
$db = new SQLite3('aufgaben.db');

// Neue Aufgabe hinzufügen (wenn Formular abgeschickt wurde)
if ($_POST['aufgabe']) {
    $aufgabe = $_POST['aufgabe'];
    $sql = "INSERT INTO aufgaben (aufgabe) VALUES ('$aufgabe')";
    
    if ($db->exec($sql)) {
        echo "<p><strong>✅ Aufgabe hinzugefügt!</strong></p>";
    } else {
        echo "<p><strong>❌ Fehler beim Hinzufügen.</strong></p>";
    }
}

// Aufgaben aus der Datenbank abrufen und anzeigen
$sql = "SELECT * FROM aufgaben ORDER BY erstellt DESC";
$result = $db->query($sql);

echo "<h2>Aufgaben:</h2>";
if ($result->numRows() > 0) {
    echo "<ul>";
    while ($row = $result->fetchArray(SQLITE3_ASSOC)) {
        echo "<li>";
        echo htmlspecialchars($row['aufgabe']);
        echo " <span class='zeit'>(" . $row['erstellt'] . ")</span>";
        echo "</li>";
    }
    echo "</ul>";
} else {
    echo "<p>Keine Aufgaben vorhanden.</p>";
}

// Verbindung schließen
$db->close();
?>

</body>
</html>

PDO:

// 1. Verbindung herstellen
$db = new PDO('sqlite:./datei.db');

// 2. SQL-Befehl mit Platzhalter vorbereiten
$stmt = $db->prepare("INSERT INTO tabelle (spalte) VALUES (:wert)");

// 3. Daten sicher ausführen
$stmt->execute([':wert' => $userEingabe]);

// 4. Ergebnisse abrufen
$result = $db->query("SELECT * FROM tabelle");
while ($row = $result->fetch(PDO::FETCH_ASSOC)) {
    echo $row['spalte'];
}

Aufgabe 3: SQLite

Erstelle eine Webanwendung, welche Aufgaben an den Server senden kann.
Der Server speichert die Aufgaben in einer SQlite-Datenbank
Liste alle Aufgaben nach Erstellungsdatum auf
Skript: erstelle_tabelle.php

// SQL-Befehl zur Erstellung der Tabelle
$sql = <<<SQL
CREATE TABLE IF NOT EXISTS aufgaben (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    aufgabe TEXT NOT NULL,
    erstellt DATETIME DEFAULT CURRENT_TIMESTAMP
);
SQL;

Rechnernetze / Kommunikationssysteme