diff --git a/Changes.md b/Changes.md
index 0fc1276..5bd7a48 100644
--- a/Changes.md
+++ b/Changes.md
@@ -2,6 +2,65 @@
 
 ---
 
+## 2026-07-30 – Fix: SMTP-Header-/Kommando-Injection über mail_from_email (Issue #148)
+
+- `SmtpMailer::sendMessage()`/`buildMessage()` verwendeten `fromEmail` roh sowohl im `MAIL FROM:<...>`-SMTP-Kommando als auch im `From:`-Header, während alle anderen dynamischen Werte (Empfänger, `fromName`, `subject`, Anhangsname) bereits validiert bzw. CRLF-bereinigt wurden. `mail_from_email` (Firmeneinstellung, per POST setzbar) durchlief keine serverseitige Prüfung – ein eingeloggter Nutzer konnte per CRLF-Payload zusätzliche SMTP-Kommandos (z.B. eine verdeckte `RCPT TO`-Zeile) einschleusen oder den `From:`-Header manipulieren (CWE-93).
+- **`src/Models/Setting.php`:** `Setting::update()` validiert `mail_from_email` jetzt über `filter_var(..., FILTER_VALIDATE_EMAIL)` (neue private Methode `sanitizeFromEmail()`); ungültige Werte (inkl. CRLF-Payloads) werden verworfen statt gespeichert.
+- **`src/Services/SmtpMailer.php`:** Defense-in-Depth – neue Methode `sanitizeAddress()` entfernt CR/LF aus `fromEmail`, bevor dieser im `MAIL FROM:`-Kommando und im `From:`-Header verwendet wird.
+- **`tests/69_MailFromEmailInjectionTest.php`:** Neuer Test prüft, dass ungültige/CRLF-behaftete Absenderadressen beim Speichern verworfen werden und dass `SmtpMailer::sanitizeAddress()` CR/LF zuverlässig entfernt.
+
+## 2026-07-27 – Fix: Produktions-Härtung der PHP-Fehlerausgabe (Issue #142)
+
+- Das Docker-Image (`php:8.3-apache`) übernahm die kompilierten PHP-Defaults, bei denen `display_errors` aktiviert ist – im offiziellen Image wird `php.ini-production` nicht automatisch aktiviert. In Kombination mit `PDO::ATTR_ERRMODE_EXCEPTION` (`src/Database.php`) und fehlendem globalem Error-Handler hätte jeder unerwartete Fehler (SQL-Fehler, DB-Verbindungsproblem, Typfehler) eine vollständige PHP-Fehlermeldung inkl. Stacktrace, absoluten Serverpfaden und ggf. SQL-Details direkt an den Client ausgegeben (CWE-209, Information Exposure Through an Error Message) – auch für nicht angemeldete Nutzer (`/login` ist vor `Auth::require()` erreichbar).
+- **`php/error-handling.ini`** (neu): `display_errors = Off`, `display_startup_errors = Off`, `log_errors = On`, `error_reporting = E_ALL & ~E_DEPRECATED`.
+- **`Dockerfile`:** Kopiert `php/error-handling.ini` zusätzlich zu `php/uploads.ini` nach `/usr/local/etc/php/conf.d/`.
+- **`public/index.php`:** Registriert ganz zu Beginn (vor Autoload/Routing) `set_error_handler` (wandelt Warnings/Notices in `ErrorException` um), `set_exception_handler` und `register_shutdown_function` (fängt Fatal Errors, die nicht als Exception auftreten). Unerwartete Fehler werden per `error_log` serverseitig geloggt; der Client erhält nur eine generische HTTP-500-Seite ohne Details.
+- **`tests/68_ProductionErrorHardeningTest.php`:** Neuer Test prüft die Ini-Direktiven, die Dockerfile-Einbindung, die Registrierung der Handler vor dem Autoload sowie dass die an den Client gesendete Fehlerseite keine Exception-Details (Message/Trace/File) enthält.
+
+## 2026-07-27 – Fix: Stored XSS über XSLT in hochgeladenen XML-Belegen (Issue #135)
+
+- `BelegController::serveFile()` liefert Belege mit dem in der DB hinterlegten `mime_type` und `Content-Disposition: inline` unverändert an den Browser aus. Da für Belege `application/xml`/`text/xml` als MIME-Typ erlaubt ist, konnte eine hochgeladene XML-Datei mit eingebettetem `<?xml-stylesheet?>`/`xsl:stylesheet` beim Öffnen über den „Datei öffnen“-Link (`target="_blank"`, kein `download`-Attribut) direkt im Browser (v.a. Firefox) per XSLT-Transformation zu ausführbarem `<script>` im Sicherheitskontext der Anwendung führen (Stored-XSS, CWE-79) – inklusive Zugriff auf das im `<meta>`-Tag liegende CSRF-Token (vgl. #132/#133).
+- **`src/Controllers/BelegController.php`:** `serveFile()` liefert XML-Belege (`application/xml`/`text/xml`) jetzt mit `Content-Disposition: attachment` statt `inline` aus, sodass der Browser die Datei herunterlädt statt sie zu navigieren/rendern; andere MIME-Typen bleiben unverändert `inline`.
+- **`public/index.php`:** Globaler `X-Content-Type-Options: nosniff`-Header für alle Responses als zusätzliche Absicherung gegen MIME-Sniffing.
+- **`tests/67_BelegXmlXsltXssTest.php`:** Neuer Test lädt einen XML-Beleg mit XSLT-Payload an und prüft, dass `serveFile()` den `Content-Disposition`-Header auf `attachment` statt `inline` setzt.
+
+## 2026-07-27 – Fix: DOM-XSS in der CSV/XLSX-Vorschau beim Bankimport (Issue #133)
+
+- `BankController::detectFormat()` liefert die aus einer hochgeladenen Bank-Umsatzdatei geparste `header_row`/`first_data` unverändert als JSON zurück; `src/Views/bank/upload.php` rendert diese Werte per `innerHTML` in ein `title="..."`-Attribut. Die dortige `esc()`-Funktion escapte bisher nur `&`, `<` und `>`, nicht aber `"`. Ein Header-/Zellwert wie `Spalte" onmouseover="alert(document.cookie)` konnte damit aus dem Attribut ausbrechen und beliebigen JavaScript-Code im Kontext des eingeloggten Nutzers ausführen (CWE-79), z.B. um das im `<meta>`-Tag liegende CSRF-Token auszulesen. Bank-Exportdateien stammen typischerweise von Dritten (Bank, per E-Mail zugeschickter Kontoauszug) und sind damit ein realistischer, angreiferkontrollierter Eingabekanal.
+- **`src/Views/bank/upload.php`:** `esc()` escaped jetzt zusätzlich `"` (zu `&quot;`) und `'` (zu `&#39;`).
+- **`tests/66_BankUploadPreviewXssTest.php`:** Neuer Test prüft per Quelltext-Check, dass `esc()` Anführungszeichen escaped, und führt die extrahierte JS-Funktion (falls `node` verfügbar ist) mit einem bösartigen Zellwert aus, um zu verifizieren, dass kein Ausbruch aus dem `title`-Attribut mehr möglich ist.
+
+## 2026-07-27 – Fix: Reflektiertes XSS über _error-Parameter bei Rechnungs-Zahlungserfassung (Issue #132)
+
+- `InvoiceController::book()` übernahm den Fehler-Array ungeprüft direkt aus `$_GET['_error']` und reichte ihn an die View weiter. Da `_error` nirgendwo serverseitig befüllt wird und der CSRF-Schutz nur für POST/PUT/DELETE/PATCH greift, konnte ein Angreifer per einfachem Link (`GET /invoices/{id}/book?_error[x]=<script>...`) beliebiges JavaScript im Kontext eines eingeloggten Nutzers ausführen und darüber auch das im `<meta>`-Tag liegende CSRF-Token auslesen.
+- **`src/Controllers/InvoiceController.php`:** `book()` übernimmt `_error` nicht mehr aus `$_GET`, `$formErrors` startet immer leer.
+- **`src/Views/invoices/book.php`, `src/Views/belege/detail.php`:** Die Fehleranzeige escaped Schlüssel und Werte jetzt konsequent mit `$h()` (zuvor ungeschütztes `implode`/`array_map`-Pattern, in `belege/detail.php` betrifft dies POST-basierte Fehler aus `BookingController`).
+- **`tests/65_InvoiceBookReflectedXssTest.php`:** Neuer Test prüft, dass ein `<script>`-Payload in `$_GET['_error']` nicht mehr unescaped in der Ausgabe von `InvoiceController::book()` erscheint.
+
+## 2026-07-27 – Fix: CSV-Formel-Injection im Anlagelisten-Export (Issue #131)
+
+- `EuerController::anlageCsv()` schrieb `assets.bezeichnung` (frei editierbarer Text) ungefiltert per `fputcsv()` in die exportierte `Anlageliste-{year}.csv`. Eine Bezeichnung wie `=cmd|'/c calc'!A1` konnte beim Öffnen der CSV in Excel/LibreOffice zu Formelausführung führen (CSV-/Formel-Injection, CWE-1236). `BelegController`/`BookingController` waren dank eigener, privater `csvSanitize()`-Methoden bereits abgesichert.
+- **`src/Controllers/BaseController.php`:** Die bisher in `BelegController` und `BookingController` duplizierte `csvSanitize()`-Methode wurde als gemeinsame `protected` Methode hierher verschoben (Präfix `'` bei führendem `=`, `+`, `-` oder `@`).
+- **`src/Controllers/EuerController.php`:** `anlageCsv()` sanitisiert `bezeichnung` jetzt über `$this->csvSanitize()`.
+- **`src/Controllers/BelegController.php`, `src/Controllers/BookingController.php`:** Duplizierte private `csvSanitize()`-Methoden entfernt, nutzen jetzt die geerbte Methode aus `BaseController`.
+- **`tests/64_AnlageCsvInjectionTest.php`:** Neuer Test prüft, dass eine Anlagenbezeichnung mit führendem `=` im CSV-Export mit vorangestelltem `'` maskiert wird.
+
+## 2026-07-27 – Fix: SSRF-Schutz per DNS-Rebinding umgehbar (TOCTOU) (Issue #130)
+
+- `SsrfGuard::assertPublicHttpsUrl()` löste den Hostnamen einmalig auf und prüfte die IPs, der eigentliche Request (cURL bzw. `php-fints`) löste den Hostnamen aber später erneut selbst auf. Ein Angreifer mit Kontrolle über die DNS-Antworten der konfigurierten Domain konnte zwischen Prüfung und Request von einer öffentlichen auf eine interne IP (127.0.0.1, internes Netz, Cloud-Metadata) umschalten und so die SSRF-Prüfung aus #127/#118 umgehen.
+- **`src/Services/SsrfGuard.php`:** Neue Methode `resolvePinned()` gibt zusätzlich zur Validierung die geprüften IP-Adressen als `CURLOPT_RESOLVE`-Einträge (`HOST:PORT:IP`) zurück; `assertPublicHttpsUrl()` bleibt als Wrapper bestehen.
+- **`src/Services/NextcloudImportService.php`:** Der Konstruktor pinnt die geprüfte(n) IP(s) der `nextcloud_url` einmalig; `newCurl()` setzt `CURLOPT_RESOLVE`, sodass alle cURL-Requests (PROPFIND/GET/MOVE/DELETE) den Hostnamen nicht erneut über den System-Resolver auflösen.
+- **`src/Services/FinTsFetchService.php`:** `php-fints` löst den Hostnamen selbst auf (kein IP-Pinning möglich) – die SSRF-Prüfung wird daher zusätzlich unmittelbar vor dem ersten tatsächlichen Request (nach `FinTs::new()`) wiederholt, um das Zeitfenster für DNS-Rebinding zu minimieren.
+- **`tests/63_SsrfPinningTest.php`:** Neuer Test prüft `SsrfGuard::resolvePinned()` (Einträge für Hostnamen, leeres Ergebnis + weiterhin Ablehnung für IP-Literale) sowie das Pinning in `NextcloudImportService`.
+
+## 2026-07-27 – Fix: CSRF-Schutz für GET /bank/direkt/{id}/run (Issue #136)
+
+- Der SSE-Endpunkt `GET /bank/direkt/{id}/run` löste einen echten Bankabruf (PayPal/FinTS) allein anhand der Session aus, ohne CSRF-Prüfung – da `EventSource` nur `GET` unterstützt, griff die bestehende CSRF-Middleware (nur für `POST`/`PUT`/`DELETE`/`PATCH`) nicht. Ein Angreifer konnte per Top-Level-Navigation (SameSite=Lax) einen eingeloggten Nutzer dazu bringen, unbeabsichtigt einen Abruf für eine beliebige Verbindungs-ID auszulösen.
+- **`src/Auth.php`:** `validateCsrfToken()` prüft jetzt über die neue, seiteneffektfreie `isValidCsrfToken()` (analog zu `cookieParams()`), damit sich die Vergleichslogik isoliert testen lässt.
+- **`src/Controllers/BankController.php`:** `direktRun()` validiert vor dem eigentlichen Abruf das per `csrf_token`-Query-Parameter übergebene Token gegen die Session.
+- **`src/Views/bank/fints.php`:** Die `EventSource`-URL hängt das bereits vorhandene, in der Seite eingebettete CSRF-Token (`meta[name="csrf-token"]`) als Query-Parameter an.
+- **`tests/62_BankDirektRunCsrfTest.php`:** Neuer Test prüft `Auth::isValidCsrfToken()` gegen korrektes, falsches, leeres und fehlendes Session-Token.
+
 ## 2026-07-27 – Feature: Netto/Brutto-Umschalter in der Buchungsmaske (Issue #137)
 
 - Beim Erfassen einer Buchung musste bisher immer der Nettobetrag eingegeben werden – lag nur der Bruttobetrag vor (z. B. von einem Kassenbon), führte die manuelle Rückrechnung regelmäßig zu Rundungsdifferenzen.
diff --git a/Dockerfile b/Dockerfile
index 0e049c6..8bc7749 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -30,6 +30,7 @@ COPY . .
 
 # PHP configuration
 COPY php/uploads.ini /usr/local/etc/php/conf.d/uploads.ini
+COPY php/error-handling.ini /usr/local/etc/php/conf.d/error-handling.ini
 
 # Apache configuration
 COPY apache/steuerkram.conf /etc/apache2/sites-available/000-default.conf
diff --git a/php/error-handling.ini b/php/error-handling.ini
new file mode 100644
index 0000000..ba59726
--- /dev/null
+++ b/php/error-handling.ini
@@ -0,0 +1,6 @@
+; Produktions-Härtung: keine Fehlerdetails (Stacktraces, Pfade, SQL-Fehler) an Clients ausgeben.
+; Fehler werden stattdessen serverseitig geloggt (Apache-Errorlog).
+display_errors = Off
+display_startup_errors = Off
+log_errors = On
+error_reporting = E_ALL & ~E_DEPRECATED
diff --git a/public/index.php b/public/index.php
index 3eb7d8a..9c42643 100644
--- a/public/index.php
+++ b/public/index.php
@@ -2,10 +2,56 @@
 
 declare(strict_types=1);
 
+// ── Zentraler Fehler-Handler ─────────────────────────────────────
+// Fängt unerwartete Fehler/Exceptions ab, loggt sie serverseitig und
+// zeigt dem Client nur eine generische 500-Seite ohne Details
+// (Stacktrace, Pfade, SQL-Fehler) – siehe auch php/error-handling.ini.
+$steuerkramShowGenericError = static function (): void {
+    if (!headers_sent()) {
+        http_response_code(500);
+        header('Content-Type: text/html; charset=utf-8');
+    }
+    echo '<!DOCTYPE html><html lang="de"><head><meta charset="utf-8">'
+        . '<title>Fehler</title></head>'
+        . '<body style="font-family:sans-serif;text-align:center;padding:4rem">'
+        . '<h1>Ein Fehler ist aufgetreten</h1>'
+        . '<p>Bitte versuchen Sie es später erneut.</p>'
+        . '</body></html>';
+};
+
+set_error_handler(static function (int $severity, string $message, string $file, int $line): bool {
+    if (!(error_reporting() & $severity)) {
+        return false;
+    }
+    throw new \ErrorException($message, 0, $severity, $file, $line);
+});
+
+set_exception_handler(function (\Throwable $e) use ($steuerkramShowGenericError): void {
+    error_log(sprintf(
+        'Unhandled exception: %s in %s:%d%s%s',
+        $e->getMessage(),
+        $e->getFile(),
+        $e->getLine(),
+        PHP_EOL,
+        $e->getTraceAsString()
+    ));
+    $steuerkramShowGenericError();
+});
+
+register_shutdown_function(function () use ($steuerkramShowGenericError): void {
+    $error = error_get_last();
+    if ($error !== null && in_array($error['type'], [E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR], true)) {
+        error_log(sprintf('Fatal error: %s in %s:%d', $error['message'], $error['file'], $error['line']));
+        $steuerkramShowGenericError();
+    }
+});
+
 define('BASE_DIR', dirname(__DIR__));
 
 require BASE_DIR . '/vendor/autoload.php';
 
+header('X-Content-Type-Options: nosniff');
+
 // Cache-Buster für statische Assets: Git-Commit-Hash aus Datei lesen
 $_assetVersionFile = BASE_DIR . '/public/static/.asset-version';
 define('ASSET_VERSION', file_exists($_assetVersionFile) ? trim(file_get_contents($_assetVersionFile)) : 'dev');
diff --git a/src/Auth.php b/src/Auth.php
index 047f7a8..5dc30fb 100644
--- a/src/Auth.php
+++ b/src/Auth.php
@@ -102,10 +102,19 @@ class Auth
     public static function validateCsrfToken(string $token): void
     {
         self::startSession();
-        $stored = $_SESSION['csrf_token'] ?? '';
-        if ($stored === '' || !hash_equals($stored, $token)) {
+        if (!self::isValidCsrfToken($token)) {
             http_response_code(403);
             exit('CSRF-Token ungültig.');
         }
     }
+
+    /**
+     * Reiner Vergleich ohne session_start()-Seiteneffekt, damit sich die
+     * Prüflogik isoliert testen lässt (siehe cookieParams()).
+     */
+    public static function isValidCsrfToken(string $token): bool
+    {
+        $stored = $_SESSION['csrf_token'] ?? '';
+        return $stored !== '' && hash_equals($stored, $token);
+    }
 }
diff --git a/src/Controllers/BankController.php b/src/Controllers/BankController.php
index d9b295e..dc7036a 100644
--- a/src/Controllers/BankController.php
+++ b/src/Controllers/BankController.php
@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Steuerkram\Controllers;
 
+use Steuerkram\Auth;
 use Steuerkram\Config;
 use Steuerkram\Models\BankProvider;
 use Steuerkram\Models\BankSource;
@@ -510,6 +511,8 @@ class BankController extends BaseController
 
     public function direktRun(array $params): void
     {
+        Auth::validateCsrfToken((string)($_GET['csrf_token'] ?? ''));
+
         $id     = (int)($params['id'] ?? 0);
         $source = BankSource::find($id);
 
diff --git a/src/Controllers/BaseController.php b/src/Controllers/BaseController.php
index 7d22093..1baf425 100644
--- a/src/Controllers/BaseController.php
+++ b/src/Controllers/BaseController.php
@@ -13,4 +13,15 @@ class BaseController
         include dirname(__DIR__) . '/Views/' . $template . '.php';
         return ob_get_clean();
     }
+
+    /**
+     * Verhindert CSV-/Formel-Injection: stellt bei führendem =, +, - oder @ ein ' voran.
+     */
+    protected function csvSanitize(string $value): string
+    {
+        if ($value !== '' && in_array($value[0], ['=', '+', '-', '@'], true)) {
+            return "'" . $value;
+        }
+        return $value;
+    }
 }
