emilsoftware-utilities 2.0.0-dev.6 → 2.0.0-dev.61

package/dist/accessi-module/Services/AuthService/AuthService.d.ts

@@ -1,24 +1,80 @@
-import { AccessiOptions } from "../../AccessiModule";
+import { TwoFactorService } from '../TwoFactorService/TwoFactorService';
+import type { AccessiOptions } from "../../AccessiModule";
 import { LoginRequest } from "../../Dtos/LoginRequest";
 import { LoginResult } from "../../Dtos/LoginResponse";
 import { UserService } from "../UserService/UserService";
-import { PermissionService } from "../PermissionService/PermissionService";
 import { FiltriService } from "../FiltriService/FiltriService";
+import { TokenResult } from '../../Dtos/TokenResult';
+/** Error code deliberately returned when a user is configured as SSO-only. */
+export declare const PASSWORD_LOGIN_DISABLED = "PASSWORD_LOGIN_DISABLED";
+interface AccessiTokenIssueOptions {
+    /** Sovrascrive jwtOptions.expiresIn per token a durata ridotta (es. Login as). */
+    expiresIn?: string | number;
+    /** Claim aggiuntive, per esempio l'attore che ha generato un token di impersonazione. */
+    extraClaims?: Record<string, unknown>;
+}
 export declare class AuthService {
     private userService;
-    private permissionService;
     private filtriService;
     private readonly accessiOptions;
+    private readonly twoFactorService;
     private readonly logger;
-    constructor(userService: UserService, permissionService: PermissionService, filtriService: FiltriService, accessiOptions: AccessiOptions);
+    constructor(userService: UserService, filtriService: FiltriService, accessiOptions: AccessiOptions, twoFactorService: TwoFactorService);
     private refreshPasswordExpiration;
     private isMockDemoUserEnabled;
+    /** Creates the normal internal JWT consumed by all existing Accessi guards. */
+    createAccessiToken(utente: LoginResult['utente'], methods?: string[], tokenOptions?: AccessiTokenIssueOptions): TokenResult;
+    /**
+     * Emette l'access token per l'utente target, con l'attore registrato nelle
+     * claim `act` e `loginAs`. La durata e' quella standard di jwtOptions.expiresIn.
+     */
+    createLoginAsToken(utente: LoginResult['utente'], actor: {
+        codiceUtente: number;
+        email?: string;
+    }): TokenResult;
+    /** Builds the standard login response for a user authenticated by a supported method. */
+    getLoginResultForUser(codiceUtente: number, scope?: string): Promise<LoginResult>;
+    /** Users without a row retain the historic password-login enabled default. */
+    private isPasswordLoginEnabled;
+    /**
+     * Autentica con credenziali locali e restituisce profilo, filtri e grant effettivi.
+     * Non crea il JWT: il controller o il flusso SSO deve chiamare `createAccessiToken` sul risultato.
+     * Per utenti SSO-only genera `PASSWORD_LOGIN_DISABLED`, da trattare come istruzione a usare l'SSO.
+     */
     login(request: LoginRequest): Promise<LoginResult>;
+    /**
+     * Verifica un JWT Accessi e ricostruisce il profilo corrente dal database.
+     * Questo evita che privilegi, stato utente o flag amministrativi presenti in un token vecchio restino validi.
+     */
     getAuthenticatedTokenPayload(token: string): Promise<Record<string, unknown>>;
-    setPassword(codiceUtente: number, nuovaPassword: string): Promise<any>;
+    /** Starts a second-factor challenge after the hosting backend has verified an SSO identity. */
+    beginFederatedTwoFactor(codiceUtente: number, identityKey: string): Promise<LoginResult>;
+    private validateTwoFactorProof;
+    verifyTwoFactor(challengeId: string, code: string): Promise<LoginResult>;
+    resendTwoFactor(challengeId: string): Promise<LoginResult>;
+    /**
+     * Persiste una password hashata e aggiorna la scadenza, se la policy password e attiva. Non invia email.
+     * Con `enforcePolicy` (default true) valida la password secondo la policy moderna; i flussi di
+     * migrazione delle password legacy passano `enforcePolicy: false` per non bloccare password storiche.
+     */
+    setPassword(codiceUtente: number, nuovaPassword: string, options?: {
+        enforcePolicy?: boolean;
+    }): Promise<import("../../../Orm").Row[]>;
+    /**
+     * Converte le password legacy cifrate nel formato hash compatibile, senza conoscere le password in chiaro.
+     * E idempotente: hash moderni e gia migrati vengono ignorati.
+     */
     migrateLegacyEncryptedPasswords(): Promise<void>;
+    /** Verifica una password locale e migra automaticamente il formato legacy dopo una verifica positiva. */
     verifyPassword(codiceUtente: number, plainPassword: string): Promise<boolean>;
+    /** Restituisce l'utente fittizio amministratore; usabile solo con `mockDemoUser` esplicitamente abilitato. */
     getAdminUser(): Promise<LoginResult>;
+    /** Restituisce l'utente demo fittizio; non contiene dati o grant reali. */
     getDemoUser(): LoginResult;
+    /**
+     * Consuma un token monouso di reset, riporta l'utente allo stato confermato e salva la nuova password.
+     * Il nonce in `UTENTI.KEYREG` viene annullato prima di impostare la password, impedendo il riuso del token.
+     */
     confirmResetPassword(token: string, newPassword: string): Promise<void>;
 }
