@hed-hog/core 0.0.387 → 0.0.393

package/src/leaked-password/leaked-password.service.ts

@@ -0,0 +1,242 @@
+import { buildBloomFilter } from '@hed-hog/vault-crypto';
+import { PrismaService } from '@hed-hog/api-prisma';
+import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
+import { createHash } from 'crypto';
+
+/**
+ * Corpus de senhas vazadas conhecidas (SHA-1), com duas leituras bem diferentes:
+ *
+ * 1. `isLeaked()` — consulta pontual, usada onde a senha em claro passa pelo
+ *    servidor de qualquer forma (cadastro e troca de senha do sistema).
+ * 2. `getFilter()` — bloom filter serializado que o navegador baixa para testar
+ *    as senhas do COFRE localmente. Aqui a senha jamais pode chegar ao servidor,
+ *    nem em prefixo de hash: é o que preserva a criptografia ponta a ponta.
+ *
+ * O filtro é caro de montar (varre o corpus inteiro), então fica em memória
+ * enquanto a versão do corpus não muda. Cada pod monta o seu — são poucos MB.
+ */
+
+/** Taxa de falso positivo do filtro. 0,1% mantém ~1,8MB por 1M de hashes. */
+const FILTER_FALSE_POSITIVE_RATE = 0.001;
+
+/** Tamanho da página ao varrer o corpus (20 bytes por hash). */
+const SCAN_PAGE_SIZE = 50_000;
+
+/** Lote de inserção no import. */
+const IMPORT_BATCH_SIZE = 5_000;
+
+/** Janela de cache da versão do corpus, para não fazer count() por request. */
+const VERSION_CACHE_MS = 60_000;
+
+export type LeakedPasswordFilter = {
+  /**
+   * `Uint8Array` e não `Buffer` de propósito: o `Buffer` do @types/node atual é
+   * genérico em `ArrayBufferLike`, e o campo `Bytes` do Prisma exige
+   * `Uint8Array<ArrayBuffer>` — misturar os dois não compila.
+   */
+  bytes: Uint8Array<ArrayBuffer>;
+  etag: string;
+  /** Hashes representados no filtro. */
+  count: number;
+};
+
+export type CorpusVersion = {
+  count: number;
+  lastCreatedAt: Date | null;
+  /** Identidade compacta do corpus, base do ETag e da invalidação do cache. */
+  tag: string;
+};
+
+export type ImportEntry = {
+  /** SHA-1 em 20 bytes. */
+  hash: Uint8Array<ArrayBuffer>;
+  occurrences: number;
+};
+
+export type ImportResult = {
+  read: number;
+  inserted: number;
+  skipped: number;
+};
+
+@Injectable()
+export class LeakedPasswordService {
+  private readonly logger = new Logger(LeakedPasswordService.name);
+
+  private cachedFilter: LeakedPasswordFilter | null = null;
+  private cachedFilterTag: string | null = null;
+
+  private cachedVersion: CorpusVersion | null = null;
+  private cachedVersionAt = 0;
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+  ) {}
+
+  /** SHA-1 da senha, o formato em que os corpus públicos são distribuídos. */
+  private digest(password: string): Uint8Array<ArrayBuffer> {
+    return new Uint8Array(createHash('sha1').update(password, 'utf8').digest());
+  }
+
+  /**
+   * A senha aparece no corpus? Só para caminhos em que o servidor já recebe a
+   * senha em claro — nunca chame isto com senha de cofre.
+   */
+  async isLeaked(password: string): Promise<boolean> {
+    if (!password) return false;
+    try {
+      const found = await this.prismaService.leaked_password.findUnique({
+        where: { hash: this.digest(password) },
+        select: { id: true },
+      });
+      return !!found;
+    } catch (error) {
+      // Corpus indisponível não pode derrubar um cadastro: falha aberta, como o
+      // resto do validador de política de senha.
+      this.logger.warn(
+        `Falha ao consultar corpus de senhas vazadas: ${(error as Error)?.message}`,
+      );
+      return false;
+    }
+  }
+
+  /** Quantas vezes a senha aparece nos vazamentos; 0 quando não aparece. */
+  async occurrencesOf(password: string): Promise<number> {
+    if (!password) return 0;
+    const found = await this.prismaService.leaked_password.findUnique({
+      where: { hash: this.digest(password) },
+      select: { occurrences: true },
+    });
+    return found?.occurrences ?? 0;
+  }
+
+  /** Versão do corpus, com cache curto para não pagar `count()` por request. */
+  async getCorpusVersion(force = false): Promise<CorpusVersion> {
+    const now = Date.now();
+    if (
+      !force &&
+      this.cachedVersion &&
+      now - this.cachedVersionAt < VERSION_CACHE_MS
+    ) {
+      return this.cachedVersion;
+    }
+
+    const [count, latest] = await Promise.all([
+      this.prismaService.leaked_password.count(),
+      this.prismaService.leaked_password.findFirst({
+        orderBy: { created_at: 'desc' },
+        select: { created_at: true },
+      }),
+    ]);
+
+    const lastCreatedAt = latest?.created_at ?? null;
+    const version: CorpusVersion = {
+      count,
+      lastCreatedAt,
+      tag: `${count}-${lastCreatedAt ? lastCreatedAt.getTime() : 0}`,
+    };
+
+    this.cachedVersion = version;
+    this.cachedVersionAt = now;
+    return version;
+  }
+
+  /**
+   * Filtro serializado do corpus. Reconstrói só quando a versão muda; o
+   * `count` da versão define o tamanho do vetor de bits.
+   */
+  async getFilter(): Promise<LeakedPasswordFilter> {
+    const version = await this.getCorpusVersion();
+    if (this.cachedFilter && this.cachedFilterTag === version.tag) {
+      return this.cachedFilter;
+    }
+
+    const startedAt = Date.now();
+    const digests = await this.scanDigests();
+    const bytes = buildBloomFilter(
+      digests,
+      version.count,
+      FILTER_FALSE_POSITIVE_RATE,
+    );
+
+    const filter: LeakedPasswordFilter = {
+      bytes,
+      count: digests.length,
+      etag: `W/"lp-${version.tag}"`,
+    };
+    this.cachedFilter = filter;
+    this.cachedFilterTag = version.tag;
+
+    this.logger.log(
+      `Bloom filter de senhas vazadas montado: ${digests.length} hashes, ` +
+        `${(bytes.length / 1024).toFixed(0)}KB, ${Date.now() - startedAt}ms`,
+    );
+    return filter;
+  }
+
+  /**
+   * Varre o corpus paginando por id. Prisma não expõe cursor de verdade, e
+   * `skip` degrada em tabela grande — o cursor por id mantém custo constante.
+   */
+  private async scanDigests(): Promise<Uint8Array[]> {
+    const out: Uint8Array[] = [];
+    let cursor: number | undefined;
+
+    for (;;) {
+      const page = await this.prismaService.leaked_password.findMany({
+        select: { id: true, hash: true },
+        orderBy: { id: 'asc' },
+        take: SCAN_PAGE_SIZE,
+        ...(cursor ? { cursor: { id: cursor }, skip: 1 } : {}),
+      });
+      if (!page.length) break;
+
+      for (const row of page) {
+        out.push(row.hash);
+      }
+      if (page.length < SCAN_PAGE_SIZE) break;
+      cursor = page[page.length - 1]?.id;
+      if (cursor === undefined) break;
+    }
+
+    return out;
+  }
+
+  /**
+   * Ingere hashes de um dump. `createMany` com `skipDuplicates` deixa o unique
+   * de `hash` resolver a repetição, então reimportar o mesmo arquivo é inócuo.
+   */
+  async importEntries(
+    entries: AsyncIterable<ImportEntry> | Iterable<ImportEntry>,
+  ): Promise<ImportResult> {
+    let read = 0;
+    let inserted = 0;
+    let batch: ImportEntry[] = [];
+
+    const flush = async () => {
+      if (!batch.length) return;
+      const result = await this.prismaService.leaked_password.createMany({
+        data: batch.map((e) => ({ hash: e.hash, occurrences: e.occurrences })),
+        skipDuplicates: true,
+      });
+      inserted += result.count;
+      batch = [];
+    };
+
+    for await (const entry of entries as AsyncIterable<ImportEntry>) {
+      if (entry.hash.length !== 20) continue;
+      read++;
+      batch.push(entry);
+      if (batch.length >= IMPORT_BATCH_SIZE) await flush();
+    }
+    await flush();
+
+    // O corpus mudou: derruba os caches para o próximo filtro já sair novo.
+    this.cachedFilter = null;
+    this.cachedFilterTag = null;
+    this.cachedVersion = null;
+
+    return { read, inserted, skipped: read - inserted };
+  }
+}

