@hed-hog/core 0.0.387 → 0.0.393

package/src/pairing/pairing.service.ts

@@ -0,0 +1,614 @@
+// `Prisma` vem de @hed-hog/api-prisma, não de '@prisma/client': o tsconfig do
+// monorepo mapeia '@prisma/client' para o client gerado (.prisma/client), que
+// não expõe o helper `Prisma.sql`. É a convenção do repo inteiro.
+import { Prisma, PrismaService } from '@hed-hog/api-prisma';
+import {
+  BadRequestException,
+  Inject,
+  Injectable,
+  Logger,
+  forwardRef,
+} from '@nestjs/common';
+import { Cron, CronExpression } from '@nestjs/schedule';
+import { timingSafeEqual } from 'crypto';
+import { AuthService } from '../auth/auth.service';
+import { SecurityService } from '../security/security.service';
+
+/**
+ * Pareamento de aparelhos por QR code, nas duas direções.
+ *
+ * Modelado no `AuthorizeService`: token opaco de que só o hash é persistido, TTL
+ * curto, e toda transição de estado decidida pelo banco com
+ * `UPDATE ... WHERE ... IS NULL RETURNING`. Dois requests concorrentes — o caso
+ * de replay — só podem ter um vencedor, e quem decide é o Postgres.
+ *
+ * ## O que este serviço NÃO faz
+ *
+ * Ele nunca decifra `payload_enc`. Aquele blob é AES-256-GCM feito no cliente,
+ * com uma chave que jamais chega até aqui: na direção A ela sai do fragmento do
+ * QR (que o navegador não transmite), na direção B da chave privada efêmera que
+ * vive só na memória da aba. Chamar `security.decrypt` nele não daria erro de
+ * compilação — daria um cofre a menos de zero-knowledge. O spec cobre isso.
+ *
+ * ## Por que a direção A tem duas fases
+ *
+ * Se o navegador subisse o blob junto com o QR, quem fotografasse a tela nos 2
+ * minutos de validade levaria a sessão e as chaves. Com claim → confirm →
+ * redeem, o aparelho que reivindica não recebe nada; o blob só sobe depois que a
+ * pessoa aprovou, olhando o IP e o user-agent de quem pediu. Um QR
+ * fotografado vira um alerta recusável na tela da própria vítima.
+ */
+@Injectable()
+export class PairingService {
+  private readonly logger = new Logger(PairingService.name);
+
+  /**
+   * Curto de propósito: o QR fica visível numa tela, e o único trabalho dele é
+   * sobreviver ao tempo de pegar o celular e apontar a câmera.
+   */
+  private readonly pairingTtlMs = 120_000;
+
+  static readonly BROWSER_TO_DEVICE = 'browser-to-device';
+  static readonly DEVICE_TO_BROWSER = 'device-to-browser';
+
+  /**
+   * Uma mensagem só para "não existe", "expirou", "já foi usado" e "está no
+   * estado errado". Distinguir esses casos contaria a um atacante exatamente
+   * onde ele está no fluxo.
+   */
+  private static readonly GENERIC_ERROR =
+    'Pareamento inválido, expirado ou já utilizado. Gere um novo QR code.';
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => SecurityService))
+    private readonly security: SecurityService,
+    @Inject(forwardRef(() => AuthService))
+    private readonly auth: AuthService,
+  ) {}
+
+  /* ------------------------------------------------------------------ */
+  /* Comum                                                               */
+  /* ------------------------------------------------------------------ */
+
+  private invalid(): BadRequestException {
+    return new BadRequestException(PairingService.GENERIC_ERROR);
+  }
+
+  private async assertClient(clientId: string) {
+    const client = await this.prisma.oauth_app_client.findUnique({
+      where: { client_id: clientId },
+    });
+
+    if (!client || !client.enabled) {
+      throw new BadRequestException('Aplicativo desconhecido ou desabilitado.');
+    }
+
+    return client;
+  }
+
+  private expiresAt(): Date {
+    return new Date(Date.now() + this.pairingTtlMs);
+  }
+
+  private parseId(id: string): bigint {
+    try {
+      const parsed = BigInt(id);
+      // BigInt(0) e não 0n: o literal exige target ES2020, e as libraries
+      // compilam com es2017 no tsconfig.production.json — ver
+      // libraries/fiscal/src/document/fiscal-document.totals.ts.
+      if (parsed <= BigInt(0)) throw new Error('id inválido');
+      return parsed;
+    } catch {
+      throw this.invalid();
+    }
+  }
+
+  /**
+   * Mesma tabela que `UserService.registerUserActivity` escreve. O insert é
+   * direto para não arrastar o UserModule inteiro — com todas as suas
+   * dependências — para dentro de um módulo de auth por causa de uma linha.
+   */
+  private async logActivity(userId: number | null, action: string) {
+    if (!userId) return;
+    await this.prisma.user_activity
+      .create({ data: { user_id: userId, action } })
+      .catch(() => null);
+  }
+
+  /**
+   * Comparação em tempo constante de duas strings base64. Usada na prova de
+   * posse da chave efêmera, que é pública mas cujo desencontro não deve vazar
+   * quantos bytes bateram.
+   */
+  private safeEquals(a: string, b: string): boolean {
+    const left = Buffer.from(a ?? '');
+    const right = Buffer.from(b ?? '');
+    if (left.length !== right.length) return false;
+    try {
+      return timingSafeEqual(left, right);
+    } catch {
+      return false;
+    }
+  }
+
+  /* ------------------------------------------------------------------ */
+  /* Direção A — navegador destravado → celular                          */
+  /* ------------------------------------------------------------------ */
+
+  /** Abre o pareamento. Chamado pelo navegador, que já está autenticado. */
+  async start(params: {
+    userId: number;
+    authTokenHash: string;
+    clientId: string;
+    ipAddress: string;
+    userAgent: string;
+  }) {
+    await this.assertClient(params.clientId);
+
+    const expiresAt = this.expiresAt();
+    const row = await this.prisma.device_pairing_request.create({
+      data: {
+        direction: PairingService.BROWSER_TO_DEVICE,
+        auth_hash: params.authTokenHash,
+        user_id: params.userId,
+        client_id: params.clientId,
+        issued_ip: params.ipAddress,
+        issued_user_agent: params.userAgent,
+        expires_at: expiresAt,
+      },
+    });
+
+    await this.logActivity(params.userId, 'device-pairing-started');
+    this.logger.debug(
+      `[PairingService] pareamento aberto id=${row.id} userId=${params.userId}`,
+    );
+
+    return { id: String(row.id), expiresAt: expiresAt.toISOString() };
+  }
+
+  /** Estado para a tela do navegador, incluindo quem reivindicou. */
+  async status(userId: number, id: string) {
+    const row = await this.prisma.device_pairing_request.findFirst({
+      where: {
+        id: this.parseId(id),
+        user_id: userId,
+        direction: PairingService.BROWSER_TO_DEVICE,
+      },
+    });
+
+    if (!row) throw this.invalid();
+
+    return {
+      status: this.deriveStatus(row),
+      claim: row.claimed_at
+        ? {
+            ip: row.claim_ip,
+            userAgent: row.claim_user_agent,
+            at: row.claimed_at.toISOString(),
+          }
+        : null,
+      expiresAt: row.expires_at.toISOString(),
+    };
+  }
+
+  private deriveStatus(row: {
+    cancelled_at: Date | null;
+    consumed_at: Date | null;
+    confirmed_at: Date | null;
+    claimed_at: Date | null;
+    expires_at: Date;
+  }): string {
+    if (row.cancelled_at) return 'cancelled';
+    if (row.consumed_at) return 'consumed';
+    if (row.expires_at.getTime() <= Date.now()) return 'expired';
+    if (row.confirmed_at) return 'confirmed';
+    if (row.claimed_at) return 'claimed';
+    return 'pending';
+  }
+
+  /**
+   * O aparelho que leu o QR se anuncia. Não recebe nada além de "aguarde": é
+   * este passo que transforma uma foto do QR num alerta na tela da vítima em vez
+   * de um comprometimento silencioso.
+   */
+  async claim(params: {
+    authToken: string;
+    clientId: string;
+    ipAddress: string;
+    userAgent: string;
+  }) {
+    const authHash = this.security.hashSha256(params.authToken);
+
+    const rows = await this.prisma.$queryRaw<
+      Array<{ id: bigint; user_id: number; expires_at: Date }>
+    >(
+      Prisma.sql`
+        UPDATE device_pairing_request
+        SET claimed_at = NOW(),
+            claim_ip = ${params.ipAddress},
+            claim_user_agent = ${params.userAgent}
+        WHERE auth_hash = ${authHash}
+          AND client_id = ${params.clientId}
+          AND direction = ${PairingService.BROWSER_TO_DEVICE}
+          AND expires_at > NOW()
+          AND claimed_at IS NULL
+          AND cancelled_at IS NULL
+          AND consumed_at IS NULL
+        RETURNING id, user_id, expires_at
+      `,
+    );
+
+    const row = rows[0];
+    if (!row) {
+      // Um segundo leitor do mesmo QR perde a corrida aqui, decidida pelo banco.
+      this.logger.warn('[PairingService] claim recusado (hash inválido ou já reivindicado)');
+      throw this.invalid();
+    }
+
+    await this.logActivity(row.user_id, 'device-pairing-claimed');
+
+    return {
+      status: 'claimed',
+      expiresAt: row.expires_at.toISOString(),
+    };
+  }
+
+  /** O navegador aprova o aparelho e só então entrega o blob cifrado. */
+  async confirm(params: { userId: number; id: string; payloadEnc: string }) {
+    const rows = await this.prisma.$queryRaw<Array<{ id: bigint }>>(
+      Prisma.sql`
+        UPDATE device_pairing_request
+        SET confirmed_at = NOW(),
+            payload_enc = ${params.payloadEnc}
+        WHERE id = ${this.parseId(params.id)}
+          AND user_id = ${params.userId}
+          AND direction = ${PairingService.BROWSER_TO_DEVICE}
+          AND expires_at > NOW()
+          AND claimed_at IS NOT NULL
+          AND confirmed_at IS NULL
+          AND cancelled_at IS NULL
+          AND consumed_at IS NULL
+        RETURNING id
+      `,
+    );
+
+    if (!rows[0]) {
+      this.logger.warn(
+        `[PairingService] confirm recusado id=${params.id} userId=${params.userId}`,
+      );
+      throw this.invalid();
+    }
+
+    await this.logActivity(params.userId, 'device-pairing-confirmed');
+    return { status: 'confirmed' };
+  }
+
+  /** "Rejeitar", fechar o diálogo, ou regerar o QR. */
+  async cancel(userId: number, id: string) {
+    await this.prisma.device_pairing_request.updateMany({
+      where: { id: this.parseId(id), user_id: userId, consumed_at: null },
+      data: { cancelled_at: new Date() },
+    });
+
+    await this.logActivity(userId, 'device-pairing-cancelled');
+    return { status: 'cancelled' };
+  }
+
+  /**
+   * O aparelho resgata. Antes de confirmado devolve `pending` SEM consumir — do
+   * contrário o primeiro poll queimaria o registro e a aprovação chegaria tarde
+   * demais.
+   */
+  async redeem(params: {
+    authToken: string;
+    clientId: string;
+    locale: string;
+    ipAddress: string;
+    userAgent: string;
+  }) {
+    const authHash = this.security.hashSha256(params.authToken);
+
+    const pending = await this.prisma.device_pairing_request.findFirst({
+      where: {
+        auth_hash: authHash,
+        client_id: params.clientId,
+        direction: PairingService.BROWSER_TO_DEVICE,
+      },
+    });
+
+    if (
+      !pending ||
+      pending.cancelled_at ||
+      pending.consumed_at ||
+      pending.expires_at.getTime() <= Date.now()
+    ) {
+      throw this.invalid();
+    }
+
+    if (!pending.confirmed_at) {
+      return { status: 'pending' as const };
+    }
+
+    const rows = await this.prisma.$queryRaw<
+      Array<{ user_id: number; payload_enc: string }>
+    >(
+      Prisma.sql`
+        UPDATE device_pairing_request
+        SET consumed_at = NOW()
+        WHERE auth_hash = ${authHash}
+          AND client_id = ${params.clientId}
+          AND direction = ${PairingService.BROWSER_TO_DEVICE}
+          AND confirmed_at IS NOT NULL
+          AND consumed_at IS NULL
+          AND cancelled_at IS NULL
+          AND expires_at > NOW()
+        RETURNING user_id, payload_enc
+      `,
+    );
+
+    const row = rows[0];
+    if (!row) {
+      this.logger.warn('[PairingService] redeem após consumo ou expiração');
+      throw this.invalid();
+    }
+
+    const { accessToken, refreshToken } = await this.auth.getAuthenticationPayload(
+      params.locale,
+      row.user_id,
+      params.ipAddress,
+      params.userAgent,
+    );
+
+    await this.logActivity(row.user_id, 'device-pairing-consumed');
+
+    return {
+      status: 'confirmed' as const,
+      accessToken,
+      refreshToken,
+      tokenType: 'Bearer',
+      // Informativo para o cliente agendar refresh; a verdade é o exp do JWT.
+      expiresIn: 3600,
+      // Devolvido intacto: este serviço não sabe (nem pode saber) o que há dentro.
+      payload: row.payload_enc,
+    };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /* Direção B — celular destravado → navegador                          */
+  /* ------------------------------------------------------------------ */
+
+  /**
+   * O navegador que QUER acesso abre o pareamento. Público: o caso principal é
+   * um computador onde ninguém está logado. O registro nasce sem dono.
+   */
+  async startReverse(params: {
+    pollHash: string;
+    ephPublicKey: string;
+    wantSession: boolean;
+    clientId: string;
+    ipAddress: string;
+    userAgent: string;
+  }) {
+    await this.assertClient(params.clientId);
+
+    const expiresAt = this.expiresAt();
+    const row = await this.prisma.device_pairing_request.create({
+      data: {
+        direction: PairingService.DEVICE_TO_BROWSER,
+        auth_hash: params.pollHash,
+        client_id: params.clientId,
+        eph_public_key: params.ephPublicKey,
+        want_session: params.wantSession,
+        issued_ip: params.ipAddress,
+        issued_user_agent: params.userAgent,
+        expires_at: expiresAt,
+      },
+    });
+
+    return { id: String(row.id), expiresAt: expiresAt.toISOString() };
+  }
+
+  /**
+   * Metadados do navegador que pediu, para o aparelho decidir se aprova.
+   *
+   * Exige a pública efêmera como prova de que quem pergunta leu mesmo o QR: o
+   * `id` é sequencial, e sem essa prova qualquer usuário autenticado poderia
+   * varrer os ids e descobrir de que IP alguém está tentando entrar.
+   */
+  async getReverseRequest(id: string, ephPublicKey: string) {
+    const row = await this.prisma.device_pairing_request.findFirst({
+      where: {
+        id: this.parseId(id),
+        direction: PairingService.DEVICE_TO_BROWSER,
+      },
+    });
+
+    if (
+      !row ||
+      !row.eph_public_key ||
+      !this.safeEquals(row.eph_public_key, ephPublicKey) ||
+      row.cancelled_at ||
+      row.consumed_at ||
+      row.confirmed_at ||
+      row.expires_at.getTime() <= Date.now()
+    ) {
+      this.logger.warn(`[PairingService] inspeção recusada id=${id}`);
+      throw this.invalid();
+    }
+
+    // Registrar a leitura deixa o navegador mostrar "celular conectado,
+    // aguardando confirmação" em vez de um QR parado.
+    await this.prisma.device_pairing_request.updateMany({
+      where: { id: row.id, claimed_at: null },
+      data: { claimed_at: new Date() },
+    });
+
+    return {
+      issuedIp: row.issued_ip,
+      issuedUserAgent: row.issued_user_agent,
+      ephPublicKey: row.eph_public_key,
+      wantSession: row.want_session,
+      expiresAt: row.expires_at.toISOString(),
+    };
+  }
+
+  /** O aparelho autenticado aprova e entrega o blob cifrado para a efêmera. */
+  async approveReverse(params: {
+    userId: number;
+    id: string;
+    ephPublicKey: string;
+    payloadEnc: string;
+  }) {
+    const rows = await this.prisma.$queryRaw<Array<{ id: bigint }>>(
+      Prisma.sql`
+        UPDATE device_pairing_request
+        SET confirmed_at = NOW(),
+            user_id = ${params.userId},
+            payload_enc = ${params.payloadEnc}
+        WHERE id = ${this.parseId(params.id)}
+          AND direction = ${PairingService.DEVICE_TO_BROWSER}
+          AND eph_public_key = ${params.ephPublicKey}
+          AND expires_at > NOW()
+          AND confirmed_at IS NULL
+          AND cancelled_at IS NULL
+          AND consumed_at IS NULL
+        RETURNING id
+      `,
+    );
+
+    if (!rows[0]) {
+      this.logger.warn(
+        `[PairingService] aprovação recusada id=${params.id} userId=${params.userId}`,
+      );
+      throw this.invalid();
+    }
+
+    await this.logActivity(params.userId, 'device-pairing-approved');
+    return { status: 'confirmed' };
+  }
+
+  async rejectReverse(params: {
+    userId: number;
+    id: string;
+    ephPublicKey: string;
+  }) {
+    await this.prisma.device_pairing_request.updateMany({
+      where: {
+        id: this.parseId(params.id),
+        direction: PairingService.DEVICE_TO_BROWSER,
+        eph_public_key: params.ephPublicKey,
+        consumed_at: null,
+      },
+      data: { cancelled_at: new Date() },
+    });
+
+    await this.logActivity(params.userId, 'device-pairing-rejected');
+    return { status: 'cancelled' };
+  }
+
+  /**
+   * O navegador pergunta se já foi aprovado. Enquanto não, devolve `pending` sem
+   * consumir. A sessão, quando pedida, nasce com o IP e o user-agent do
+   * NAVEGADOR — é ele quem vai usá-la, não o celular que aprovou.
+   */
+  async pollReverse(params: { pollToken: string; locale: string }) {
+    const pollHash = this.security.hashSha256(params.pollToken);
+
+    const pending = await this.prisma.device_pairing_request.findFirst({
+      where: {
+        auth_hash: pollHash,
+        direction: PairingService.DEVICE_TO_BROWSER,
+      },
+    });
+
+    if (
+      !pending ||
+      pending.cancelled_at ||
+      pending.consumed_at ||
+      pending.expires_at.getTime() <= Date.now()
+    ) {
+      throw this.invalid();
+    }
+
+    if (!pending.confirmed_at) {
+      return {
+        status: 'pending' as const,
+        claimed: Boolean(pending.claimed_at),
+      };
+    }
+
+    const rows = await this.prisma.$queryRaw<
+      Array<{
+        user_id: number;
+        payload_enc: string;
+        want_session: boolean;
+        issued_ip: string | null;
+        issued_user_agent: string | null;
+      }>
+    >(
+      Prisma.sql`
+        UPDATE device_pairing_request
+        SET consumed_at = NOW()
+        WHERE auth_hash = ${pollHash}
+          AND direction = ${PairingService.DEVICE_TO_BROWSER}
+          AND confirmed_at IS NOT NULL
+          AND consumed_at IS NULL
+          AND cancelled_at IS NULL
+          AND expires_at > NOW()
+        RETURNING user_id, payload_enc, want_session, issued_ip, issued_user_agent
+      `,
+    );
+
+    const row = rows[0];
+    if (!row) {
+      this.logger.warn('[PairingService] poll após consumo ou expiração');
+      throw this.invalid();
+    }
+
+    await this.logActivity(row.user_id, 'device-pairing-consumed');
+
+    if (!row.want_session) {
+      return { status: 'confirmed' as const, payload: row.payload_enc };
+    }
+
+    const { accessToken, refreshToken, session } =
+      await this.auth.getAuthenticationPayload(
+        params.locale,
+        row.user_id,
+        row.issued_ip ?? '',
+        row.issued_user_agent ?? '',
+      );
+
+    return {
+      status: 'confirmed' as const,
+      payload: row.payload_enc,
+      accessToken,
+      refreshToken,
+      session,
+      tokenType: 'Bearer',
+      expiresIn: 3600,
+    };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /* Limpeza                                                             */
+  /* ------------------------------------------------------------------ */
+
+  /**
+   * Os registros são minúsculos e de vida curta, mas nada os apagava — mesmo
+   * buraco que `oauth_authorization_code` tem. Sem isto, ciphertext aprovado e
+   * nunca resgatado ficaria no banco para sempre.
+   */
+  @Cron(CronExpression.EVERY_DAY_AT_4AM)
+  async purgeExpired() {
+    const { count } = await this.prisma.device_pairing_request.deleteMany({
+      where: { expires_at: { lt: new Date(Date.now() - 24 * 60 * 60 * 1000) } },
+    });
+
+    if (count > 0) {
+      this.logger.log(`[PairingService] ${count} pareamentos expirados removidos`);
+    }
+  }
+}