+export {};

package/dist/accessi-module/Services/AuthService/AuthService.js

@@ -55,24 +55,27 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 var AuthService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthService = void 0;
+exports.AuthService = exports.PASSWORD_LOGIN_DISABLED = void 0;
 const common_1 = require("@nestjs/common");
+const TwoFactorService_1 = require("../TwoFactorService/TwoFactorService");
 const jwt = __importStar(require("jsonwebtoken"));
 const Orm_1 = require("../../../Orm");
 const Utilities_1 = require("../../../Utilities");
 const StatoRegistrazione_1 = require("../../Dtos/StatoRegistrazione");
 const UserService_1 = require("../UserService/UserService");
-const PermissionService_1 = require("../PermissionService/PermissionService");
 const FiltriService_1 = require("../FiltriService/FiltriService");
 const authenticatedToken_1 = require("../../security/authenticatedToken");
 const passwordResetToken_1 = require("../../security/passwordResetToken");
+const passwordPolicy_1 = require("../../security/passwordPolicy");
 const Logger_1 = require("../../../Logger");
+/** Error code deliberately returned when a user is configured as SSO-only. */
+exports.PASSWORD_LOGIN_DISABLED = 'PASSWORD_LOGIN_DISABLED';
 let AuthService = AuthService_1 = class AuthService {
-    constructor(userService, permissionService, filtriService, accessiOptions) {
+    constructor(userService, filtriService, accessiOptions, twoFactorService) {
         this.userService = userService;
-        this.permissionService = permissionService;
         this.filtriService = filtriService;
         this.accessiOptions = accessiOptions;
+        this.twoFactorService = twoFactorService;
         this.logger = new Logger_1.Logger(AuthService_1.name);
     }
     refreshPasswordExpiration(codiceUtente) {
@@ -93,11 +96,99 @@ let AuthService = AuthService_1 = class AuthService {
         if (!this.accessiOptions.mockDemoUser) {
             return false;
         }
+        // La backdoor mock non e mai attiva in produzione, nemmeno con variabili d'ambiente,
+        // perche emette un superutente senza verifica password.
         const nodeEnv = ((_a = process.env.NODE_ENV) !== null && _a !== void 0 ? _a : "production").toLowerCase();
-        return nodeEnv !== "production" || process.env.ACCESSI_ALLOW_MOCK_DEMO_USER === "true";
+        return nodeEnv !== "production";
     }
+    /** Creates the normal internal JWT consumed by all existing Accessi guards. */
+    createAccessiToken(utente, methods = [], tokenOptions = {}) {
+        var _a, _b;
+        if (!(utente === null || utente === void 0 ? void 0 : utente.codiceUtente)) {
+            throw new Error('Impossibile creare un token senza un utente Accessi valido.');
+        }
+        const loginAs = methods.includes('login_as');
+        if ((utente.flagDueFattori === true || Number(utente.flagDueFattori) === 1) && !methods.includes('otp') && !loginAs) {
+            throw new common_1.UnauthorizedException('Verifica del codice di accesso richiesta.');
+        }
+        const expiresIn = (_a = tokenOptions.expiresIn) !== null && _a !== void 0 ? _a : this.accessiOptions.jwtOptions.expiresIn;
+        const expiresInIsValid = typeof expiresIn === 'number'
+            ? Number.isFinite(expiresIn) && expiresIn > 0
+            : typeof expiresIn === 'string' && expiresIn.trim() !== '';
+        if (!expiresInIsValid) {
+            throw new Error('jwtOptions.expiresIn non configurato: impossibile emettere token senza scadenza.');
+        }
+        const token = jwt.sign(Object.assign(Object.assign({}, ((_b = tokenOptions.extraClaims) !== null && _b !== void 0 ? _b : {})), { utente, typ: 'access', amr: methods }), (0, passwordResetToken_1.getAccessiJwtSecret)(this.accessiOptions), { expiresIn: expiresIn });
+        // Difesa in profondita: un `expiresIn` malformato farebbe emettere un token permanente.
+        const decoded = jwt.decode(token);
+        const decodedPayload = decoded && typeof decoded === 'object' ? decoded : undefined;
+        if (typeof (decodedPayload === null || decodedPayload === void 0 ? void 0 : decodedPayload.exp) !== 'number') {
+            throw new Error('Token emesso senza scadenza: configurazione JWT non valida.');
+        }
+        // Il contratto TokenResult espone sempre la validita in secondi, anche quando
+        // jwtOptions.expiresIn usa un formato leggibile come '24h'.
+        const issuedAt = typeof decodedPayload.iat === 'number' ? decodedPayload.iat : Math.floor(Date.now() / 1000);
+        const expiresInSeconds = Math.max(0, Math.trunc(decodedPayload.exp - issuedAt));
+        return {
+            expiresIn: String(expiresInSeconds),
+            value: token,
+            type: 'Bearer',
+        };
+    }
+    /**
+     * Emette l'access token per l'utente target, con l'attore registrato nelle
+     * claim `act` e `loginAs`. La durata e' quella standard di jwtOptions.expiresIn.
+     */
+    createLoginAsToken(utente, actor) {
+        return this.createAccessiToken(utente, ['login_as'], {
+            extraClaims: {
+                loginAs: true,
+                act: {
+                    sub: String(actor.codiceUtente),
+                    email: actor.email,
+                },
+            },
+        });
+    }
+    /** Builds the standard login response for a user authenticated by a supported method. */
+    getLoginResultForUser(codiceUtente, scope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const users = yield this.userService.getUsers({ codiceUtente }, Object.assign({ includeExtensionFields: true, includeGrants: true }, (scope ? { scope } : {})));
+            const result = users[0];
+            if (!(result === null || result === void 0 ? void 0 : result.utente)) {
+                throw new Error('Utente Accessi non trovato.');
+            }
+            const current = yield this.userService.getAuthenticatedUserSnapshot(codiceUtente);
+            if (!(0, authenticatedToken_1.isAuthenticatedUserEnabledForJwt)(current))
+                throw new common_1.UnauthorizedException('Utente non abilitato.');
+            result.utente = Object.assign(Object.assign({}, result.utente), current);
+            return {
+                utente: result.utente,
+                filtri: yield this.filtriService.getFiltriUser(codiceUtente),
+                userGrants: result.userGrants,
+                extensionFields: result.extensionFields,
+            };
+        });
+    }
+    /** Users without a row retain the historic password-login enabled default. */
+    isPasswordLoginEnabled(codiceUtente) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (((_a = this.accessiOptions.federatedAuthentication) === null || _a === void 0 ? void 0 : _a.enabled) !== true)
+                return true;
+            const rows = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, 'SELECT COALESCE(FLGPASSWORD, 1) AS password_login_enabled FROM UTENTI_CONFIG WHERE CODUTE = ?', [codiceUtente]);
+            const policy = rows.map(Utilities_1.RestUtilities.convertKeysToCamelCase)[0];
+            return (policy === null || policy === void 0 ? void 0 : policy.passwordLoginEnabled) !== false && (policy === null || policy === void 0 ? void 0 : policy.passwordLoginEnabled) !== 0 && (policy === null || policy === void 0 ? void 0 : policy.passwordLoginEnabled) !== '0';
+        });
+    }
+    /**
+     * Autentica con credenziali locali e restituisce profilo, filtri e grant effettivi.
+     * Non crea il JWT: il controller o il flusso SSO deve chiamare `createAccessiToken` sul risultato.
+     * Per utenti SSO-only genera `PASSWORD_LOGIN_DISABLED`, da trattare come istruzione a usare l'SSO.
+     */
     login(request) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             const mockDemoUserEnabled = this.isMockDemoUserEnabled();
             if (mockDemoUserEnabled &&
                 request.email.toLowerCase() === "demo") {
@@ -107,9 +198,19 @@ let AuthService = AuthService_1 = class AuthService {
                 request.email.toLowerCase() === "admin") {
                 return this.getAdminUser();
             }
-            const utente = yield this.userService.getUserByEmail(request.email.toLowerCase());
-            if (!utente)
+            const utente = yield this.userService.getUserByEmail(request.email.trim().toLowerCase());
+            if (!utente) {
+                if (!request.password)
+                    return { passwordRequired: true };
                 throw new Error("Nome utente o password errata!");
+            }
+            const currentUser = yield this.userService.getAuthenticatedUserSnapshot(utente.codiceUtente);
+            if ((0, authenticatedToken_1.isAuthenticatedUserEnabledForJwt)(currentUser) && currentUser.flagDueFattori && currentUser.passwordlessLoginEnabled) {
+                return { challenge: yield this.twoFactorService.issue({ codiceUtente: utente.codiceUtente, email: ((_a = currentUser.email) !== null && _a !== void 0 ? _a : '').trim(), mode: 'passwordless' }) };
+            }
+            // The email-only step has the same response for unknown and ordinary local accounts.
+            if (!request.password)
+                return { passwordRequired: true };
             switch (utente.statoRegistrazione) {
                 case undefined:
                     throw new Error("Struttura dati compromessa: Stato Registrazione inesistente.");
@@ -122,52 +223,117 @@ let AuthService = AuthService_1 = class AuthService {
             if (utente.statoRegistrazione !== StatoRegistrazione_1.StatoRegistrazione.CONF) {
                 throw new Error(`Errore generico. Stato di registrazione non valido: ${utente.statoRegistrazione}.`);
             }
+            if (!(0, authenticatedToken_1.isAuthenticatedUserEnabledForJwt)(currentUser))
+                throw new Error('Utente non abilitato');
+            if (!(yield this.isPasswordLoginEnabled(utente.codiceUtente))) {
+                throw new Error(exports.PASSWORD_LOGIN_DISABLED);
+            }
+            if (typeof request.password !== 'string' || request.password.length === 0) {
+                throw new Error('Nome utente o password errata!');
+            }
             const isPasswordValid = yield this.verifyPassword(utente.codiceUtente, request.password);
             if (!isPasswordValid)
                 throw new Error("Nome utente o password errata!");
             if (this.accessiOptions.passwordExpiration &&
                 this.accessiOptions.passwordExpiration == true) {
                 const today = new Date();
-                const targetDate = new Date(utente.dataScadenzaPassword);
-                if (today >= targetDate) {
+                const targetDate = utente.dataScadenzaPassword
+                    ? new Date(utente.dataScadenzaPassword)
+                    : undefined;
+                // Legacy users may not have an expiration date. Preserve the former non-expiring behaviour for them.
+                if (targetDate && !Number.isNaN(targetDate.getTime()) && today >= targetDate) {
                     throw new Error("PASSWORD_EXPIRED");
                 }
             }
-            const userGrants = yield this.permissionService.getUserRolesAndGrants(utente.codiceUtente);
-            const filtri = yield this.filtriService.getFiltriUser(utente.codiceUtente);
+            if (currentUser.flagDueFattori) {
+                return { challenge: yield this.twoFactorService.issue({ codiceUtente: utente.codiceUtente, email: (_b = currentUser.email) !== null && _b !== void 0 ? _b : '', mode: 'password' }) };
+            }
             const updateLastAccessDateQuery = "UPDATE UTENTI SET DATLASTLOGIN = CURRENT_TIMESTAMP WHERE CODUTE = ?";
             yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, updateLastAccessDateQuery, [utente.codiceUtente]);
-            const extensionFields = {};
-            if (this.accessiOptions.extensionFieldsOptions &&
-                this.accessiOptions.extensionFieldsOptions.length > 0) {
-                for (const ext of this.accessiOptions.extensionFieldsOptions) {
-                    const values = (yield Orm_1.Orm.query(ext.databaseOptions, `SELECT ${ext.tableFields.join(",")} FROM ${ext.tableName} WHERE ${ext.tableJoinFieldName} = ?`, [utente.codiceUtente])).map(Utilities_1.RestUtilities.convertKeysToCamelCase);
-                    extensionFields[ext.objectKey] = values;
-                }
-            }
-            return { utente, filtri, userGrants, extensionFields };
+            return this.getLoginResultForUser(utente.codiceUtente, request.scope);
         });
     }
