emilsoftware-utilities 2.0.0-dev.7 → 2.0.0-dev.71

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

@@ -55,24 +55,32 @@ 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 crypto_1 = require("crypto");
+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 sessionRevocation_1 = require("../../security/sessionRevocation");
+const refreshTokenRotation_1 = require("../../security/refreshTokenRotation");
+const audit_1 = require("../../security/audit");
+const jwtTokenOptions_1 = require("../../security/jwtTokenOptions");
+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 +101,125 @@ 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";
     }
+    createToken(utente, methods, type, 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('Durata token non configurata: impossibile emettere token senza scadenza.');
+        }
+        const signing = type === 'refresh'
+            ? (0, jwtTokenOptions_1.getAccessiRefreshTokenSigningConfig)(this.accessiOptions)
+            : (0, jwtTokenOptions_1.getAccessiAccessTokenSigningConfig)(this.accessiOptions);
+        const token = jwt.sign(Object.assign(Object.assign({}, ((_b = tokenOptions.extraClaims) !== null && _b !== void 0 ? _b : {})), { utente, typ: type, amr: methods, jti: (0, crypto_1.randomUUID)(), 
+            // Millisecondi: rende deterministica la revoca sessioni anche quando
+            // il token e emesso nello stesso secondo del cambio password.
+            iatMs: Date.now() }), signing.key, Object.assign({ expiresIn: expiresIn, algorithm: signing.algorithm }, signing.signOptions));
+        // 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',
+        };
+    }
+    /** Creates the normal internal JWT consumed by all existing Accessi guards. */
+    createAccessiToken(utente, methods = [], tokenOptions = {}) {
+        return this.createToken(utente, methods, 'access', tokenOptions);
+    }
+    /** Emette il refresh token quando `jwtOptions.refreshExpiresIn` e configurato. */
+    createRefreshToken(utente, methods = [], tokenOptions = {}) {
+        const expiresIn = this.accessiOptions.jwtOptions.refreshExpiresIn;
+        if (!expiresIn)
+            return undefined;
+        return this.createToken(utente, methods, 'refresh', Object.assign(Object.assign({}, tokenOptions), { expiresIn }));
+    }
+    /** Crea la coppia access + refresh token usata da login, 2FA e SSO. */
+    createTokenPair(utente, methods = [], options) {
+        var _a;
+        // La famiglia identifica il login: access e refresh condividono lo stesso
+        // `fid`, cosi la revoca per riuso sospetto invalida entrambi.
+        const familyId = (_a = options === null || options === void 0 ? void 0 : options.familyId) !== null && _a !== void 0 ? _a : (0, crypto_1.randomUUID)();
+        const access = this.createAccessiToken(utente, methods, { extraClaims: { fid: familyId } });
+        const refresh = this.createRefreshToken(utente, methods, { extraClaims: { fid: familyId } });
+        return Object.assign({ access }, (refresh ? { refresh } : {}));
+    }
+    /**
+     * 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 +229,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 +254,281 @@ 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 this.getLoginResultForUser(utente.codiceUtente, request.scope);
+        });
+    }
+    /**
+     * Verifica un access token Accessi senza sollevare eccezioni per token invalidi.
+     *
+     * Gli errori di configurazione o database continuano a propagarsi: un problema
+     * infrastrutturale non deve essere confuso con un token scaduto.
+     */
+    introspectAccessToken(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof token !== "string" || token.trim() === "") {
+                return { active: false };
+            }
+            const verification = (0, jwtTokenOptions_1.getAccessiAccessTokenVerificationConfig)(this.accessiOptions);
+            let decoded;
+            try {
+                decoded = jwt.verify(token.trim(), verification.key, verification.verifyOptions);
             }
-            return { utente, filtri, userGrants, extensionFields };
+            catch (_a) {
+                return { active: false };
+            }
+            const codiceUtente = (0, authenticatedToken_1.resolveCodiceUtenteFromTokenPayload)(decoded);
+            if (!codiceUtente) {
+                return { active: false };
+            }
+            if (yield (0, sessionRevocation_1.isAccessiTokenRevoked)(this.accessiOptions, decoded, codiceUtente)) {
+                return { active: false };
+            }
+            const currentUser = yield this.userService.getAuthenticatedUserSnapshot(codiceUtente);
+            if (!currentUser ||
+                !(0, authenticatedToken_1.isAuthenticatedUserEnabledForJwt)(currentUser) ||
+                !(0, authenticatedToken_1.isAccessiTokenAllowedForUser)(decoded, currentUser)) {
+                return { active: false };
+            }
+            return {
+                active: true,
+                codiceUtente,
+                payload: (0, authenticatedToken_1.buildAuthenticatedTokenPayload)(decoded, currentUser),
+            };
         });
     }