diff --git a/src/Controllers/BelegController.php b/src/Controllers/BelegController.php
index a97d165..2f962ed 100644
--- a/src/Controllers/BelegController.php
+++ b/src/Controllers/BelegController.php
@@ -323,8 +323,13 @@ class BelegController extends BaseController
         }
         if (!file_exists($realPath)) { http_response_code(404); return; }
 
+        // XML kann eingebettete XSLT-Stylesheets enthalten, die bei Inline-Anzeige
+        // im Browser (v.a. Firefox) als Stored-XSS ausgeführt würden -> Download erzwingen.
+        $isXml       = in_array($beleg['mime_type'], ['application/xml', 'text/xml'], true);
+        $disposition = $isXml ? 'attachment' : 'inline';
+
         header('Content-Type: ' . $beleg['mime_type']);
-        header('Content-Disposition: inline; filename="' . $beleg['filename'] . '"');
+        header('Content-Disposition: ' . $disposition . '; filename="' . $beleg['filename'] . '"');
         header('Content-Length: ' . filesize($realPath));
         readfile($realPath);
     }
@@ -485,12 +490,4 @@ class BelegController extends BaseController
         Beleg::updateHash($id, hash_file('sha256', $absPath));
         echo json_encode(['ok' => true]);
     }
-
-    private function csvSanitize(string $value): string
-    {
-        if ($value !== '' && in_array($value[0], ['=', '+', '-', '@'], true)) {
-            return "'" . $value;
-        }
-        return $value;
-    }
 }