+    /**
+     * Verifica un JWT Accessi e ricostruisce il profilo corrente dal database.
+     * Questo evita che privilegi, stato utente o flag amministrativi presenti in un token vecchio restino validi.
+     */
     getAuthenticatedTokenPayload(token) {
         return __awaiter(this, void 0, void 0, function* () {
             if (typeof token !== "string" || token.trim() === "") {
                 throw new Error("Token non fornito.");
             }
             const secret = (0, passwordResetToken_1.getAccessiJwtSecret)(this.accessiOptions);
-            const decoded = jwt.verify(token.trim(), secret);
+            const decoded = jwt.verify(token.trim(), secret, { algorithms: ['HS256'] });
             const codiceUtente = (0, authenticatedToken_1.resolveCodiceUtenteFromTokenPayload)(decoded);
             if (!codiceUtente) {
                 throw new Error("Token non valido.");
             }
             const currentUser = yield this.userService.getAuthenticatedUserSnapshot(codiceUtente);
-            if (!(0, authenticatedToken_1.isAuthenticatedUserEnabledForJwt)(currentUser)) {
+            if (!currentUser || !(0, authenticatedToken_1.isAuthenticatedUserEnabledForJwt)(currentUser) || !(0, authenticatedToken_1.isAccessiTokenAllowedForUser)(decoded, currentUser)) {
                 throw new Error("Token non valido o utente non autorizzato.");
             }
             return (0, authenticatedToken_1.buildAuthenticatedTokenPayload)(decoded, currentUser);
         });
     }
-    setPassword(codiceUtente, nuovaPassword) {
+    /** Starts a second-factor challenge after the hosting backend has verified an SSO identity. */
+    beginFederatedTwoFactor(codiceUtente, identityKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const user = yield this.userService.getAuthenticatedUserSnapshot(codiceUtente);
+            if (!(0, authenticatedToken_1.isAuthenticatedUserEnabledForJwt)(user) || !user.flagDueFattori)
+                throw new common_1.UnauthorizedException();
+            return { challenge: yield this.twoFactorService.issue({ codiceUtente, email: (_a = user.email) !== null && _a !== void 0 ? _a : '', mode: 'federated', identityKey }) };
+        });
+    }
+    validateTwoFactorProof(proof) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const user = yield this.userService.getAuthenticatedUserSnapshot(proof.codiceUtente);
+            if (!(0, authenticatedToken_1.isAuthenticatedUserEnabledForJwt)(user) || !user.flagDueFattori || ((_a = user.email) === null || _a === void 0 ? void 0 : _a.trim().toLowerCase()) !== proof.email.trim().toLowerCase()) {
+                throw new common_1.UnauthorizedException('Profilo modificato o utente non abilitato. Ripeti l accesso.');
+            }
+            if (proof.mode === 'passwordless' && !user.passwordlessLoginEnabled)
+                throw new common_1.UnauthorizedException('Accesso senza password disabilitato.');
+            if (proof.mode === 'password' && !(yield this.isPasswordLoginEnabled(proof.codiceUtente)))
+                throw new common_1.UnauthorizedException('Login locale disabilitato.');
+            if (proof.mode === 'federated') {
+                if (!((_b = this.accessiOptions.federatedAuthentication) === null || _b === void 0 ? void 0 : _b.enabled))
+                    throw new common_1.UnauthorizedException();
+                const rows = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, 'SELECT I.IDNKEY FROM UTENTI_IDENTITA_EXT I INNER JOIN SSO_PROVIDER P ON P.PROVIDER = I.PROVIDER WHERE I.IDNKEY = ? AND I.CODUTE = ? AND I.FLGATTIVO = 1 AND P.FLGATTIVO = 1', [proof.identityKey, proof.codiceUtente], false);
+                if (!rows.length)
+                    throw new common_1.UnauthorizedException('Identita SSO non piu abilitata.');
+            }
+        });
+    }
+    verifyTwoFactor(challengeId, code) {
         return __awaiter(this, void 0, void 0, function* () {
+            const proof = yield this.twoFactorService.consume(challengeId, code);
+            yield this.validateTwoFactorProof(proof);
+            const result = yield this.getLoginResultForUser(proof.codiceUtente);
+            result.token = this.createAccessiToken(result.utente, [proof.mode, 'otp']);
+            yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, 'UPDATE UTENTI SET DATLASTLOGIN = CURRENT_TIMESTAMP WHERE CODUTE = ?', [proof.codiceUtente]);
+            if (proof.mode === 'federated') {
+                yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, 'UPDATE UTENTI_IDENTITA_EXT SET DATLASTLOGIN = CURRENT_TIMESTAMP WHERE IDNKEY = ?', [proof.identityKey]);
+            }
+            return result;
+        });
+    }
+    resendTwoFactor(challengeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.validateTwoFactorProof(yield this.twoFactorService.describe(challengeId));
+            return { challenge: yield this.twoFactorService.resend(challengeId) };
+        });
+    }
+    /**
+     * Persiste una password hashata e aggiorna la scadenza, se la policy password e attiva. Non invia email.
+     * Con `enforcePolicy` (default true) valida la password secondo la policy moderna; i flussi di
+     * migrazione delle password legacy passano `enforcePolicy: false` per non bloccare password storiche.
+     */
+    setPassword(codiceUtente, nuovaPassword, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((options === null || options === void 0 ? void 0 : options.enforcePolicy) !== false) {
+                (0, passwordPolicy_1.assertStrongPassword)(nuovaPassword);
+            }
             try {
                 const query = `UPDATE OR INSERT INTO UTENTI_PWD (CODUTE, PWD) VALUES (?, ?)`;
                 const hashedPassword = Utilities_1.PasswordUtilities.hashPassword(nuovaPassword);
@@ -183,6 +349,10 @@ let AuthService = AuthService_1 = class AuthService {
             }
         });
     }
