Anmeldung ueber das zentrale Auth-Modul awlauth — v1.1.0 [deploy]

NetDiag war die letzte AWL-App mit eigenem Login: eigenes JWT, eigener Schluessel,
eigene Gueltigkeitsdauer, keine Moeglichkeit ein verlorenes Handy gezielt abzumelden.

- api/auth.php prueft das Passwort ueber awlauth_login(). Damit greifen dort auch die
  Brute-Force-Bremse (5 Fehlversuche je IP in 15 min, 10 je Benutzername in 30 min)
  und die einheitliche, nicht-verraeterische Fehlermeldung. Das Token kommt aus
  awlauth_issue_bearer() und legt eine Sitzungszeile an: das Geraet erscheint als
  "NetDiag-App · Android" in der awlauth-Geraeteliste und ist dort einzeln abmeldbar.
- netdiag_api_authenticate() prueft zuerst das awlauth-Token; ein widerrufenes Token
  fuehrt sofort zu 401, auch wenn die Signatur noch stimmt.
- Uebergangsweise gilt ein bereits ausgestelltes altes netdiag-JWT weiter, damit die
  Umstellung niemanden mitten im Einsatz aussperrt. Faellt weg, sobald alle Geraete
  einmal neu angemeldet sind.
- Ohne aktives awlauth laeuft das Modul unveraendert mit dem eigenen JWT weiter.

Die Antwortform von auth.php bleibt bewusst {token, expiresIn, user}: bereits
installierte APKs laufen nach einer einmaligen Neuanmeldung ohne Update weiter.
Haette man sie geaendert, waeren alle Geraete ausgesperrt — und die neue APK gibt es
nur ueber update.php, das Anmeldung verlangt.

CORS: Wildcard-Origin raus. Die API liefert Kundendaten aus; ein * erlaubt jeder
Webseite die Antwort auszulesen, sobald sie an ein Token kommt. Erlaubt sind jetzt nur
die App-Origins und der Vite-Dev-Server, dazu Vary: Origin. Anfragen ohne Origin
(nativer Client, APK-Downloader im Plugin, curl) sind unveraendert.

Lokal gegen das Test-Dolibarr geprueft: Login liefert awlauth-Token, Sitzungszeile
entsteht, orders.php mit Bearer = 200, falsches Passwort = 401, kein/manipuliertes
Token = 401, 4. Fehlversuch = 429 mit Wartezeit, Alt-Token = 200 (Fallback),
fremder Origin bekommt keinen CORS-Header. Anschliessend im Emulator durchgespielt.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

ChangeLog.md

@@ -1,5 +1,38 @@
 # Changelog NetDiag
 
+## 1.1.0 — 2026-08-14
+
+### Anmeldung läuft über das zentrale Auth-Modul (awlauth)
+
+NetDiag war die letzte AWL-App mit eigenem Login: eigenes JWT, eigener Schlüssel
+(`NETDIAG_API_JWT_SECRET`), eigene Gültigkeitsdauer, keine Möglichkeit, ein verlorenes
+Handy gezielt abzumelden. Ab sofort stellt awlauth das Token aus — dasselbe Token,
+derselbe Schlüssel und dieselbe Sitzungs-Registry wie bei den sechs Browser-Apps.
+
+- `api/auth.php` prüft das Passwort über `awlauth_login()`. Damit greifen dort auch die
+  **Brute-Force-Bremse** (5 Fehlversuche je IP in 15 min, 10 je Benutzername in 30 min)
+  und die einheitliche, nicht-verräterische Fehlermeldung. Das Token kommt aus
+  `awlauth_issue_bearer()` und legt eine Sitzungszeile an — das Gerät erscheint als
+  „NetDiag-App · Android" in der awlauth-Geräteliste und ist dort einzeln abmeldbar.
+- `netdiag_api_authenticate()` prüft zuerst das awlauth-Token. Ein **abgelaufenes oder
+  widerrufenes** Token führt sofort zu 401, auch wenn die Signatur noch stimmt.
+- **Übergangsweise** wird ein bereits ausgestelltes altes netdiag-JWT weiterhin akzeptiert,
+  damit die Umstellung niemanden mitten im Einsatz aussperrt. Dieser Pfad entfällt, sobald
+  alle Geräte einmal neu angemeldet sind.
+- Ohne aktives awlauth-Modul läuft NetDiag unverändert mit dem eigenen JWT weiter.
+
+**Die Antwortform von `auth.php` ist bewusst unverändert** (`{token, expiresIn, user}`).
+Bereits installierte APKs laufen nach einer **einmaligen Neuanmeldung** ohne Update weiter.
+
+### CORS enger gefasst
+
+`Access-Control-Allow-Origin: *` ist raus. Die API liefert Kundendaten aus; ein Wildcard
+erlaubt jeder beliebigen Webseite, die Antwort auszulesen, sobald sie an ein Token kommt.
+Erlaubt sind jetzt nur die App-Origins (`https://localhost`, `capacitor://localhost`,
+`http://localhost`, `ionic://localhost`) und der Vite-Dev-Server; dazu `Vary: Origin`.
+Anfragen ohne Origin-Header (nativer HTTP-Client, der APK-Downloader im Kotlin-Plugin,
+curl) bekommen wie bisher eine Antwort — dort greift die Same-Origin-Policy ohnehin nicht.
+
 ## 1.0.0
 
 - Erstversion

