emilsoftware-utilities 2.0.0-dev.84 → 2.0.0-dev.85

package/dist/accessi-service/services/auth-service/AuthService.js

@@ -0,0 +1,734 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var AuthService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = exports.PASSWORD_LOGIN_DISABLED = void 0;
+const common_1 = require("@nestjs/common");
+const crypto_1 = require("crypto");
+const TwoFactorService_1 = require("../two-factor-service/TwoFactorService");
+const jwt = __importStar(require("jsonwebtoken"));
+const Orm_1 = require("../../../Orm");
+const Utilities_1 = require("../../../Utilities");
+const metrics_1 = require("../../observability/metrics");
+const StatoRegistrazione_1 = require("../../dtos/StatoRegistrazione");
+const UserService_1 = require("../user-service/UserService");
+const FiltriService_1 = require("../filtri-service/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, filtriService, accessiOptions, twoFactorService) {
+        this.userService = userService;
+        this.filtriService = filtriService;
+        this.accessiOptions = accessiOptions;
+        this.twoFactorService = twoFactorService;
+        this.logger = new Logger_1.Logger(AuthService_1.name);
+    }
+    refreshPasswordExpiration(codiceUtente) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.accessiOptions.passwordExpiration) {
+                return;
+            }
+            const configuredDays = Number(this.accessiOptions.passwordExpirationDays);
+            const expirationDays = Number.isFinite(configuredDays) && configuredDays > 0
+                ? Math.trunc(configuredDays)
+                : 90;
+            const query = `UPDATE UTENTI SET DATSCAPWD = DATEADD(${expirationDays} DAY TO CURRENT_TIMESTAMP) WHERE CODUTE = ?`;
+            yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, query, [codiceUtente]);
+        });
+    }
+    isMockDemoUserEnabled() {
+        var _a;
+        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";
+    }
+    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") {
+                return this.getDemoUser();
+            }
+            if (mockDemoUserEnabled &&
+                request.email.toLowerCase() === "admin") {
+                return this.getAdminUser();
+            }
+            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.");
+                case StatoRegistrazione_1.StatoRegistrazione.BLOCC:
+                case StatoRegistrazione_1.StatoRegistrazione.DELETE:
+                    throw new Error("Utente non abilitato");
+                case StatoRegistrazione_1.StatoRegistrazione.INVIO:
+                    throw new Error("Rinnovo password necessario.");
+            }
+            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 = 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");
+                }
+            }
+            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]);
+            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 = (0, jwtTokenOptions_1.verifyAccessiJwt)(token.trim(), verification);
+            }
+            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 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 = (0, jwtTokenOptions_1.verifyAccessiJwt)(refreshToken.trim(), verification);
+            }
+            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 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) || !(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.',
+                    });
+                }
+            }
+            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;
+        });
+    }
+    /**
+     * 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, _d;
+            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,
+            });
+            (0, metrics_1.countAccessiMetric)(this.accessiOptions, 'refresh_reuse_total', {
+                user_sessions_revoked: ((_c = this.accessiOptions.refreshTokenRotation) === null || _c === void 0 ? void 0 : _c.revokeUserSessionsOnReuse) === true,
+            });
+            try {
+                if (params.familyId) {
+                    yield (0, refreshTokenRotation_1.revokeRefreshTokenFamily)(this.accessiOptions, params.familyId, params.expiresAtMs);
+                    (0, metrics_1.countAccessiMetric)(this.accessiOptions, 'refresh_family_revoked_total', { reason: 'reuse' });
+                }
+                if (((_d = this.accessiOptions.refreshTokenRotation) === null || _d === void 0 ? void 0 : _d.revokeUserSessionsOnReuse) === true) {
+                    yield (0, sessionRevocation_1.revokeAccessiUserSessions)(this.accessiOptions, params.codiceUtente, Date.now(), 'refresh_token_reuse');
+                }
+            }
+            catch (error) {
+                (0, metrics_1.recordAccessiMetric)('accessi_store_errors_total', 1, { store: 'refresh_token_rotation' });
+                // 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);
+                const result = yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, query, [
+                    codiceUtente,
+                    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) {
+                throw error;
+            }
+        });
+    }
+    /**
+     * 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();
+            this.logger.info("Avvio migrazione password legacy accessi.");
+            const results = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, "SELECT CODUTE AS codice_utente, PWD AS password FROM UTENTI_PWD WHERE PWD IS NOT NULL", []);
+            const rows = results.map(Utilities_1.RestUtilities.convertKeysToCamelCase);
+            let migratedCount = 0;
+            let skippedCount = 0;
+            for (const row of rows) {
+                const codiceUtente = Number(row.codiceUtente);
+                const storedPassword = typeof row.password === "string" ? row.password : null;
+                if (!codiceUtente ||
+                    !storedPassword ||
+                    Utilities_1.PasswordUtilities.isPasswordHash(storedPassword) ||
+                    Utilities_1.PasswordUtilities.isLegacyPasswordHash(storedPassword)) {
+                    skippedCount += 1;
+                    continue;
+                }
+                const protectedLegacyPassword = Utilities_1.PasswordUtilities.hashLegacyEncryptedPassword(storedPassword);
+                yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, "UPDATE UTENTI_PWD SET PWD = ? WHERE CODUTE = ? AND PWD = ?", [protectedLegacyPassword, codiceUtente, storedPassword]);
+                migratedCount += 1;
+            }
+            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)));
+            const stored = result[0];
+            if (!stored || typeof stored.password !== "string") {
+                return false;
+            }
+            const storedPassword = stored.password;
+            if (Utilities_1.PasswordUtilities.isPasswordHash(storedPassword)) {
+                return Utilities_1.PasswordUtilities.verifyPassword(plainPassword, storedPassword);
+            }
+            const legacyEncryptedPassword = Utilities_1.CryptUtilities.encrypt(plainPassword, this.accessiOptions.encryptionKey);
+            if (Utilities_1.PasswordUtilities.isLegacyPasswordHash(storedPassword)) {
+                const isMigratedLegacyPasswordValid = Utilities_1.PasswordUtilities.verifyLegacyEncryptedPassword(legacyEncryptedPassword, storedPassword);
+                if (isMigratedLegacyPasswordValid) {
+                    yield this.setPassword(codiceUtente, plainPassword, {
+                        enforcePolicy: false,
+                        revokeSessions: false,
+                    });
+                }
+                return isMigratedLegacyPasswordValid;
+            }
+            const isLegacyPasswordValid = Utilities_1.PasswordUtilities.timingSafeStringEquals(storedPassword, legacyEncryptedPassword);
+            if (isLegacyPasswordValid) {
+                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 {
+                utente: {
+                    codiceUtente: 6789,
+                    email: "admin",
+                    statoRegistrazione: StatoRegistrazione_1.StatoRegistrazione.CONF,
+                    cognome: "Admin",
+                    nome: "Admin",
+                    flagGdpr: true,
+                    avatar: "/path/to/avatar.jpg",
+                    flagDueFattori: false,
+                    codiceLingua: "IT",
+                    cellulare: "+391234567890",
+                    flagSuper: true,
+                    roles: [],
+                    permissions: [],
+                },
+                filtri: null,
+                userGrants: {
+                    abilitazioni: [],
+                    grants: [],
+                    ruoli: [],
+                },
+            };
+        });
+    }
+    /** Restituisce l'utente demo fittizio; non contiene dati o grant reali. */
+    getDemoUser() {
+        return {
+            utente: {
+                codiceUtente: 12345,
+                email: "jdoe",
+                statoRegistrazione: StatoRegistrazione_1.StatoRegistrazione.CONF,
+                cognome: "Doe",
+                nome: "John",
+                flagGdpr: true,
+                avatar: "/path/to/avatar.jpg",
+                flagDueFattori: false,
+                codiceLingua: "IT",
+                cellulare: "+391234567890",
+                flagSuper: false,
+                roles: [],
+                permissions: [],
+            },
+            filtri: null,
+            userGrants: {
+                abilitazioni: [],
+                grants: [],
+                ruoli: [],
+            },
+        };
+    }
+    /**
+     * 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.");
+                }
+                (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 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;
+            }
+        });
+    }
+};
+exports.AuthService = AuthService;
+exports.AuthService = AuthService = AuthService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(2, (0, common_1.Inject)("ACCESSI_OPTIONS")),
+    __metadata("design:paramtypes", [UserService_1.UserService,
+        FiltriService_1.FiltriService, Object, TwoFactorService_1.TwoFactorService])
+], AuthService);
+//# sourceMappingURL=AuthService.js.map