+    /**
+     * 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 codiceUtente = (0, authenticatedToken_1.resolveCodiceUtenteFromTokenPayload)(decoded);
+            const introspection = yield this.introspectAccessToken(token);
+            if (!introspection.active || !introspection.payload) {
+                throw new Error("Token non valido o utente non autorizzato.");
+            }
+            return introspection.payload;
+        });
+    }
+    /**
+     * Scambia un refresh token valido con una nuova coppia access + refresh.
+     *
+     * Il refresh token non e accettato dai guard API: ha `typ: "refresh"`.
+     */
+    refreshAccessToken(refreshToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.accessiOptions.jwtOptions.refreshExpiresIn) {
+                throw new common_1.UnauthorizedException('Refresh token non abilitato.');
+            }
+            if (typeof refreshToken !== 'string' || refreshToken.trim() === '') {
+                throw new common_1.UnauthorizedException('Refresh token mancante.');
+            }
+            const verification = (0, jwtTokenOptions_1.getAccessiRefreshTokenVerificationConfig)(this.accessiOptions);
+            let decoded;
+            try {
+                decoded = jwt.verify(refreshToken.trim(), verification.key, verification.verifyOptions);
+            }
+            catch (_a) {
+                throw new common_1.UnauthorizedException('Refresh token non valido o scaduto.');
+            }
+            const codiceUtente = (0, authenticatedToken_1.resolveCodiceUtenteFromTokenPayload)(decoded, 'refresh');
             if (!codiceUtente) {
-                throw new Error("Token non valido.");
+                throw new common_1.UnauthorizedException('Refresh token privo di un utente valido.');
+            }
+            const decodedRecord = decoded;
+            const familyId = typeof decodedRecord.fid === 'string' && decodedRecord.fid.trim() !== ''
+                ? decodedRecord.fid
+                : undefined;
+            const jti = typeof decodedRecord.jti === 'string' ? decodedRecord.jti : undefined;
+            const expiresAt = Number(decodedRecord.exp);
+            // La famiglia va controllata per prima: un token appena emesso da uno store
+            // compromesso deve produrre un codice stabile, non il generico 401 utente.
+            if (yield (0, refreshTokenRotation_1.isRefreshTokenFamilyRevoked)(this.accessiOptions, familyId)) {
+                throw new common_1.UnauthorizedException({
+                    code: 'ACCESSI_REFRESH_FAMILY_REVOKED',
+                    message: 'Sessione revocata per riuso sospetto del refresh token.',
+                });
+            }
+            if (yield (0, sessionRevocation_1.isAccessiTokenRevoked)(this.accessiOptions, decoded, codiceUtente)) {
+                throw new common_1.UnauthorizedException('Sessione revocata.');
             }
             const currentUser = yield this.userService.getAuthenticatedUserSnapshot(codiceUtente);
-            if (!(0, authenticatedToken_1.isAuthenticatedUserEnabledForJwt)(currentUser)) {
-                throw new Error("Token non valido o utente non autorizzato.");
+            if (!(0, authenticatedToken_1.isAuthenticatedUserEnabledForJwt)(currentUser) || !(0, authenticatedToken_1.isAccessiTokenAllowedForUser)(decoded, currentUser)) {
+                throw new common_1.UnauthorizedException('Utente non piu autorizzato.');
+            }
+            const rotationStore = (0, refreshTokenRotation_1.getRefreshTokenRotationStore)(this.accessiOptions);
+            if (rotationStore) {
+                if (!jti || !Number.isFinite(expiresAt)) {
+                    throw new common_1.UnauthorizedException('Refresh token privo di jti o scadenza.');
+                }
+                let outcome;
+                try {
+                    outcome = yield (0, refreshTokenRotation_1.consumeRefreshToken)(this.accessiOptions, jti, expiresAt * 1000);
+                }
+                catch (_b) {
+                    throw new common_1.ServiceUnavailableException({
+                        code: 'ACCESSI_REFRESH_ROTATION_UNAVAILABLE',
+                        message: 'Rotazione refresh token non disponibile. Riprova piu tardi.',
+                    });
+                }
+                if (outcome && !outcome.consumed) {
+                    yield this.handleRefreshTokenReuse({
+                        codiceUtente,
+                        jti,
+                        familyId,
+                        consumedAtMs: outcome.consumedAtMs,
+                        expiresAtMs: expiresAt * 1000,
+                    });
+                    throw new common_1.UnauthorizedException({
+                        code: 'ACCESSI_REFRESH_TOKEN_REUSE',
+                        message: 'Refresh token gia utilizzato.',
+                    });
+                }
             }
-            return (0, authenticatedToken_1.buildAuthenticatedTokenPayload)(decoded, currentUser);
+            const login = yield this.getLoginResultForUser(codiceUtente);
+            const methods = Array.isArray(decoded.amr)
+                ? (decoded.amr.filter((method) => typeof method === 'string'))
+                : [];
+            const pair = this.createTokenPair(login.utente, methods, { familyId });
+            login.token = pair.access;
+            if (pair.refresh)
+                login.refreshToken = pair.refresh;
+            return login;
         });
     }
