@hed-hog/core 0.0.390 → 0.0.393

package/src/auth/auth.service.ts

@@ -1,9 +1,15 @@
-import { getLocaleText } from '@hed-hog/api-locale';
+import {
+  getLocaleFromContext,
+  getLocaleText,
+  isLocaleDetectedFromContext,
+  normalizeLocaleCode,
+} from '@hed-hog/api-locale';
 import { PrismaService } from '@hed-hog/api-prisma';
 import { User } from '@hed-hog/api-types';
 import type { PublicKeyCredentialRequestOptionsJSON } from '@simplewebauthn/server';
 import {
   BadRequestException,
+  ForbiddenException,
   forwardRef,
   Inject,
   Injectable,
@@ -17,8 +23,11 @@ import { SecurityService } from '../security/security.service';
 import { SessionService } from '../session/session.service';
 import { SettingService } from '../setting/setting.service';
 import { TokenService } from '../token/token.service';
+import { UserDeviceService } from '../user-device/user-device.service';
 import { hasPendingPasswordReset } from '../user/user-credential.util';
+import { CreateWithEmailAndPasswordDTO } from '../user/dto/create-with-email-and-password.dto';
 import { UserService } from '../user/user.service';
+import { buildSecurityEventVars } from '../utils/security-event-vars';
 import { resolveWebAuthnOrigin } from '../utils/webauthn-origin';
 import { ForgetDTO } from './dto/forget.dto';
 import { LoginDTO } from './dto/login.dto';
@@ -44,6 +53,8 @@ export class AuthService {
     private readonly user: UserService,
     @Inject(forwardRef(() => ChallengeService))
     private readonly challenge: ChallengeService,
+    @Inject(forwardRef(() => UserDeviceService))
+    private readonly userDevice: UserDeviceService,
   ) { }
 
   async getAuthenticationPayload(locale: string, userId: number, ipAddress: string, userAgent: string, browserId?: string | null) {
@@ -51,6 +62,18 @@ export class AuthService {
     const payload = { sub: userId, sessionId: session.id };
     const accessToken = await this.token.createAccessToken(payload);
     await this.prisma.user.update({ where: { id: userId }, data: { last_login_at: new Date() } });
+
+    // Unico ponto por onde todo caminho de autenticacao passa (senha, MFA,
+    // WebAuthn, recovery code, OAuth, pairing), entao e aqui que o dispositivo
+    // e aprendido. Quem checa `isNewDevice` faz isso antes de chegar aqui.
+    await this.userDevice.remember(userId, { userAgent, browserId, ipAddress });
+
+    // O idioma e aprendido junto com o dispositivo, e pelo mesmo motivo: e o
+    // unico momento em que o cliente se apresenta. Fica antes do alerta de
+    // dispositivo desconhecido (disparado por quem chamou este metodo), entao o
+    // proprio e-mail do primeiro login ja sai traduzido.
+    await this.persistDetectedLanguage(locale, userId);
+
     this.logger.debug(`[AuthService] Session created userId=${userId} sessionId=${session.id}`);
 
     return {
@@ -61,7 +84,66 @@ export class AuthService {
 
   }
 
-  async issueDesktopToken(locale: string, userId: number, ipAddress: string, userAgent: string) {
+  /**
+   * Adota o idioma do cliente como preferencia do usuario - uma unica vez.
+   *
+   * Escrita write-once de proposito: sobrescrever a cada login faria um acesso
+   * de aparelho emprestado, ou de um navegador em outro idioma, apagar a
+   * escolha que o usuario fez na tela de preferencias.
+   *
+   * Nunca lanca. Idioma e acabamento; login que falha por causa dele seria uma
+   * troca pessima.
+   */
+  private async persistDetectedLanguage(locale: string, userId: number) {
+    try {
+      // `detected` distingue a escolha do cliente do default do middleware.
+      // Sem isso, todo cliente que nao manda `Accept-Language` congelaria `en`.
+      if (!isLocaleDetectedFromContext()) {
+        return;
+      }
+
+      const code = normalizeLocaleCode(getLocaleFromContext());
+
+      if (!code) {
+        return;
+      }
+
+      // `setSettingUserValue` valida que a setting aceita override, mas nao o
+      // valor. Sem esta checagem um navegador em `de-DE` gravaria `de`, e todo
+      // e-mail seguinte procuraria um template inexistente.
+      const allowed = await this.setting.getSettingListValues('language');
+
+      if (allowed.length && !allowed.includes(code)) {
+        return;
+      }
+
+      if (await this.setting.getUserSettingValue(userId, 'language')) {
+        return;
+      }
+
+      await this.setting.setSettingUserValue(locale, userId, 'language', code);
+    } catch (error) {
+      this.logger.warn(
+        `[AuthService] Could not persist detected language for userId=${userId}: ${error}`,
+      );
+    }
+  }
+
+  async issueDesktopToken(locale: string, userId: number, ipAddress: string, userAgent: string, isImpersonating = false) {
+    // Aqui o `userId` vem de @User(), que numa simulacao e o ALVO — sem esta
+    // guarda, o operador cunharia para ele uma sessao completa, RENOVAVEL e de
+    // 30 dias, furando o teto da simulacao e saindo da trilha de auditoria. O
+    // RoleGuard ja bloqueia a rota; isto e a segunda barreira.
+    if (isImpersonating) {
+      throw new ForbiddenException(
+        getLocaleText(
+          'impersonation.restrictedRoute',
+          locale,
+          'This action is not available during an access simulation.',
+        ),
+      );
+    }
+
     const { accessToken, refreshToken } = await this.getAuthenticationPayload(locale, userId, ipAddress, userAgent);
     return { accessToken, refreshToken };
   }
@@ -279,7 +361,10 @@ export class AuthService {
           user_identifier_id: true,
           user_identifier: {
             select: {
-              user_id: true
+              user_id: true,
+              // Destinatario do alerta de dispositivo novo: o endereco que o
+              // usuario de fato verificou para entrar.
+              value: true
             }
           }
         }
@@ -320,14 +405,54 @@ export class AuthService {
 
       const user = await this.user.findUserById(locale, challenge.user_identifier.user_id);
 
-      return this.login(locale, user as unknown as User, ipAddress, userAgent, res, browserId, origin);
+      return this.login(locale, user as unknown as User, ipAddress, userAgent, res, browserId, origin, challenge.user_identifier.value);
 
     } catch (error) {
         throw error;
     }
   }
 
-  private async login(locale: string, user: User, ipAddress: string, userAgent: string, res: any, browserId?: string | null, origin?: string) {
+  /**
+   * Dispara o alerta de acesso de dispositivo desconhecido.
+   *
+   * O `await` aqui cobre so a resolucao do app (leitura de setting memoizada);
+   * o envio em si continua sem await de proposito, para nao somar a latencia do
+   * SMTP ao tempo de resposta do login.
+   */
+  private async sendNewDeviceLoginMail(
+    locale: string,
+    user: { name?: string } | null | undefined,
+    email: string | null | undefined,
+    ipAddress: string,
+    userAgent: string,
+    origin?: string,
+  ): Promise<void> {
+    // Tokens de desafio emitidos antes de o `email` passar a ser gravado no
+    // payload chegam aqui sem destinatario; alertar ninguem e melhor do que
+    // deixar o envio explodir dentro do fluxo de login.
+    if (!email) {
+      return;
+    }
+
+    const app = await this.challenge.resolveAppKeyFromOrigin(origin);
+
+    // As variaveis sao formatadas aqui (data e nome do pais saem do `Intl`),
+    // entao o idioma do destinatario tem que ser resolvido ANTES do envio -
+    // senao o corpo sai em portugues com a data em ingles.
+    const recipientLocale = await this.mail.resolveRecipientLocale(email, locale);
+
+    this.mail.sendTemplatedMail(recipientLocale, {
+      email,
+      slug: 'auth-login-new-device',
+      variables: {
+        name: user?.name ?? '',
+        ...buildSecurityEventVars({ ipAddress, userAgent, locale: recipientLocale }),
+      },
+      app,
+    });
+  }
+
+  private async login(locale: string, user: User, ipAddress: string, userAgent: string, res: any, browserId?: string | null, origin?: string, loginEmail?: string) {
 
     // Conta excluída pelo próprio usuário: os identificadores já foram
     // anonimizados, mas a checagem fecha qualquer caminho remanescente.
@@ -352,6 +477,8 @@ export class AuthService {
       throw new BadRequestException(getLocaleText('accessDenied', locale, 'Access denied.'));
     }
 
+    const newDevice = await this.userDevice.isNewDevice(user.id, userAgent, browserId);
+
     const { accessToken, refreshToken, session } = await this.getAuthenticationPayload(
       locale,
       user.id,
@@ -360,26 +487,16 @@ export class AuthService {
       browserId,
     );
 
-    const app = await this.challenge.resolveAppKeyFromOrigin(origin);
-
-    for (const emailObj of emails) {
+    if (newDevice) {
+      // So o endereco usado para entrar. Avisar todos os identificadores
+      // contava, para um e-mail secundario, que o principal tinha sido usado.
+      const wanted = (loginEmail ?? '').trim().toLowerCase();
+      const recipient =
+        emails.find((e) => e.value?.toLowerCase() === wanted)?.value ??
+        emails[0].value;
 
-        this.mail.sendTemplatedMail(
-          locale,
-          {
-            email: emailObj.value,
-            slug: 'auth-login-new-device',
-            variables: {
-              name: user.name,
-              ipAddress,
-              userAgent,
-              location: 'Unknown',
-            },
-            app,
-          }
-        );
-
-      }
+      await this.sendNewDeviceLoginMail(locale, user, recipient, ipAddress, userAgent, origin);
+    }
 
     await this.user.registerUserActivity(user.id, "login")
 
@@ -466,7 +583,55 @@ export class AuthService {
 
     }
 
-    return this.login(locale, user as unknown as User, ipAddress, userAgent, res, browserId, origin);
+    return this.login(locale, user as unknown as User, ipAddress, userAgent, res, browserId, origin, email);
+  }
+
+  /**
+   * Cadastro por e-mail e senha.
+   *
+   * Com `require-email-verification` desligada (o default), a conta já nasce
+   * utilizável e o e-mail de confirmação é apenas informativo — devolver a
+   * pessoa para a tela de login só a obrigaria a digitar de novo o que acabou
+   * de digitar, então o cadastro já termina com a sessão emitida.
+   *
+   * Com a setting ligada, `loginWithEmailAndPassword` barraria o acesso logo em
+   * seguida; nesse caso não emitimos sessão e devolvemos `hasChallenge` para o
+   * app mandar a pessoa confirmar o endereço antes.
+   */
+  async signupWithEmailAndPassword(
+    res: any,
+    locale: string,
+    ipAddress: string,
+    userAgent: string,
+    data: CreateWithEmailAndPasswordDTO,
+    browserId?: string | null,
+    origin?: string,
+  ) {
+    const { user } = await this.user.createWithEmailAndPassword(locale, data);
+
+    const settings = await this.setting.getSettingValues([
+      'require-email-verification',
+    ]);
+
+    if (settings['require-email-verification'] === true) {
+      return { user, hasChallenge: true };
+    }
+
+    // `isNewDevice` retorna false quando o usuário ainda não tem dispositivo
+    // nenhum, então o auto-login não dispara o alerta de "novo acesso" — que
+    // logo após o cadastro pareceria um aviso de invasão.
+    const session = await this.login(
+      locale,
+      user as unknown as User,
+      ipAddress,
+      userAgent,
+      res,
+      browserId,
+      origin,
+      data.email,
+    );
+
+    return { user, hasChallenge: false, ...session };
   }
 
   async verifyRoles(_locale: string, userId: number) {
@@ -484,13 +649,46 @@ export class AuthService {
     })
   }
 
-  async verifyUser(locale: string, userId: number) {
+  async verifyUser(locale: string, userId: number, sessionId?: number | null) {
     const user = await this.user.findUserById(locale, userId);
     const requiresPasswordReset = this.hasPendingPasswordReset(user);
     delete user.user_credential;
     return {
       ...user,
       requires_password_reset: requiresPasswordReset,
+      // Fonte de verdade do banner de simulacao no cliente: a sessionStorage do
+      // navegador e so cache e e gravavel por quem estiver na aba.
+      impersonation: await this.describeImpersonation(sessionId),
+    };
+  }
+
+  private async describeImpersonation(sessionId?: number | null) {
+    if (!sessionId) {
+      return null;
+    }
+
+    const session = await this.prisma.user_session.findUnique({
+      where: { id: sessionId },
+      select: {
+        impersonator_user_id: true,
+        impersonation_reason: true,
+        expires_at: true,
+      },
+    });
+
+    if (!session?.impersonator_user_id) {
+      return null;
+    }
+
+    const operator = await this.prisma.user.findUnique({
+      where: { id: session.impersonator_user_id },
+      select: { id: true, name: true },
+    });
+
+    return {
+      by: operator ?? { id: session.impersonator_user_id, name: '' },
+      reason: session.impersonation_reason,
+      expires_at: session.expires_at.toISOString(),
     };
   }
 
@@ -531,6 +729,17 @@ export class AuthService {
   }
 
   async logout(res, req, refreshToken: string) {
+    // Numa sessao simulada o cookie `rt` da mesma origem e o do OPERADOR: limpar
+    // e revogar por hash aqui derrubaria a sessao real dele. O RoleGuard ja
+    // bloqueia esta rota durante uma simulacao (impersonation-restrictions.ts);
+    // isto e a segunda barreira, no caso de a rota ser alcancada por outro
+    // caminho. Sair de uma simulacao e POST /impersonation/stop.
+    if (req?.auth?.imp === true) {
+      throw new ForbiddenException(
+        'This action is not available during an access simulation.',
+      );
+    }
+
     const result = await this.session.deleteRefreshTokenCookie(res, refreshToken);
     const logoutUserId = req.auth?.sub ?? result?.userId ?? null;
 
@@ -628,6 +837,96 @@ export class AuthService {
     return { userId: targetUserId, token, hasPassword: passwordCount > 0 };
   }
 
+  /**
+   * Confirma o e-mail a partir do link enviado no cadastro. Não emite sessão: o
+   * link só prova o controle da caixa, quem quiser entrar passa pelo login.
+   *
+   * Idempotente de propósito — clientes de e-mail fazem pré-fetch do link e o
+   * usuário costuma clicar de novo depois, e nesses casos ver "link inválido"
+   * assusta mais do que ajuda.
+   */
+  async confirmEmail(locale: string, token: string) {
+    const { userIdentifierId } = await this.token.verifyEmailConfirmationToken(
+      locale,
+      token,
+    );
+
+    const identifier = await this.prisma.user_identifier.findUnique({
+      where: { id: userIdentifierId },
+      include: { user: { select: { id: true, name: true } } },
+    });
+
+    if (!identifier) {
+      throw new BadRequestException(
+        getLocaleText(
+          'confirmEmail.invalidOrExpired',
+          locale,
+          'This confirmation link is invalid or has expired.',
+        ),
+      );
+    }
+
+    if (identifier.verified_at) {
+      return {
+        confirmed: true,
+        alreadyConfirmed: true,
+        email: identifier.value,
+        name: identifier.user?.name ?? null,
+      };
+    }
+
+    await this.prisma.user_identifier.update({
+      where: { id: identifier.id },
+      data: { verified_at: new Date(), enabled: true },
+    });
+
+    await this.user.registerUserActivity(identifier.user_id, 'confirmEmail');
+
+    return {
+      confirmed: true,
+      alreadyConfirmed: false,
+      email: identifier.value,
+      name: identifier.user?.name ?? null,
+    };
+  }
+
+  /**
+   * Reenvia o link de confirmação do cadastro.
+   *
+   * Responde `{ sent: true }` mesmo quando o e-mail não existe ou já está
+   * confirmado: qualquer diferença na resposta transformaria a rota num
+   * oráculo para descobrir quais endereços têm conta.
+   */
+  async resendEmailConfirmation(
+    locale: string,
+    email: string,
+    app?: string,
+    origin?: string,
+  ) {
+    try {
+      const user = await this.user.findUserByEmail(locale, email);
+
+      if (user) {
+        await this.challenge.sendEmailConfirmationLink(
+          locale,
+          user.id,
+          email,
+          app,
+          origin,
+        );
+      }
+    } catch (error: any) {
+      // `sendEmailConfirmationLink` lança NotFound quando o endereço já está
+      // verificado — e uma falha de envio não pode virar erro para o cliente,
+      // sob pena de vazar a existência da conta.
+      this.logger.warn(
+        'Resend of signup confirmation email failed: ' + (error?.message ?? error),
+      );
+    }
+
+    return { sent: true };
+  }
+
   /**
    * Valida (sem consumir) um token de convite de criação de conta e retorna os
    * dados básicos para pré-preencher o formulário no app de treinamentos.
@@ -851,6 +1150,8 @@ export class AuthService {
       throw new BadRequestException(getLocaleText('invalidMfaCode', locale, 'Invalid MFA code.'));
     }
 
+    const newDevice = await this.userDevice.isNewDevice(user.id, userAgent, browserId);
+
     const { accessToken, refreshToken, session } = await this.getAuthenticationPayload(
       locale,
       user.id,
@@ -859,20 +1160,9 @@ export class AuthService {
       browserId,
     );
 
-    this.mail.sendTemplatedMail(
-      locale,
-      {
-        email: payload.email,
-        slug: 'auth-login-new-device',
-        variables: {
-          name: user.name,
-          ipAddress,
-          userAgent,
-          location: 'Unknown',
-        },
-        app: await this.challenge.resolveAppKeyFromOrigin(origin),
-      }
-    );
+    if (newDevice) {
+      await this.sendNewDeviceLoginMail(locale, user, payload.email, ipAddress, userAgent, origin);
+    }
 
     await this.user.registerUserActivity(user.id, "login");
     const requiresPasswordReset = await this.getRequiresPasswordResetByUserId(
@@ -881,7 +1171,7 @@ export class AuthService {
     return { accessToken, refreshToken, session, requiresPasswordReset };
   }
 
-  async verifyMfaRecoveryCode(locale: string, mfaToken: string, recoveryCode: string, ipAddress: string, userAgent: string, browserId?: string | null) {
+  async verifyMfaRecoveryCode(locale: string, mfaToken: string, recoveryCode: string, ipAddress: string, userAgent: string, browserId?: string | null, origin?: string) {
     const payload = await this.token.verifyMfaChallengeToken(mfaToken);
     const user = await this.prisma.user.findUnique({
       where: { id: payload.userId },
@@ -909,6 +1199,8 @@ export class AuthService {
       throw new BadRequestException(getLocaleText('invalidRecoveryCode', locale, 'Invalid recovery code.'));
     }
 
+    const newDevice = await this.userDevice.isNewDevice(user.id, userAgent, browserId);
+
     const { accessToken, refreshToken, session } = await this.getAuthenticationPayload(
       locale,
       user.id,
@@ -917,6 +1209,12 @@ export class AuthService {
       browserId,
     );
 
+    // Entrar por codigo de recuperacao e o caminho mais sensivel dos tres, e era
+    // justamente o unico que nao avisava ninguem.
+    if (newDevice) {
+      await this.sendNewDeviceLoginMail(locale, user, payload.email, ipAddress, userAgent, origin);
+    }
+
     await this.user.registerUserActivity(user.id, "login");
     const requiresPasswordReset = await this.getRequiresPasswordResetByUserId(
       user.id,
@@ -1058,6 +1356,8 @@ export class AuthService {
       data: { verified_at: new Date() }
     });
 
+    const newDevice = await this.userDevice.isNewDevice(userId, userAgent, browserId);
+
     const { accessToken, refreshToken, session } = await this.getAuthenticationPayload(
       locale,
       userId,
@@ -1066,21 +1366,10 @@ export class AuthService {
       browserId,
     );
 
-    const user = await this.prisma.user.findFirst({ where: { id: userId } });
-    this.mail.sendTemplatedMail(
-      locale,
-      {
-        email: payload.email,
-        slug: 'auth-login-new-device',
-        variables: {
-          name: user.name,
-          ipAddress,
-          userAgent,
-          location: 'Unknown',
-        },
-        app: await this.challenge.resolveAppKeyFromOrigin(requestOrigin),
-      }
-    );
+    if (newDevice) {
+      const user = await this.prisma.user.findFirst({ where: { id: userId } });
+      await this.sendNewDeviceLoginMail(locale, user, payload.email, ipAddress, userAgent, requestOrigin);
+    }
 
     await this.user.registerUserActivity(userId, 'login');
     const requiresPasswordReset = await this.getRequiresPasswordResetByUserId(

package/src/auth/dto/confirm-email.dto.ts

@@ -0,0 +1,7 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class ConfirmEmailDTO {
+  @IsString()
+  @IsNotEmpty()
+  token: string;
+}

package/src/auth/dto/resend-confirmation.dto.ts

@@ -0,0 +1,20 @@
+import { getLocaleText } from '@hed-hog/api-locale';
+import { IsNotEmpty, IsOptional, IsString } from 'class-validator';
+import { IsEmailWithSettings } from '../../validators/is-email-with-settings.validator';
+
+export class ResendConfirmationDTO {
+  @IsNotEmpty({ message: (args) => getLocaleText('validation.currentEmailRequired', args.value) })
+  @IsEmailWithSettings({ message: (args) => getLocaleText('validation.currentEmailInvalid', args.value) })
+  set email(value: string) {
+    this._email = value?.trim().toLowerCase();
+  }
+  get email(): string {
+    return this._email;
+  }
+  private _email: string;
+
+  /** Chave do app de origem (ex.: "class"), usada para montar a URL do link. */
+  @IsOptional()
+  @IsString()
+  app?: string;
+}

package/src/authorize/authorize.controller.ts

@@ -85,6 +85,7 @@ export class AuthorizeController {
     @Locale() locale: string,
     @Ip() ipAddress: string,
     @Headers('user-agent') userAgent: string,
+    @Headers('x-browser-id') browserId: string,
   ) {
     return this.service.exchangeCode({
       code: body.code,
@@ -94,6 +95,7 @@ export class AuthorizeController {
       locale,
       ipAddress,
       userAgent,
+      browserId: browserId || null,
     });
   }
 }

package/src/authorize/authorize.service.spec.ts

@@ -191,6 +191,29 @@ describe('AuthorizeService', () => {
         7,
         '127.0.0.1',
         'jest',
+        undefined,
+      );
+    });
+
+    it('repassa o browserId, que identifica o dispositivo da extensão', async () => {
+      const verifier = makeVerifier();
+      deps.prisma.$queryRaw.mockResolvedValue([
+        { user_id: 7, code_challenge: sha256b64url(verifier), scope: 'vaults' },
+      ] as never);
+
+      await service.exchangeCode({
+        ...validExchangeParams('CODE', verifier),
+        browserId: 'ext-install-1',
+      });
+
+      // Sem isto o dispositivo cairia no User-Agent — o do Chrome inteiro, que
+      // muda a cada atualização do navegador.
+      expect(deps.auth.getAuthenticationPayload).toHaveBeenCalledWith(
+        'en',
+        7,
+        '127.0.0.1',
+        'jest',
+        'ext-install-1',
       );
     });
 

package/src/authorize/authorize.service.ts

@@ -168,6 +168,13 @@ export class AuthorizeService {
     locale: string;
     ipAddress: string;
     userAgent: string;
+    /**
+     * Id estavel da instalacao do cliente (header `X-Browser-ID`). Sem ele o
+     * dispositivo e identificado pelo User-Agent, que numa extensao e o do
+     * navegador inteiro — muda a cada atualizacao do Chrome e enche a lista de
+     * dispositivos do usuario de entradas repetidas.
+     */
+    browserId?: string | null;
   }) {
     const client = await this.getClient(params.clientId);
 
@@ -212,6 +219,7 @@ export class AuthorizeService {
       row.user_id,
       params.ipAddress,
       params.userAgent,
+      params.browserId,
     );
 
     return {