api/auth.php

@@ -18,9 +18,20 @@
 /**
  *  \file       netdiag/api/auth.php
  *  \ingroup    netdiag
- *  \brief      API-Endpunkt: Anmeldung der mobilen App, liefert JWT.
+ *  \brief      API-Endpunkt: Anmeldung der mobilen App, liefert ein Token.
  *
  *  POST {login, password}  ->  {token, expiresIn, user}
+ *
+ *  Das Token stellt seit v1.4.0 das zentrale Auth-Modul awlauth aus (gleicher
+ *  Schlüssel und gleiche Sitzungs-Registry wie alle anderen AWL-Apps, damit ein
+ *  verlorenes Handy an EINER Stelle abgemeldet werden kann). Da die App im
+ *  Capacitor-WebView auf einem eigenen Origin läuft, kann sie das SSO-Cookie
+ *  nicht nutzen — sie bekommt denselben Token im Antwort-Body und schickt ihn
+ *  als "Authorization: Bearer ..." zurück.
+ *
+ *  Die ANTWORTFORM ist bewusst unverändert geblieben: bereits installierte
+ *  APKs lesen {token, expiresIn, user} und laufen nach einer einmaligen
+ *  Neuanmeldung ohne Update weiter.
  */
 
 require_once __DIR__.'/netdiag_api.lib.php';