-    setPassword(codiceUtente, nuovaPassword) {
+    /**
+     * Gestisce il riuso di un refresh token gia consumato.
+     *
+     * Il riuso entro `reuseGraceMs` e trattato come retry concorrente del client e
+     * non revoca nulla. Oltre la finestra e considerato un possibile furto: viene
+     * revocata l'intera famiglia (stesso login) e, solo se esplicitamente
+     * configurato, anche le altre sessioni dell'utente.
+     */
+    handleRefreshTokenReuse(params) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const configuredGrace = Number((_b = (_a = this.accessiOptions.refreshTokenRotation) === null || _a === void 0 ? void 0 : _a.reuseGraceMs) !== null && _b !== void 0 ? _b : 10000);
+            const graceMs = Number.isFinite(configuredGrace) ? Math.max(0, configuredGrace) : 10000;
+            const consumedAtMs = params.consumedAtMs;
+            if (graceMs > 0
+                && consumedAtMs !== undefined
+                && Number.isFinite(consumedAtMs)
+                && Date.now() - consumedAtMs <= graceMs) {
+                return;
+            }
+            (0, audit_1.auditAccessi)('accessi_refresh_token_reuse', {
+                codiceUtente: params.codiceUtente,
+                jti: params.jti,
+                familyId: params.familyId,
+                consumedAtMs,
+            });
+            try {
+                if (params.familyId) {
+                    yield (0, refreshTokenRotation_1.revokeRefreshTokenFamily)(this.accessiOptions, params.familyId, params.expiresAtMs);
+                }
+                if (((_c = this.accessiOptions.refreshTokenRotation) === null || _c === void 0 ? void 0 : _c.revokeUserSessionsOnReuse) === true) {
+                    yield (0, sessionRevocation_1.revokeAccessiUserSessions)(this.accessiOptions, params.codiceUtente, Date.now(), 'refresh_token_reuse');
+                }
+            }
+            catch (error) {
+                // La revoca e best effort: il token presentato resta comunque rifiutato.
+                this.logger.error(`Revoca famiglia refresh token fallita: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    /** 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, scope) {
+        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, scope);
+            const tokens = this.createTokenPair(result.utente, [proof.mode, 'otp']);
+            result.token = tokens.access;
+            if (tokens.refresh)
+                result.refreshToken = tokens.refresh;
+            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.
+     * Con `revokeSessions` (default true) invalida le sessioni precedenti: un cambio password deve
+     * interrompere i token gia emessi.
+     */
+    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);
@@ -176,6 +537,9 @@ let AuthService = AuthService_1 = class AuthService {
                     hashedPassword,
                 ]);
                 yield this.refreshPasswordExpiration(codiceUtente);
+                if ((options === null || options === void 0 ? void 0 : options.revokeSessions) !== false) {
+                    yield this.revokeSessionsAfterSecurityChange(codiceUtente, 'password_change');
+                }
                 return result;
             }
             catch (error) {
@@ -183,6 +547,25 @@ let AuthService = AuthService_1 = class AuthService {
             }
         });
     }
+    /**
+     * Revoca le sessioni dopo un evento che deve invalidare i token esistenti.
+     * Best effort: un errore dello store non deve annullare l'operazione gia
+     * persistita (cambio password, blocco, cancellazione).
+     */
+    revokeSessionsAfterSecurityChange(codiceUtente, reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield (0, sessionRevocation_1.revokeAccessiUserSessionsIfConfigured)(this.accessiOptions, codiceUtente, reason);
+            }
+            catch (error) {
+                this.logger.error(`Revoca sessioni fallita per l'utente ${codiceUtente} (${reason}): ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    /**
+     * 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 +591,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 +608,24 @@ 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,
+                        revokeSessions: 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,
+                    revokeSessions: 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 +641,6 @@ let AuthService = AuthService_1 = class AuthService {
                     codiceLingua: "IT",
                     cellulare: "+391234567890",
                     flagSuper: true,
-                    paginaDefault: "/home",
                     roles: [],
                     permissions: [],
                 },
@@ -262,6 +653,7 @@ let AuthService = AuthService_1 = class AuthService {
             };
         });
     }
+    /** Restituisce l'utente demo fittizio; non contiene dati o grant reali. */
     getDemoUser() {
         return {
             utente: {
@@ -276,7 +668,6 @@ let AuthService = AuthService_1 = class AuthService {
                 codiceLingua: "IT",
                 cellulare: "+391234567890",
                 flagSuper: false,
-                paginaDefault: "/home",
                 roles: [],
                 permissions: [],
             },
@@ -288,30 +679,38 @@ 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]);
+                    }
+                }));
+                // Il reset e un cambio password: i token emessi prima non devono piu valere.
+                yield this.revokeSessionsAfterSecurityChange(codiceUtente, 'password_reset');
             }
             catch (error) {
                 throw error;
@@ -322,9 +721,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