+    /**
+     * Converte le password legacy cifrate nel formato hash compatibile, senza conoscere le password in chiaro.
+     * E idempotente: hash moderni e gia migrati vengono ignorati.
+     */
     migrateLegacyEncryptedPasswords() {
         return __awaiter(this, void 0, void 0, function* () {
             const startedAt = performance.now();
@@ -208,14 +378,16 @@ let AuthService = AuthService_1 = class AuthService {
             this.logger.info(`Migrazione password legacy accessi completata. Letti=${rows.length}, migrati=${migratedCount}, ignorati=${skippedCount}, durataMs=${(performance.now() - startedAt).toFixed(2)}`);
         });
     }
+    /** Verifica una password locale e migra automaticamente il formato legacy dopo una verifica positiva. */
     verifyPassword(codiceUtente, plainPassword) {
         return __awaiter(this, void 0, void 0, function* () {
             const query = `SELECT PWD AS password FROM UTENTI_PWD WHERE CODUTE = ?`;
             const result = (yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, query, [codiceUtente]).then((results) => results.map(Utilities_1.RestUtilities.convertKeysToCamelCase)));
-            if (result.length === 0 || typeof result[0].password !== "string") {
+            const stored = result[0];
+            if (!stored || typeof stored.password !== "string") {
                 return false;
             }
-            const storedPassword = result[0].password;
+            const storedPassword = stored.password;
             if (Utilities_1.PasswordUtilities.isPasswordHash(storedPassword)) {
                 return Utilities_1.PasswordUtilities.verifyPassword(plainPassword, storedPassword);
             }
@@ -223,17 +395,18 @@ let AuthService = AuthService_1 = class AuthService {
             if (Utilities_1.PasswordUtilities.isLegacyPasswordHash(storedPassword)) {
                 const isMigratedLegacyPasswordValid = Utilities_1.PasswordUtilities.verifyLegacyEncryptedPassword(legacyEncryptedPassword, storedPassword);
                 if (isMigratedLegacyPasswordValid) {
-                    yield this.setPassword(codiceUtente, plainPassword);
+                    yield this.setPassword(codiceUtente, plainPassword, { enforcePolicy: false });
                 }
                 return isMigratedLegacyPasswordValid;
             }
-            const isLegacyPasswordValid = storedPassword === legacyEncryptedPassword;
+            const isLegacyPasswordValid = Utilities_1.PasswordUtilities.timingSafeStringEquals(storedPassword, legacyEncryptedPassword);
             if (isLegacyPasswordValid) {
-                yield this.setPassword(codiceUtente, plainPassword);
+                yield this.setPassword(codiceUtente, plainPassword, { enforcePolicy: false });
             }
             return isLegacyPasswordValid;
         });
     }
+    /** Restituisce l'utente fittizio amministratore; usabile solo con `mockDemoUser` esplicitamente abilitato. */
     getAdminUser() {
         return __awaiter(this, void 0, void 0, function* () {
             return {
@@ -249,7 +422,6 @@ let AuthService = AuthService_1 = class AuthService {
                     codiceLingua: "IT",
                     cellulare: "+391234567890",
                     flagSuper: true,
-                    paginaDefault: "/home",
                     roles: [],
                     permissions: [],
                 },
@@ -262,6 +434,7 @@ let AuthService = AuthService_1 = class AuthService {
             };
         });
     }
+    /** Restituisce l'utente demo fittizio; non contiene dati o grant reali. */
     getDemoUser() {
         return {
             utente: {
@@ -276,7 +449,6 @@ let AuthService = AuthService_1 = class AuthService {
                 codiceLingua: "IT",
                 cellulare: "+391234567890",
                 flagSuper: false,
-                paginaDefault: "/home",
                 roles: [],
                 permissions: [],
             },
@@ -288,30 +460,36 @@ let AuthService = AuthService_1 = class AuthService {
             },
         };
     }
+    /**
+     * Consuma un token monouso di reset, riporta l'utente allo stato confermato e salva la nuova password.
+     * Il nonce in `UTENTI.KEYREG` viene annullato prima di impostare la password, impedendo il riuso del token.
+     */
     confirmResetPassword(token, newPassword) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 if (typeof token !== "string" || token.trim() === "") {
                     throw new Error("Token non valido.");
                 }
-                if (typeof newPassword !== "string" ||
-                    newPassword.length < 8 ||
-                    newPassword.length > 100) {
-                    throw new Error("La nuova password deve essere compresa tra 8 e 100 caratteri.");
-                }
-                const secret = (0, passwordResetToken_1.getAccessiJwtSecret)(this.accessiOptions);
+                (0, passwordPolicy_1.assertStrongPassword)(newPassword);
+                const secret = (0, passwordResetToken_1.getAccessiJwtSecret)(this.accessiOptions, 'reset');
                 const { codiceUtente, nonce } = (0, passwordResetToken_1.verifyPasswordResetToken)(token.trim(), secret);
-                const result = (yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, "SELECT CODUTE AS codice_utente, STAREG AS stato_registrazione FROM UTENTI WHERE CODUTE = ? AND KEYREG = ?", [codiceUtente, nonce]).then((rows) => rows.map(Utilities_1.RestUtilities.convertKeysToCamelCase)));
-                if (result.length === 0) {
-                    throw new Error("Token non valido o gia usato.");
-                }
-                const currentState = Number(result[0].statoRegistrazione);
-                if (currentState === StatoRegistrazione_1.StatoRegistrazione.BLOCC ||
-                    currentState === StatoRegistrazione_1.StatoRegistrazione.DELETE) {
-                    throw new Error("Utente non autorizzato a completare il reset password.");
-                }
-                yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, "UPDATE UTENTI SET KEYREG = NULL, STAREG = ? WHERE CODUTE = ?", [StatoRegistrazione_1.StatoRegistrazione.CONF, codiceUtente]);
-                yield this.setPassword(codiceUtente, newPassword);
+                const hashedPassword = Utilities_1.PasswordUtilities.hashPassword(newPassword);
+                yield Orm_1.Orm.withTransaction(this.accessiOptions.databaseOptions, (transaction) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    // A conditional write claims the nonce under the database row lock. A second
+                    // concurrent reset cannot also consume it; failures roll the whole reset back.
+                    const claimed = yield Orm_1.Orm.transactionQuery(transaction, 'UPDATE UTENTI SET KEYREG = NULL, STAREG = ? WHERE CODUTE = ? AND KEYREG = ? AND STAREG IN (?, ?) RETURNING CODUTE', [StatoRegistrazione_1.StatoRegistrazione.CONF, codiceUtente, nonce, StatoRegistrazione_1.StatoRegistrazione.CONF, StatoRegistrazione_1.StatoRegistrazione.INVIO]);
+                    const row = (Array.isArray(claimed) ? claimed[0] : claimed);
+                    if (Number((_a = row === null || row === void 0 ? void 0 : row.CODUTE) !== null && _a !== void 0 ? _a : row === null || row === void 0 ? void 0 : row.codute) !== codiceUtente) {
+                        throw new Error('Token non valido, gia usato o utente non autorizzato.');
+                    }
+                    yield Orm_1.Orm.transactionQuery(transaction, 'UPDATE OR INSERT INTO UTENTI_PWD (CODUTE, PWD) VALUES (?, ?) MATCHING (CODUTE)', [codiceUtente, hashedPassword]);
+                    if (this.accessiOptions.passwordExpiration) {
+                        const days = Number(this.accessiOptions.passwordExpirationDays);
+                        const expirationDays = Number.isFinite(days) && days > 0 ? Math.trunc(days) : 90;
+                        yield Orm_1.Orm.transactionQuery(transaction, `UPDATE UTENTI SET DATSCAPWD = DATEADD(${expirationDays} DAY TO CURRENT_TIMESTAMP) WHERE CODUTE = ?`, [codiceUtente]);
+                    }
+                }));
             }
             catch (error) {
                 throw error;
@@ -322,9 +500,8 @@ let AuthService = AuthService_1 = class AuthService {
 exports.AuthService = AuthService;
 exports.AuthService = AuthService = AuthService_1 = __decorate([
     (0, common_1.Injectable)(),
-    __param(3, (0, common_1.Inject)("ACCESSI_OPTIONS")),
+    __param(2, (0, common_1.Inject)("ACCESSI_OPTIONS")),
     __metadata("design:paramtypes", [UserService_1.UserService,
-        PermissionService_1.PermissionService,
-        FiltriService_1.FiltriService, Object])
+        FiltriService_1.FiltriService, Object, TwoFactorService_1.TwoFactorService])
 ], AuthService);
 //# sourceMappingURL=AuthService.js.map