diff --git a/src/Controllers/BookingController.php b/src/Controllers/BookingController.php
index 1e23129..ae84636 100644
--- a/src/Controllers/BookingController.php
+++ b/src/Controllers/BookingController.php
@@ -330,13 +330,5 @@ class BookingController extends BaseController
             View::redirect('/journal', $e->getMessage(), 'error');
         }
     }
-
-    private function csvSanitize(string $value): string
-    {
-        if ($value !== '' && in_array($value[0], ['=', '+', '-', '@'], true)) {
-            return "'" . $value;
-        }
-        return $value;
-    }
 }
 
diff --git a/src/Controllers/EuerController.php b/src/Controllers/EuerController.php
index a4a6827..0adc567 100644
--- a/src/Controllers/EuerController.php
+++ b/src/Controllers/EuerController.php
@@ -116,7 +116,7 @@ class EuerController extends BaseController
 
             fputcsv($out, [
                 $al['anlage_nr'] ?: $al['lfd_nr'],
-                $al['bezeichnung'],
+                $this->csvSanitize((string)$al['bezeichnung']),
                 $fmtDate($al['anschaffungsdatum']),
                 $fmtNum($al['basis']),
                 $nd,
diff --git a/src/Controllers/InvoiceController.php b/src/Controllers/InvoiceController.php
index b5187fe..a7fb793 100644
--- a/src/Controllers/InvoiceController.php
+++ b/src/Controllers/InvoiceController.php
@@ -367,7 +367,7 @@ class InvoiceController extends BaseController
 
         $bookings    = Booking::forBeleg((int)$invoice['beleg_id']);
         $accounts    = Account::all(['aktiv' => 1]);
-        $formErrors  = $_GET['_error'] ?? [];
+        $formErrors  = [];
         $formData    = [];
 
         $view = new View();
diff --git a/src/Models/Setting.php b/src/Models/Setting.php
index 0d38f74..7f65e95 100644
--- a/src/Models/Setting.php
+++ b/src/Models/Setting.php
@@ -85,7 +85,7 @@ class Setting
                 $data['mail_smtp_user'] ?: '',
                 !empty($data['mail_smtp_pass']) ? Crypto::encrypt($data['mail_smtp_pass']) : '',
                 $data['mail_from_name'] ?: '',
-                $data['mail_from_email'] ?: '',
+                self::sanitizeFromEmail($data['mail_from_email'] ?? ''),
                 $data['mail_subject_template'] ?: 'Rechnung %RNR%',
                 $data['mail_body_template'] ?: null,
                 max(50, (int)($data['logo_max_width'] ?? 600)),
@@ -99,6 +99,16 @@ class Setting
         );
     }
 