package/src/leaked-password/seed/build-seed-sql.mjs

@@ -0,0 +1,180 @@
+/**
+ * Gera o SQL de seed da tabela `leaked_password` a partir de common-passwords.txt.
+ *
+ * Roda na mão, só quando a lista base muda, e o resultado é colado numa migration
+ * nova (as migrations existentes nunca são reescritas). O SHA-1 é calculado aqui
+ * porque o `pgcrypto` está disponível mas NÃO instalado no Postgres do projeto —
+ * depender de `CREATE EXTENSION` exigiria superusuário no cluster de produção.
+ *
+ *   node build-seed-sql.mjs > /tmp/seed.sql   # perfil compacto (vai na migration)
+ *   node build-seed-sql.mjs --count          # só relata o tamanho gerado
+ *   node build-seed-sql.mjs --full --plain   # lista completa em texto, para o import
+ *
+ * Dois perfis porque a expansão total passa de 100 mil entradas — bom para
+ * ingerir pelo comando de import, inviável de carregar numa migration. O perfil
+ * compacto fica nas poucas milhares de variações mais frequentes.
+ *
+ * Expansão: cada palavra-base vira as variações que dominam corpus de vazamento
+ * (sufixo numérico, ano, capitalização, leet, símbolo final). Linhas com `=` no
+ * início entram só como literal.
+ */
+
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const LIST = join(HERE, 'common-passwords.txt');
+
+const FULL = process.argv.includes('--full');
+
+/** Sufixos numéricos e simbólicos mais frequentes depois de uma palavra. */
+const NUMERIC_SUFFIXES = FULL
+  ? [
+      '',
+      '1',
+      '12',
+      '123',
+      '1234',
+      '12345',
+      '123456',
+      '01',
+      '007',
+      '11',
+      '22',
+      '99',
+      '00',
+      '321',
+      '!',
+      '@',
+      '#',
+      '123!',
+      '123@',
+      '@123',
+    ]
+  : ['', '1', '123', '1234', '123456', '@123'];
+
+/** Anos que aparecem como sufixo (nascimento, ano corrente, ano de cadastro). */
+const YEARS = [];
+if (FULL) {
+  for (let y = 1980; y <= 2030; y++) YEARS.push(String(y));
+  for (let y = 80; y <= 99; y++) YEARS.push(String(y));
+} else {
+  // No compacto só os anos que realmente aparecem como sufixo recente.
+  YEARS.push('1990', '2000', '2010', '2020', '2023', '2024', '2025', '2026');
+}
+
+/** Trocas leet aplicadas à palavra inteira, uma passada só. */
+const LEET = [
+  ['a', '4'],
+  ['e', '3'],
+  ['i', '1'],
+  ['o', '0'],
+  ['s', '5'],
+];
+
+function capitalize(word) {
+  return word.charAt(0).toUpperCase() + word.slice(1);
+}
+
+function leetVariants(word) {
+  const out = new Set();
+  // Uma troca por vez, mais a troca de todas juntas: as combinações completas
+  // explodiriam o seed sem ganho real de cobertura.
+  for (const [from, to] of LEET) {
+    if (word.includes(from)) out.add(word.replaceAll(from, to));
+  }
+  let all = word;
+  for (const [from, to] of LEET) all = all.replaceAll(from, to);
+  if (all !== word) out.add(all);
+  return [...out];
+}
+
+function expand(base) {
+  const out = new Set();
+  const stems = new Set([base, capitalize(base)]);
+  if (FULL) {
+    stems.add(base.toUpperCase());
+    for (const leet of leetVariants(base)) {
+      stems.add(leet);
+      stems.add(capitalize(leet));
+    }
+  } else {
+    // No compacto, só a troca leet completa — as parciais são a cauda longa.
+    const all = leetVariants(base).at(-1);
+    if (all) stems.add(all);
+  }
+
+  for (const stem of stems) {
+    for (const suffix of NUMERIC_SUFFIXES) out.add(stem + suffix);
+  }
+  // Ano só na forma original e capitalizada: cruzar com leet triplicaria o seed.
+  for (const stem of [base, capitalize(base)]) {
+    for (const year of YEARS) {
+      out.add(stem + year);
+      if (FULL) out.add(`${stem}@${year}`);
+    }
+  }
+  return [...out];
+}
+
+function readBases() {
+  const literals = [];
+  const bases = [];
+  for (const rawLine of readFileSync(LIST, 'utf8').split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+    if (line.startsWith('=')) literals.push(line.slice(1));
+    else bases.push(line);
+  }
+  return { literals, bases };
+}
+
+const { literals, bases } = readBases();
+
+const passwords = new Set(literals);
+for (const base of bases) {
+  for (const variant of expand(base)) passwords.add(variant);
+}
+
+// Senha com menos de 4 caracteres não chega a ser cadastrável em nenhum fluxo.
+const finalList = [...passwords].filter((p) => p.length >= 4);
+
+const hashes = [...new Set(finalList.map((p) => createHash('sha1').update(p, 'utf8').digest('hex').toUpperCase()))].sort();
+
+if (process.argv.includes('--count')) {
+  console.error(
+    `perfil=${FULL ? 'full' : 'compacto'} bases=${bases.length} literais=${literals.length} senhas=${finalList.length} hashes=${hashes.length}`,
+  );
+  process.exit(0);
+}
+
+// `--plain` emite `HASH:0` (formato do dump do Pwned Passwords), para alimentar
+// o comando de import com a lista completa sem passar por SQL.
+if (process.argv.includes('--plain')) {
+  process.stdout.write(hashes.map((h) => `${h}:0`).join('\n'));
+  process.exit(0);
+}
+
+const CHUNK = 500;
+const lines = [];
+lines.push(
+  '-- Core: seed base da tabela `leaked_password` (SHA-1 das senhas notoriamente',
+  '-- vazadas/triviais). GERADO por libraries/core/src/leaked-password/seed/build-seed-sql.mjs',
+  '-- a partir de common-passwords.txt — nao editar a mao; regerar e criar migration nova.',
+  `-- Entradas: ${hashes.length}`,
+  '',
+);
+
+for (let i = 0; i < hashes.length; i += CHUNK) {
+  const chunk = hashes.slice(i, i + CHUNK);
+  lines.push('INSERT INTO "leaked_password" ("hash", "occurrences")');
+  lines.push('SELECT decode(h, \'hex\'), 0 FROM unnest(ARRAY[');
+  lines.push(chunk.map((h) => `  '${h}'`).join(',\n'));
+  lines.push(']) AS h');
+  lines.push('ON CONFLICT ("hash") DO NOTHING;');
+  lines.push('');
+}
+
+process.stdout.write(lines.join('\n'));