@@ -44,39 +55,75 @@ if ($login === '' || $password === '') {
 require_once DOL_DOCUMENT_ROOT.'/core/lib/security2.lib.php';
 require_once DOL_DOCUMENT_ROOT.'/user/class/user.class.php';
 
-// Zugangsdaten gegen Dolibarr prüfen (Standard-Login-Backend)
+if (netdiag_awlauth_available()) {
-$entitytocheck = (int) $conf->entity;
+	// ---------------------------------------------------------------------
-$authmode = (getDolGlobalString('MAIN_AUTHENTICATION_MODE') ? getDolGlobalString('MAIN_AUTHENTICATION_MODE') : 'dolibarr');
+	// Zentrale Anmeldung über awlauth (Rate-Limit, Passwortprüfung,
-$resultlogin = checkLoginPassEntity($login, $password, $entitytocheck, explode(',', $authmode));
+	// SSO-Eignung) — dieselbe Prüfung wie in allen anderen AWL-Apps.
+	// ---------------------------------------------------------------------
+	$res = awlauth_login($login, $password);
+	if (empty($res['success'])) {
+		netdiag_api_error($res['error'], (int) $res['http']);
+	}
+	$user = $res['user'];
 
-if (empty($resultlogin)) {
+	if (!$user->hasRight('netdiag', 'protocol', 'read')) {
+		netdiag_api_error('Keine Berechtigung für NetDiag', 403);
+	}
+
+	// Gerätebezeichnung für die awlauth-Geräteliste. Ein WebView meldet sich
+	// als Chrome — ohne eigenen Namen wäre die App dort nicht wiederzuerkennen.
+	$ua = isset($_SERVER['HTTP_USER_AGENT']) ? (string) $_SERVER['HTTP_USER_AGENT'] : '';
+	$label = 'NetDiag-App';
+	if ($ua !== '' && function_exists('awlauth_device_label')) {
+		$parts = explode(' · ', awlauth_device_label($ua));
+		if (!empty($parts[0])) {
+			$label .= ' · '.$parts[0];
+		}
+	}
+
+	$issued = awlauth_issue_bearer($user, 0, 'password', $label);
+	if ($issued === null) {
+		netdiag_api_error('Anmeldung konnte nicht abgeschlossen werden', 500);
+	}
+	$token = $issued['token'];
+	$ttl = (int) $issued['expiresIn'];
+} else {
+	// ---------------------------------------------------------------------
+	// Fallback ohne awlauth: modul-eigenes JWT (Alt-Verhalten).
+	// ---------------------------------------------------------------------
+	$entitytocheck = (int) $conf->entity;
+	$authmode = (getDolGlobalString('MAIN_AUTHENTICATION_MODE') ? getDolGlobalString('MAIN_AUTHENTICATION_MODE') : 'dolibarr');
+	$resultlogin = checkLoginPassEntity($login, $password, $entitytocheck, explode(',', $authmode));
+
+	if (empty($resultlogin)) {
 		// Kurze Verzögerung gegen Brute-Force
 		sleep(1);
 		netdiag_api_error('Login fehlgeschlagen', 401);
-}
+	}
 
-$user = new User($db);
+	$user = new User($db);
-if ($user->fetch('', $resultlogin, '', 0, $entitytocheck) <= 0 || empty($user->id)) {
+	if ($user->fetch('', $resultlogin, '', 0, $entitytocheck) <= 0 || empty($user->id)) {
 		netdiag_api_error('Benutzer nicht gefunden', 401);
-}
+	}
-if (!empty($user->statut) && $user->statut == 0) {
+	if (!empty($user->statut) && $user->statut == 0) {
 		netdiag_api_error('Benutzer deaktiviert', 403);
-}
+	}
-$user->loadRights();
+	$user->loadRights();
 
-if (!$user->hasRight('netdiag', 'protocol', 'read')) {
+	if (!$user->hasRight('netdiag', 'protocol', 'read')) {
 		netdiag_api_error('Keine Berechtigung für NetDiag', 403);
-}
+	}
 
-$ttl = (int) getDolGlobalString('NETDIAG_API_TOKEN_TTL', '604800');
+	$ttl = (int) getDolGlobalString('NETDIAG_API_TOKEN_TTL', '604800');
-if ($ttl < 60) {
+	if ($ttl < 60) {
 		$ttl = 604800;
-}
+	}
 
-$token = netdiag_jwt_encode(array(
+	$token = netdiag_jwt_encode(array(
 		'sub'  => (int) $user->id,
 		'name' => $user->getFullName($langs),
-), $ttl);
+	), $ttl);
+}
 
 netdiag_api_respond(array(
 	'token'     => $token,

api/netdiag_api.lib.php

@@ -84,21 +84,54 @@ if (!$res) {
 }
 unset($res, $tmp, $tmp2, $i, $j);
 
+/**
+ * Herkünfte, die die API im Browser-Sinne aufrufen dürfen.
+ *
+ * Die App läuft im Capacitor-WebView auf einem eigenen Origin — je nach
+ * `androidScheme` in capacitor.config.ts ist das `https://localhost` (Release)
+ * oder `http://localhost` (lokaler Debug-Build gegen ein Test-Dolibarr).
+ * Dazu der Vite-Dev-Server für die Entwicklung im Browser.
+ *
+ * @return string[] Erlaubte Origins
+ */
+function netdiag_api_allowed_origins()
+{
+	return array(
+		'https://localhost',
+		'http://localhost',
+		'capacitor://localhost',
+		'ionic://localhost',
+		'http://localhost:5173',
+	);
+}
+
 /**
  * CORS-Header setzen und Preflight (OPTIONS) sofort beantworten.
  *
  * Dolibarr selbst ist zu diesem Zeitpunkt bereits geladen (siehe Block
  * oben, der beim require_once dieser Lib im globalen Scope läuft).
  *
+ * Kein Wildcard-Origin mehr: die API liefert Kundendaten aus und wird per
+ * Bearer-Token authentifiziert. Ein `*` erlaubt jeder beliebigen Webseite,
+ * die Antwort auszulesen, sobald sie an ein Token kommt. Fehlt der
+ * Origin-Header ganz (native HTTP-Clients, curl, der APK-Downloader im
+ * Kotlin-Plugin), wird kein CORS-Header gesetzt — dort greift die Same-Origin-
+ * Policy des Browsers ohnehin nicht.
+ *
  * @return void
  */
 function netdiag_api_bootstrap()
 {
-	// CORS: Bearer-Token-Auth, daher Wildcard-Origin erlaubt (keine Cookies)
+	$origin = isset($_SERVER['HTTP_ORIGIN']) ? (string) $_SERVER['HTTP_ORIGIN'] : '';
-	header('Access-Control-Allow-Origin: *');
+	// Antwort hängt vom Origin ab -> Caches/Proxys müssen das wissen
+	header('Vary: Origin');
+
+	if ($origin !== '' && in_array($origin, netdiag_api_allowed_origins(), true)) {
+		header('Access-Control-Allow-Origin: '.$origin);
 		header('Access-Control-Allow-Methods: GET, POST, OPTIONS');
 		header('Access-Control-Allow-Headers: Content-Type, Authorization');
 		header('Access-Control-Max-Age: 86400');
+	}
 
 	// Preflight sofort beantworten
 	if ($_SERVER['REQUEST_METHOD'] === 'OPTIONS') {
@@ -107,6 +140,31 @@ function netdiag_api_bootstrap()
 	}
 }
 
+/**
+ * Zentrales Auth-Modul einbinden, sofern vorhanden und aktiv.
+ *
+ * NetDiag läuft auch ohne awlauth weiter (Fallback auf das modul-eigene JWT) —
+ * so, wie es die awlauth-Doku für Fremdmodule vorschreibt. Damit lässt sich das
+ * Modul auch in einer Instanz betreiben, in der awlauth nicht installiert ist.
+ *
+ * @return bool True wenn awlauth benutzbar ist
+ */
+function netdiag_awlauth_available()
+{
+	static $ok = null;
+	if ($ok !== null) {
+		return $ok;
+	}
+	$ok = false;
+	if (function_exists('dol_include_once')) {
+		dol_include_once('/awlauth/lib/awlauth.lib.php');
+	}
+	if (function_exists('awlauth_is_enabled') && function_exists('awlauth_verify_token')) {
+		$ok = awlauth_is_enabled();
+	}
+	return $ok;
+}
+
 /**
  * JSON-Antwort senden und Skript beenden.
  *
@@ -253,6 +311,12 @@ function netdiag_api_read_token()
 /**
  * Aktuellen Request authentifizieren. Bricht mit 401 ab, wenn ungültig.
  *
+ * Reihenfolge: zuerst das zentrale awlauth-Token (Signatur + serverseitig
+ * widerrufbare Sitzung), danach als Übergangslösung das alte modul-eigene JWT.
+ * Der Fallback hält bereits ausgestellte App-Tokens bis zu ihrem Ablauf gültig,
+ * damit die Umstellung niemanden mitten im Einsatz aussperrt. Er entfällt,
+ * sobald alle Geräte einmal neu angemeldet sind (siehe ROADMAP_UMSETZUNG L5).
+ *
  * @param  DoliDB $db Datenbank-Handler
  * @return User       Geladenes Benutzer-Objekt
  */
@@ -262,20 +326,33 @@ function netdiag_api_authenticate($db)
 	if (empty($token)) {
 		netdiag_api_error('Kein Token übermittelt', 401);
 	}
-	$payload = netdiag_jwt_decode($token);
+
-	if ($payload === null || empty($payload['sub'])) {
+	$user = null;
-		netdiag_api_error('Token ungültig oder abgelaufen', 401);
+
+	// 1. Zentrales Auth-Modul
+	if (netdiag_awlauth_available()) {
+		$user = awlauth_verify_token($token);
 	}
 
+	// 2. Übergang: altes netdiag-JWT
+	if ($user === null) {
+		$payload = netdiag_jwt_decode($token);
+		if ($payload !== null && !empty($payload['sub'])) {
 			require_once DOL_DOCUMENT_ROOT.'/user/class/user.class.php';
-	$user = new User($db);
+			$legacy = new User($db);
-	if ($user->fetch((int) $payload['sub']) <= 0 || empty($user->id)) {
+			if ($legacy->fetch((int) $payload['sub']) > 0 && !empty($legacy->id)) {
-		netdiag_api_error('Benutzer nicht gefunden', 401);
+				$legacy->loadRights();
+				$user = $legacy;
 			}
-	if (!empty($user->statut) && $user->statut == 0) {
+		}
+	}
+
+	if ($user === null || empty($user->id)) {
+		netdiag_api_error('Token ungültig oder abgelaufen', 401);
+	}
+	if (isset($user->statut) && $user->statut == 0) {
 		netdiag_api_error('Benutzer deaktiviert', 403);
 	}
-	$user->loadRights();
 
 	if (!$user->hasRight('netdiag', 'protocol', 'read')) {
 		netdiag_api_error('Keine Berechtigung für NetDiag', 403);

core/modules/modNetDiag.class.php

@@ -67,7 +67,7 @@ class modNetDiag extends DolibarrModules
 		$this->editor_url = '';
 		$this->editor_squarred_logo = '';
 
-		$this->version = '1.0.0';
+		$this->version = '1.1.0';
 
 		// Konstanten-Name in llx_const für Modul-Status
 		$this->const_name = 'MAIN_MODULE_'.strtoupper($this->name);