+    /**
+     * Validiert die Absender-Adresse; bei ungültiger Eingabe wird der Wert verworfen,
+     * damit kein CRLF-Payload als SMTP-Kommando/Header injiziert werden kann (CWE-93).
+     */
+    private static function sanitizeFromEmail(string $value): string
+    {
+        $value = trim($value);
+        return filter_var($value, FILTER_VALIDATE_EMAIL) !== false ? $value : '';
+    }
+
     public static function setLogo(string $path): void
     {
         Database::execute('UPDATE company_settings SET logo_path=? WHERE id=1', [$path]);
diff --git a/src/Services/FinTsFetchService.php b/src/Services/FinTsFetchService.php
index 7ac309a..a506521 100644
--- a/src/Services/FinTsFetchService.php
+++ b/src/Services/FinTsFetchService.php
@@ -95,6 +95,18 @@ class FinTsFetchService
         }
         $fints = $this->fints;
 
+        // Erneute Prüfung unmittelbar vor dem ersten tatsächlichen Request: php-fints
+        // löst den Hostnamen beim Verbindungsaufbau selbst über den System-Resolver auf
+        // (kein IP-Pinning wie bei den selbst gesteuerten cURL-Aufrufen in
+        // NextcloudImportService möglich) – die zweite Prüfung minimiert das Zeitfenster
+        // für DNS-Rebinding zwischen Validierung und Verbindungsaufbau (siehe Issue #130).
+        try {
+            SsrfGuard::assertPublicHttpsUrl($url);
+        } catch (\Throwable $e) {
+            $log('FEHLER: Unzulässige FinTS-URL – ' . $e->getMessage());
+            return;
+        }
+
         $log('TAN-Verfahren werden ermittelt…');
         try {
             $tanModes = $fints->getTanModes();
diff --git a/src/Services/NextcloudImportService.php b/src/Services/NextcloudImportService.php
index e4db152..c9542e0 100644
--- a/src/Services/NextcloudImportService.php
+++ b/src/Services/NextcloudImportService.php
@@ -49,6 +49,8 @@ class NextcloudImportService
     private string $davBase;
     private array $pendingEvents = [];
     private string|null $configError = null;
+    /** @var string[] CURLOPT_RESOLVE-Einträge für die beim Konstruieren geprüfte(n) IP(s) von baseUrl */
+    private array $pinnedResolve = [];
 
     public function __construct()
     {
@@ -61,10 +63,14 @@ class NextcloudImportService
         $this->doneFolder = $doneRaw !== '' ? ('/' . trim($doneRaw, '/')) : null;
 
         // Defensiv geprüft, auch wenn die URL beim Speichern in den Einstellungen
-        // bereits validiert wurde (Schutz gegen SSRF, siehe SsrfGuard).
+        // bereits validiert wurde (Schutz gegen SSRF, siehe SsrfGuard). Die dabei
+        // geprüften IP-Adressen werden für alle cURL-Requests dieser Instanz fest
+        // angebunden (CURLOPT_RESOLVE in newCurl()), damit cURL den Hostnamen nicht
+        // zu einem späteren Zeitpunkt erneut selbst auflöst (DNS-Rebinding/TOCTOU,
+        // siehe Issue #130).
         if ($this->baseUrl !== '') {
             try {
-                SsrfGuard::assertPublicHttpsUrl($this->baseUrl);
+                $this->pinnedResolve = SsrfGuard::resolvePinned($this->baseUrl);
             } catch (\RuntimeException $e) {
                 $this->configError = 'Nextcloud-URL ungültig: ' . $e->getMessage();
                 $this->baseUrl     = '';
@@ -401,6 +407,12 @@ class NextcloudImportService
         curl_setopt($ch, CURLOPT_FOLLOWLOCATION, false);
         curl_setopt($ch, CURLOPT_TIMEOUT, 60);
         curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
+        if (!empty($this->pinnedResolve)) {
+            // Host fest auf die beim Konstruieren geprüfte(n) IP(s) anbinden, statt
+            // ihn erneut über den System-Resolver aufzulösen (DNS-Rebinding-Schutz,
+            // siehe SsrfGuard::resolvePinned()). Host-Header/SNI bleiben unverändert.
+            curl_setopt($ch, CURLOPT_RESOLVE, $this->pinnedResolve);
+        }
         return $ch;
     }
 }
diff --git a/src/Services/SmtpMailer.php b/src/Services/SmtpMailer.php
index 0435f6b..8709cab 100644
--- a/src/Services/SmtpMailer.php
+++ b/src/Services/SmtpMailer.php
@@ -122,7 +122,7 @@ class SmtpMailer
         ?string $attachContent,
         ?string $attachName,
     ): void {
-        $this->cmd('MAIL FROM:<' . $this->fromEmail . '>');
+        $this->cmd('MAIL FROM:<' . $this->sanitizeAddress($this->fromEmail) . '>');
         $this->expect(250);
 
         foreach ($to as $addr) {
@@ -150,7 +150,7 @@ class SmtpMailer
         ?string $attachName,
     ): string {
         $date     = date('r');
-        $fromHdr  = $this->encodeHeader($this->fromName) . ' <' . $this->fromEmail . '>';
+        $fromHdr  = $this->encodeHeader($this->fromName) . ' <' . $this->sanitizeAddress($this->fromEmail) . '>';
         $toHdr    = implode(', ', $to);
         $subjHdr  = $this->encodeHeader($subject);
         $msgId    = '<' . uniqid('sk', true) . '@' . (gethostname() ?: 'localhost') . '>';
@@ -228,6 +228,12 @@ class SmtpMailer
         } while ($line[3] === '-');
     }
 
+    /** Entfernt eingebettete CRLF, damit die Adresse nicht als SMTP-Kommando/Header-Injection missbraucht werden kann. */
+    private function sanitizeAddress(string $value): string
+    {
+        return str_replace(["\r", "\n"], '', $value);
+    }
+
     private function encodeHeader(string $value): string
     {
         $value = str_replace(["\r", "\n"], '', $value);
diff --git a/src/Services/SsrfGuard.php b/src/Services/SsrfGuard.php
index c836c24..0810a63 100644
--- a/src/Services/SsrfGuard.php
+++ b/src/Services/SsrfGuard.php
@@ -16,6 +16,23 @@ class SsrfGuard
      * @throws \RuntimeException wenn die URL kein zulässiges Ziel ist
      */
     public static function assertPublicHttpsUrl(string $url): void
+    {
+        self::resolvePinned($url);
+    }
+
+    /**
+     * Wie assertPublicHttpsUrl(), gibt aber zusätzlich die bereits geprüften
+     * IP-Adressen als CURLOPT_RESOLVE-Einträge ("HOST:PORT:IP") zurück. Damit
+     * kann der aufrufende Code den Host für den tatsächlichen Request auf genau
+     * diese IP(s) festnageln, statt ihn (z.B. durch cURL selbst) erneut über
+     * den System-Resolver aufzulösen – Schutz gegen DNS-Rebinding/TOCTOU
+     * zwischen Prüfung und Verbindungsaufbau (siehe Issue #130).
+     *
+     * @return string[] leer, wenn der Host bereits ein IP-Literal ist (dann
+     *                   ist kein Pinning nötig, cURL löst nichts auf)
+     * @throws \RuntimeException wenn die URL kein zulässiges Ziel ist
+     */
+    public static function resolvePinned(string $url): array
     {
         $parts = parse_url($url);
         if ($parts === false || empty($parts['scheme']) || empty($parts['host'])) {
@@ -29,10 +46,11 @@ class SsrfGuard
         }
 
         $host = trim((string)$parts['host'], '[]');
+        $port = (int)($parts['port'] ?? 443);
 
         if (filter_var($host, FILTER_VALIDATE_IP)) {
             self::assertPublicIp($host);
-            return;
+            return [];
         }
 
         if (strtolower($host) === 'localhost') {
@@ -46,6 +64,11 @@ class SsrfGuard
         foreach ($ips as $ip) {
             self::assertPublicIp($ip);
         }
+
+        return array_map(
+            static fn(string $ip): string => sprintf('%s:%d:%s', $host, $port, $ip),
+            $ips
+        );
     }
 
     private static function assertPublicIp(string $ip): void
diff --git a/src/Views/bank/fints.php b/src/Views/bank/fints.php
index 77d8572..008f0e0 100644
--- a/src/Views/bank/fints.php
+++ b/src/Views/bank/fints.php
@@ -470,6 +470,7 @@ $csvDateFormatOptions = [
 <script>
 (function () {
     const connections = <?= $connectionsJson ?>;
+    const csrfToken = (document.querySelector('meta[name="csrf-token"]') || {}).content || '';
 
     // ── NEU-Modal ────────────────────────────────────────────────
     const modalNew   = document.getElementById('modal-new-connection');
@@ -847,7 +848,7 @@ $csvDateFormatOptions = [
             modalRun.style.display = 'flex';
 
             if (activeEs) activeEs.close();
-            activeEs = new EventSource('/bank/direkt/' + id + '/run');
+            activeEs = new EventSource('/bank/direkt/' + id + '/run?csrf_token=' + encodeURIComponent(csrfToken));
 
             activeEs.addEventListener('log', (ev) => {
                 runLogArea.textContent += ev.data + '\n';
diff --git a/src/Views/bank/upload.php b/src/Views/bank/upload.php
index 22a51e7..90c084f 100644
--- a/src/Views/bank/upload.php
+++ b/src/Views/bank/upload.php
@@ -131,7 +131,9 @@
     }
 
     function esc(str) {
-        return String(str ?? '').replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
+        return String(str ?? '')
+            .replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;')
+            .replace(/"/g,'&quot;').replace(/'/g,'&#39;');
     }
 
     function renderHeaderRow(headerRow, firstData) {
diff --git a/src/Views/belege/detail.php b/src/Views/belege/detail.php
index 5ef2d14..723f7c8 100644
--- a/src/Views/belege/detail.php
+++ b/src/Views/belege/detail.php
@@ -426,7 +426,7 @@ $suppliers = $suppliers ?? [];
                     <?php if (isset($formErrors['_exception'])): ?>
                         Fehler: <?= $h($formErrors['_exception']) ?>
                     <?php else: ?>
-                        <?= implode(' &nbsp;|&nbsp; ', array_map(fn($k,$v) => "<strong>$k:</strong> $v", array_keys($formErrors), $formErrors)) ?>
+                        <?= implode(' &nbsp;|&nbsp; ', array_map(fn($k,$v) => '<strong>'.$h($k).':</strong> '.$h($v), array_keys($formErrors), $formErrors)) ?>
                     <?php endif; ?>
                 </div>
                 <?php endif; ?>
diff --git a/src/Views/invoices/book.php b/src/Views/invoices/book.php
index eedc7b4..6dca500 100644
--- a/src/Views/invoices/book.php
+++ b/src/Views/invoices/book.php
@@ -118,7 +118,7 @@ foreach ($accounts as $acc) {
             <?php if (isset($formErrors['_exception'])): ?>
                 Fehler: <?= $h($formErrors['_exception']) ?>
             <?php else: ?>
-                <?= implode(' &nbsp;|&nbsp; ', array_map(fn($k,$v) => "<strong>$k:</strong> $v", array_keys($formErrors), $formErrors)) ?>
+                <?= implode(' &nbsp;|&nbsp; ', array_map(fn($k,$v) => '<strong>'.$h($k).':</strong> '.$h($v), array_keys($formErrors), $formErrors)) ?>
             <?php endif; ?>
         </div>
         <?php endif; ?>
diff --git a/tests/62_BankDirektRunCsrfTest.php b/tests/62_BankDirektRunCsrfTest.php
new file mode 100644
index 0000000..b62f0fa
--- /dev/null
+++ b/tests/62_BankDirektRunCsrfTest.php
@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+use Steuerkram\Auth;
+
+class BankDirektRunCsrfTest extends TestCase
+{
+    protected string $testName = 'Test 62: CSRF-Schutz für GET /bank/direkt/{id}/run';
+
+    public function run(): void
+    {
+        $backup = $_SESSION['csrf_token'] ?? null;
+        try {
+            $_SESSION['csrf_token'] = 'geheimes-session-token';
+
+            $this->assert(
+                Auth::isValidCsrfToken('geheimes-session-token'),
+                'Korrektes Token wird akzeptiert'
+            );
+            $this->assert(
+                !Auth::isValidCsrfToken('falsches-token'),
+                'Falsches Token wird abgelehnt'
+            );
+            $this->assert(
+                !Auth::isValidCsrfToken(''),
+                'Leeres Token (fehlender Query-Parameter) wird abgelehnt'
+            );
+
+            unset($_SESSION['csrf_token']);
+            $this->assert(
+                !Auth::isValidCsrfToken('irgendein-token'),
+                'Ohne Session-Token wird jedes Token abgelehnt'
+            );
+        } finally {
+            if ($backup === null) {
+                unset($_SESSION['csrf_token']);
+            } else {
+                $_SESSION['csrf_token'] = $backup;
+            }
+        }
+    }
+}
diff --git a/tests/63_SsrfPinningTest.php b/tests/63_SsrfPinningTest.php
new file mode 100644
index 0000000..d8475e5
--- /dev/null
+++ b/tests/63_SsrfPinningTest.php
@@ -0,0 +1,71 @@
+<?php
+
+declare(strict_types=1);
+
+use Steuerkram\Database;
+use Steuerkram\Services\NextcloudImportService;
+use Steuerkram\Services\SsrfGuard;
+
+/**
+ * Test 63: SSRF-Schutz gegen DNS-Rebinding/TOCTOU (Issue #130).
+ * SsrfGuard::resolvePinned() liefert für gültige https-Hosts CURLOPT_RESOLVE-Einträge
+ * mit den bereits geprüften IP-Adressen zurück, statt dass der spätere Request den
+ * Hostnamen erneut selbst auflösen muss. NextcloudImportService übernimmt diese
+ * Einträge und nutzt sie für alle eigenen cURL-Requests.
+ */
+class SsrfPinningTest extends TestCase
+{
+    protected string $testName = 'Test 63: SSRF-Schutz gegen DNS-Rebinding (IP-Pinning)';
+
+    public function run(): void
+    {
+        // Hostname: resolvePinned() liefert nicht-leere CURLOPT_RESOLVE-Einträge im
+        // Format "HOST:PORT:IP" mit dem tatsächlich geprüften Hostnamen und Port.
+        $entries = SsrfGuard::resolvePinned('https://example.com/fints');
+        $this->assertNotEmpty($entries, 'resolvePinned() liefert Einträge für einen gültigen Hostnamen');
+        foreach ($entries as $entry) {
+            $this->assert(
+                str_starts_with($entry, 'example.com:443:'),
+                'CURLOPT_RESOLVE-Eintrag beginnt mit "example.com:443:" (Eintrag: ' . $entry . ')'
+            );
+        }
+
+        // IP-Literal als Host: kein Pinning nötig/möglich, resolvePinned() liefert leeres Array,
+        // validiert aber weiterhin gegen private/interne Bereiche.
+        $entries = SsrfGuard::resolvePinned('https://8.8.8.8/fints');
+        $this->assertEquals([], $entries, 'resolvePinned() liefert kein Pinning für ein bereits öffentliches IP-Literal');
+
+        try {
+            SsrfGuard::resolvePinned('https://127.0.0.1/fints');
+            $this->assert(false, 'resolvePinned() lehnt private IP-Literale weiterhin ab');
+        } catch (\RuntimeException $e) {
+            $this->assert(true, 'resolvePinned() lehnt private IP-Literale weiterhin ab');
+        }
+
+        // NextcloudImportService: pinnedResolve wird beim Konstruieren aus der geprüften
+        // baseUrl befüllt und für alle eigenen cURL-Requests verwendet (newCurl()).
+        $this->configure('https://example.com', 'importuser', 'geheim');
+        $svc     = new NextcloudImportService();
+        $pinned  = $this->readProperty($svc, 'pinnedResolve');
+        $this->assertNotEmpty($pinned, 'NextcloudImportService pinnt die IP(s) der geprüften baseUrl');
+        $this->assert(
+            str_starts_with($pinned[0], 'example.com:443:'),
+            'Gepinnter Eintrag bezieht sich auf den Host der baseUrl'
+        );
+    }
+
+    private function configure(string $url, string $user, string $pass): void
+    {
+        Database::execute(
+            'UPDATE company_settings SET nextcloud_url=?, nextcloud_user=?, nextcloud_pass=? WHERE id=1',
+            [$url, $user, $pass]
+        );
+    }
+
+    private function readProperty(object $obj, string $name): mixed
+    {
+        $prop = new \ReflectionProperty($obj, $name);
+        $prop->setAccessible(true);
+        return $prop->getValue($obj);
+    }
+}
diff --git a/tests/64_AnlageCsvInjectionTest.php b/tests/64_AnlageCsvInjectionTest.php
new file mode 100644
index 0000000..8a743a9
--- /dev/null
+++ b/tests/64_AnlageCsvInjectionTest.php
@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types=1);
+
+use Steuerkram\Controllers\EuerController;
+
+class AnlageCsvInjectionTest extends TestCase
+{
+    protected string $testName = 'Test 64: CSV-Formel-Injection im Anlagelisten-Export verhindert';
+
+    public function run(): void
+    {
+        $year = (int)date('Y');
+
+        \Steuerkram\Database::execute(
+            "INSERT INTO assets (lfd_nr, anlage_nr, bezeichnung, anschaffungsdatum, anschaffungskosten)
+             VALUES (9998, 'TEST-CSV-INJ', ?, ?, 500.00)",
+            ["=cmd|'/c calc'!A1", $year . '-01-15']
+        );
+
+        ob_start();
+        $controller = new EuerController();
+        $controller->anlageCsv(['year' => (string)$year]);
+        $csv = ob_get_clean();
+
+        $lines = explode("\n", $csv);
+        $zeile = null;
+        foreach ($lines as $line) {
+            if (str_contains($line, 'TEST-CSV-INJ')) {
+                $zeile = $line;
+                break;
+            }
+        }
+        $this->assertNotEmpty($zeile, 'Zeile mit Test-Anlage in der CSV-Ausgabe gefunden');
+
+        $felder = explode(';', (string)$zeile);
+        $bezeichnung = $felder[1] ?? '';
+
+        $this->assertEquals(
+            "'=cmd|'/c calc'!A1",
+            $bezeichnung,
+            'Führendes = in der Bezeichnung wird mit vorangestelltem \' entschärft'
+        );
+        $this->assert(
+            !str_starts_with($bezeichnung, '='),
+            'Bezeichnungsfeld beginnt nicht mehr mit = (kein von Excel interpretiertes Formelfeld)'
+        );
+    }
+}
diff --git a/tests/65_InvoiceBookReflectedXssTest.php b/tests/65_InvoiceBookReflectedXssTest.php
new file mode 100644
index 0000000..3fe59bc
--- /dev/null
+++ b/tests/65_InvoiceBookReflectedXssTest.php
@@ -0,0 +1,84 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * Test 65: Reflektiertes XSS über den _error-GET-Parameter bei der
+ * Zahlungserfassung (InvoiceController::book()) ist geschlossen.
+ */
+class InvoiceBookReflectedXssTest extends TestCase
+{
+    protected string $testName = 'Test 65: Kein reflektiertes XSS über _error-Parameter bei Rechnungs-Zahlungserfassung';
+
+    public function run(): void
+    {
+        $datum = date('Y-m-d');
+
+        $customerId = \Steuerkram\Models\Customer::create([
+            'nachname'     => 'XssTest',
+            'firma'        => 'XSS Test GmbH',
+            'strasse'      => 'Teststraße 1',
+            'plz'          => '10115',
+            'ort'          => 'Berlin',
+            'payment_days' => 14,
+        ]);
+
+        $invoiceId = \Steuerkram\Models\Invoice::create([
+            'customer_id'           => $customerId,
+            'betreff'               => 'Testrechnung für XSS-Test',
+            'rechnungs_datum'       => $datum,
+            'leistungszeitraum_von' => date('Y-m-01'),
+            'leistungszeitraum_bis' => date('Y-m-t'),
+            'lines'                 => [
+                [
+                    'bezeichnung' => 'Beratungsleistung',
+                    'menge'       => 1,
+                    'einheit'     => 'h',
+                    'einzelpreis' => 100.00,
+                    'ust_satz'    => 19.0,
+                ],
+            ],
+        ]);
+        $rechnungsNr = \Steuerkram\Models\Invoice::finalize($invoiceId);
+        $invoice     = \Steuerkram\Models\Invoice::find($invoiceId);
+
+        $belegNr = \Steuerkram\Models\Beleg::generateBelegNr();
+        $belegId = \Steuerkram\Models\Beleg::create([
+            'beleg_nr'      => $belegNr,
+            'filename'      => $rechnungsNr . '.pdf',
+            'storage_path'  => '',
+            'mime_type'     => 'application/pdf',
+            'file_hash'     => hash('sha256', $rechnungsNr),
+            'beleg_datum'   => $invoice['rechnungs_datum'],
+            'rechnungs_nr'  => $rechnungsNr,
+            'betrag_brutto' => $invoice['betrag_brutto'],
+            'belegtyp'      => 'Ausgangsrechnung',
+            'notes'         => 'Test Ausgangsrechnung',
+        ]);
+        \Steuerkram\Database::execute(
+            'UPDATE invoices SET beleg_id=? WHERE id=?', [$belegId, $invoiceId]
+        );
+
+        $payload      = '<script>alert(document.cookie)</script>';
+        $getBackup    = $_GET;
+        $_GET['_error'] = ['x' => $payload];
+
+        try {
+            $controller = new \Steuerkram\Controllers\InvoiceController();
+            ob_start();
+            $controller->book(['id' => (string)$invoiceId]);
+            $html = ob_get_clean();
+        } finally {
+            $_GET = $getBackup;
+        }
+
+        $this->assert(
+            !str_contains($html, $payload),
+            'Roher <script>-Payload aus $_GET[_error] erscheint nicht unescaped in der Ausgabe'
+        );
+        $this->assert(
+            !str_contains($html, '<script>alert(document.cookie)'),
+            'Kein ausführbares <script>-Tag in der Ausgabe (auch nicht durch Groß-/Kleinschreibung o.ä. verschleiert)'
+        );
+    }
+}
diff --git a/tests/66_BankUploadPreviewXssTest.php b/tests/66_BankUploadPreviewXssTest.php
new file mode 100644
index 0000000..553d695
--- /dev/null
+++ b/tests/66_BankUploadPreviewXssTest.php
@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * Test 66: Attribut-basiertes DOM-XSS in der CSV/XLSX-Vorschau beim
+ * Bankimport (bank/upload.php) ist geschlossen.
+ *
+ * Die clientseitige esc()-Funktion escapte bisher nur &, < und >, nicht
+ * aber " und '. Da escapte Werte per innerHTML in ein title="..."-Attribut
+ * eingesetzt werden, konnte ein Header-/Zellwert wie
+ * `Spalte" onmouseover="alert(1)` aus dem Attribut ausbrechen.
+ */
+class BankUploadPreviewXssTest extends TestCase
+{
+    protected string $testName = 'Test 66: Kein DOM-XSS in der Bankimport-Vorschau (esc() escaped Anführungszeichen)';
+
+    public function run(): void
+    {
+        $viewFile = __DIR__ . '/../src/Views/bank/upload.php';
+        $content  = file_get_contents($viewFile);
+
+        $this->assert(
+            $content !== false,
+            'View-Datei bank/upload.php ist lesbar'
+        );
+
+        $this->assert(
+            str_contains($content, "replace(/\"/g,'&quot;')")
+            && str_contains($content, "replace(/'/g,'&#39;')"),
+            'esc() escaped sowohl " als auch \' zusätzlich zu &, < und >'
+        );
+
+        $node = trim((string)shell_exec('command -v node'));
+        if ($node === '') {
+            $this->assert(true, 'node nicht verfügbar – Escaping nur per Quelltext-Check geprüft');
+            return;
+        }
+
+        if (!preg_match('/function esc\(str\) \{.*?\n    \}/s', $content, $m)) {
+            $this->assert(false, 'esc()-Funktion konnte aus der View-Datei extrahiert werden');
+            return;
+        }
+
+        $script = $m[0] . "\nconsole.log(esc('Spalte\" onmouseover=\"alert(1)'));";
+        $tmp    = tempnam(sys_get_temp_dir(), 'esc_test_') . '.js';
+        file_put_contents($tmp, $script);
+        $output = shell_exec(escapeshellarg($node) . ' ' . escapeshellarg($tmp) . ' 2>&1');
+        @unlink($tmp);
+
+        $this->assert(
+            $output !== null && !str_contains($output, '" onmouseover="'),
+            'esc() liefert für einen bösartigen Zellwert kein aus dem title-Attribut ausbrechendes Ergebnis'
+        );
+
+        $this->assert(
+            $output !== null && str_contains($output, '&quot;'),
+            'esc() liefert für einen bösartigen Zellwert das erwartete &quot;-Escaping'
+        );
+    }
+}
diff --git a/tests/67_BelegXmlXsltXssTest.php b/tests/67_BelegXmlXsltXssTest.php
new file mode 100644
index 0000000..aa0db09
--- /dev/null
+++ b/tests/67_BelegXmlXsltXssTest.php
@@ -0,0 +1,76 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * Test 67: Stored XSS über XSLT in hochgeladenen XML-Belegen ist geschlossen
+ * (BelegController::serveFile liefert XML-Belege als Download statt inline aus).
+ */
+class BelegXmlXsltXssTest extends TestCase
+{
+    protected string $testName = 'Test 67: XML-Belege werden als Attachment statt inline ausgeliefert';
+
+    public function run(): void
+    {
+        $belegNr = \Steuerkram\Models\Beleg::generateBelegNr();
+        $year    = date('Y');
+        $relDir  = "{$year}/{$belegNr}";
+        $absDir  = \Steuerkram\Config::get('upload_dir') . "/{$relDir}";
+        if (!is_dir($absDir)) {
+            mkdir($absDir, 0755, true);
+        }
+        $storagePath = "{$relDir}/original.xml";
+        $absPath     = \Steuerkram\Config::get('upload_dir') . "/{$storagePath}";
+
+        $xmlPayload = <<<'XML'
+        <?xml version="1.0"?>
+        <?xml-stylesheet type="text/xsl" href="#stylesheet"?>
+        <doc>
+          <xsl:stylesheet id="stylesheet" version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+            <xsl:template match="/">
+              <html><body><script>alert(document.domain)</script></body></html>
+            </xsl:template>
+          </xsl:stylesheet>
+        </doc>
+        XML;
+        file_put_contents($absPath, $xmlPayload);
+
+        $belegId = \Steuerkram\Models\Beleg::create([
+            'beleg_nr'      => $belegNr,
+            'filename'      => 'rechnung.xml',
+            'storage_path'  => $storagePath,
+            'mime_type'     => 'text/xml',
+            'file_hash'     => hash('sha256', $xmlPayload),
+            'beleg_datum'   => date('Y-m-d'),
+            'rechnungs_nr'  => null,
+            'betrag_brutto' => 100.00,
+            'belegtyp'      => 'Eingangsrechnung',
+            'notes'         => 'XSLT-XSS-Test',
+        ]);
+
+        $controller = new \Steuerkram\Controllers\BelegController();
+
+        ob_start();
+        $controller->serveFile(['id' => (string)$belegId]);
+        ob_get_clean();
+
+        $headers     = headers_list();
+        $disposition = '';
+        foreach ($headers as $header) {
+            if (stripos($header, 'Content-Disposition:') === 0) {
+                $disposition = $header;
+            }
+        }
+
+        $this->assertNotEmpty(
+            $disposition,
+            'Es wurde ein Content-Disposition-Header gesetzt'
+        );
+        $this->assert(
+            stripos($disposition, 'attachment') !== false,
+            "XML-Beleg wird als attachment statt inline ausgeliefert (erhalten: {$disposition})"
+        );
+
+        @unlink($absPath);
+    }
+}
diff --git a/tests/68_ProductionErrorHardeningTest.php b/tests/68_ProductionErrorHardeningTest.php
new file mode 100644
index 0000000..b9b220b
--- /dev/null
+++ b/tests/68_ProductionErrorHardeningTest.php
@@ -0,0 +1,78 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * Test 68: Produktions-Härtung der PHP-Fehlerausgabe (Issue #142).
+ * Prüft, dass display_errors deaktiviert ist, die Ini im Image landet und
+ * public/index.php Fehler zentral abfängt statt Details an den Client zu senden.
+ */
+class ProductionErrorHardeningTest extends TestCase
+{
+    protected string $testName = 'Test 68: display_errors aus & zentraler Error-Handler ohne Detail-Leak';
+
+    public function run(): void
+    {
+        $baseDir = dirname(__DIR__);
+
+        $iniPath = $baseDir . '/php/error-handling.ini';
+        $this->assert(is_file($iniPath), 'php/error-handling.ini existiert');
+        $ini = file_get_contents($iniPath) ?: '';
+        $this->assert(
+            (bool) preg_match('/^\s*display_errors\s*=\s*Off\s*$/mi', $ini),
+            'display_errors ist in error-handling.ini auf Off gesetzt'
+        );
+        $this->assert(
+            (bool) preg_match('/^\s*log_errors\s*=\s*On\s*$/mi', $ini),
+            'log_errors ist in error-handling.ini auf On gesetzt'
+        );
+
+        $dockerfile = file_get_contents($baseDir . '/Dockerfile') ?: '';
+        $this->assert(
+            str_contains($dockerfile, 'php/error-handling.ini') && str_contains($dockerfile, '/usr/local/etc/php/conf.d/'),
+            'Dockerfile kopiert error-handling.ini in den PHP conf.d-Ordner'
+        );
+
+        $index = file_get_contents($baseDir . '/public/index.php') ?: '';
+        $this->assert(
+            str_contains($index, 'set_exception_handler'),
+            'index.php registriert einen globalen Exception-Handler'
+        );
+        $this->assert(
+            str_contains($index, 'set_error_handler'),
+            'index.php registriert einen globalen Error-Handler'
+        );
+        $this->assert(
+            str_contains($index, 'register_shutdown_function'),
+            'index.php registriert einen Shutdown-Handler für Fatal Errors'
+        );
+
+        // Der Handler muss vor dem Autoload/Routing stehen, damit auch frühe Fehler abgefangen werden.
+        $handlerPos  = strpos($index, 'set_exception_handler');
+        $autoloadPos = strpos($index, "require BASE_DIR . '/vendor/autoload.php'");
+        $this->assert(
+            $handlerPos !== false && $autoloadPos !== false && $handlerPos < $autoloadPos,
+            'Exception-Handler wird vor dem Autoload registriert'
+        );
+
+        // Sicherstellen, dass im an den Client gesendeten HTML keine Exception-Details landen.
+        $exceptionHandlerBlock = substr($index, $handlerPos, 400);
+        foreach (['getMessage()', 'getTraceAsString()', 'getFile()', '$e->'] as $forbidden) {
+            $this->assert(
+                !str_contains($this->extractEchoBlock($index), $forbidden),
+                "Client-Ausgabe enthält keinen Verweis auf {$forbidden}"
+            );
+        }
+        unset($exceptionHandlerBlock);
+    }
+
+    private function extractEchoBlock(string $index): string
+    {
+        $start = strpos($index, "echo '<!DOCTYPE html>");
+        $end   = strpos($index, "};", $start !== false ? $start : 0);
+        if ($start === false || $end === false) {
+            return '';
+        }
+        return substr($index, $start, $end - $start);
+    }
+}
diff --git a/tests/69_MailFromEmailInjectionTest.php b/tests/69_MailFromEmailInjectionTest.php
new file mode 100644
index 0000000..8fbc904
--- /dev/null
+++ b/tests/69_MailFromEmailInjectionTest.php
@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+use Steuerkram\Models\Setting;
+use Steuerkram\Services\SmtpMailer;
+
+/**
+ * Test 69: SMTP-Header-/Kommando-Injection über mail_from_email verhindert (Fix #148).
+ */
+class MailFromEmailInjectionTest extends TestCase
+{
+    protected string $testName = 'Test 69: mail_from_email – Validierung & SmtpMailer-Härtung';
+
+    public function run(): void
+    {
+        $before = Setting::get();
+        $base   = array_merge($before, [
+            'firma'   => $before['firma'] ?: 'Testfirma',
+            'strasse' => $before['strasse'] ?: 'Teststr. 1',
+            'plz'     => $before['plz'] ?: '12345',
+            'ort'     => $before['ort'] ?: 'Testort',
+        ]);
+
+        // Gültige Adresse wird unverändert übernommen
+        Setting::update(array_merge($base, [
+            'mail_from_email' => 'rechnung@firma.example',
+        ]));
+        $this->assertEquals('rechnung@firma.example', Setting::get()['mail_from_email'], 'Gültige Absenderadresse wird gespeichert');
+
+        // CRLF-Payload (SMTP-Kommando-Injection) wird beim Speichern verworfen, nicht nur bereinigt
+        Setting::update(array_merge($base, [
+            'mail_from_email' => "admin@firma.example>\r\nRCPT TO:<angreifer@evil.example>\r\nDATA",
+        ]));
+        $stored = Setting::get()['mail_from_email'];
+        $this->assert(
+            !str_contains($stored, "\r") && !str_contains($stored, "\n"),
+            'Gespeicherte Absenderadresse enthält kein CR/LF'
+        );
+        $this->assertEquals('', $stored, 'Ungültige (CRLF-behaftete) Absenderadresse wird verworfen statt gespeichert');
+
+        // Andere ungültige Werte (kein E-Mail-Format) werden ebenfalls verworfen
+        Setting::update(array_merge($base, [
+            'mail_from_email' => 'keine-email-adresse',
+        ]));
+        $this->assertEquals('', Setting::get()['mail_from_email'], 'Nicht-E-Mail-Wert wird verworfen');
+
+        // Ursprünglichen Zustand wiederherstellen
+        Setting::update(array_merge($base, [
+            'mail_from_email' => $before['mail_from_email'] ?? '',
+        ]));
+
+        // Defense-in-depth: SmtpMailer::sanitizeAddress() entfernt CRLF selbst,
+        // falls eine mit CRLF behaftete Adresse trotzdem in den Mailer gelangt.
+        $mailer = new SmtpMailer(
+            host:       '127.0.0.1',
+            port:       1,
+            encryption: 'none',
+            user:       '',
+            pass:       '',
+            fromEmail:  'absender@example.com',
+            fromName:   'Absender',
+        );
+        $ref = new \ReflectionMethod($mailer, 'sanitizeAddress');
+        $ref->setAccessible(true);
+        $result = $ref->invoke($mailer, "admin@firma.example>\r\nRCPT TO:<angreifer@evil.example>");
+        $this->assert(
+            !str_contains($result, "\r") && !str_contains($result, "\n"),
+            'sanitizeAddress() entfernt CR/LF aus der Absenderadresse'
+        );
+    }
+}